Package org.elasticsearch.index.mapper

Class FieldMapper.Parameter<T>

java.lang.Object
org.elasticsearch.index.mapper.FieldMapper.Parameter<T>
Type Parameters:
T - the type of the value the parameter holds
All Implemented Interfaces:
Supplier<T>
Enclosing class:
FieldMapper
public static final class FieldMapper.Parameter<T> extends Object implements Supplier<T>
A configurable parameter for a field mapper

  • Field Details

    • name

      public final String name

  • Constructor Details

    • Parameter

      public Parameter(String name, boolean updateable, Supplier<T> defaultValue, TriFunction<String,MappingParserContext,Object,T> parser, Function<FieldMapper,T> initializer)
      Creates a new Parameter
      Parameters:
      name - the parameter name, used in parsing and serialization
      updateable - whether the parameter can be updated with a new value during a mapping update
      defaultValue - the default value for the parameter, used if unspecified in mappings
      parser - a function that converts an object to a parameter value
      initializer - a function that reads a parameter value from an existing mapper

  • Method Details

    • getValue

      public T getValue()
      Returns the current value of the parameter

    • get

      public T get()
      Specified by:
      get in interface Supplier<T>

    • getDefaultValue

      public T getDefaultValue()
      Returns the default value of the parameter

    • setValue

      public void setValue(T value)
      Sets the current value of the parameter

    • isConfigured

      public boolean isConfigured()

    • acceptsNull

      public FieldMapper.Parameter<T> acceptsNull()
      Allows the parameter to accept a null value

    • canAcceptNull

      public boolean canAcceptNull()

    • addDeprecatedName

      public FieldMapper.Parameter<T> addDeprecatedName(String deprecatedName)
      Adds a deprecated parameter name. If this parameter name is encountered during parsing, a deprecation warning will be emitted. The parameter will be serialized with its main name.

    • deprecated

      public FieldMapper.Parameter<T> deprecated()
      Deprecates the entire parameter. If this parameter is encountered during parsing, a deprecation warning will be emitted.

    • setValidator

      public FieldMapper.Parameter<T> setValidator(Consumer<T> validator)
      Adds validation to a parameter, called after parsing and merging

    • setSerializer

      public FieldMapper.Parameter<T> setSerializer(FieldMapper.Serializer<T> serializer, Function<T,String> conflictSerializer)
      Configure a custom serializer for this parameter

    • setSerializerCheck

      public FieldMapper.Parameter<T> setSerializerCheck(FieldMapper.SerializerCheck<T> check)
      Configure a custom serialization check for this parameter

    • alwaysSerialize

      public FieldMapper.Parameter<T> alwaysSerialize()
      Always serialize this parameter, no matter its value

    • neverSerialize

      public FieldMapper.Parameter<T> neverSerialize()
      Never serialize this parameter, no matter its value

    • setMergeValidator

      public FieldMapper.Parameter<T> setMergeValidator(FieldMapper.MergeValidator<T> mergeValidator)
      Sets a custom merge validator. By default, merges are accepted if the parameter is updateable, or if the previous and new values are equal

    • requiresParameters

      public FieldMapper.Parameter<T> requiresParameters(FieldMapper.Parameter<?>... ps)

    • precludesParameters

      public FieldMapper.Parameter<T> precludesParameters(FieldMapper.Parameter<?>... ps)

    • parse

      public void parse(String field, MappingParserContext context, Object in)
      Parse the field value from an Object
      Parameters:
      field - the field name
      context - the parser context
      in - the object

    • toXContent

      protected void toXContent(org.elasticsearch.common.xcontent.XContentBuilder builder, boolean includeDefaults) throws IOException
      Throws:
      IOException

    • boolParam

      public static FieldMapper.Parameter<Boolean> boolParam(String name, boolean updateable, Function<FieldMapper,Boolean> initializer, boolean defaultValue)
      Defines a parameter that takes the values true or false
      Parameters:
      name - the parameter name
      updateable - whether the parameter can be changed by a mapping update
      initializer - a function that reads the parameter value from an existing mapper
      defaultValue - the default value, to be used if the parameter is undefined in a mapping

    • explicitBoolParam

      public static FieldMapper.Parameter<Explicit<Boolean>> explicitBoolParam(String name, boolean updateable, Function<FieldMapper,Explicit<Boolean>> initializer, boolean defaultValue)
      Defines a parameter that takes the values true or false, and will always serialize its value if configured.
      Parameters:
      name - the parameter name
      updateable - whether the parameter can be changed by a mapping update
      initializer - a function that reads the parameter value from an existing mapper
      defaultValue - the default value, to be used if the parameter is undefined in a mapping

    • doubleParam

      public static FieldMapper.Parameter<Double> doubleParam(String name, boolean updateable, Function<FieldMapper,Double> initializer, double defaultValue)
      Defines a parameter that takes a double value
      Parameters:
      name - the parameter name
      updateable - whether the parameter can be changed by a mapping update
      initializer - a function that reads the parameter value from an existing mapper
      defaultValue - the default value, to be used if the parameter is undefined in a mapping

    • floatParam

      public static FieldMapper.Parameter<Float> floatParam(String name, boolean updateable, Function<FieldMapper,Float> initializer, float defaultValue)
      Defines a parameter that takes a float value
      Parameters:
      name - the parameter name
      updateable - whether the parameter can be changed by a mapping update
      initializer - a function that reads the parameter value from an existing mapper
      defaultValue - the default value, to be used if the parameter is undefined in a mapping

    • intParam

      public static FieldMapper.Parameter<Integer> intParam(String name, boolean updateable, Function<FieldMapper,Integer> initializer, int defaultValue)
      Defines a parameter that takes an integer value
      Parameters:
      name - the parameter name
      updateable - whether the parameter can be changed by a mapping update
      initializer - a function that reads the parameter value from an existing mapper
      defaultValue - the default value, to be used if the parameter is undefined in a mapping

    • stringParam

      public static FieldMapper.Parameter<String> stringParam(String name, boolean updateable, Function<FieldMapper,String> initializer, String defaultValue)
      Defines a parameter that takes a string value
      Parameters:
      name - the parameter name
      updateable - whether the parameter can be changed by a mapping update
      initializer - a function that reads the parameter value from an existing mapper
      defaultValue - the default value, to be used if the parameter is undefined in a mapping

    • stringArrayParam

      public static FieldMapper.Parameter<List<String>> stringArrayParam(String name, boolean updateable, Function<FieldMapper,List<String>> initializer, List<String> defaultValue)

    • restrictedStringParam

      public static FieldMapper.Parameter<String> restrictedStringParam(String name, boolean updateable, Function<FieldMapper,String> initializer, String... values)
      Defines a parameter that takes one of a restricted set of string values
      Parameters:
      name - the parameter name
      updateable - whether the parameter can be changed by a mapping update
      initializer - a function that reads the parameter value from an existing mapper
      values - the set of values that the parameter can take. The first value in the list is the default value, to be used if the parameter is undefined in a mapping

    • analyzerParam

      public static FieldMapper.Parameter<NamedAnalyzer> analyzerParam(String name, boolean updateable, Function<FieldMapper,NamedAnalyzer> initializer, Supplier<NamedAnalyzer> defaultAnalyzer)
      Defines a parameter that takes an analyzer name
      Parameters:
      name - the parameter name
      updateable - whether the parameter can be changed by a mapping update
      initializer - a function that reads the parameter value from an existing mapper
      defaultAnalyzer - the default value, to be used if the parameter is undefined in a mapping

    • metaParam

      public static FieldMapper.Parameter<Map<String,String>> metaParam()
      Declares a metadata parameter

    • boostParam

      public static FieldMapper.Parameter<Float> boostParam()

    • indexParam

      public static FieldMapper.Parameter<Boolean> indexParam(Function<FieldMapper,Boolean> initializer, boolean defaultValue)

    • storeParam

      public static FieldMapper.Parameter<Boolean> storeParam(Function<FieldMapper,Boolean> initializer, boolean defaultValue)

    • docValuesParam

      public static FieldMapper.Parameter<Boolean> docValuesParam(Function<FieldMapper,Boolean> initializer, boolean defaultValue)

    • scriptParam

      public static FieldMapper.Parameter<Script> scriptParam(Function<FieldMapper,Script> initializer)
      Defines a script parameter
      Parameters:
      initializer - retrieves the equivalent parameter from an existing FieldMapper for use in merges
      Returns:
      a script parameter

    • onScriptErrorParam

      public static FieldMapper.Parameter<String> onScriptErrorParam(Function<FieldMapper,String> initializer, FieldMapper.Parameter<Script> dependentScriptParam)
      Defines an on_script_error parameter
      Parameters:
      initializer - retrieves the equivalent parameter from an existing FieldMapper for use in merges
      dependentScriptParam - the corresponding required script parameter
      Returns:
      a new on_error_script parameter