new HashMap<>();

  /**
   * Given a set of features, add to it all the features directly or indirectly implied by any of
   * them, and return it.
   *
   * @param features the set of features to expand
   * @return the same set of features, expanded with all implied features
   */
  @CanIgnoreReturnValue
  public static Set<Feature<?>> addImpliedFeatures(Set<Feature<?>> features) {

### Short

It has sensible **defaults** for everything, with optional configurations everywhere. All the parameters can be fine-tuned to do what you need and to define the API you need.

But by default, it all **"just works"**.

### Validation

* Validation for most (or all?) Python **data types**, including:
    * JSON objects (`dict`).
    * JSON array (`list`) defining item types.

  }

  /**
   * A thread-safe cache that contains the mapping from each class to all methods in that class and
   * all super-classes, that are annotated with {@code @Subscribe}. The cache is shared across all
   * instances of this class; this greatly improves performance if multiple EventBus instances are
   * created and objects of the same class are registered on all of them.
   */

This has been mostly done, but there remain a few holdouts (fixing these is out of scope).

To keep the Groovy DSL ergonomic, we generate methods as necessary from the non-Groovy equivalents.

Doing this provides the following specific benefits:
- **Reduce the API surface** - We no longer need to maintain two methods.

	"github.com/minio/madmin-go/v3"
)

// BucketTargetUsageInfo - bucket target usage info provides
// - replicated size for all objects sent to this target
// - replica size for all objects received from this target
// - replication pending size for all objects pending replication to this target
// - replication failed size for all objects failed replication to this target
// - replica pending count
// - replica failed count

	deleteAll(ctx context.Context, bucket, prefix string)
}

// newBucketMetacache creates a new bucketMetacache.
// Optionally remove all existing caches.
func newBucketMetacache(bucket string, cleanup bool) *bucketMetacache {
	if cleanup {
		// Recursively delete all caches.
		objAPI := newObjectLayerFn()
		if objAPI != nil {
			ez, ok := objAPI.(deleteAllStorager)
			if ok {
				ctx := context.Background()

  // defaults

  /**
   * Copies all characters between the {@link Reader} and {@link StringBuilder} objects. Does not
   * close or flush the reader.
   *
   * <p>This is identical to {@link #copy(Readable, Appendable)} but optimized for these specific
   * types. CharBuffer has poor performance when being written into or read out of so round tripping

 *       prevent its use, because this would also rule out all ungenerified (pre-JDK1.5) data types.
 *       <b>This may change in the future.</b>
 * </ul>
 *
 * <h3>Other notes</h3>
 *
 * <ul>
 *   <li>All ranges are shallow-immutable.
 *   <li>Instances of this type are obtained using the static factory methods in this class.
 *   <li>Ranges are <i>convex</i>: whenever two values are contained, all values in between them

      Short[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class ShortsAsListTailSubListGenerator extends TestShortListGenerator {
    @Override
    protected List<Short> create(Short[] elements) {
      Short[] prefix = {(short) 86, (short) 99};
      Short[] all = concat(prefix, elements);

      Character[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class CharsAsListTailSubListGenerator extends TestCharListGenerator {
    @Override
    protected List<Character> create(Character[] elements) {
      Character[] prefix = {(char) 86, (char) 99};
      Character[] all = concat(prefix, elements);