//
//msgp:ignore localLocker
type localLocker struct {
	mutex   sync.Mutex
	lockMap map[string][]lockRequesterInfo
	lockUID map[string]string // UUID -> resource map.
}

func (l *localLocker) String() string {
	return globalEndpoints.Localhost()
}

func (l *localLocker) canTakeLock(resources ...string) bool {
	for _, resource := range resources {
		_, lockTaken := l.lockMap[resource]
		if lockTaken {

public abstract class CorsHandler {

    protected static final String ACCESS_CONTROL_ALLOW_ORIGIN = "Access-Control-Allow-Origin";

    protected static final String ACCESS_CONTROL_ALLOW_HEADERS = "Access-Control-Allow-Headers";

    protected static final String ACCESS_CONTROL_ALLOW_METHODS = "Access-Control-Allow-Methods";

    protected static final String ACCESS_CONTROL_ALLOW_PRIVATE_NETWORK = "Access-Control-Allow-Private-Network";

                        type: string
                      privateKey:
                        description: REQUIRED if mode is `MUTUAL`.
                        type: string
                      sni:
                        description: SNI string to present to the server during TLS
                          handshake.
                        type: string
                      subjectAltNames:

        }

        @Override
        public String getLocation() {
            return src.toString();
        }

        @Override
        public Source resolve(String relative) {
            return ModelSource.fromPath(path.resolve(relative));
        }

        @Override
        public ModelSource resolve(ModelLocator locator, String relative) {

				err = msgp.WrapError(err, "MinioEnv")
				return
			}
			if z.MinioEnv == nil {
				z.MinioEnv = make(map[string]string, zb0003)
			} else if len(z.MinioEnv) > 0 {
				for key := range z.MinioEnv {
					delete(z.MinioEnv, key)
				}
			}
			for zb0003 > 0 {
				zb0003--
				var za0002 string
				var za0003 string
				za0002, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "MinioEnv")
					return

	testCases := []struct {
		queryParams map[string]string
		headers     map[string]string
		region      string
		expected    APIErrorCode
	}{
		// (0) Should error without a set URL query.
		{
			region:   globalMinioDefaultRegion,
			expected: ErrInvalidQueryParams,
		},
		// (1) Should error on an invalid access key.
		{
			queryParams: map[string]string{
				"X-Amz-Algorithm":     signV4Algorithm,

                operator fun Boolean.invoke(some: Int) {}

                fun String.invoke(some: Int) {}
                operator fun Long.invoke(some: Int) {}

                fun Float.invoke(some: Int) {}
                infix fun Byte.invoke(some: Int) {}

                interface Source {
                    infix fun String.plus(some: List<Int>): String
                    operator fun Int.plus(some: List<Int>): Int
                }

    }

    public static class Artifact {
        private String groupId;

        private String artifactId;

        private String version;

        private String extension;

        private String classifier;

        public Artifact(String groupId, String artifactId, String version, String extension, String classifier) {
            this.groupId = groupId;

        }
        return false;
    }

    protected String readIndexSetting(final String fesenType, final String indexConfigFile, final String numberOfShards,
            final String autoExpandReplicas) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        String source = FileUtil.readUTF8(indexConfigFile);
        String dictionaryPath = System.getProperty("fess.dictionary.path", StringUtil.EMPTY);

	public static final fun basic (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
	public static final fun basic (Ljava/lang/String;Ljava/lang/String;Ljava/nio/charset/Charset;)Ljava/lang/String;
	public static synthetic fun basic$default (Ljava/lang/String;Ljava/lang/String;Ljava/nio/charset/Charset;ILjava/lang/Object;)Ljava/lang/String;
}

public final class okhttp3/Dispatcher {