}

type eventArgs struct {
	EventName    event.Name
	BucketName   string
	Object       ObjectInfo
	ReqParams    map[string]string
	RespElements map[string]string
	Host         string
	UserAgent    string
}

// ToEvent - converts to notification event.
func (args eventArgs) ToEvent(escape bool) event.Event {
	eventTime := UTCNow()

     * @return {@link Map}
     */
    public static final Map<String, String> convertMap(final ResourceBundle bundle) {
        assertArgumentNotNull("bundle", bundle);

        final Map<String, String> ret = newHashMap();
        for (final Enumeration<String> e = bundle.getKeys(); e.hasMoreElements();) {
            final String key = e.nextElement();
            final String value = bundle.getString(key);
            ret.put(key, value);

        Set<String> projectIds = new HashSet<>();

        getDownstreamProjects(ProjectSorter.getId(project), projectIds, transitive);

        return getSortedProjects(projectIds);
    }

    private void getDownstreamProjects(String projectId, Set<String> projectIds, boolean transitive) {
        for (String id : sorter.getDependents(projectId)) {

type LogOnce func(ctx context.Context, err error, id string, errKind ...interface{})

type onceErr struct {
	Err   error
	Count int
}

// Holds a map of recently logged errors.
type logOnceType struct {
	IDMap map[string]onceErr
	sync.Mutex
}

func (l *logOnceType) logOnceConsoleIf(ctx context.Context, subsystem string, err error, id string, errKind ...interface{}) {
	if err == nil {
		return
	}

     */
    public void merge(Settings dominant, Settings recessive, String recessiveSourceLevel) {
        if (dominant == null || recessive == null) {
            return;
        }

        recessive.setSourceLevel(recessiveSourceLevel);

        List<String> dominantActiveProfiles = dominant.getActiveProfiles();
        List<String> recessiveActiveProfiles = recessive.getActiveProfiles();

        map.put("エ", new String[] { "e" });
        map.put("オ", new String[] { "o" });

        map.put("カ", new String[] { "ka" });
        map.put("キ", new String[] { "ki" });
        map.put("ク", new String[] { "ku" });
        map.put("ケ", new String[] { "ke" });
        map.put("コ", new String[] { "ko" });

        map.put("サ", new String[] { "sa" });

    public List<Map<String, Object>> documentItems;

    public String pageSize;

    public String currentPageNumber;

    public String allRecordCount;

    public String allPageCount;

    public boolean existNextPage;

    public boolean existPrevPage;

    public String currentStartRecordNumber;

    public String currentEndRecordNumber;

	Recycle()
}

// MSS is a map[string]string that can be serialized.
// It is not very efficient, but it is only used for easy parameter passing.
type MSS map[string]string

// Get returns the value for the given key.
func (m *MSS) Get(key string) string {
	if m == nil {
		return ""
	}
	return (*m)[key]
}

// Set a key, value pair.
func (m *MSS) Set(key, value string) {
	if m == nil {

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
                "HTTPValidationError": {

    @Required
    @Size(max = 100)
    public String docId;

    @Size(max = 10000)
    @Required
    public String rt;

    public String hash;

    @Required
    public String queryId;

    public Integer order;

    // for error page

    public String q;

    public String num;

    public String sort;

    public String lang;