this.createContexts = newContexts;
        }
    }

    /**
     * Add a lease V1 context to this request
     * @param leaseKey the lease key
     * @param requestedState the requested lease state
     */
    public void addLeaseV1Context(Smb2LeaseKey leaseKey, int requestedState) {
        LeaseV1CreateContextRequest leaseContext = new LeaseV1CreateContextRequest(leaseKey, requestedState);

		result = append(result, bi)
	}

	sort.Slice(result, func(i, j int) bool {
		return result[i].Name < result[j].Name
	})

	return result, nil
}

// GetBucketInfo returns bucket stat info about bucket on disk across all peers
func (sys *S3PeerSys) GetBucketInfo(ctx context.Context, bucket string, opts BucketOptions) (binfo BucketInfo, err error) {
	g := errgroup.WithNErrs(len(sys.peerClients))

        regA(builder);
        return builder;
    }

    protected StatsAggregationBuilder regStatsA(String name, String field) {
        StatsAggregationBuilder builder = AggregationBuilders.stats(name).field(field);
        regA(builder);
        return builder;
    }

    protected PercentilesAggregationBuilder regPercentilesA(String name, String field) {

        assertDoesNotThrow(() -> {
            // Validate that witness client configuration is properly set up
            assertTrue(mockConfig.isUseWitness() || !mockConfig.isUseWitness()); // Either state is valid
            assertTrue(mockConfig.getWitnessHeartbeatTimeout() > 0);
            assertTrue(mockConfig.getWitnessRegistrationTimeout() > 0);
            assertTrue(mockConfig.getWitnessReconnectDelay() >= 0);

	// Create a Stmt object and set its Transaction property.
	// The prepared channel is used to synchronize the statement preparation state.
	cacheStmt := &Stmt{
		Transaction: isTransaction,
		prepared:    make(chan struct{}),
	}
	// Cache the Stmt object with the associated key.
	s.Set(key, cacheStmt)

type bucketMetacache struct {
	// Name of bucket
	bucket string

	// caches indexed by id.
	caches map[string]metacache
	// cache ids indexed by root paths
	cachesRoot map[string][]string `msg:"-"`

	// Internal state
	mu      sync.RWMutex `msg:"-"`
	updated bool         `msg:"-"`
}

type deleteAllStorager interface {
	deleteAll(ctx context.Context, bucket, prefix string)
}

```
mc cp test.file myminio/bucket/
test.file:              5 B / 5 B  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  100.00% 337 B/s 0s
```

```
mc stat myminio/bucket/test.file
Name      : test.file
...
Encrypted :
  X-Amz-Server-Side-Encryption: AES256
```

## Encrypted Private Key

 * Map<String, Object> dataMap = XmlUtil.getDataMap(accessResultData);
 * }
 * </pre>
 *
 * <h2>Thread Safety:</h2>
 * <p>
 * This class is thread-safe as it does not maintain any state.
 * </p>
 *
 * <h2>Dependencies:</h2>
 * <ul>
 *   <li>org.apache.logging.log4j.Logger</li>
 *   <li>org.apache.logging.log4j.LogManager</li>
 *   <li>org.xml.sax.InputSource</li>

// handlers.
//
// It is set per-"handler function registration" in the router to allow for
// behavior modification via flags.
//
// This middleware always calls `collectAPIStats` to collect API stats.
//
// The passed in handler function must be a method of `objectAPIHandlers` for
// the name displayed in logs and trace to be accurate. The name is extracted
// via reflection.
//

   * addListener/SES.schedule. The later racy write in cancel() is not guaranteed to be observed,
   * however that is fine since the correctness is based on the atomic state in our base class. The
   * initial write to timer is never definitely visible to Fire.run since it is assigned after
   * SES.schedule is called. Therefore Fire.run has to check for null. However, it should be visible