How to subclass Guava's ImmutableList?

Question

When I try to implement my own ImmutableList (actually a wrapper that delegates to the underlying list) I get the following compiler error:

ImmutableListWrapper is not abstract and does not override abstract method isPartialView() in com.google.common.collect.ImmutableCollection

But in fact, it seems to be impossible to override isPartialView() because it is package protected and I'd like to declare the wrapper in my own package.

Why don't I simply extend ImmutableCollection? Because I want ImmutableList.copyOf() to return my instance without making a defensive copy.

The only approach I can think of is declaring a subclass in guava's package which changes isPartialView() from package-protected to public, and then having my wrapper extend that. Is there a cleaner way?

What I am trying to do

I am attempting to fix https://github.com/google/guava/issues/2029 by creating a wrapper that would delegate to the underlying ImmutableList for all methods except spliterator(), which would it override.

I am working under the assumption that users may define variables of type ImmutableList and expect the the wrapper to be a drop-in replacement (i.e. it isn't enough to implement List, they are expecting an ImmutableList).

Answer 1

If you want your own immutable list but don't want to implement it, just use a ForwardingList. Also, to actually make a copy, use Iterator as parameter for the copyOf. Here's a solution that should fulfill all your requirements described in the question and your answer.

public final class MyVeryOwnImmutableList<T> extends ForwardingList<T> {
  public static <T> MyVeryOwnImmutableList<T> copyOf(List<T> list) {
    // Iterator forces a real copy. List or Iterable doesn't.
    return new MyVeryOwnImmutableList<T>(list.iterator());
  }

  private final ImmutableList<T> delegate;

  private MyVeryOwnImmutableList(Iterator<T> it) {
    this.delegate = ImmutableList.copyOf(it);
  }

  @Override
  protected List<T> delegate()
  {
    return delegate;
  }
}

Answer 2

If you want different behavior than ImmutableList.copyOf() provides, simply define a different method, e.g.

public class MyList {
  public static List<E> copyOf(Iterable<E> iter) {
    if (iter instanceof MyList) {
      return (List<E>)iter;
    return ImmutableList.copyOf(iter);
  }
}

Guava's immutable classes provide a number of guarantees and make a number of assumptions about how their implementations work. These would be violated if other authors could implement their own classes that extend Guava's immutable types. Even if you correctly implemented your class to work with these guarantees and assumptions, there's nothing stopping these implementation details from changing in a future release, at which point your code could break in strange or undetectable ways.

Please do not attempt to implement anything in Guava's Imutable* heirarchy; you're only shooting yourself in the foot.

If you have a legitimate use case, file a feature request and describe what you need, maybe it'll get incorporated. Otherwise, just write your wrappers in a different package and provide your own methods and guarantees. There's nothing forcing you, for instance, to use ImmutableList.copyOf(). If you need different behavior, just write your own method.

Answer 3

Upon digging further, it looks like this limitation is by design:

Quoting http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ImmutableList.html:

Note: Although this class is not final, it cannot be subclassed as it has no public or protected constructors. Thus, instances of this type are guaranteed to be immutable.

So it seems I need to create my wrapper in the guava package.