Add support for multi-string mapping.

Author: Luc Boutier

elasticsearch-annotations/src/main/java/org/elasticsearch/annotation/StringField.java

@@ -128,4 +128,6 @@
      * @return
      */
     int positionOffsetGap() default 0;
+
+
 }

elasticsearch-annotations/src/main/java/org/elasticsearch/annotation/StringFieldMulti.java

@@ -0,0 +1,22 @@
+package org.elasticsearch.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation allow to specifies multiple StringField on a unique field to map it on multiple es fields.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ ElementType.FIELD, ElementType.METHOD })
+public @interface StringFieldMulti {
+    /** The main string field to manage. */
+    StringField main();
+
+    /** Name of the multi */
+    String[] multiNames();
+
+    /** The multiple fields to add to the mapping. */
+    StringField[] multi();
+}

elasticsearch-mapping/src/main/java/org/elasticsearch/mapping/FieldsMappingBuilder.java

@@ -308,6 +308,7 @@ private void processStringOrPrimitive(Class<?> clazz, Map<String, Object> proper
 
         // String field annotations.
         processFieldAnnotation(StringField.class, new StringFieldAnnotationParser(), propertiesDefinitionMap, pathPrefix, indexable);
+        processFieldAnnotation(StringFieldMulti.class, new StringFieldMultiAnnotationParser(), propertiesDefinitionMap, pathPrefix, indexable);
         processFieldAnnotation(Analyser.class, new AnalyserAnnotationParser(), propertiesDefinitionMap, pathPrefix, indexable);
         processFieldAnnotation(IndexAnalyser.class, new IndexAnalyserAnnotationParser(), propertiesDefinitionMap, pathPrefix, indexable);
         processFieldAnnotation(SearchAnalyser.class, new SearchAnalyserAnnotationParser(), propertiesDefinitionMap, pathPrefix, indexable);

elasticsearch-mapping/src/main/java/org/elasticsearch/mapping/parser/StringFieldAnnotationParser.java

@@ -59,6 +59,6 @@ public void parseAnnotation(StringField annotation, Map<String, Object> fieldDef
             fieldDefinition.put("ignore_above", annotation.ignoreAbove());
         }
 
-        annotation.positionOffsetGap();
+        // FIXME annotation.positionOffsetGap();
     }
 }

elasticsearch-mapping/src/main/java/org/elasticsearch/mapping/parser/StringFieldMultiAnnotationParser.java

@@ -0,0 +1,42 @@
+package org.elasticsearch.mapping.parser;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.elasticsearch.annotation.StringField;
+import org.elasticsearch.annotation.StringFieldMulti;
+import org.elasticsearch.common.collect.Maps;
+import org.elasticsearch.common.logging.ESLogger;
+import org.elasticsearch.common.logging.Loggers;
+import org.elasticsearch.mapping.*;
+
+/**
+ * Parse a {@link StringField} annotation.
+ * 
+ * @author luc boutier
+ */
+public class StringFieldMultiAnnotationParser implements IPropertyAnnotationParser<StringFieldMulti> {
+    private static final ESLogger LOGGER = Loggers.getLogger(MappingBuilder.class);
+    private StringFieldAnnotationParser wrapped = new StringFieldAnnotationParser();
+
+    public void parseAnnotation(StringFieldMulti annotation, Map<String, Object> fieldDefinition, String pathPrefix, Indexable indexable) {
+        if (fieldDefinition.get("type") != null) {
+            LOGGER.info("Overriding mapping for field {} for class {} was defined as type {}", indexable.getName(), indexable.getDeclaringClassName(),
+                    fieldDefinition.get("type"));
+            fieldDefinition.clear();
+        }
+
+        StringField mainStringField = annotation.main();
+        wrapped.parseAnnotation(mainStringField, fieldDefinition, pathPrefix, indexable);
+
+        Map<String, Object> multiFields = Maps.newHashMap();
+
+        for (int i = 0; i < annotation.multi().length; i++) {
+            StringField multi = annotation.multi()[i];
+            Map<String, Object> multiFieldDefinition = Maps.newHashMap();
+            wrapped.parseAnnotation(multi, multiFieldDefinition, pathPrefix, indexable);
+            multiFields.put(annotation.multiNames()[i], multiFieldDefinition);
+        }
+        fieldDefinition.put("fields", multiFields);
+    }
+}