// ignore modtime zero objects
	if oi.ModTime.IsZero() {
		return roi
	}

	if isVeeamSOSAPIObject(oi.Name) {
		return roi
	}
	if rcfg.Config == nil || rcfg.remotes == nil {
		return roi
	}
	roi = getHealReplicateObjectInfo(oi, rcfg)
	roi.RetryCount = uint32(retryCount)
	if !roi.Dsc.ReplicateAny() {
		return
	}
	// early return if replication already done, otherwise we need to determine if this

            this.session = session;
            return this;
        }

        public ProjectBuilderRequestBuilder path(Path path) {
            this.path = path;
            return this;
        }

        public ProjectBuilderRequestBuilder source(Source source) {
            this.source = source;
            return this;
        }

	cause      error
}

func (err *s3Error) Cause() error {
	return err.cause
}

func (err *s3Error) ErrorCode() string {
	return err.code
}

func (err *s3Error) ErrorMessage() string {
	return err.message
}

func (err *s3Error) HTTPStatusCode() int {
	return err.statusCode
}

func (err *s3Error) Error() string {
	return err.message
}

func errMalformedXML(err error) *s3Error {

            key,
            (k, oldValue) -> {
              if (oldValue == null || oldValue == 0) {
                noValue.set(true);
                return newValue;
              } else {
                return oldValue;
              }
            });
    return noValue.get() ? 0L : requireNonNull(result).longValue();
  }

  /**

	select {
	case <-h.ctx.Done():
		return true
	default:
		return false
	}
}

// check if the heal sequence has ended
func (h *healSequence) hasEnded() bool {
	h.mutex.RLock()
	defer h.mutex.RUnlock()
	// background heal never ends
	if h.clientToken == bgHealingUUID {
		return false
	}
	return !h.endTime.IsZero()
}

    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeDataWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int readSetupWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }
    int readParametersWireFormat( byte[] buffer, int bufferIndex, int len ) {

      return ImmutableSet.copyOf(elements);
    }
  }

  public static class ImmutableSetUnsizedBuilderGenerator extends TestStringSetGenerator {
    @Override
    protected Set<String> create(String[] elements) {
      ImmutableSet.Builder<String> builder = ImmutableSet.builder();
      for (String e : elements) {
        builder.add(e);
      }
      return builder.build();
    }
  }

    public Object get(final String key) {
        return params.get(key);
    }

    public String getAsString(final String key) {
        if (params.get(key) instanceof final String strValue) {
            return strValue;
        }
        final Object value = params.get(key);
        if (value != null) {
            return value.toString();
        }
        return null;
    }

  @Override
  public int count(@CheckForNull Object element) {
    return forward.count(element);
  }

  @Override
  @CheckForNull
  public Entry<E> firstEntry() {
    return forward.lastEntry();
  }

  @Override
  @CheckForNull
  public Entry<E> lastEntry() {
    return forward.firstEntry();
  }

  @Override
  public int size() {
    return forward.size();
  }

  @Override

     * @param selectedMech
     * @return whether the specified mechanism is preferred
     */
    boolean isPreferredMech ( ASN1ObjectIdentifier selectedMech );


    /**
     * @return context flags
     */
    int getFlags ();


    /**
     * @return array of supported mechanism OIDs
     */
    ASN1ObjectIdentifier[] getSupportedMechs ();


    /**
     *