fun parse()

in alerting/src/main/kotlin/org/opensearch/alerting/aggregation/bucketselectorext/BucketSelectorExtAggregationBuilder.kt [139:248]
109 lines of code
14 McCabe index (conditional complexity)

        fun parse(reducerName: String, parser: XContentParser): BucketSelectorExtAggregationBuilder {
            var token: XContentParser.Token
            var script: Script? = null
            var currentFieldName: String? = null
            var bucketsPathsMap: MutableMap<String, String>? = null
            var gapPolicy: GapPolicy? = null
            var parentBucketPath: String? = null
            var filter: BucketSelectorExtFilter? = null
            while (parser.nextToken().also { token = it } !== XContentParser.Token.END_OBJECT) {
                if (token === XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName()
                } else if (token === XContentParser.Token.VALUE_STRING) {
                    when {
                        PipelineAggregator.Parser.BUCKETS_PATH.match(currentFieldName, parser.deprecationHandler) -> {
                            bucketsPathsMap = HashMap()
                            bucketsPathsMap["_value"] = parser.text()
                        }
                        PipelineAggregator.Parser.GAP_POLICY.match(currentFieldName, parser.deprecationHandler) -> {
                            gapPolicy = GapPolicy.parse(parser.text(), parser.tokenLocation)
                        }
                        Script.SCRIPT_PARSE_FIELD.match(currentFieldName, parser.deprecationHandler) -> {
                            script = Script.parse(parser)
                        }
                        PARENT_BUCKET_PATH.match(currentFieldName, parser.deprecationHandler) -> {
                            parentBucketPath = parser.text()
                        }
                        else -> {
                            throw ParsingException(
                                parser.tokenLocation,
                                "Unknown key for a $token in [$reducerName]: [$currentFieldName]."
                            )
                        }
                    }
                } else if (token === XContentParser.Token.START_ARRAY) {
                    if (PipelineAggregator.Parser.BUCKETS_PATH.match(currentFieldName, parser.deprecationHandler)) {
                        val paths: MutableList<String> = ArrayList()
                        while (parser.nextToken().also { token = it } !== XContentParser.Token.END_ARRAY) {
                            val path = parser.text()
                            paths.add(path)
                        }
                        bucketsPathsMap = HashMap()
                        for (i in paths.indices) {
                            bucketsPathsMap["_value$i"] = paths[i]
                        }
                    } else {
                        throw ParsingException(
                            parser.tokenLocation,
                            "Unknown key for a $token in [$reducerName]: [$currentFieldName]."
                        )
                    }
                } else if (token === XContentParser.Token.START_OBJECT) {
                    when {
                        Script.SCRIPT_PARSE_FIELD.match(currentFieldName, parser.deprecationHandler) -> {
                            script = Script.parse(parser)
                        }
                        PipelineAggregator.Parser.BUCKETS_PATH.match(currentFieldName, parser.deprecationHandler) -> {
                            val map = parser.map()
                            bucketsPathsMap = HashMap()
                            for ((key, value) in map) {
                                bucketsPathsMap[key] = value.toString()
                            }
                        }
                        BUCKET_SELECTOR_FILTER.match(currentFieldName, parser.deprecationHandler) -> {
                            filter = BucketSelectorExtFilter.parse(reducerName, false, parser)
                        }
                        BUCKET_SELECTOR_COMPOSITE_AGG_FILTER.match(
                            currentFieldName,
                            parser.deprecationHandler
                        ) -> {
                            filter = BucketSelectorExtFilter.parse(reducerName, true, parser)
                        }
                        else -> {
                            throw ParsingException(
                                parser.tokenLocation,
                                "Unknown key for a $token in [$reducerName]: [$currentFieldName]."
                            )
                        }
                    }
                } else {
                    throw ParsingException(parser.tokenLocation, "Unexpected token $token in [$reducerName].")
                }
            }
            if (bucketsPathsMap == null) {
                throw ParsingException(
                    parser.tokenLocation,
                    "Missing required field [" + PipelineAggregator.Parser.BUCKETS_PATH.preferredName +
                        "] for bucket_selector aggregation [" + reducerName + "]"
                )
            }
            if (script == null) {
                throw ParsingException(
                    parser.tokenLocation,
                    "Missing required field [" + Script.SCRIPT_PARSE_FIELD.preferredName +
                        "] for bucket_selector aggregation [" + reducerName + "]"
                )
            }

            if (parentBucketPath == null) {
                throw ParsingException(
                    parser.tokenLocation,
                    "Missing required field [" + PARENT_BUCKET_PATH +
                        "] for bucket_selector aggregation [" + reducerName + "]"
                )
            }
            val factory = BucketSelectorExtAggregationBuilder(reducerName, bucketsPathsMap, script, parentBucketPath, filter)
            if (gapPolicy != null) {
                factory.gapPolicy(gapPolicy)
            }
            return factory
        }