Remove trivial uses of Guava from agent.

[anuraaga]

The only remaining usage in the agent is caching, and there is usage at compile time by muzzle of the graph library and some test usage. So we'll be able to replace the caching with caffeine for a bit smaller distribution size and probably better cache performance.

[iNikem]

Hope you do understand this and tested it :) Looks like black magic to me

[anuraaga]

The Stream (single use) vs Iterable (multiuse) dilemma is always annoying. The safe way to convert a Stream into an Iterable is creating a Lambda that initializes the Stream and returns the iterator, which is what an Iterable is.

The alternative is to collect(toList) each time which I'm ok with but I don't know this part well enough to know if the extra allocations would be problematic.

[trask]

I think naming the Iterable <-> Stream transformations makes it (a bit) easier to read:

    public Iterable<Iterable<Class<?>>> resolve(Instrumentation instrumentation) {
      // filter out our agent classes and injected helper classes
      return iterableOf(
          streamOf(delegate.resolve(instrumentation))
              .map(classes -> iterableOf(streamOf(classes).filter(c -> !isIgnored(c)))));
    }

    private static <E> Stream<E> streamOf(Iterable<E> iterable) {
      return StreamSupport.stream(iterable.spliterator(), false);
    }

    private static <E> Iterable<E> iterableOf(Stream<E> stream) {
      return stream::iterator;
    }

[anuraaga]

Unfortunately stream:: iterator isn't a real Iterable since it can't be replayed, so toIterable would need to accept Supplier<Stream>. Not sure if that ends up better.

[anuraaga]

Tried, how is it?

[trask]

Unfortunately stream:: iterator isn't a real Iterable since it can't be replayed

😭

ok, how about

    public Iterable<Iterable<Class<?>>> resolve(Instrumentation instrumentation) {
      // filter out our agent classes and injected helper classes
      return () -> streamOf(delegate.resolve(instrumentation)).map(this::filterClasses).iterator();
    }

    private Iterable<Class<?>> filterClasses(Iterable<Class<?>> classes) {
      return () -> streamOf(classes).filter(c -> !isIgnored(c)).iterator();
    }

    private static <T> Stream<T> streamOf(Iterable<T> iterable) {
      return StreamSupport.stream(iterable.spliterator(), false);
    }

[anuraaga]

Sure seems good

[trask]

I think naming the Iterable <-> Stream transformations makes it (a bit) easier to read:

    public Iterable<Iterable<Class<?>>> resolve(Instrumentation instrumentation) {
      // filter out our agent classes and injected helper classes
      return iterableOf(
          streamOf(delegate.resolve(instrumentation))
              .map(classes -> iterableOf(streamOf(classes).filter(c -> !isIgnored(c)))));
    }

    private static <E> Stream<E> streamOf(Iterable<E> iterable) {
      return StreamSupport.stream(iterable.spliterator(), false);
    }

    private static <E> Iterable<E> iterableOf(Stream<E> stream) {
      return stream::iterator;
    }