return nil
	}
	r.RLock()
	defer r.RUnlock()
	return append(make([]KeyVal, 0, len(r.tags)), r.tags...)
}

// GetTagsMap - returns the user defined tags in a map structure
func (r *ReqInfo) GetTagsMap() map[string]string {
	if r == nil {
		return nil
	}
	r.RLock()
	defer r.RUnlock()
	m := make(map[string]string, len(r.tags))
	for _, t := range r.tags {
		m[t.Key] = t.Val
	}
	return m
}

	isAllPoliciesQuery := len(q.Users) == 0 && len(q.Groups) == 0 && len(q.Policies) == 0

	if len(q.Users) > 0 {
		result.UserMappings = store.listUserPolicyMappings(cache, q.Users, userPredicate, decodeFunc)
	}
	if len(q.Groups) > 0 {
		result.GroupMappings = store.listGroupPolicyMappings(cache, q.Groups, groupPredicate, decodeFunc)
	}
	if len(q.Policies) > 0 || isAllPoliciesQuery {

var _debugMsg_index = [...]uint8{0, 13, 29, 46, 62, 86, 112, 130, 151, 176}

func (i debugMsg) String() string {
	if i < 0 || i >= debugMsg(len(_debugMsg_index)-1) {
		return "debugMsg(" + strconv.FormatInt(int64(i), 10) + ")"
	}
	return _debugMsg_name[_debugMsg_index[i]:_debugMsg_index[i+1]]

	if r == nil {
		return nil
	}
	peerBucketStatsList := globalNotificationSys.GetClusterAllBucketStats(GlobalContext)
	bucketsReplicationStats = make(map[string]BucketStats, len(bucketsUsage))

	for bucket := range bucketsUsage {
		bucketStats := make([]BucketStats, len(peerBucketStatsList))
		for i, peerBucketStats := range peerBucketStatsList {
			bucketStat, ok := peerBucketStats.Stats[bucket]
			if !ok {
				continue
			}

	if err != nil {
		t.Fatalf("%s : %s", instanceType, err.Error())
	}

	// Put an empty directory
	_, err = obj.PutObject(context.Background(), "test-getobjectinfo", "Asia/empty-dir/", mustGetPutObjReader(t, bytes.NewBufferString(""), int64(len("")), "", ""), opts)
	if err != nil {
		t.Fatalf("%s : %s", instanceType, err.Error())

		t.Log("1: server payload: ", len(payload), "bytes.")
		return append([]byte{}, payload...), nil
	}))
	// 2: Return as error
	errFatal(local.RegisterSingleHandler(handlerTest2, func(payload []byte) ([]byte, *RemoteErr) {
		t.Log("2: server payload: ", len(payload), "bytes.")
		err := RemoteErr(payload)
		return nil, &err
	}))

		return "strict"
	}

	return t.listQuorum
}

func (t *apiConfig) getCorsAllowOrigins() []string {
	t.mu.RLock()
	defer t.mu.RUnlock()

	if len(t.corsAllowOrigins) == 0 {
		return []string{"*"}
	}

	corsAllowOrigins := make([]string, len(t.corsAllowOrigins))
	copy(corsAllowOrigins, t.corsAllowOrigins)
	return corsAllowOrigins
}

func (t *apiConfig) getStaleUploadsCleanupInterval() time.Duration {

	maxSTSSessionPolicySize = 2048
)

type stsClaims map[string]any

func (c stsClaims) populateSessionPolicy(form url.Values) error {
	if len(form) == 0 {
		return nil
	}

	sessionPolicyStr := form.Get(stsPolicy)
	if len(sessionPolicyStr) == 0 {
		return nil
	}

	sessionPolicy, err := policy.ParseConfig(bytes.NewReader([]byte(sessionPolicyStr)))
	if err != nil {
		return err
	}

	_ = x[batchJobMetricExpire-2]
}

const _batchJobMetric_name = "ReplicationKeyRotationExpire"

var _batchJobMetric_index = [...]uint8{0, 11, 22, 28}

func (i batchJobMetric) String() string {
	if i >= batchJobMetric(len(_batchJobMetric_index)-1) {
		return "batchJobMetric(" + strconv.FormatInt(int64(i), 10) + ")"
	}
	return _batchJobMetric_name[_batchJobMetric_index[i]:_batchJobMetric_index[i+1]]

}

const _healingMetric_name = "BucketObjectCheckAbandonedParts"

var _healingMetric_index = [...]uint8{0, 6, 12, 31}

func (i healingMetric) String() string {
	if i >= healingMetric(len(_healingMetric_index)-1) {
		return "healingMetric(" + strconv.FormatInt(int64(i), 10) + ")"
	}
	return _healingMetric_name[_healingMetric_index[i]:_healingMetric_index[i+1]]