this.backingMap = backingMap;
    }

    @Override
    protected Map<K, V> delegate() {
      return backingMap;
    }

    @Override
    public boolean containsKey(Object key) {
      return standardContainsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
      return standardContainsValue(value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> map) {

    @Override
    public String getProjectName() {
        return null;
    }

    @Override
    public String getProjectPrefix() {
        return null;
    }

    @Override
    public String getGenerationGapBasePrefix() {
        return null;
    }

    @Override
    public DBDef getCurrentDBDef() {
        return null;
    }

            @Override
            public void onPhaseStart(String phase, String message) {
                events.add("start:" + phase + ":" + message);
            }

            @Override
            public void onPhaseComplete(String phase) {
                events.add("complete:" + phase);
            }

            @Override
            public void onChunk(String content, boolean done) {

    }

    @Override
    public FileInputStream openStream() throws IOException {
      return new FileInputStream(file);
    }

    @Override
    public Optional<Long> sizeIfKnown() {
      if (file.isFile()) {
        return Optional.of(file.length());
      } else {
        return Optional.absent();
      }
    }

    @Override
    public long size() throws IOException {

    this.comparator = checkNotNull(comparator);
  }

  @Override
  public SortedSet<E> elementSet() {
    return (SortedSet<E>) super.elementSet();
  }

  @Override
  SortedSet<E> createElementSet() {
    return new SortedMultisets.ElementSet<E>(this);
  }

  @Override
  public Comparator<? super E> comparator() {
    return comparator;
  }

  @Override
  public @Nullable Entry<E> firstEntry() {

  abstract E get(int index);

  @Override
  public UnmodifiableIterator<E> iterator() {
    return asList().iterator();
  }

  @Override
  public Spliterator<E> spliterator() {
    return CollectSpliterators.indexed(size(), SPLITERATOR_CHARACTERISTICS, this::get);
  }

  @Override
  public void forEach(Consumer<? super E> consumer) {
    checkNotNull(consumer);

  }

  @Override
  public NavigableSet<E> elementSet() {
    return (NavigableSet<E>) super.elementSet();
  }

  @Override
  NavigableSet<E> createElementSet() {
    return new SortedMultisets.NavigableElementSet<>(this);
  }

  @Override
  public Comparator<? super E> comparator() {
    return comparator;
  }

  @Override
  public @Nullable Entry<E> firstEntry() {

     */
    @SuppressWarnings("unchecked")
    @Override
    public <T extends DfsReferralData> T unwrap(final Class<T> type) {
        if (type.isAssignableFrom(this.getClass())) {
            return (T) this;
        }
        throw new ClassCastException();
    }

    @Override
    public long getExpiration() {
        return this.expiration;
    }

    @Override
    public int getPathConsumed() {

    }
  }

  private static class BaseTypeVisitor extends TypeVisitor {
    @Override
    void visitTypeVariable(TypeVariable<?> t) {
      throw new UnsupportedOperationException();
    }

    @Override
    void visitWildcardType(WildcardType t) {
      throw new UnsupportedOperationException();
    }

    @Override
    void visitParameterizedType(ParameterizedType t) {

  /*
   * TODO(cpovirk): if we start to override indexOf/lastIndexOf under GWT, we'll want some way to
   * override subList to return an ImmutableSortedAsList for better performance. Right now, I'm not
   * sure there's any performance hit from our failure to override subListUnchecked under GWT
   */
  @Override
  ImmutableList<E> subListUnchecked(int fromIndex, int toIndex) {