@Override public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { if (parserContext.indexVersionCreated().before(Version.V_1_3_0)) { throw new IllegalArgumentException( "type=" + CONTENT_TYPE + " is not supported on indices created before version 1.3.0. Is your cluster running multiple datanode versions?"); } FieldNamesFieldMapper.Builder builder = fieldNames(); if (parserContext.indexVersionCreated().before(Version.V_2_0_0)) { parseField(builder, builder.name, node, parserContext); } for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = Strings.toUnderscoreCase(entry.getKey()); Object fieldNode = entry.getValue(); if (fieldName.equals("enabled")) { builder.enabled(nodeBooleanValue(fieldNode)); iterator.remove(); } } return builder; }
@Override public MetadataFieldMapper.Builder parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { Builder builder = new Builder(parserContext.type()); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = Strings.toUnderscoreCase(entry.getKey()); Object fieldNode = entry.getValue(); if (fieldName.equals("type")) { builder.type(fieldNode.toString()); iterator.remove(); } else if (fieldName.equals("postings_format") && parserContext.indexVersionCreated().before(Version.V_2_0_0_beta1)) { // ignore before 2.0, reject on and after 2.0 iterator.remove(); } else if (fieldName.equals("fielddata")) { // Only take over `loading`, since that is the only option now that is configurable: Map<String, String> fieldDataSettings = SettingsLoader.Helper.loadNestedFromMap(nodeMapValue(fieldNode, "fielddata")); if (fieldDataSettings.containsKey(MappedFieldType.Loading.KEY)) { Settings settings = settingsBuilder() .put( MappedFieldType.Loading.KEY, fieldDataSettings.get(MappedFieldType.Loading.KEY)) .build(); builder.fieldDataSettings(settings); } iterator.remove(); } } return builder; }
@Override public Mapper.Builder<?, ?> parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { if (parserContext.indexVersionCreated().before(Version.V_5_0_0_alpha2)) { return new LegacyIpFieldMapper.TypeParser().parse(name, node, parserContext); } Builder builder = new Builder(name); TypeParsers.parseField(builder, name, node, parserContext); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String propName = entry.getKey(); Object propNode = entry.getValue(); if (propName.equals("null_value")) { if (propNode == null) { throw new MapperParsingException("Property [null_value] cannot be null."); } builder.nullValue(InetAddresses.forString(propNode.toString())); iterator.remove(); } else if (propName.equals("ignore_malformed")) { builder.ignoreMalformed( TypeParsers.nodeBooleanValue("ignore_malformed", propNode, parserContext)); iterator.remove(); } else if (TypeParsers.parseMultiField(builder, name, parserContext, propName, propNode)) { iterator.remove(); } } return builder; }
@Override public Mapper.Builder<?, ?> parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { CompletionFieldMapper.Builder builder = completionField(name); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = entry.getKey(); Object fieldNode = entry.getValue(); if (fieldName.equals("type")) { continue; } if (fieldName.equals("analyzer")) { NamedAnalyzer analyzer = getNamedAnalyzer(parserContext, fieldNode.toString()); builder.indexAnalyzer(analyzer); builder.searchAnalyzer(analyzer); iterator.remove(); } else if (Fields.INDEX_ANALYZER.match(fieldName)) { builder.indexAnalyzer(getNamedAnalyzer(parserContext, fieldNode.toString())); iterator.remove(); } else if (Fields.SEARCH_ANALYZER.match(fieldName)) { builder.searchAnalyzer(getNamedAnalyzer(parserContext, fieldNode.toString())); iterator.remove(); } else if (fieldName.equals(Fields.PAYLOADS)) { builder.payloads(Boolean.parseBoolean(fieldNode.toString())); iterator.remove(); } else if (Fields.PRESERVE_SEPARATORS.match(fieldName)) { builder.preserveSeparators(Boolean.parseBoolean(fieldNode.toString())); iterator.remove(); } else if (Fields.PRESERVE_POSITION_INCREMENTS.match(fieldName)) { builder.preservePositionIncrements(Boolean.parseBoolean(fieldNode.toString())); iterator.remove(); } else if (Fields.MAX_INPUT_LENGTH.match(fieldName)) { builder.maxInputLength(Integer.parseInt(fieldNode.toString())); iterator.remove(); } else if ("fields".equals(fieldName) || "path".equals(fieldName)) { if (parseMultiField(builder, name, parserContext, fieldName, fieldNode)) { iterator.remove(); } } else if (fieldName.equals(Fields.CONTEXT)) { builder.contextMapping( ContextBuilder.loadMappings(fieldNode, parserContext.indexVersionCreated())); iterator.remove(); } } if (builder.searchAnalyzer == null) { builder.searchAnalyzer(parserContext.analysisService().analyzer("simple")); } if (builder.indexAnalyzer == null) { builder.indexAnalyzer(parserContext.analysisService().analyzer("simple")); } // we are just using this as the default to be wrapped by the CompletionPostingsFormatProvider // in the SuggesteFieldMapper ctor builder.postingsFormat(parserContext.postingFormatService().get("default")); return builder; }
MultiFieldParserContext(ParserContext in) { super( in.type(), in.analysisService, in.similarityLookupService(), in.mapperService(), in.typeParsers(), in.indexVersionCreated(), in.parseFieldMatcher(), in.queryShardContext()); }
@Override public MetadataFieldMapper.Builder<?, ?> parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { if (parserContext.indexVersionCreated().onOrAfter(Version.V_2_0_0_beta1)) { throw new MapperParsingException(NAME + " is not configurable"); } Builder builder = new Builder(parserContext.mapperService().fullName(NAME)); parseField(builder, builder.name, node, parserContext); return builder; }
protected static boolean parseObjectProperties( String name, String fieldName, Object fieldNode, ParserContext parserContext, ObjectMapper.Builder builder) { if (fieldName.equals("path") && parserContext.indexVersionCreated().before(Version.V_2_0_0)) { builder.pathType(parsePathType(name, fieldNode.toString())); return true; } return false; }
@Override public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { RoutingFieldMapper.Builder builder = routing(); if (parserContext.indexVersionCreated().before(Version.V_2_0_0)) { parseField(builder, builder.name, node, parserContext); } for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = Strings.toUnderscoreCase(entry.getKey()); Object fieldNode = entry.getValue(); if (fieldName.equals("required")) { builder.required(nodeBooleanValue(fieldNode)); iterator.remove(); } else if (fieldName.equals("path") && parserContext.indexVersionCreated().before(Version.V_2_0_0)) { builder.path(fieldNode.toString()); iterator.remove(); } } return builder; }
@Override public MetadataFieldMapper.Builder<?, ?> parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { Builder builder = new Builder(); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = Strings.toUnderscoreCase(entry.getKey()); if (fieldName.equals("doc_values_format") && parserContext.indexVersionCreated().before(Version.V_2_0_0_beta1)) { // ignore in 1.x, reject in 2.x iterator.remove(); } } return builder; }
@Override public Mapper.Builder parse( String fieldName, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { TextFieldMapper.Builder builder = new TextFieldMapper.Builder(fieldName); builder.fieldType().setIndexAnalyzer(parserContext.analysisService().defaultIndexAnalyzer()); builder .fieldType() .setSearchAnalyzer(parserContext.analysisService().defaultSearchAnalyzer()); builder .fieldType() .setSearchQuoteAnalyzer(parserContext.analysisService().defaultSearchQuoteAnalyzer()); parseTextField(builder, fieldName, node, parserContext); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String propName = entry.getKey(); Object propNode = entry.getValue(); if (propName.equals("position_increment_gap")) { int newPositionIncrementGap = XContentMapValues.nodeIntegerValue(propNode, -1); builder.positionIncrementGap(newPositionIncrementGap); iterator.remove(); } else if (propName.equals("fielddata")) { builder.fielddata(XContentMapValues.nodeBooleanValue(propNode)); iterator.remove(); } else if (propName.equals("eager_global_ordinals")) { builder.eagerGlobalOrdinals(XContentMapValues.nodeBooleanValue(propNode)); iterator.remove(); } else if (propName.equals("fielddata_frequency_filter")) { Map<?, ?> frequencyFilter = (Map<?, ?>) propNode; double minFrequency = XContentMapValues.nodeDoubleValue(frequencyFilter.remove("min"), 0); double maxFrequency = XContentMapValues.nodeDoubleValue(frequencyFilter.remove("max"), Integer.MAX_VALUE); int minSegmentSize = XContentMapValues.nodeIntegerValue(frequencyFilter.remove("min_segment_size"), 0); builder.fielddataFrequencyFilter(minFrequency, maxFrequency, minSegmentSize); DocumentMapperParser.checkNoRemainingFields( propName, frequencyFilter, parserContext.indexVersionCreated()); iterator.remove(); } } return builder; }
@Override public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { if (parserContext.indexVersionCreated().onOrAfter(Version.V_2_0_0)) { throw new MapperParsingException(NAME + " is not configurable"); } IdFieldMapper.Builder builder = id(); parseField(builder, builder.name, node, parserContext); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = Strings.toUnderscoreCase(entry.getKey()); Object fieldNode = entry.getValue(); if (fieldName.equals("path")) { builder.path(fieldNode.toString()); iterator.remove(); } } return builder; }
@Override public MetadataFieldMapper.Builder<?, ?> parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { Builder builder = new Builder(parserContext.mapperService().fullName(NAME)); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = Strings.toUnderscoreCase(entry.getKey()); Object fieldNode = entry.getValue(); if (fieldName.equals("enabled")) { builder.enabled( nodeBooleanValue(fieldNode) ? EnabledAttributeMapper.ENABLED : EnabledAttributeMapper.DISABLED); iterator.remove(); } else if (fieldName.equals("store") && parserContext.indexVersionCreated().before(Version.V_2_0_0_beta1)) { builder.store(parseStore(fieldName, fieldNode.toString())); iterator.remove(); } } return builder; }
protected static void parseProperties( ObjectMapper.Builder objBuilder, Map<String, Object> propsNode, ParserContext parserContext) { Iterator<Map.Entry<String, Object>> iterator = propsNode.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry<String, Object> entry = iterator.next(); String propName = entry.getKey(); // Should accept empty arrays, as a work around for when the // user can't provide an empty Map. (PHP for example) boolean isEmptyList = entry.getValue() instanceof List && ((List<?>) entry.getValue()).isEmpty(); if (entry.getValue() instanceof Map) { @SuppressWarnings("unchecked") Map<String, Object> propNode = (Map<String, Object>) entry.getValue(); String type; Object typeNode = propNode.get("type"); if (typeNode != null) { type = typeNode.toString(); } else { // lets see if we can derive this... if (propNode.get("properties") != null) { type = ObjectMapper.CONTENT_TYPE; } else if (propNode.size() == 1 && propNode.get("enabled") != null) { // if there is a single property with the enabled // flag on it, make it an object // (usually, setting enabled to false to not index // any type, including core values, which type = ObjectMapper.CONTENT_TYPE; } else { throw new MapperParsingException("No type specified for property [" + propName + "]"); } } Mapper.TypeParser typeParser = parserContext.typeParser(type); if (typeParser == null) { throw new MapperParsingException( "No handler for type [" + type + "] declared on field [" + propName + "]"); } objBuilder.add(typeParser.parse(propName, propNode, parserContext)); propNode.remove("type"); DocumentMapperParser.checkNoRemainingFields( propName, propNode, parserContext.indexVersionCreated()); iterator.remove(); } else if (isEmptyList) { iterator.remove(); } else { throw new MapperParsingException( "Expected map for property [fields] on field [" + propName + "] but got a " + propName.getClass()); } } DocumentMapperParser.checkNoRemainingFields( propsNode, parserContext.indexVersionCreated(), "DocType mapping definition has unsupported parameters: "); }
@Override public Mapper.Builder<?, ?> parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { ContentPath.Type pathType = null; FieldMapper.Builder mainFieldBuilder = null; List<FieldMapper.Builder> fields = null; String firstType = null; for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = Strings.toUnderscoreCase(entry.getKey()); Object fieldNode = entry.getValue(); if (fieldName.equals("path") && parserContext.indexVersionCreated().before(Version.V_2_0_0_beta1)) { pathType = parsePathType(name, fieldNode.toString()); iterator.remove(); } else if (fieldName.equals("fields")) { Map<String, Object> fieldsNode = (Map<String, Object>) fieldNode; for (Iterator<Map.Entry<String, Object>> fieldsIterator = fieldsNode.entrySet().iterator(); fieldsIterator.hasNext(); ) { Map.Entry<String, Object> entry1 = fieldsIterator.next(); String propName = entry1.getKey(); Map<String, Object> propNode = (Map<String, Object>) entry1.getValue(); String type; Object typeNode = propNode.get("type"); if (typeNode != null) { type = typeNode.toString(); if (firstType == null) { firstType = type; } } else { throw new MapperParsingException( "no type specified for property [" + propName + "]"); } Mapper.TypeParser typeParser = parserContext.typeParser(type); if (typeParser == null) { throw new MapperParsingException( "no handler for type [" + type + "] declared on field [" + fieldName + "]"); } if (propName.equals(name)) { mainFieldBuilder = (FieldMapper.Builder) typeParser.parse(propName, propNode, parserContext); fieldsIterator.remove(); } else { if (fields == null) { fields = new ArrayList<>(2); } fields.add( (FieldMapper.Builder) typeParser.parse(propName, propNode, parserContext)); fieldsIterator.remove(); } } fieldsNode.remove("type"); DocumentMapperParser.checkNoRemainingFields( fieldName, fieldsNode, parserContext.indexVersionCreated()); iterator.remove(); } } if (mainFieldBuilder == null) { if (fields == null) { // No fields at all were specified in multi_field, so lets return a non indexed string // field. return new StringFieldMapper.Builder(name).index(false); } Mapper.TypeParser typeParser = parserContext.typeParser(firstType); if (typeParser == null) { // The first multi field's type is unknown mainFieldBuilder = new StringFieldMapper.Builder(name).index(false); } else { Mapper.Builder substitute = typeParser.parse(name, Collections.<String, Object>emptyMap(), parserContext); if (substitute instanceof FieldMapper.Builder) { mainFieldBuilder = ((FieldMapper.Builder) substitute).index(false); } else { // The first multi isn't a core field type mainFieldBuilder = new StringFieldMapper.Builder(name).index(false); } } } if (fields != null && pathType != null) { for (Mapper.Builder field : fields) { mainFieldBuilder.addMultiField(field); } mainFieldBuilder.multiFieldPathType(pathType); } else if (fields != null) { for (Mapper.Builder field : fields) { mainFieldBuilder.addMultiField(field); } } else if (pathType != null) { mainFieldBuilder.multiFieldPathType(pathType); } return mainFieldBuilder; }
@Override public Mapper.Builder<?, ?> parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { Builder builder = geoPointField(name); final boolean indexCreatedBeforeV2_0 = parserContext.indexVersionCreated().before(Version.V_2_0_0); parseField(builder, name, node, parserContext); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = Strings.toUnderscoreCase(entry.getKey()); Object fieldNode = entry.getValue(); if (fieldName.equals("path") && parserContext.indexVersionCreated().before(Version.V_2_0_0_beta1)) { builder.multiFieldPathType(parsePathType(name, fieldNode.toString())); iterator.remove(); } else if (fieldName.equals("lat_lon")) { builder.enableLatLon(XContentMapValues.nodeBooleanValue(fieldNode)); iterator.remove(); } else if (fieldName.equals("geohash")) { builder.enableGeoHash(XContentMapValues.nodeBooleanValue(fieldNode)); iterator.remove(); } else if (fieldName.equals("geohash_prefix")) { builder.geohashPrefix(XContentMapValues.nodeBooleanValue(fieldNode)); if (XContentMapValues.nodeBooleanValue(fieldNode)) { builder.enableGeoHash(true); } iterator.remove(); } else if (fieldName.equals("precision_step")) { builder.precisionStep(XContentMapValues.nodeIntegerValue(fieldNode)); iterator.remove(); } else if (fieldName.equals("geohash_precision")) { if (fieldNode instanceof Integer) { builder.geoHashPrecision(XContentMapValues.nodeIntegerValue(fieldNode)); } else { builder.geoHashPrecision(GeoUtils.geoHashLevelsForPrecision(fieldNode.toString())); } iterator.remove(); } else if (fieldName.equals(Names.IGNORE_MALFORMED)) { if (builder.fieldType().coerce == false) { builder.fieldType().ignoreMalformed = XContentMapValues.nodeBooleanValue(fieldNode); } iterator.remove(); } else if (indexCreatedBeforeV2_0 && fieldName.equals("validate")) { if (builder.fieldType().ignoreMalformed == false) { builder.fieldType().ignoreMalformed = !XContentMapValues.nodeBooleanValue(fieldNode); } iterator.remove(); } else if (indexCreatedBeforeV2_0 && fieldName.equals("validate_lon")) { if (builder.fieldType().ignoreMalformed() == false) { builder.fieldType().ignoreMalformed = !XContentMapValues.nodeBooleanValue(fieldNode); } iterator.remove(); } else if (indexCreatedBeforeV2_0 && fieldName.equals("validate_lat")) { if (builder.fieldType().ignoreMalformed == false) { builder.fieldType().ignoreMalformed = !XContentMapValues.nodeBooleanValue(fieldNode); } iterator.remove(); } else if (fieldName.equals(Names.COERCE)) { builder.fieldType().coerce = XContentMapValues.nodeBooleanValue(fieldNode); if (builder.fieldType().coerce == true) { builder.fieldType().ignoreMalformed = true; } iterator.remove(); } else if (indexCreatedBeforeV2_0 && fieldName.equals("normalize")) { builder.fieldType().coerce = XContentMapValues.nodeBooleanValue(fieldNode); iterator.remove(); } else if (indexCreatedBeforeV2_0 && fieldName.equals("normalize_lat")) { builder.fieldType().coerce = XContentMapValues.nodeBooleanValue(fieldNode); iterator.remove(); } else if (indexCreatedBeforeV2_0 && fieldName.equals("normalize_lon")) { if (builder.fieldType().coerce == false) { builder.fieldType().coerce = XContentMapValues.nodeBooleanValue(fieldNode); } iterator.remove(); } else if (parseMultiField(builder, name, parserContext, fieldName, fieldNode)) { iterator.remove(); } } return builder; }
@Override public Mapper.Builder<?, ?> parse( String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { CompletionFieldMapper.Builder builder = completionField(name); NamedAnalyzer indexAnalyzer = null; NamedAnalyzer searchAnalyzer = null; for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = entry.getKey(); Object fieldNode = entry.getValue(); if (fieldName.equals("type")) { continue; } if (Fields.ANALYZER.equals(fieldName) || // index_analyzer is for backcompat, remove for v3.0 fieldName.equals("index_analyzer") && parserContext.indexVersionCreated().before(Version.V_2_0_0)) { indexAnalyzer = getNamedAnalyzer(parserContext, fieldNode.toString()); iterator.remove(); } else if (parserContext.parseFieldMatcher().match(fieldName, Fields.SEARCH_ANALYZER)) { searchAnalyzer = getNamedAnalyzer(parserContext, fieldNode.toString()); iterator.remove(); } else if (fieldName.equals(Fields.PAYLOADS)) { builder.payloads(Boolean.parseBoolean(fieldNode.toString())); iterator.remove(); } else if (parserContext.parseFieldMatcher().match(fieldName, Fields.PRESERVE_SEPARATORS)) { builder.preserveSeparators(Boolean.parseBoolean(fieldNode.toString())); iterator.remove(); } else if (parserContext .parseFieldMatcher() .match(fieldName, Fields.PRESERVE_POSITION_INCREMENTS)) { builder.preservePositionIncrements(Boolean.parseBoolean(fieldNode.toString())); iterator.remove(); } else if (parserContext.parseFieldMatcher().match(fieldName, Fields.MAX_INPUT_LENGTH)) { builder.maxInputLength(Integer.parseInt(fieldNode.toString())); iterator.remove(); } else if (parseMultiField(builder, name, parserContext, fieldName, fieldNode)) { iterator.remove(); } else if (fieldName.equals(Fields.CONTEXT)) { builder.contextMapping( ContextBuilder.loadMappings(fieldNode, parserContext.indexVersionCreated())); iterator.remove(); } } if (indexAnalyzer == null) { if (searchAnalyzer != null) { throw new MapperParsingException( "analyzer on completion field [" + name + "] must be set when search_analyzer is set"); } indexAnalyzer = searchAnalyzer = parserContext.analysisService().analyzer("simple"); } else if (searchAnalyzer == null) { searchAnalyzer = indexAnalyzer; } builder.indexAnalyzer(indexAnalyzer); builder.searchAnalyzer(searchAnalyzer); return builder; }
@SuppressWarnings({"unchecked"}) @Override public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException { AttachmentMapper.Builder builder = new AttachmentMapper.Builder(name); for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); String fieldName = entry.getKey(); Object fieldNode = entry.getValue(); if (fieldName.equals("path") && parserContext.indexVersionCreated().before(Version.V_2_0_0_beta1)) { builder.pathType(parsePathType(name, fieldNode.toString())); iterator.remove(); } else if (fieldName.equals("fields")) { Map<String, Object> fieldsNode = (Map<String, Object>) fieldNode; for (Iterator<Map.Entry<String, Object>> fieldsIterator = fieldsNode.entrySet().iterator(); fieldsIterator.hasNext(); ) { Map.Entry<String, Object> entry1 = fieldsIterator.next(); String propName = entry1.getKey(); Map<String, Object> propNode = (Map<String, Object>) entry1.getValue(); Mapper.Builder<?, ?> mapperBuilder = findMapperBuilder(propNode, propName, parserContext); if (parseMultiField( (FieldMapper.Builder) mapperBuilder, fieldName, parserContext, propName, propNode)) { fieldsIterator.remove(); } else if (propName.equals(name) && parserContext.indexVersionCreated().before(Version.V_2_0_0_beta1)) { builder.content(mapperBuilder); fieldsIterator.remove(); } else { switch (propName) { case FieldNames.CONTENT: builder.content(mapperBuilder); fieldsIterator.remove(); break; case FieldNames.DATE: builder.date(mapperBuilder); fieldsIterator.remove(); break; case FieldNames.AUTHOR: builder.author(mapperBuilder); fieldsIterator.remove(); break; case FieldNames.CONTENT_LENGTH: builder.contentLength(mapperBuilder); fieldsIterator.remove(); break; case FieldNames.CONTENT_TYPE: builder.contentType(mapperBuilder); fieldsIterator.remove(); break; case FieldNames.KEYWORDS: builder.keywords(mapperBuilder); fieldsIterator.remove(); break; case FieldNames.LANGUAGE: builder.language(mapperBuilder); fieldsIterator.remove(); break; case FieldNames.TITLE: builder.title(mapperBuilder); fieldsIterator.remove(); break; case FieldNames.NAME: builder.name(mapperBuilder); fieldsIterator.remove(); break; } } } DocumentMapperParser.checkNoRemainingFields( fieldName, fieldsNode, parserContext.indexVersionCreated()); iterator.remove(); } } return builder; }