org.jboss.resteasy.util

## Class FeatureContextDelegate

- java.lang.Object
- - org.jboss.resteasy.util.FeatureContextDelegate

- All Implemented Interfaces:
    Configurable<FeatureContext>, FeatureContext

      public class FeatureContextDelegate
      extends Object
      implements FeatureContext

  Version:
    $Revision: 1 $
  Author:
    Bill Burke

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Configurable` | `configurable`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `FeatureContextDelegate(Configurable configurable)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Configuration` | `getConfiguration()` Get a live view of an internal configuration state of this configurable instance.
    `FeatureContext` | `property(String name, Object value)` Set the new configuration property, if already set, the existing value of the property will be updated.
    `FeatureContext` | `register(Class<?> componentClass)` Register a class of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.
    `FeatureContext` | `register(Class<?> componentClass, Class<?>... contracts)` Register a class of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.
    `FeatureContext` | `register(Class<?> componentClass, int priority)` Register a class of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.
    `FeatureContext` | `register(Class<?> componentClass, Map<Class<?>,Integer> contracts)` Register a class of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.
    `FeatureContext` | `register(Object component)` Register an instance of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.
    `FeatureContext` | `register(Object component, Class<?>... contracts)` Register an instance of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.
    `FeatureContext` | `register(Object component, int priority)` Register an instance of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.
    `FeatureContext` | `register(Object component, Map<Class<?>,Integer> contracts)` Register an instance of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.

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

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

- - ### Field Detail

    - #### configurable

          protected Configurable configurable

  - ### Constructor Detail

    - #### FeatureContextDelegate

          public FeatureContextDelegate(Configurable configurable)

  - ### Method Detail

    - #### getConfiguration

          public Configuration getConfiguration()

      Description copied from interface: `Configurable`
      Get a live view of an internal configuration state of this configurable instance. Any changes made using methods of this `Configurable` instance will be reflected in the returned `Configuration` instance.

      The returned `Configuration` instance and the collection data it provides are not thread-safe wrt. modification made using methods on the parent configurable object.

      Specified by:
        `getConfiguration` in interface `Configurable<FeatureContext>`
      Returns:
        configuration live view of the internal configuration state.

    - #### property

          public FeatureContext property(String name,
                                Object value)

      Description copied from interface: `Configurable`
      Set the new configuration property, if already set, the existing value of the property will be updated. Setting a `null` value into a property effectively removes the property from the property bag.
      Specified by:
        `property` in interface `Configurable<FeatureContext>`
      Parameters:
        `name` - property name.
        `value` - (new) property value. `null` value removes the property with the given name.
      Returns:
        the updated configurable instance.

    - #### register

          public FeatureContext register(Class<?> componentClass)

      Description copied from interface: `Configurable`
      Register a class of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context. Implementations SHOULD warn about and ignore registrations that do not conform to the requirements of supported JAX-RS component types in the given configurable context. Any subsequent registration attempts for a component type, for which a class or instance-based registration already exists in the system MUST be rejected by the JAX-RS implementation and a warning SHOULD be raised to inform the user about the rejected registration. The registered JAX-RS component class is registered as a contract provider of all the recognized JAX-RS or implementation-specific extension contracts including meta-provider contracts, such as `Feature` or `DynamicFeature`.

      As opposed to component instances registered via `Configurable.register(Object)` method, the lifecycle of components registered using this class-based `register(...)` method is fully managed by the JAX-RS implementation or any underlying IoC container supported by the implementation.

      Specified by:
        `register` in interface `Configurable<FeatureContext>`
      Parameters:
        `componentClass` - JAX-RS component class to be configured in the scope of this configurable context.
      Returns:
        the updated configurable context.

    - #### register

          public FeatureContext register(Class<?> componentClass,
                                int priority)

      Description copied from interface: `Configurable`
      Register a class of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.

      This registration method provides the same functionality as `Configurable.register(Class)` except that any priority specified on the registered JAX-RS component class via `javax.annotation.Priority` annotation is overridden with the supplied `priority` value.

      Note that in case the priority is not applicable to a particular provider contract implemented by the class of the registered component, the supplied `priority` value will be ignored for that contract.

      Specified by:
        `register` in interface `Configurable<FeatureContext>`
      Parameters:
        `componentClass` - JAX-RS component class to be configured in the scope of this configurable context.
        `priority` - the overriding priority for the registered component and all the provider contracts the component implements.
      Returns:
        the updated configurable context.

    - #### register

          public FeatureContext register(Class<?> componentClass,
                                Class<?>... contracts)

      Description copied from interface: `Configurable`
      Register a class of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.

      This registration method provides the same functionality as `Configurable.register(Class)` except the JAX-RS component class is only registered as a provider of the listed extension provider or meta-provider `contracts`. All explicitly enumerated contract types must represent a class or an interface implemented or extended by the registered component. Contracts that are not `assignable from` the registered component class MUST be ignored and implementations SHOULD raise a warning to inform users about the ignored contract(s).

      Specified by:
        `register` in interface `Configurable<FeatureContext>`
      Parameters:
        `componentClass` - JAX-RS component class to be configured in the scope of this configurable context.
        `contracts` - the specific extension provider or meta-provider contracts implemented by the component for which the component should be registered. Implementations MUST ignore attempts to register a component class for an empty or `null` collection of contracts via this method and SHOULD raise a warning about such event.
      Returns:
        the updated configurable context.

    - #### register

          public FeatureContext register(Class<?> componentClass,
                                Map<Class<?>,Integer> contracts)

      Description copied from interface: `Configurable`
      Register a class of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.

      This registration method provides same functionality as `Configurable.register(Class, Class[])` except that any priority specified on the registered JAX-RS component class via `javax.annotation.Priority` annotation is overridden for each extension provider contract type separately with an integer priority value specified as a value in the supplied map of [contract type, priority] pairs.

      Note that in case a priority is not applicable to a provider contract registered for the JAX-RS component, the supplied priority value is ignored for such contract.

      Specified by:
        `register` in interface `Configurable<FeatureContext>`
      Parameters:
        `componentClass` - JAX-RS component class to be configured in the scope of this configurable context.
        `contracts` - map of the specific extension provider and meta-provider contracts and their associated priorities for which the JAX-RS component is registered. All contracts in the map must represent a class or an interface implemented or extended by the JAX-RS component. Contracts that are not `assignable from` the registered component class MUST be ignored and implementations SHOULD raise a warning to inform users about the ignored contract(s).
      Returns:
        the updated configurable context.

    - #### register

          public FeatureContext register(Object component)

      Description copied from interface: `Configurable`
      Register an instance of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context. Implementations SHOULD warn about and ignore registrations that do not conform to the requirements of supported JAX-RS component types in the given configurable context. Any subsequent registration attempts for a component type, for which a class or instance-based registration already exists in the system MUST be rejected by the JAX-RS implementation and a warning SHOULD be raised to inform the user about the rejected registration. The registered JAX-RS component is registered as a contract provider of all the recognized JAX-RS or implementation-specific extension contracts including meta-provider contracts, such as `Feature` or `DynamicFeature`.

      As opposed to components registered via `Configurable.register(Class)` method, the lifecycle of providers registered using this instance-based `register(...)` is not managed by JAX-RS runtime. The same registered component instance is used during the whole lifespan of the configurable context. Fields and properties of all registered JAX-RS component instances are injected with their declared dependencies (see `Context`) by the JAX-RS runtime prior to use.

      Specified by:
        `register` in interface `Configurable<FeatureContext>`
      Parameters:
        `component` - JAX-RS component instance to be configured in the scope of this configurable context.
      Returns:
        the updated configurable context.

    - #### register

          public FeatureContext register(Object component,
                                int priority)

      Description copied from interface: `Configurable`
      Register an instance of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.

      This registration method provides the same functionality as `Configurable.register(Object)` except that any priority specified on the registered JAX-RS component class via `javax.annotation.Priority` annotation is overridden with the supplied `priority` value.

      Note that in case the priority is not applicable to a particular provider contract implemented by the class of the registered component, the supplied `priority` value will be ignored for that contract.

      Specified by:
        `register` in interface `Configurable<FeatureContext>`
      Parameters:
        `component` - JAX-RS component instance to be configured in the scope of this configurable context.
        `priority` - the overriding priority for the registered component and all the provider contracts the component implements.
      Returns:
        the updated configurable context.

    - #### register

          public FeatureContext register(Object component,
                                Class<?>... contracts)

      Description copied from interface: `Configurable`
      Register an instance of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.

      This registration method provides the same functionality as `Configurable.register(Object)` except the JAX-RS component class is only registered as a provider of the listed extension provider or meta-provider `contracts`. All explicitly enumerated contract types must represent a class or an interface implemented or extended by the registered component. Contracts that are not `assignable from` the registered component class MUST be ignored and implementations SHOULD raise a warning to inform users about the ignored contract(s).

      Specified by:
        `register` in interface `Configurable<FeatureContext>`
      Parameters:
        `component` - JAX-RS component instance to be configured in the scope of this configurable context.
        `contracts` - the specific extension provider or meta-provider contracts implemented by the component for which the component should be registered. Implementations MUST ignore attempts to register a component class for an empty or `null` collection of contracts via this method and SHOULD raise a warning about such event.
      Returns:
        the updated configurable context.

    - #### register

          public FeatureContext register(Object component,
                                Map<Class<?>,Integer> contracts)

      Description copied from interface: `Configurable`
      Register an instance of a custom JAX-RS component (such as an extension provider or a `feature` meta-provider) to be instantiated and used in the scope of this configurable context.

      This registration method provides same functionality as `Configurable.register(Object, Class[])` except that any priority specified on the registered JAX-RS component class via `javax.annotation.Priority` annotation is overridden for each extension provider contract type separately with an integer priority value specified as a value in the supplied map of [contract type, priority] pairs.

      Note that in case a priority is not applicable to a provider contract registered for the JAX-RS component, the supplied priority value is ignored for such contract.

      Specified by:
        `register` in interface `Configurable<FeatureContext>`
      Parameters:
        `component` - JAX-RS component instance to be configured in the scope of this configurable context.
        `contracts` - map of the specific extension provider and meta-provider contracts and their associated priorities for which the JAX-RS component is registered. All contracts in the map must represent a class or an interface implemented or extended by the JAX-RS component. Contracts that are not `assignable from` the registered component class MUST be ignored and implementations SHOULD raise a warning to inform users about the ignored contract(s).
      Returns:
        the updated configurable context.

Copyright © 2014. All Rights Reserved.