super.addFieldToSource(sourceMap, field, DateTimeFormatter.ISO_INSTANT.format(zdt));
        } else {
            super.addFieldToSource(sourceMap, field, value);
        }
    }

    @Override
    public void setUserInfoId(final String value) {
        userInfo = null;
        super.setUserInfoId(value);
    }

    @Override

    implements SortedMultiset<E> {
  UnmodifiableSortedMultiset(SortedMultiset<E> delegate) {
    super(delegate);
  }

  @Override
  protected SortedMultiset<E> delegate() {
    return (SortedMultiset<E>) super.delegate();
  }

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

  @Override
  SortedSet<E> createElementSet() {

    /**
     * Constructs a NetShareEnumResponse
     * @param config
     *            the configuration to use
     */
    public NetShareEnumResponse(final Configuration config) {
        super(config);
    }

    @Override
    protected int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override

     * @param maxReferralLevel the maximum referral level to request
     */
    public Trans2GetDfsReferral(final Configuration config, final String filename, final int maxReferralLevel) {
        super(config, SMB_COM_TRANSACTION2, TRANS2_GET_DFS_REFERRAL);
        this.maxReferralLevel = maxReferralLevel;
        this.request = new DfsReferralRequestBuffer(filename, maxReferralLevel);
        this.totalDataCount = 0;

        public void write(Buffer source, long byteCount) throws IOException {
          super.write(source, byteCount);
          totalBytesWritten += byteCount;
          progressListener.update(totalBytesWritten, contentLength(), completed);
        }

        @Override
        public void close() throws IOException {
          super.close();
          if (!completed) {
            completed = true;

    private final Artifact artifact;

    VersionsMetadata(Artifact artifact, Date timestamp) {
        super(createRepositoryMetadata(artifact), (Path) null, timestamp);
        this.artifact = artifact;
    }

    VersionsMetadata(Artifact artifact, Path path, Date timestamp) {
        super(createRepositoryMetadata(artifact), path, timestamp);
        this.artifact = artifact;
    }

    @Override
    @J2ktIncompatible
    @GwtIncompatible
        Object writeReplace() {
      return super.writeReplace();
    }
  }

  static <R, C, V> RegularImmutableTable<R, C, V> forCells(
      List<Cell<R, C, V>> cells,
      @Nullable Comparator<? super R> rowComparator,
      @Nullable Comparator<? super C> columnComparator) {
    checkNotNull(cells);
    if (rowComparator != null || columnComparator != null) {

          Collector<T, A, R> collector, BiPredicate<? super R, ? super R> equivalence) {
    return new CollectorTester<>(collector, equivalence);
  }

  private final Collector<T, A, R> collector;
  private final BiPredicate<? super R, ? super R> equivalence;

  private CollectorTester(
      Collector<T, A, R> collector, BiPredicate<? super R, ? super R> equivalence) {
    this.collector = checkNotNull(collector);

    SortedKeySet(SortedMap<K, Collection<V>> subMap) {
      super(subMap);
    }

    SortedMap<K, Collection<V>> sortedMap() {
      return (SortedMap<K, Collection<V>>) super.map();
    }

    @Override
    public @Nullable Comparator<? super K> comparator() {
      return sortedMap().comparator();
    }

    @Override
    @ParametricNullness

    public InvalidPluginException(String message, ProjectBuildingException e) {
        super(message, e);
    }

    public InvalidPluginException(String message, InvalidDependencyVersionException e) {
        super(message, e);
    }

    public InvalidPluginException(String message) {
        super(message);
    }