org.jboss.resteasy.spi

## Class ResteasyProviderFactory

- java.lang.Object
- - javax.ws.rs.ext.RuntimeDelegate
  - - org.jboss.resteasy.spi.ResteasyProviderFactory

- All Implemented Interfaces:
    Configurable<ResteasyProviderFactory>, Configuration, Providers, HeaderValueProcessor
  Direct Known Subclasses:
    ThreadLocalResteasyProviderFactory

      public class ResteasyProviderFactory
      extends RuntimeDelegate
      implements Providers, HeaderValueProcessor, Configurable<ResteasyProviderFactory>, Configuration

  Version:
    $Revision: 1 $
  Author:
    Bill Burke

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected static class` | `ResteasyProviderFactory.SortedKey<T>` Allow us to sort message body implementations that are more specific for their types i.e.

    - ### Nested classes/interfaces inherited from class javax.ws.rs.ext.RuntimeDelegate

      `RuntimeDelegate.HeaderDelegate<T>`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected boolean` | `builtinsRegistered`
    `protected Map<Class<?>,Map<Class<?>,Integer>>` | `classContracts`
    `protected Set<DynamicFeature>` | `clientDynamicFeatures`
    `protected List<ClientErrorInterceptor>` | `clientErrorInterceptors`
    `protected Map<Class<?>,ClientExceptionMapper>` | `clientExceptionMappers`
    `protected InterceptorRegistry<ClientExecutionInterceptor>` | `clientExecutionInterceptorRegistry`
    `protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>>` | `clientMessageBodyReaders`
    `protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>>` | `clientMessageBodyWriters`
    `protected ReaderInterceptorRegistry` | `clientReaderInterceptorRegistry`
    `protected JaxrsInterceptorRegistry<ClientRequestFilter>` | `clientRequestFilters`
    `protected ClientResponseFilterRegistry` | `clientResponseFilters`
    `protected WriterInterceptorRegistry` | `clientWriterInterceptorRegistry`
    `protected ContainerRequestFilterRegistry` | `containerRequestFilterRegistry`
    `protected ContainerResponseFilterRegistry` | `containerResponseFilterRegistry`
    `protected Map<Class<?>,MediaTypeMap<ResteasyProviderFactory.SortedKey<ContextResolver>>>` | `contextResolvers`
    `protected static ThreadLocalStack<Map<Class<?>,Object>>` | `contextualData`
    `protected Set<Feature>` | `enabledFeatures`
    `protected Map<Class<?>,ExceptionMapper>` | `exceptionMappers`
    `protected Set<Class<?>>` | `featureClasses`
    `protected Set<Object>` | `featureInstances`
    `protected Map<Class<?>,RuntimeDelegate.HeaderDelegate>` | `headerDelegates`
    `protected InjectorFactory` | `injectorFactory`
    `protected static ResteasyProviderFactory` | `instance`
    `protected static int` | `maxForwards`
    `protected List<ParamConverterProvider>` | `paramConverterProviders`
    `protected ResteasyProviderFactory` | `parent`
    `protected static AtomicReference<ResteasyProviderFactory>` | `pfr`
    `protected LegacyPrecedence` | `precedence`
    `protected Map<String,Object>` | `properties`
    `protected Set<Class<?>>` | `providerClasses`
    `protected Set<Object>` | `providerInstances`
    `static boolean` | `registerBuiltinByDefault`
    `protected boolean` | `registerBuiltins`
    `protected Set<DynamicFeature>` | `serverDynamicFeatures`
    `protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>>` | `serverMessageBodyReaders`
    `protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>>` | `serverMessageBodyWriters`
    `protected ReaderInterceptorRegistry` | `serverReaderInterceptorRegistry`
    `protected WriterInterceptorRegistry` | `serverWriterInterceptorRegistry`
    `protected Map<Class<?>,StringConverter>` | `stringConverters`
    `protected Map<Class<?>,Class<? extends StringParameterUnmarshaller>>` | `stringParameterUnmarshallers`

    - ### Fields inherited from class javax.ws.rs.ext.RuntimeDelegate

      `JAXRS_RUNTIME_DELEGATE_PROPERTY`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ResteasyProviderFactory()`
    `ResteasyProviderFactory(ResteasyProviderFactory parent)` Copies a specific component registry when a new provider is added.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addClientErrorInterceptor(ClientErrorInterceptor handler)` Add a `ClientErrorInterceptor` to this provider factory instance.
    `void` | `addClientExceptionMapper(Class<? extends ClientExceptionMapper<?>> providerClass)`
    `void` | `addClientExceptionMapper(ClientExceptionMapper<?> provider)`
    `void` | `addClientExceptionMapper(ClientExceptionMapper<?> provider, Class<?> providerClass)`
    `void` | `addClientExceptionMapper(ClientExceptionMapper<?> provider, Type exceptionType)`
    `protected void` | `addClientMessageBodyReader(ResteasyProviderFactory.SortedKey<MessageBodyReader> key, Consumes consumeMime)`
    `protected void` | `addClientMessageBodyWriter(Produces consumeMime, ResteasyProviderFactory.SortedKey<MessageBodyWriter> key)`
    `static Map<Class<?>,Object>` | `addContextDataLevel()`
    `protected void` | `addContextResolver(Class<? extends ContextResolver> resolver, boolean builtin)`
    `protected void` | `addContextResolver(ContextResolver provider)`
    `protected void` | `addContextResolver(ContextResolver provider, boolean builtin)`
    `protected void` | `addContextResolver(ContextResolver provider, Class providerClass, boolean builtin)`
    `protected void` | `addContextResolver(ContextResolver provider, Type typeParameter, Class providerClass, boolean builtin)`
    `protected void` | `addExceptionMapper(Class<? extends ExceptionMapper> providerClass)`
    `protected void` | `addExceptionMapper(ExceptionMapper provider)`
    `protected void` | `addExceptionMapper(ExceptionMapper provider, Class providerClass)`
    `protected void` | `addExceptionMapper(ExceptionMapper provider, Type exceptionType)`
    `void` | `addHeaderDelegate(Class clazz, RuntimeDelegate.HeaderDelegate header)`
    `protected void` | `addMessageBodyReader(Class<? extends MessageBodyReader> provider, boolean isBuiltin)`
    `protected void` | `addMessageBodyReader(MessageBodyReader provider)`
    `protected void` | `addMessageBodyReader(MessageBodyReader provider, boolean isBuiltin)`
    `protected void` | `addMessageBodyReader(MessageBodyReader provider, Class<?> providerClass, boolean isBuiltin)` Specify the provider class.
    `protected void` | `addMessageBodyWriter(Class<? extends MessageBodyWriter> provider, boolean isBuiltin)`
    `protected void` | `addMessageBodyWriter(MessageBodyWriter provider)`
    `protected void` | `addMessageBodyWriter(MessageBodyWriter provider, Class<?> providerClass, boolean isBuiltin)` Specify the provider class.
    `protected void` | `addServerMessageBodyReader(ResteasyProviderFactory.SortedKey<MessageBodyReader> key, Consumes consumeMime)`
    `protected void` | `addServerMessageBodyWriter(Produces consumeMime, ResteasyProviderFactory.SortedKey<MessageBodyWriter> key)`
    `protected void` | `addStringConverter(Class<? extends StringConverter> resolver)`
    `protected void` | `addStringConverter(StringConverter provider)`
    `protected void` | `addStringConverter(StringConverter provider, Class providerClass)`
    `protected void` | `addStringConverter(StringConverter provider, Type typeParameter)`
    `void` | `addStringParameterUnmarshaller(Class<? extends StringParameterUnmarshaller> provider)`
    `void` | `appendInterceptorPrecedence(String precedence)` Append interceptor predence
    `static void` | `clearContextData()`
    `static void` | `clearInstanceIfEqual(ResteasyProviderFactory factory)`
    `<T> ConstructorInjector` | `createConstructorInjector(Class<? extends T> clazz)`
    `<T> T` | `createEndpoint(Application applicationConfig, Class<T> endpointType)` this is a spec method that is unsupported.
    `<T> RuntimeDelegate.HeaderDelegate<T>` | `createHeaderDelegate(Class<T> tClass)` Obtain an instance of a `RuntimeDelegate.HeaderDelegate` for the supplied class.
    `protected <T> RuntimeDelegate.HeaderDelegate<T>` | `createHeaderDelegateFromInterfaces(Class<?>[] interfaces)`
    `Link.Builder` | `createLinkBuilder()` Create a new instance of a `Link.Builder`.
    `<T> T` | `createProviderInstance(Class<? extends T> clazz)` Create an instance of a class using provider allocation rules of the specification as well as the InjectorFactory only does constructor injection
    `Response.ResponseBuilder` | `createResponseBuilder()` Create a new instance of a `Response.ResponseBuilder`.
    `<T> StringParameterUnmarshaller<T>` | `createStringParameterUnmarshaller(Class<T> clazz)`
    `UriBuilder` | `createUriBuilder()` Create a new instance of a `UriBuilder`.
    `Variant.VariantListBuilder` | `createVariantListBuilder()` Create a new instance of a `Variant.VariantListBuilder`.
    `Map<Class<?>,Map<Class<?>,Integer>>` | `getClassContracts()`
    `Set<Class<?>>` | `getClasses()` Get the immutable set of registered JAX-RS component (such as provider or `feature`) classes to be instantiated, injected and utilized in the scope of the configurable instance.
    `Set<DynamicFeature>` | `getClientDynamicFeatures()`
    `List<ClientErrorInterceptor>` | `getClientErrorInterceptors()` Return the list of currently registered `ClientErrorInterceptor` instances.
    `<T extends Throwable> ClientExceptionMapper<T>` | `getClientExceptionMapper(Class<T> type)`
    `protected Map<Class<?>,ClientExceptionMapper>` | `getClientExceptionMappers()`
    `InterceptorRegistry<ClientExecutionInterceptor>` | `getClientExecutionInterceptorRegistry()`
    `<T> MessageBodyReader<T>` | `getClientMessageBodyReader(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType)`
    `protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>>` | `getClientMessageBodyReaders()`
    `<T> MessageBodyWriter<T>` | `getClientMessageBodyWriter(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType)`
    `protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>>` | `getClientMessageBodyWriters()`
    `ReaderInterceptorRegistry` | `getClientReaderInterceptorRegistry()`
    `JaxrsInterceptorRegistry<ClientRequestFilter>` | `getClientRequestFilters()`
    `ClientResponseFilterRegistry` | `getClientResponseFilters()`
    `WriterInterceptorRegistry` | `getClientWriterInterceptorRegistry()`
    `MediaType` | `getConcreteMediaTypeFromMessageBodyWriters(Class type, Type genericType, Annotation[] annotations, MediaType mediaType)`
    `Configuration` | `getConfiguration()` Get a live view of an internal configuration state of this configurable instance.
    `ContainerRequestFilterRegistry` | `getContainerRequestFilterRegistry()`
    `ContainerResponseFilterRegistry` | `getContainerResponseFilterRegistry()`
    `static <T> T` | `getContextData(Class<T> type)`
    `static int` | `getContextDataLevelCount()`
    `static Map<Class<?>,Object>` | `getContextDataMap()`
    `<T> ContextResolver<T>` | `getContextResolver(Class<T> contextType, MediaType mediaType)` Get a context resolver for a particular type of context and media type.
    `protected Map<Class<?>,MediaTypeMap<ResteasyProviderFactory.SortedKey<ContextResolver>>>` | `getContextResolvers()`
    `List<ContextResolver>` | `getContextResolvers(Class<?> clazz, MediaType type)`
    `Map<Class<?>,Integer>` | `getContracts(Class<?> componentClass)` Get the extension contract registration information for a component of a given class.
    `Collection<Feature>` | `getEnabledFeatures()`
    `<T extends Throwable> ExceptionMapper<T>` | `getExceptionMapper(Class<T> type)` Get an exception mapping provider for a particular class of exception.
    `Map<Class<?>,ExceptionMapper>` | `getExceptionMappers()`
    `Set<Class<?>>` | `getFeatureClasses()`
    `Set<Object>` | `getFeatureInstances()`
    `RuntimeDelegate.HeaderDelegate` | `getHeaderDelegate(Class<?> aClass)` Checks to see if RuntimeDelegate is a ResteasyProviderFactory If it is, then use that, otherwise use this
    `protected Map<Class<?>,RuntimeDelegate.HeaderDelegate>` | `getHeaderDelegates()`
    `InjectorFactory` | `getInjectorFactory()`
    `static ResteasyProviderFactory` | `getInstance()` Initializes ResteasyProviderFactory singleton if not set
    `Set<Object>` | `getInstances()` Get the immutable set of registered JAX-RS component (such as provider or `feature`) instances to be utilized by the configurable instance.
    `<T> MessageBodyReader<T>` | `getMessageBodyReader(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType)` Always returns server MBRs
    `<T> MessageBodyWriter<T>` | `getMessageBodyWriter(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType)` Always gets server MBW
    `Map<String,Object>` | `getMutableProperties()`
    `ParamConverter` | `getParamConverter(Class clazz, Type genericType, Annotation[] annotations)`
    `protected List<ParamConverterProvider>` | `getParamConverterProviders()`
    `ResteasyProviderFactory` | `getParent()`
    `protected LegacyPrecedence` | `getPrecedence()`
    `protected int` | `getPriority(Integer override, Map<Class<?>,Integer> contracts, Class type, Class<?> component)`
    `Map<String,Object>` | `getProperties()` Get the immutable bag of configuration properties.
    `Object` | `getProperty(String name)` Get the value for the property with a given name.
    `Collection<String>` | `getPropertyNames()` Returns an immutable `collection` containing the property names available within the context of the current configuration instance.
    `Set<Class<?>>` | `getProviderClasses()` Copy
    `Set<Object>` | `getProviderInstances()` Copy
    `RuntimeType` | `getRuntimeType()` Get the runtime type of this configuration context.
    `Set<DynamicFeature>` | `getServerDynamicFeatures()`
    `<T> MessageBodyReader<T>` | `getServerMessageBodyReader(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType)`
    `protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>>` | `getServerMessageBodyReaders()`
    `<T> MessageBodyWriter<T>` | `getServerMessageBodyWriter(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType)`
    `protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>>` | `getServerMessageBodyWriters()`
    `ReaderInterceptorRegistry` | `getServerReaderInterceptorRegistry()`
    `WriterInterceptorRegistry` | `getServerWriterInterceptorRegistry()`
    `StringConverter` | `getStringConverter(Class<?> clazz)`
    `protected Map<Class<?>,StringConverter>` | `getStringConverters()`
    `protected Map<Class<?>,Class<? extends StringParameterUnmarshaller>>` | `getStringParameterUnmarshallers()`
    `protected void` | `initialize()`
    `<T> T` | `injectedInstance(Class<? extends T> clazz)` Property and constructor injection using the InjectorFactory
    `<T> T` | `injectedInstance(Class<? extends T> clazz, HttpRequest request, HttpResponse response)` Property and constructor injection using the InjectorFactory
    `void` | `injectProperties(Class declaring, Object obj)`
    `void` | `injectProperties(Object obj)`
    `void` | `injectProperties(Object obj, HttpRequest request, HttpResponse response)`
    `void` | `insertInterceptorPrecedenceAfter(String after, String newPrecedence)`
    `void` | `insertInterceptorPrecedenceBefore(String before, String newPrecedence)`
    `protected boolean` | `isA(Class target, Class type, Map<Class<?>,Integer> contracts)`
    `protected boolean` | `isA(Object target, Class type, Map<Class<?>,Integer> contracts)`
    `boolean` | `isBuiltinsRegistered()`
    `boolean` | `isEnabled(Class<? extends Feature> featureClass)` Check if a `feature` instance of `featureClass` class has been previously enabled in the runtime configuration context.
    `boolean` | `isEnabled(Feature feature)` Check if a particular `feature` instance has been previously enabled in the runtime configuration context.
    `boolean` | `isRegisterBuiltins()`
    `boolean` | `isRegistered(Class<?> componentClass)` Check if a JAX-RS component of the supplied `componentClass` class has been previously registered in the runtime configuration context.
    `boolean` | `isRegistered(Object component)` Check if a particular JAX-RS `component` instance (such as providers or `features`) has been previously registered in the runtime configuration context.
    `static ResteasyProviderFactory` | `peekInstance()` Will not initialize singleton if not set
    `static <T> T` | `popContextData(Class<T> type)`
    `ResteasyProviderFactory` | `property(String name, Object value)` Set the new configuration property, if already set, the existing value of the property will be updated.
    `static <T> void` | `pushContext(Class<T> type, T data)`
    `static void` | `pushContextDataMap(Map<Class<?>,Object> map)`
    `ResteasyProviderFactory` | `register(Class<?> providerClass)` 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.
    `ResteasyProviderFactory` | `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.
    `ResteasyProviderFactory` | `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.
    `ResteasyProviderFactory` | `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.
    `ResteasyProviderFactory` | `register(Object provider)` 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.
    `ResteasyProviderFactory` | `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.
    `ResteasyProviderFactory` | `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.
    `ResteasyProviderFactory` | `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.
    `protected void` | `registerDefaultInterceptorPrecedences()`
    `protected void` | `registerDefaultInterceptorPrecedences(InterceptorRegistry registry)`
    `void` | `registerProvider(Class provider)`
    `void` | `registerProvider(Class provider, boolean isBuiltin)` Register a @Provider class.
    `void` | `registerProvider(Class provider, Integer priorityOverride, boolean isBuiltin, Map<Class<?>,Integer> contracts)`
    `void` | `registerProviderInstance(Object provider)` Register a @Provider object.
    `void` | `registerProviderInstance(Object provider, Map<Class<?>,Integer> contracts, Integer priorityOverride, boolean builtIn)`
    `static void` | `removeContextDataLevel()`
    `protected <T> MessageBodyReader<T>` | `resolveMessageBodyReader(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType, MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>> availableReaders)`
    `protected <T> MessageBodyWriter<T>` | `resolveMessageBodyWriter(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType, MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>> availableWriters)`
    `void` | `setBuiltinsRegistered(boolean builtinsRegistered)`
    `void` | `setInjectorFactory(InjectorFactory injectorFactory)`
    `static void` | `setInstance(ResteasyProviderFactory factory)`
    `ResteasyProviderFactory` | `setProperties(Map<String,?> properties)`
    `static void` | `setRegisterBuiltinByDefault(boolean registerBuiltinByDefault)`
    `void` | `setRegisterBuiltins(boolean registerBuiltins)`
    `String` | `toHeaderString(Object object)` Convert an object to a header string.
    `String` | `toString(Object object, Class clazz, Type genericType, Annotation[] annotations)` Convert an object to a string.

    - ### Methods inherited from class javax.ws.rs.ext.RuntimeDelegate

      `setInstance`

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

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

- - ### Field Detail

    - #### pfr

          protected static AtomicReference<ResteasyProviderFactory> pfr

    - #### contextualData

          protected static ThreadLocalStack<Map<Class<?>,Object>> contextualData

    - #### maxForwards

          protected static int maxForwards

    - #### instance

          protected static volatile ResteasyProviderFactory instance

    - #### registerBuiltinByDefault

          public static boolean registerBuiltinByDefault

    - #### serverMessageBodyReaders

          protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>> serverMessageBodyReaders

    - #### serverMessageBodyWriters

          protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>> serverMessageBodyWriters

    - #### clientMessageBodyReaders

          protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>> clientMessageBodyReaders

    - #### clientMessageBodyWriters

          protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>> clientMessageBodyWriters

    - #### exceptionMappers

          protected Map<Class<?>,ExceptionMapper> exceptionMappers

    - #### clientExceptionMappers

          protected Map<Class<?>,ClientExceptionMapper> clientExceptionMappers

    - #### contextResolvers

          protected Map<Class<?>,MediaTypeMap<ResteasyProviderFactory.SortedKey<ContextResolver>>> contextResolvers

    - #### stringConverters

          protected Map<Class<?>,StringConverter> stringConverters

    - #### paramConverterProviders

          protected List<ParamConverterProvider> paramConverterProviders

    - #### stringParameterUnmarshallers

          protected Map<Class<?>,Class<? extends StringParameterUnmarshaller>> stringParameterUnmarshallers

    - #### classContracts

          protected Map<Class<?>,Map<Class<?>,Integer>> classContracts

    - #### headerDelegates

          protected Map<Class<?>,RuntimeDelegate.HeaderDelegate> headerDelegates

    - #### precedence

          protected LegacyPrecedence precedence

    - #### serverReaderInterceptorRegistry

          protected ReaderInterceptorRegistry serverReaderInterceptorRegistry

    - #### serverWriterInterceptorRegistry

          protected WriterInterceptorRegistry serverWriterInterceptorRegistry

    - #### containerRequestFilterRegistry

          protected ContainerRequestFilterRegistry containerRequestFilterRegistry

    - #### containerResponseFilterRegistry

          protected ContainerResponseFilterRegistry containerResponseFilterRegistry

    - #### clientRequestFilters

          protected JaxrsInterceptorRegistry<ClientRequestFilter> clientRequestFilters

    - #### clientResponseFilters

          protected ClientResponseFilterRegistry clientResponseFilters

    - #### clientReaderInterceptorRegistry

          protected ReaderInterceptorRegistry clientReaderInterceptorRegistry

    - #### clientWriterInterceptorRegistry

          protected WriterInterceptorRegistry clientWriterInterceptorRegistry

    - #### clientExecutionInterceptorRegistry

          protected InterceptorRegistry<ClientExecutionInterceptor> clientExecutionInterceptorRegistry

    - #### clientErrorInterceptors

          protected List<ClientErrorInterceptor> clientErrorInterceptors

    - #### builtinsRegistered

          protected boolean builtinsRegistered

    - #### registerBuiltins

          protected boolean registerBuiltins

    - #### injectorFactory

          protected InjectorFactory injectorFactory

    - #### parent

          protected ResteasyProviderFactory parent

    - #### serverDynamicFeatures

          protected Set<DynamicFeature> serverDynamicFeatures

    - #### clientDynamicFeatures

          protected Set<DynamicFeature> clientDynamicFeatures

    - #### enabledFeatures

          protected Set<Feature> enabledFeatures

    - #### properties

          protected Map<String,Object> properties

    - #### providerClasses

          protected Set<Class<?>> providerClasses

    - #### providerInstances

          protected Set<Object> providerInstances

    - #### featureClasses

          protected Set<Class<?>> featureClasses

    - #### featureInstances

          protected Set<Object> featureInstances

  - ### Constructor Detail

    - #### ResteasyProviderFactory

          public ResteasyProviderFactory()

    - #### ResteasyProviderFactory

          public ResteasyProviderFactory(ResteasyProviderFactory parent)

      Copies a specific component registry when a new provider is added. Otherwise delegates to the parent.
      Parameters:
        `parent` -

  - ### Method Detail

    - #### initialize

          protected void initialize()

    - #### getServerDynamicFeatures

          public Set<DynamicFeature> getServerDynamicFeatures()

    - #### getClientDynamicFeatures

          public Set<DynamicFeature> getClientDynamicFeatures()

    - #### getServerMessageBodyReaders

          protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>> getServerMessageBodyReaders()

    - #### getServerMessageBodyWriters

          protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>> getServerMessageBodyWriters()

    - #### getClientMessageBodyReaders

          protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>> getClientMessageBodyReaders()

    - #### getClientMessageBodyWriters

          protected MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>> getClientMessageBodyWriters()

    - #### getExceptionMappers

          public Map<Class<?>,ExceptionMapper> getExceptionMappers()

    - #### getClientExceptionMappers

          protected Map<Class<?>,ClientExceptionMapper> getClientExceptionMappers()

    - #### getContextResolvers

          protected Map<Class<?>,MediaTypeMap<ResteasyProviderFactory.SortedKey<ContextResolver>>> getContextResolvers()

    - #### getStringConverters

          protected Map<Class<?>,StringConverter> getStringConverters()

    - #### getParamConverterProviders

          protected List<ParamConverterProvider> getParamConverterProviders()

    - #### getStringParameterUnmarshallers

          protected Map<Class<?>,Class<? extends StringParameterUnmarshaller>> getStringParameterUnmarshallers()

    - #### getProviderClasses

          public Set<Class<?>> getProviderClasses()

      Copy
      Returns:

    - #### getProviderInstances

          public Set<Object> getProviderInstances()

      Copy
      Returns:

    - #### getClassContracts

          public Map<Class<?>,Map<Class<?>,Integer>> getClassContracts()

    - #### getPrecedence

          protected LegacyPrecedence getPrecedence()

    - #### getParent

          public ResteasyProviderFactory getParent()

    - #### registerDefaultInterceptorPrecedences

          protected void registerDefaultInterceptorPrecedences(InterceptorRegistry registry)

    - #### registerDefaultInterceptorPrecedences

          protected void registerDefaultInterceptorPrecedences()

    - #### appendInterceptorPrecedence

          public void appendInterceptorPrecedence(String precedence)

      Append interceptor predence
      Parameters:
        `precedence` -

    - #### insertInterceptorPrecedenceAfter

          public void insertInterceptorPrecedenceAfter(String after,
                                              String newPrecedence)

      Parameters:
        `after` - put newPrecedence after this
        `newPrecedence` -

    - #### insertInterceptorPrecedenceBefore

          public void insertInterceptorPrecedenceBefore(String before,
                                               String newPrecedence)

      Parameters:
        `before` - put newPrecedence before this
        `newPrecedence` -

    - #### pushContext

          public static <T> void pushContext(Class<T> type,
                             T data)

    - #### pushContextDataMap

          public static void pushContextDataMap(Map<Class<?>,Object> map)

    - #### getContextDataMap

          public static Map<Class<?>,Object> getContextDataMap()

    - #### getContextData

          public static <T> T getContextData(Class<T> type)

    - #### popContextData

          public static <T> T popContextData(Class<T> type)

    - #### clearContextData

          public static void clearContextData()

    - #### addContextDataLevel

          public static Map<Class<?>,Object> addContextDataLevel()

    - #### getContextDataLevelCount

          public static int getContextDataLevelCount()

    - #### removeContextDataLevel

          public static void removeContextDataLevel()

    - #### peekInstance

          public static ResteasyProviderFactory peekInstance()

      Will not initialize singleton if not set
      Returns:

    - #### clearInstanceIfEqual

          public static void clearInstanceIfEqual(ResteasyProviderFactory factory)

    - #### setInstance

          public static void setInstance(ResteasyProviderFactory factory)

    - #### getInstance

          public static ResteasyProviderFactory getInstance()

      Initializes ResteasyProviderFactory singleton if not set
      Returns:

    - #### setRegisterBuiltinByDefault

          public static void setRegisterBuiltinByDefault(boolean registerBuiltinByDefault)

    - #### isRegisterBuiltins

          public boolean isRegisterBuiltins()

    - #### setRegisterBuiltins

          public void setRegisterBuiltins(boolean registerBuiltins)

    - #### getInjectorFactory

          public InjectorFactory getInjectorFactory()

    - #### setInjectorFactory

          public void setInjectorFactory(InjectorFactory injectorFactory)

    - #### getClientExecutionInterceptorRegistry

          public InterceptorRegistry<ClientExecutionInterceptor> getClientExecutionInterceptorRegistry()

    - #### getServerReaderInterceptorRegistry

          public ReaderInterceptorRegistry getServerReaderInterceptorRegistry()

    - #### getServerWriterInterceptorRegistry

          public WriterInterceptorRegistry getServerWriterInterceptorRegistry()

    - #### getContainerRequestFilterRegistry

          public ContainerRequestFilterRegistry getContainerRequestFilterRegistry()

    - #### getContainerResponseFilterRegistry

          public ContainerResponseFilterRegistry getContainerResponseFilterRegistry()

    - #### getClientReaderInterceptorRegistry

          public ReaderInterceptorRegistry getClientReaderInterceptorRegistry()

    - #### getClientWriterInterceptorRegistry

          public WriterInterceptorRegistry getClientWriterInterceptorRegistry()

    - #### getClientRequestFilters

          public JaxrsInterceptorRegistry<ClientRequestFilter> getClientRequestFilters()

    - #### getClientResponseFilters

          public ClientResponseFilterRegistry getClientResponseFilters()

    - #### isBuiltinsRegistered

          public boolean isBuiltinsRegistered()

    - #### setBuiltinsRegistered

          public void setBuiltinsRegistered(boolean builtinsRegistered)

    - #### createUriBuilder

          public UriBuilder createUriBuilder()

      Description copied from class: `RuntimeDelegate`
      Create a new instance of a `UriBuilder`.
      Specified by:
        `createUriBuilder` in class `RuntimeDelegate`
      Returns:
        new `UriBuilder` instance.
      See Also:
        `UriBuilder`

    - #### createResponseBuilder

          public Response.ResponseBuilder createResponseBuilder()

      Description copied from class: `RuntimeDelegate`
      Create a new instance of a `Response.ResponseBuilder`.
      Specified by:
        `createResponseBuilder` in class `RuntimeDelegate`
      Returns:
        new `ResponseBuilder` instance.
      See Also:
        `Response.ResponseBuilder`

    - #### createVariantListBuilder

          public Variant.VariantListBuilder createVariantListBuilder()

      Description copied from class: `RuntimeDelegate`
      Create a new instance of a `Variant.VariantListBuilder`.
      Specified by:
        `createVariantListBuilder` in class `RuntimeDelegate`
      Returns:
        new `VariantListBuilder` instance.
      See Also:
        `Variant.VariantListBuilder`

    - #### createHeaderDelegate

          public <T> RuntimeDelegate.HeaderDelegate<T> createHeaderDelegate(Class<T> tClass)

      Description copied from class: `RuntimeDelegate`
      Obtain an instance of a `RuntimeDelegate.HeaderDelegate` for the supplied class. An implementation is required to support the following values for type: `CacheControl`, `Cookie`, `EntityTag`, `Link`, `NewCookie`, `MediaType` and `java.util.Date`.
      Specified by:
        `createHeaderDelegate` in class `RuntimeDelegate`
      Type Parameters:
        `T` - header type.
      Parameters:
        `tClass` - the class of the header.
      Returns:
        an instance of `HeaderDelegate` for the supplied type.
      See Also:
        `RuntimeDelegate.HeaderDelegate`

    - #### createHeaderDelegateFromInterfaces

          protected <T> RuntimeDelegate.HeaderDelegate<T> createHeaderDelegateFromInterfaces(Class<?>[] interfaces)

    - #### getHeaderDelegates

          protected Map<Class<?>,RuntimeDelegate.HeaderDelegate> getHeaderDelegates()

    - #### addHeaderDelegate

          public void addHeaderDelegate(Class clazz,
                               RuntimeDelegate.HeaderDelegate header)

    - #### addMessageBodyReader

          protected void addMessageBodyReader(Class<? extends MessageBodyReader> provider,
                                  boolean isBuiltin)

    - #### addMessageBodyReader

          protected void addMessageBodyReader(MessageBodyReader provider)

    - #### addMessageBodyReader

          protected void addMessageBodyReader(MessageBodyReader provider,
                                  boolean isBuiltin)

    - #### addMessageBodyReader

          protected void addMessageBodyReader(MessageBodyReader provider,
                                  Class<?> providerClass,
                                  boolean isBuiltin)

      Specify the provider class. This is there jsut in case the provider instance is a proxy. Proxies tend to lose generic type information
      Parameters:
        `provider` -
        `providerClass` -
        `isBuiltin` -

    - #### addServerMessageBodyReader

          protected void addServerMessageBodyReader(ResteasyProviderFactory.SortedKey<MessageBodyReader> key,
                                        Consumes consumeMime)

    - #### addClientMessageBodyReader

          protected void addClientMessageBodyReader(ResteasyProviderFactory.SortedKey<MessageBodyReader> key,
                                        Consumes consumeMime)

    - #### addMessageBodyWriter

          protected void addMessageBodyWriter(Class<? extends MessageBodyWriter> provider,
                                  boolean isBuiltin)

    - #### addMessageBodyWriter

          protected void addMessageBodyWriter(MessageBodyWriter provider)

    - #### addMessageBodyWriter

          protected void addMessageBodyWriter(MessageBodyWriter provider,
                                  Class<?> providerClass,
                                  boolean isBuiltin)

      Specify the provider class. This is there jsut in case the provider instance is a proxy. Proxies tend to lose generic type information
      Parameters:
        `provider` -
        `providerClass` -
        `isBuiltin` -

    - #### addServerMessageBodyWriter

          protected void addServerMessageBodyWriter(Produces consumeMime,
                                        ResteasyProviderFactory.SortedKey<MessageBodyWriter> key)

    - #### addClientMessageBodyWriter

          protected void addClientMessageBodyWriter(Produces consumeMime,
                                        ResteasyProviderFactory.SortedKey<MessageBodyWriter> key)

    - #### getServerMessageBodyReader

          public <T> MessageBodyReader<T> getServerMessageBodyReader(Class<T> type,
                                                            Type genericType,
                                                            Annotation[] annotations,
                                                            MediaType mediaType)

    - #### getMessageBodyReader

          public <T> MessageBodyReader<T> getMessageBodyReader(Class<T> type,
                                                      Type genericType,
                                                      Annotation[] annotations,
                                                      MediaType mediaType)

      Always returns server MBRs
      Specified by:
        `getMessageBodyReader` in interface `Providers`
      Type Parameters:
        `T` -
      Parameters:
        `type` - the class of the object that is to be read.
        `genericType` - the type of object to be produced. E.g. if the message body is to be converted into a method parameter, this will be the formal type of the method parameter as returned by `Class.getGenericParameterTypes`.
        `annotations` - an array of the annotations on the declaration of the artifact that will be initialized with the produced instance. E.g. if the message body is to be converted into a method parameter, this will be the annotations on that parameter returned by `Class.getParameterAnnotations`.
        `mediaType` - the media type of the data that will be read.
      Returns:

    - #### getClientMessageBodyReader

          public <T> MessageBodyReader<T> getClientMessageBodyReader(Class<T> type,
                                                            Type genericType,
                                                            Annotation[] annotations,
                                                            MediaType mediaType)

    - #### resolveMessageBodyReader

          protected <T> MessageBodyReader<T> resolveMessageBodyReader(Class<T> type,
                                                          Type genericType,
                                                          Annotation[] annotations,
                                                          MediaType mediaType,
                                                          MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyReader>> availableReaders)

    - #### addExceptionMapper

          protected void addExceptionMapper(Class<? extends ExceptionMapper> providerClass)

    - #### addExceptionMapper

          protected void addExceptionMapper(ExceptionMapper provider)

    - #### addExceptionMapper

          protected void addExceptionMapper(ExceptionMapper provider,
                                Class providerClass)

    - #### addExceptionMapper

          protected void addExceptionMapper(ExceptionMapper provider,
                                Type exceptionType)

    - #### addClientExceptionMapper

          public void addClientExceptionMapper(Class<? extends ClientExceptionMapper<?>> providerClass)

    - #### addClientExceptionMapper

          public void addClientExceptionMapper(ClientExceptionMapper<?> provider)

    - #### addClientExceptionMapper

          public void addClientExceptionMapper(ClientExceptionMapper<?> provider,
                                      Class<?> providerClass)

    - #### addClientExceptionMapper

          public void addClientExceptionMapper(ClientExceptionMapper<?> provider,
                                      Type exceptionType)

    - #### addClientErrorInterceptor

          public void addClientErrorInterceptor(ClientErrorInterceptor handler)

      Add a `ClientErrorInterceptor` to this provider factory instance. Duplicate handlers are ignored. (For Client Proxy API only)

    - #### getClientErrorInterceptors

          public List<ClientErrorInterceptor> getClientErrorInterceptors()

      Return the list of currently registered `ClientErrorInterceptor` instances.

    - #### addContextResolver

          protected void addContextResolver(Class<? extends ContextResolver> resolver,
                                boolean builtin)

    - #### addContextResolver

          protected void addContextResolver(ContextResolver provider)

    - #### addContextResolver

          protected void addContextResolver(ContextResolver provider,
                                boolean builtin)

    - #### addContextResolver

          protected void addContextResolver(ContextResolver provider,
                                Class providerClass,
                                boolean builtin)

    - #### addContextResolver

          protected void addContextResolver(ContextResolver provider,
                                Type typeParameter,
                                Class providerClass,
                                boolean builtin)

    - #### addStringConverter

          protected void addStringConverter(Class<? extends StringConverter> resolver)

    - #### addStringConverter

          protected void addStringConverter(StringConverter provider)

    - #### addStringConverter

          protected void addStringConverter(StringConverter provider,
                                Class providerClass)

    - #### addStringConverter

          protected void addStringConverter(StringConverter provider,
                                Type typeParameter)

    - #### addStringParameterUnmarshaller

          public void addStringParameterUnmarshaller(Class<? extends StringParameterUnmarshaller> provider)

    - #### getContextResolvers

          public List<ContextResolver> getContextResolvers(Class<?> clazz,
                                                  MediaType type)

    - #### getParamConverter

          public ParamConverter getParamConverter(Class clazz,
                                         Type genericType,
                                         Annotation[] annotations)

    - #### getStringConverter

          public StringConverter getStringConverter(Class<?> clazz)

    - #### createStringParameterUnmarshaller

          public <T> StringParameterUnmarshaller<T> createStringParameterUnmarshaller(Class<T> clazz)

    - #### registerProvider

          public void registerProvider(Class provider)

    - #### toString

          public String toString(Object object,
                        Class clazz,
                        Type genericType,
                        Annotation[] annotations)

      Convert an object to a string. First try StringConverter then, object.ToString()
      Parameters:
        `object` -
      Returns:

    - #### toHeaderString

          public String toHeaderString(Object object)

      Description copied from interface: `HeaderValueProcessor`
      Convert an object to a header string. First try StringConverter, then HeaderDelegate, then object.toString()
      Specified by:
        `toHeaderString` in interface `HeaderValueProcessor`
      Returns:

    - #### getHeaderDelegate

          public RuntimeDelegate.HeaderDelegate getHeaderDelegate(Class<?> aClass)

      Checks to see if RuntimeDelegate is a ResteasyProviderFactory If it is, then use that, otherwise use this
      Parameters:
        `aClass` -
      Returns:

    - #### registerProvider

          public void registerProvider(Class provider,
                              boolean isBuiltin)

      Register a @Provider class. Can be a MessageBodyReader/Writer or ExceptionMapper.
      Parameters:
        `provider` -

    - #### isA

          protected boolean isA(Class target,
                    Class type,
                    Map<Class<?>,Integer> contracts)

    - #### isA

          protected boolean isA(Object target,
                    Class type,
                    Map<Class<?>,Integer> contracts)

    - #### getPriority

          protected int getPriority(Integer override,
                        Map<Class<?>,Integer> contracts,
                        Class type,
                        Class<?> component)

    - #### registerProvider

          public void registerProvider(Class provider,
                              Integer priorityOverride,
                              boolean isBuiltin,
                              Map<Class<?>,Integer> contracts)

    - #### registerProviderInstance

          public void registerProviderInstance(Object provider)

      Register a @Provider object. Can be a MessageBodyReader/Writer or ExceptionMapper.
      Parameters:
        `provider` -

    - #### registerProviderInstance

          public void registerProviderInstance(Object provider,
                                      Map<Class<?>,Integer> contracts,
                                      Integer priorityOverride,
                                      boolean builtIn)

    - #### getExceptionMapper

          public <T extends Throwable> ExceptionMapper<T> getExceptionMapper(Class<T> type)

      Description copied from interface: `Providers`
      Get an exception mapping provider for a particular class of exception. Returns the provider whose generic type is the nearest superclass of `type`.
      Specified by:
        `getExceptionMapper` in interface `Providers`
      Type Parameters:
        `T` - type of the exception handled by the exception mapping provider.
      Parameters:
        `type` - the class of exception.
      Returns:
        an `ExceptionMapper` for the supplied type or `null` if none is found.

    - #### getClientExceptionMapper

          public <T extends Throwable> ClientExceptionMapper<T> getClientExceptionMapper(Class<T> type)

    - #### getConcreteMediaTypeFromMessageBodyWriters

          public MediaType getConcreteMediaTypeFromMessageBodyWriters(Class type,
                                                             Type genericType,
                                                             Annotation[] annotations,
                                                             MediaType mediaType)

    - #### getServerMessageBodyWriter

          public <T> MessageBodyWriter<T> getServerMessageBodyWriter(Class<T> type,
                                                            Type genericType,
                                                            Annotation[] annotations,
                                                            MediaType mediaType)

    - #### getMessageBodyWriter

          public <T> MessageBodyWriter<T> getMessageBodyWriter(Class<T> type,
                                                      Type genericType,
                                                      Annotation[] annotations,
                                                      MediaType mediaType)

      Always gets server MBW
      Specified by:
        `getMessageBodyWriter` in interface `Providers`
      Type Parameters:
        `T` -
      Parameters:
        `type` - the class of the object that is to be written.
        `genericType` - the type of object to be written. E.g. if the message body is to be produced from a field, this will be the declared type of the field as returned by `Field.getGenericType`.
        `annotations` - an array of the annotations on the declaration of the artifact that will be written. E.g. if the message body is to be produced from a field, this will be the annotations on that field returned by `Field.getDeclaredAnnotations`.
        `mediaType` - the media type of the data that will be written.
      Returns:

    - #### getClientMessageBodyWriter

          public <T> MessageBodyWriter<T> getClientMessageBodyWriter(Class<T> type,
                                                            Type genericType,
                                                            Annotation[] annotations,
                                                            MediaType mediaType)

    - #### resolveMessageBodyWriter

          protected <T> MessageBodyWriter<T> resolveMessageBodyWriter(Class<T> type,
                                                          Type genericType,
                                                          Annotation[] annotations,
                                                          MediaType mediaType,
                                                          MediaTypeMap<ResteasyProviderFactory.SortedKey<MessageBodyWriter>> availableWriters)

    - #### createEndpoint

          public <T> T createEndpoint(Application applicationConfig,
                             Class<T> endpointType)
                           throws IllegalArgumentException,
                                  UnsupportedOperationException

      this is a spec method that is unsupported. it is an optional method anyways.
      Specified by:
        `createEndpoint` in class `RuntimeDelegate`
      Type Parameters:
        `T` - endpoint type.
      Parameters:
        `applicationConfig` -
        `endpointType` -
      Returns:
      Throws:
        `IllegalArgumentException`
        `UnsupportedOperationException`

    - #### getContextResolver

          public <T> ContextResolver<T> getContextResolver(Class<T> contextType,
                                                  MediaType mediaType)

      Description copied from interface: `Providers`
      Get a context resolver for a particular type of context and media type. The set of resolvers is first filtered by comparing the supplied value of `mediaType` with the value of each resolver's `Produces`, ensuring the generic type of the context resolver is assignable to the supplied value of `contextType`, and eliminating those that do not match. If only one resolver matches the criteria then it is returned. If more than one resolver matches then the list of matching resolvers is ordered with those with the best matching values of `Produces` (x/y > x/* > */*) sorted first. A proxy is returned that delegates calls to `ContextResolver.getContext(java.lang.Class)` to each matching context resolver in order and returns the first non-null value it obtains or null if all matching context resolvers return null.
      Specified by:
        `getContextResolver` in interface `Providers`
      Type Parameters:
        `T` - type of the context.
      Parameters:
        `contextType` - the class of context desired.
        `mediaType` - the media type of data for which a context is required.
      Returns:
        a matching context resolver instance or `null` if no matching context providers are found.

    - #### createProviderInstance

          public <T> T createProviderInstance(Class<? extends T> clazz)

      Create an instance of a class using provider allocation rules of the specification as well as the InjectorFactory

      only does constructor injection
      Type Parameters:
        `T` -
      Parameters:
        `clazz` -
      Returns:

    - #### createConstructorInjector

          public <T> ConstructorInjector createConstructorInjector(Class<? extends T> clazz)

    - #### injectedInstance

          public <T> T injectedInstance(Class<? extends T> clazz)

      Property and constructor injection using the InjectorFactory
      Type Parameters:
        `T` -
      Parameters:
        `clazz` -
      Returns:

    - #### injectedInstance

          public <T> T injectedInstance(Class<? extends T> clazz,
                               HttpRequest request,
                               HttpResponse response)

      Property and constructor injection using the InjectorFactory
      Type Parameters:
        `T` -
      Parameters:
        `clazz` -
      Returns:

    - #### injectProperties

          public void injectProperties(Class declaring,
                              Object obj)

    - #### injectProperties

          public void injectProperties(Object obj)

    - #### injectProperties

          public void injectProperties(Object obj,
                              HttpRequest request,
                              HttpResponse response)

    - #### getMutableProperties

          public Map<String,Object> getMutableProperties()

    - #### getProperties

          public Map<String,Object> getProperties()

      Description copied from interface: `Configuration`
      Get the immutable bag of configuration properties.
      Specified by:
        `getProperties` in interface `Configuration`
      Returns:
        the immutable view of configuration properties.

    - #### getProperty

          public Object getProperty(String name)

      Description copied from interface: `Configuration`
      Get the value for the property with a given name.
      Specified by:
        `getProperty` in interface `Configuration`
      Parameters:
        `name` - property name.
      Returns:
        the property value for the specified property name or `null` if the property with such name is not configured.

    - #### setProperties

          public ResteasyProviderFactory setProperties(Map<String,?> properties)

    - #### property

          public ResteasyProviderFactory 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<ResteasyProviderFactory>`
      Parameters:
        `name` - property name.
        `value` - (new) property value. `null` value removes the property with the given name.
      Returns:
        the updated configurable instance.

    - #### getEnabledFeatures

          public Collection<Feature> getEnabledFeatures()

    - #### getFeatureClasses

          public Set<Class<?>> getFeatureClasses()

    - #### getFeatureInstances

          public Set<Object> getFeatureInstances()

    - #### register

          public ResteasyProviderFactory register(Class<?> providerClass)

      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<ResteasyProviderFactory>`
      Parameters:
        `providerClass` - JAX-RS component class to be configured in the scope of this configurable context.
      Returns:
        the updated configurable context.

    - #### register

          public ResteasyProviderFactory register(Object provider)

      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<ResteasyProviderFactory>`
      Parameters:
        `provider` - JAX-RS component instance to be configured in the scope of this configurable context.
      Returns:
        the updated configurable context.

    - #### register

          public ResteasyProviderFactory 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<ResteasyProviderFactory>`
      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 ResteasyProviderFactory 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<ResteasyProviderFactory>`
      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 ResteasyProviderFactory 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<ResteasyProviderFactory>`
      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 ResteasyProviderFactory 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<ResteasyProviderFactory>`
      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 ResteasyProviderFactory 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<ResteasyProviderFactory>`
      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 ResteasyProviderFactory 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<ResteasyProviderFactory>`
      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.

    - #### 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<ResteasyProviderFactory>`
      Returns:
        configuration live view of the internal configuration state.

    - #### getRuntimeType

          public RuntimeType getRuntimeType()

      Description copied from interface: `Configuration`
      Get the runtime type of this configuration context.
      Specified by:
        `getRuntimeType` in interface `Configuration`
      Returns:
        configuration context runtime type.

    - #### getPropertyNames

          public Collection<String> getPropertyNames()

      Description copied from interface: `Configuration`
      Returns an immutable `collection` containing the property names available within the context of the current configuration instance.

      Use the `Configuration.getProperty(java.lang.String)` method with a property name to get the value of a property.

      Specified by:
        `getPropertyNames` in interface `Configuration`
      Returns:
        an immutable `collection` of property names.
      See Also:
        `Configuration.getProperty(java.lang.String)`

    - #### isEnabled

          public boolean isEnabled(Feature feature)

      Description copied from interface: `Configuration`
      Check if a particular `feature` instance has been previously enabled in the runtime configuration context.

      Method returns `true` only in case an instance equal to the `feature` instance is already present among the features previously successfully enabled in the configuration context.

      Specified by:
        `isEnabled` in interface `Configuration`
      Parameters:
        `feature` - a feature instance to test for.
      Returns:
        `true` if the feature instance has been previously enabled in this configuration context, `false` otherwise.

    - #### isEnabled

          public boolean isEnabled(Class<? extends Feature> featureClass)

      Description copied from interface: `Configuration`
      Check if a `feature` instance of `featureClass` class has been previously enabled in the runtime configuration context.

      Method returns `true` in case any instance of the `featureClass` class is already present among the features previously successfully enabled in the configuration context.

      Specified by:
        `isEnabled` in interface `Configuration`
      Parameters:
        `featureClass` - a feature class to test for.
      Returns:
        `true` if a feature of a given class has been previously enabled in this configuration context, `false` otherwise.

    - #### isRegistered

          public boolean isRegistered(Object component)

      Description copied from interface: `Configuration`
      Check if a particular JAX-RS `component` instance (such as providers or `features`) has been previously registered in the runtime configuration context.

      Method returns `true` only in case an instance equal to the `component` instance is already present among the components previously registered in the configuration context.

      Specified by:
        `isRegistered` in interface `Configuration`
      Parameters:
        `component` - a component instance to test for.
      Returns:
        `true` if the component instance has been previously registered in this configuration context, `false` otherwise.
      See Also:
        `Configuration.isEnabled(Feature)`

    - #### isRegistered

          public boolean isRegistered(Class<?> componentClass)

      Description copied from interface: `Configuration`
      Check if a JAX-RS component of the supplied `componentClass` class has been previously registered in the runtime configuration context.

      Method returns `true` in case a component of the supplied `componentClass` class is already present among the previously registered component classes or instances in the configuration context.

      Specified by:
        `isRegistered` in interface `Configuration`
      Parameters:
        `componentClass` - a component class to test for.
      Returns:
        `true` if a component of a given class has been previously registered in this configuration context, `false` otherwise.
      See Also:
        `Configuration.isEnabled(Class)`

    - #### getContracts

          public Map<Class<?>,Integer> getContracts(Class<?> componentClass)

      Description copied from interface: `Configuration`
      Get the extension contract registration information for a component of a given class. For component classes that are not configured in this configuration context the method returns an empty `Map`. Method does not return `null`.
      Specified by:
        `getContracts` in interface `Configuration`
      Returns:
        map of extension contracts and their priorities for which the component class is registered. May return an empty map in case the component has not been registered for any extension contract supported by the implementation.

    - #### getClasses

          public Set<Class<?>> getClasses()

      Description copied from interface: `Configuration`
      Get the immutable set of registered JAX-RS component (such as provider or `feature`) classes to be instantiated, injected and utilized in the scope of the configurable instance.

      For each component type, there can be only a single class-based or instance-based registration present in the configuration context at any given time.

      Specified by:
        `getClasses` in interface `Configuration`
      Returns:
        the immutable set of registered JAX-RS component classes. The returned value may be empty but will never be `null`.
      See Also:
        `Configuration.getInstances()`

    - #### getInstances

          public Set<Object> getInstances()

      Description copied from interface: `Configuration`
      Get the immutable set of registered JAX-RS component (such as provider or `feature`) instances to be utilized by the configurable instance. Fields and properties of returned instances are injected with their declared dependencies (see `Context`) by the runtime prior to use.

      For each component type, there can be only a single class-based or instance-based registration present in the configuration context at any given time.

      Specified by:
        `getInstances` in interface `Configuration`
      Returns:
        the immutable set of registered JAX-RS component instances. The returned value may be empty but will never be `null`.
      See Also:
        `Configuration.getClasses()`

    - #### createLinkBuilder

          public Link.Builder createLinkBuilder()

      Description copied from class: `RuntimeDelegate`
      Create a new instance of a `Link.Builder`.
      Specified by:
        `createLinkBuilder` in class `RuntimeDelegate`
      Returns:
        new `Link.Builder` instance.
      See Also:
        `Link.Builder`

Copyright © 2014. All Rights Reserved.