javax.el

## Class TypeConverter

- java.lang.Object
- - javax.el.ELResolver
  - - javax.el.TypeConverter

-     public abstract class TypeConverter
      extends ELResolver

  A convenient class for writing an ELResolver to do custom type conversions.

  For example, to convert a String to an instance of MyDate, one can write

  >          ELProcessor elp = new ELProcessor();
  >          elp.getELManager().addELResolver(new TypeConverter() {
  >              Object convertToType(ELContext context, Object obj, Class type) {
  >                  if ((obj instanceof String) && type == MyDate.class) {
  >                      context.setPropertyResolved(obj, type);
  >                      return (obj == null)? null: new MyDate(obj.toString());
  >                  }
  >                  return null;
  >              }
  >           };

  Since:
    EL 3.0

- - ### Field Summary

    - ### Fields inherited from class javax.el.ELResolver

      `RESOLVABLE_AT_DESIGN_TIME, TYPE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TypeConverter()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract Object` | `convertToType(ELContext context, Object obj, Class<?> targetType)` Converts an object to a specific type.
    `Class<?>` | `getCommonPropertyType(ELContext context, Object base)` Returns the most general type that this resolver accepts for the `property` argument, given a `base` object.
    `Iterator<FeatureDescriptor>` | `getFeatureDescriptors(ELContext context, Object base)` Returns information about the set of variables or properties that can be resolved for the given `base` object.
    `Class<?>` | `getType(ELContext context, Object base, Object property)` For a given `base` and `property`, attempts to identify the most general type that is acceptable for an object to be passed as the `value` parameter in a future call to the `ELResolver.setValue(javax.el.ELContext, java.lang.Object, java.lang.Object, java.lang.Object)` method.
    `Object` | `getValue(ELContext context, Object base, Object property)` Attempts to resolve the given `property` object on the given `base` object.
    `boolean` | `isReadOnly(ELContext context, Object base, Object property)` For a given `base` and `property`, attempts to determine whether a call to `ELResolver.setValue(javax.el.ELContext, java.lang.Object, java.lang.Object, java.lang.Object)` will always fail.
    `void` | `setValue(ELContext context, Object base, Object property, Object value)` Attempts to set the value of the given `property` object on the given `base` object.

    - ### Methods inherited from class javax.el.ELResolver

      `invoke`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### TypeConverter

          public TypeConverter()

  - ### Method Detail

    - #### getValue

          public Object getValue(ELContext context,
                        Object base,
                        Object property)

      Description copied from class: `ELResolver`
      Attempts to resolve the given `property` object on the given `base` object.

      If this resolver handles the given (base, property) pair, the `propertyResolved` property of the `ELContext` object must be set to `true` by the resolver, before returning. If this property is not `true` after this method is called, the caller should ignore the return value.

      Specified by:
        `getValue` in class `ELResolver`
      Parameters:
        `context` - The context of this evaluation.
        `base` - The base object whose property value is to be returned, or `null` to resolve a top-level variable.
        `property` - The property or variable to be resolved.
      Returns:
        If the `propertyResolved` property of `ELContext` was set to `true`, then the result of the variable or property resolution; otherwise undefined.

    - #### getType

          public Class<?> getType(ELContext context,
                         Object base,
                         Object property)

      Description copied from class: `ELResolver`
      For a given `base` and `property`, attempts to identify the most general type that is acceptable for an object to be passed as the `value` parameter in a future call to the `ELResolver.setValue(javax.el.ELContext, java.lang.Object, java.lang.Object, java.lang.Object)` method.

      If this resolver handles the given (base, property) pair, the `propertyResolved` property of the `ELContext` object must be set to `true` by the resolver, before returning. If this property is not `true` after this method is called, the caller should ignore the return value.

      This is not always the same as `getValue().getClass()`. For example, in the case of an `ArrayELResolver`, the `getType` method will return the element type of the array, which might be a superclass of the type of the actual element that is currently in the specified array element.

      Specified by:
        `getType` in class `ELResolver`
      Parameters:
        `context` - The context of this evaluation.
        `base` - The base object whose property value is to be analyzed, or `null` to analyze a top-level variable.
        `property` - The property or variable to return the acceptable type for.
      Returns:
        If the `propertyResolved` property of `ELContext` was set to `true`, then the most general acceptable type; otherwise undefined.

    - #### setValue

          public void setValue(ELContext context,
                      Object base,
                      Object property,
                      Object value)

      Description copied from class: `ELResolver`
      Attempts to set the value of the given `property` object on the given `base` object.

      If this resolver handles the given (base, property) pair, the `propertyResolved` property of the `ELContext` object must be set to `true` by the resolver, before returning. If this property is not `true` after this method is called, the caller can safely assume no value has been set.

      Specified by:
        `setValue` in class `ELResolver`
      Parameters:
        `context` - The context of this evaluation.
        `base` - The base object whose property value is to be set, or `null` to set a top-level variable.
        `property` - The property or variable to be set.
        `value` - The value to set the property or variable to.

    - #### isReadOnly

          public boolean isReadOnly(ELContext context,
                           Object base,
                           Object property)

      Description copied from class: `ELResolver`
      For a given `base` and `property`, attempts to determine whether a call to `ELResolver.setValue(javax.el.ELContext, java.lang.Object, java.lang.Object, java.lang.Object)` will always fail.

      If this resolver handles the given (base, property) pair, the `propertyResolved` property of the `ELContext` object must be set to `true` by the resolver, before returning. If this property is not `true` after this method is called, the caller should ignore the return value.

      Specified by:
        `isReadOnly` in class `ELResolver`
      Parameters:
        `context` - The context of this evaluation.
        `base` - The base object whose property value is to be analyzed, or `null` to analyze a top-level variable.
        `property` - The property or variable to return the read-only status for.
      Returns:
        If the `propertyResolved` property of `ELContext` was set to `true`, then `true` if the property is read-only or `false` if not; otherwise undefined.

    - #### getFeatureDescriptors

          public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext context,
                                                          Object base)

      Description copied from class: `ELResolver`
      Returns information about the set of variables or properties that can be resolved for the given `base` object. One use for this method is to assist tools in auto-completion.

      If the `base` parameter is `null`, the resolver must enumerate the list of top-level variables it can resolve.

      The `Iterator` returned must contain zero or more instances of `FeatureDescriptor`, in no guaranteed order. In the case of primitive types such as `int`, the value `null` must be returned. This is to prevent the useless iteration through all possible primitive values. A return value of `null` indicates that this resolver does not handle the given `base` object or that the results are too complex to represent with this method and the `ELResolver.getCommonPropertyType(javax.el.ELContext, java.lang.Object)` method should be used instead.

      Each `FeatureDescriptor` will contain information about a single variable or property. In addition to the standard properties, the `FeatureDescriptor` must have two named attributes (as set by the `setValue` method):

      - `ELResolver.TYPE` - The value of this named attribute must be an instance of `java.lang.Class` and specify the runtime type of the variable or property.
      - `ELResolver.RESOLVABLE_AT_DESIGN_TIME` - The value of this named attribute must be an instance of `java.lang.Boolean` and indicates whether it is safe to attempt to resolve this property at design-time. For instance, it may be unsafe to attempt a resolution at design time if the `ELResolver` needs access to a resource that is only available at runtime and no acceptable simulated value can be provided.

      The caller should be aware that the `Iterator` returned might iterate through a very large or even infinitely large set of properties. Care should be taken by the caller to not get stuck in an infinite loop.

      This is a "best-effort" list. Not all `ELResolver`s will return completely accurate results, but all must be callable at both design-time and runtime (i.e. whether or not `Beans.isDesignTime()` returns `true`), without causing errors.

      The `propertyResolved` property of the `ELContext` is not relevant to this method. The results of all `ELResolver`s are concatenated in the case of composite resolvers.

      Specified by:
        `getFeatureDescriptors` in class `ELResolver`
      Parameters:
        `context` - The context of this evaluation.
        `base` - The base object whose set of valid properties is to be enumerated, or `null` to enumerate the set of top-level variables that this resolver can evaluate.
      Returns:
        An `Iterator` containing zero or more (possibly infinitely more) `FeatureDescriptor` objects, or `null` if this resolver does not handle the given `base` object or that the results are too complex to represent with this method
      See Also:
        `FeatureDescriptor`

    - #### getCommonPropertyType

          public Class<?> getCommonPropertyType(ELContext context,
                                       Object base)

      Description copied from class: `ELResolver`
      Returns the most general type that this resolver accepts for the `property` argument, given a `base` object. One use for this method is to assist tools in auto-completion.

      This assists tools in auto-completion and also provides a way to express that the resolver accepts a primitive value, such as an integer index into an array. For example, the `ArrayELResolver` will accept any `int` as a `property`, so the return value would be `Integer.class`.

      Specified by:
        `getCommonPropertyType` in class `ELResolver`
      Parameters:
        `context` - The context of this evaluation.
        `base` - The base object to return the most general property type for, or `null` to enumerate the set of top-level variables that this resolver can evaluate.
      Returns:
        `null` if this `ELResolver` does not know how to handle the given `base` object; otherwise `Object.class` if any type of `property` is accepted; otherwise the most general `property` type accepted for the given `base`.

    - #### convertToType

          public abstract Object convertToType(ELContext context,
                             Object obj,
                             Class<?> targetType)

      Converts an object to a specific type.

      An `ELException` is thrown if an error occurs during the conversion.

      Overrides:
        `convertToType` in class `ELResolver`
      Parameters:
        `context` - The context of this evaluation.
        `obj` - The object to convert.
        `targetType` - The target type for the conversion.
      Throws:
        `ELException` - thrown if errors occur.

Copyright © 1996-2013, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.