static <K extends Enum<K>, V> ImmutableMap<K, V> asImmutable(EnumMap<K, V> map) {
    switch (map.size()) {
      case 0:
        return ImmutableMap.of();
      case 1:
        Entry<K, V> entry = getOnlyElement(map.entrySet());
        return ImmutableMap.of(entry.getKey(), entry.getValue());
      default:
        return new ImmutableEnumMap<>(map);
    }
  }

  private final transient EnumMap<K, V> delegate;

    protected boolean validating;

    protected boolean includeAware;

    protected final Map<String, Object> attributeMap = new HashMap<>();

    protected final Map<String, String> featureMap = new HashMap<>();

    protected Map<String, String> fieldRuleMap = new LinkedHashMap<>();

    /** a flag to trim a space characters. */
    protected boolean trimSpaceEnabled = true;

        String field = settings.array().get(SuggestSettings.DefaultKeys.SUPPORTED_FIELDS)[0];

        Map<String, Object> document = new HashMap<>();
        document.put(field, "この柿は美味しい。");
        suggester.indexer().indexFromDocument(new Map[] { document });
        suggester.refresh();

    protected int maxAlphanumTermSize = -1;

    protected int maxSymbolTermSize = -1;

    protected TikaConfig tikaConfig;

    private final Map<String, TesseractOCRConfig> tesseractOCRConfigMap = new ConcurrentHashMap<>();

    private final Map<String, PDFParserConfig> pdfParserConfigMap = new ConcurrentHashMap<>();

    @PostConstruct
    public void init() {

                                    }
                                } else if (Map.class.isAssignableFrom(type)) {
                                    Map<Object, Object> m = (Map<Object, Object>) field.get(target);
                                    if (m != null && !m.isEmpty()) {
                                        for (Map.Entry<Object, Object> entry : m.entrySet()) {

	targetList     *event.TargetList
	bucketRulesMap map[string]event.RulesMap
}

// NewEventNotifier - creates new event notification object.
func NewEventNotifier(ctx context.Context) *EventNotifier {
	// targetList/bucketRulesMap/bucketRemoteTargetRulesMap are populated by NotificationSys.InitBucketTargets()
	return &EventNotifier{
		targetList:     event.NewTargetList(ctx),
		bucketRulesMap: make(map[string]event.RulesMap),
	}
}

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

import org.codelibs.fess.suggest.Suggester;
import org.codelibs.fess.suggest.settings.SuggestSettings;

}

func path2BucketObject(s string) (bucket, prefix string) {
	return path2BucketObjectWithBasePath("", s)
}

// cloneMSS will clone a map[string]string.
// If input is nil an empty map is returned, not nil.
func cloneMSS(v map[string]string) map[string]string {
	r := make(map[string]string, len(v))
	for k, v := range v {
		r[k] = v
	}
	return r
}

// URI scheme constants.
const (

 *   <dd>An extension of {@link java.util.Map} that guarantees the uniqueness of its values as well
 *       as that of its keys. This is sometimes called an "invertible map," since the restriction on
 *       values enables it to support an {@linkplain BiMap#inverse inverse view} -- which is another
 *       instance of {@code BiMap}.
 *   <dt>{@link Table}
 *   <dd>A new type, which is similar to {@link java.util.Map}, but which indexes its values by an

 *   <dd>An extension of {@link java.util.Map} that guarantees the uniqueness of its values as well
 *       as that of its keys. This is sometimes called an "invertible map," since the restriction on
 *       values enables it to support an {@linkplain BiMap#inverse inverse view} -- which is another
 *       instance of {@code BiMap}.
 *   <dt>{@link Table}
 *   <dd>A new type, which is similar to {@link java.util.Map}, but which indexes its values by an