// Make subtype to avoid recursive UnmarshalXML().
	type deleteReplication DeleteReplication
	drep := deleteReplication{}

	if err := dec.DecodeElement(&drep, &start); err != nil {
		return err
	}
	if len(drep.Status) == 0 {
		drep.Status = Disabled
	}
	d.Status = drep.Status
	return nil
}

// ExistingObjectReplication - whether existing object replication is enabled

     */
    <REQ extends Request<?>, REP extends Result<REQ>> REP request(REQ req, Function<REQ, REP> supplier);

    /**
     * Executes and optionally caches a batch of requests using the provided supplier function.
     * This method allows for efficient batch processing of multiple requests.
     * <p>
     * The implementation may optimize the execution by:

    int dummy = 0;
    for (int rep = 0; rep < reps; rep++) {
      List<Object> builder = new ArrayList<>();
      for (int i = 0; i < size; i++) {
        builder.add(OBJECT);
      }
      dummy += ImmutableList.copyOf(builder).size();
    }
    return dummy;
  }

  @Benchmark
  int copyPreSizedArrayList(int reps) {
    int size = this.size;
    int tmp = 0;
    for (int rep = 0; rep < reps; rep++) {

  }

  @Benchmark
  void concurrentHashMap(int rep) {
    for (int i = 0; i < rep; i++) {
      map.get(TEST_KEY);
    }
  }

  @Benchmark
  void cacheBuilder_stats(int rep) {
    for (int i = 0; i < rep; i++) {
      cache.getIfPresent(TEST_KEY);
    }
  }

  @Benchmark
  void cacheBuilder(int rep) {
    for (int i = 0; i < rep; i++) {
      cacheNoStats.getIfPresent(TEST_KEY);
    }
  }

 * @since 4.0.0
 */
@Experimental
public record RequestResult<REQ extends Request<?>, REP extends Result<REQ>>(
        /**
         * The original request that was processed
         */
        REQ request,

        /**
         * The result of the request, if successful; may be null if an error occurred
         */
        REP result,

        /**

                "test-grp", "test-artifact", VersionRange.createFromVersion("1.0"), "type", null, "system", "provided");
        Artifact artifact2 = factory.createDependencyArtifact(
                "test-grp", "test-artifact-2", VersionRange.createFromVersion("1.0"), "type", null, "system", "test");
        Artifact artifact3 = factory.createDependencyArtifact(
                "test-grp",
                "test-artifact-3",

     * @param <REQ> The type of the request
     * @param <REP> The type of the response
     * @param message The error message describing the batch operation failure
     * @param allResults List of results from all attempted requests in the batch
     */
    public <REQ extends Request<?>, REP extends Result<REQ>> BatchRequestException(
            String message, List<RequestResult<REQ, REP>> allResults) {
        super(message);

    // second, then signals that it's reached the end of the data
    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          private int rep;

          @Override
          public @Nullable Integer computeNext() {
            switch (rep++) {
              case 0:
                return 0;
              case 1:
                return 1;
              case 2:
                return endOfData();

    // second, then signals that it's reached the end of the data
    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          private int rep;

          @Override
          public @Nullable Integer computeNext() {
            switch (rep++) {
              case 0:
                return 0;
              case 1:
                return 1;
              case 2:
                return endOfData();

    /**
     * Replace all occurances of the given type
     *
     * @param pairs the list of AV pairs to modify
     * @param rep the replacement AV pair
     */
    public static void replace(final List<AvPair> pairs, final AvPair rep) {
        remove(pairs, rep.getType());
        pairs.add(rep);
    }

    /**
     * Encodes a list of AV pairs into byte array format
     *