* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

*

* Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.

*

* The contents of this file are subject to the terms of either the GNU

* General Public License Version 2 only ("GPL") or the Common Development

* and Distribution License("CDDL") (collectively, the "License").  You

* may not use this file except in compliance with the License.  You can

* obtain a copy of the License at

* http://glassfish.java.net/public/CDDL+GPL_1_1.html

* or packager/legal/LICENSE.txt.  See the License for the specific

* language governing permissions and limitations under the License.

*

* When distributing the software, include this License Header Notice in each

* file and include the License file at packager/legal/LICENSE.txt.

*

* GPL Classpath Exception:

* Oracle designates this particular file as subject to the "Classpath"

* exception as provided by Oracle in the GPL Version 2 section of the License

* file that accompanied this code.

*

* Modifications:

* If applicable, add the following below the License Header, with the fields

* enclosed by brackets [] replaced by your own identifying information:

* "Portions Copyright [year] [name of copyright owner]"

*

* Contributor(s):

* If you wish your version of this file to be governed by only the CDDL or

* only the GPL Version 2, indicate your decision by adding "[Contributor]

* elects to include this software in this distribution under the [CDDL or GPL

* Version 2] license."  If you don't indicate a single choice of license, a

* recipient has the option to distribute your version of this file under

* either the CDDL, the GPL Version 2 or to extend the choice of license to

* its licensees as provided above.  However, if you add GPL Version 2 code

* and therefore, elected the GPL Version 2 license, then the option applies

* only if the new code is made subject to such option by the copyright

* holder.

*/

* A Web application that contains a set of resources, each referenced by

* an absolute URI template.

*

* @author Paul.Sandoz@Sun.Com

*/

    private static final Logger LOGGER = Logger.getLogger(WebApplicationImpl.class.getName());

    private final Map<Class, AbstractResource> abstractResourceMap =

            new HashMap<Class, AbstractResource>();

    private final ConcurrentMap<Class, UriRules<UriRule>> rulesMap =

            new ConcurrentHashMap<Class, UriRules<UriRule>>();

    private final ConcurrentMap<Class, ResourceComponentProvider> providerMap =

            new ConcurrentHashMap<Class, ResourceComponentProvider>();

    private static class ClassAnnotationKey {

        private final Class c;

        private final Set<Annotation> as;

        public ClassAnnotationKey(Class c, Annotation[] as) {

            this.c = c;

            this.as = new HashSet<Annotation>(Arrays.asList(as));

        }

        @Override

        public int hashCode() {

            int hash = 5;

            hash = 67 * hash + (this.c != null ? this.c.hashCode() : 0);

            hash = 67 * hash + (this.as != null ? this.as.hashCode() : 0);

            return hash;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj == null) {

                return false;

            }

            if (getClass() != obj.getClass()) {

                return false;

            }

            final ClassAnnotationKey other = (ClassAnnotationKey) obj;

            if (this.c != other.c && (this.c == null || !this.c.equals(other.c))) {

                return false;

            }

            if (this.as != other.as && (this.as == null || !this.as.equals(other.as))) {

                return false;

            }

            return true;

        }

    }

    private final ConcurrentMap<ClassAnnotationKey, ResourceComponentProvider> providerWithAnnotationKeyMap =

            new ConcurrentHashMap<ClassAnnotationKey, ResourceComponentProvider>();

    private final ThreadLocalHttpContext context;

    private final CloseableServiceFactory closeableFactory;

    private boolean initiated;

    private ResourceConfig resourceConfig;

    private RootResourceClassesRule rootsRule;

    private ServerInjectableProviderFactory injectableFactory;

    private ProviderFactory cpFactory;

    private ResourceFactory rcpFactory;

    private IoCComponentProviderFactory provider;

    private List<IoCComponentProviderFactory> providerFactories;

    private Providers providers;

    private MessageBodyFactory bodyFactory;

    private StringReaderFactory stringReaderFactory;

    private TemplateContext templateContext;

    private ExceptionMapperFactory exceptionFactory;

    private ResourceMethodDispatchProvider dispatcherFactory;

    private ResourceContext resourceContext;

    private Set<AbstractResource> abstractRootResources;

    private Map<String, AbstractResource> explicitAbstractRootResources;

    private final AbstractResourceModelContext armContext = new AbstractResourceModelContext() {

            @Override

            public Set<AbstractResource> getAbstractRootResources() {

                return abstractRootResources;

            }

        };

    private FilterFactory filterFactory;

    private WadlFactory wadlFactory;

    private boolean isTraceEnabled;

    private RequestListener requestListener;

    private DispatchingListenerProxy dispatchingListener;

    private ResponseListener responseListener;

    public WebApplicationImpl() {

        this.context = new ThreadLocalHttpContext();

        InvocationHandler requestHandler = new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                try {

                    return method.invoke(context.getRequest(), args);

                } catch (IllegalAccessException ex) {

                    throw new IllegalStateException(ex);

                } catch (InvocationTargetException ex) {

                    throw ex.getTargetException();

                }

            }

        };

        InvocationHandler uriInfoHandler = new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                try {

                    return method.invoke(context.getUriInfo(), args);

                } catch (IllegalAccessException ex) {

                    throw new IllegalStateException(ex);

                } catch (InvocationTargetException ex) {

                    throw ex.getTargetException();

                }

            }

        };

        // Create injectable provider factory

        this.injectableFactory = new ServerInjectableProviderFactory();

        injectableFactory.add(new ContextInjectableProvider<InjectableProviderContext>(

                InjectableProviderContext.class, injectableFactory));

        injectableFactory.add(new ContextInjectableProvider<ServerInjectableProviderContext>(

                ServerInjectableProviderContext.class, injectableFactory));

        // Add proxied injectables

        final Map<Type, Object> m = new HashMap<Type, Object>();

        m.put(HttpContext.class, context);

        m.put(HttpHeaders.class, createProxy(HttpHeaders.class, requestHandler));

        m.put(UriInfo.class, createProxy(UriInfo.class, uriInfoHandler));

        m.put(ExtendedUriInfo.class, createProxy(ExtendedUriInfo.class, uriInfoHandler));

        m.put(Request.class, createProxy(Request.class, requestHandler));

        m.put(SecurityContext.class, createProxy(SecurityContext.class, requestHandler));

        injectableFactory.add(new InjectableProvider<Context, Type>() {

            @Override

            public ComponentScope getScope() {

                return ComponentScope.Singleton;

            }

            @Override

            public Injectable getInjectable(ComponentContext ic, Context a, Type c) {

                final Object o = m.get(c);

                if (o != null) {

                    return new Injectable() {

                        @Override

                        public Object getValue() {

                            return o;

                        }

                    };

                } else

                    return null;

            }

        });

        injectableFactory.add(new InjectableProvider<Context, Type>() {

            @Override

            public ComponentScope getScope() {

                return ComponentScope.Singleton;

            }

            @Override

            public Injectable<Injectable> getInjectable(ComponentContext ic, Context a, Type c) {

                if (c instanceof ParameterizedType) {

                    ParameterizedType pt = (ParameterizedType)c;

                    if (pt.getRawType() == Injectable.class) {

                        if (pt.getActualTypeArguments().length == 1) {

                            final Injectable<?> i = injectableFactory.getInjectable(

                                    a.annotationType(),

                                    ic,

                                    a,

                                    pt.getActualTypeArguments()[0],

                                    ComponentScope.PERREQUEST_UNDEFINED_SINGLETON);

                            if (i == null)

                                return null;

                            return new Injectable<Injectable>() {

                                @Override

                                public Injectable getValue() {

                                    return i;

                                }

                            };

                        }

                    }

                }

                return null;

            }

        });

        injectableFactory.add(new InjectableProvider<Inject, Type>() {

            @Override

            public ComponentScope getScope() {

                return ComponentScope.Singleton;

            }

            @Override

            public Injectable<Injectable> getInjectable(ComponentContext ic, Inject a, Type c) {

                if (c instanceof ParameterizedType) {

                    ParameterizedType pt = (ParameterizedType)c;

                    if (pt.getRawType() == Injectable.class) {

                        if (pt.getActualTypeArguments().length == 1) {

                            final Injectable<?> i = injectableFactory.getInjectable(

                                    a.annotationType(),

                                    ic,

                                    a,

                                    pt.getActualTypeArguments()[0],

                                    ComponentScope.PERREQUEST_UNDEFINED_SINGLETON);

                            if (i == null)

                                return null;

                            return new Injectable<Injectable>() {

                                @Override

                                public Injectable getValue() {

                                    return i;

                                }

                            };

                        }

                    }

                }

                return null;

            }

        });

        injectableFactory.add(new InjectableProvider<InjectParam, Type>() {

            @Override

            public ComponentScope getScope() {

                return ComponentScope.Singleton;

            }

            @Override

            public Injectable<Injectable> getInjectable(ComponentContext ic, InjectParam a, Type c) {

                if (c instanceof ParameterizedType) {

                    ParameterizedType pt = (ParameterizedType)c;

                    if (pt.getRawType() == Injectable.class) {

                        if (pt.getActualTypeArguments().length == 1) {

                            final Injectable<?> i = injectableFactory.getInjectable(

                                    a.annotationType(),

                                    ic,

                                    a,

                                    pt.getActualTypeArguments()[0],

                                    ComponentScope.PERREQUEST_UNDEFINED_SINGLETON);

                            if (i == null)

                                return null;

                            return new Injectable<Injectable>() {

                                @Override

                                public Injectable getValue() {

                                    return i;

                                }

                            };

                        }

                    }

                }

                return null;

            }

        });

        closeableFactory = new CloseableServiceFactory(context);

        injectableFactory.add(closeableFactory);

    }

    private class ComponentProcessorImpl implements IoCComponentProcessor {

        private final ResourceComponentInjector rci;

        ComponentProcessorImpl(ResourceComponentInjector rci) {

            this.rci = rci;

        }

        @Override

        public void preConstruct() {

        }

        @Override

        public void postConstruct(Object o) {

            rci.inject(context.get(), o);

        }

    }

    private static final IoCComponentProcessor NULL_COMPONENT_PROCESSOR = new IoCComponentProcessor() {

        @Override

        public void preConstruct() {

        }

        @Override

        public void postConstruct(Object o) {

        }

    };

    private class ComponentProcessorFactoryImpl implements IoCComponentProcessorFactory {

        private final ConcurrentMap<Class, IoCComponentProcessor> componentProcessorMap =

                new ConcurrentHashMap<Class, IoCComponentProcessor>();

        @Override

        public ComponentScope getScope(Class c) {

            return rcpFactory.getScope(c);

        }

        @Override

        public IoCComponentProcessor get(final Class c, final ComponentScope scope) {

            IoCComponentProcessor cp = componentProcessorMap.get(c);

            if (cp != null) {

                return (cp == NULL_COMPONENT_PROCESSOR) ? null : cp;

            }

            synchronized (abstractResourceMap) {

                cp = componentProcessorMap.get(c);

                if (cp != null) {

                    return (cp == NULL_COMPONENT_PROCESSOR) ? null : cp;

                }

                final ResourceComponentInjector rci = Errors.processWithErrors(new Errors.Closure<ResourceComponentInjector>() {

                    @Override

                    public ResourceComponentInjector f() {

                        return new ResourceComponentInjector(

                                injectableFactory, scope, getAbstractResource(c));

                    }

                });

                if (rci.hasInjectableArtifacts()) {

                    cp = new ComponentProcessorImpl(rci);

                    componentProcessorMap.put(c, cp);

                } else {

                    cp = null;

                    componentProcessorMap.put(c, NULL_COMPONENT_PROCESSOR);

                }

            }

            return cp;

        }

    }

    @Override

    public FeaturesAndProperties getFeaturesAndProperties() {

        return resourceConfig;

    }

    @Override

    public WebApplication clone() {

        WebApplicationImpl wa = new WebApplicationImpl();

        wa.initiate(resourceConfig, provider);

        return wa;

    }

    /* package */ UriRules<UriRule> getUriRules(final Class c) {

        assert c != null;

        // Try the non-blocking read, the most common operation

        UriRules<UriRule> r = rulesMap.get(c);

        if (r != null) {

            return r;

        }

        // Not present use a synchronized block to ensure that only one

        // instance is created and put to the map

        synchronized (abstractResourceMap) {

            // One or more threads may have been blocking on the synchronized

            // block, re-check the map

            r = rulesMap.get(c);

            if (r != null) {

                return r;

            }

            r = Errors.processWithErrors(new Errors.Closure<ResourceUriRules>() {

                @Override

                public ResourceUriRules f() {

                    return newResourceUriRules(getAbstractResource(c));

                }

            }).getRules();

            rulesMap.put(c, r);

        }

        return r;

    }

    /* package */ ResourceComponentProvider getResourceComponentProvider(final Class c) {

        assert c != null;

        // Try the non-blocking read, the most common operation

        ResourceComponentProvider rcp = providerMap.get(c);

        if (rcp != null) {

            return rcp;

        }

        // Not present use a synchronized block to ensure that only one

        // instance is created and put to the map

        synchronized (abstractResourceMap) {

            // One or more threads may have been blocking on the synchronized

            // block, re-check the map

            rcp = providerMap.get(c);

            if (rcp != null) {

                return rcp;

            }

            final ResourceComponentProvider _rcp = rcp = rcpFactory.getComponentProvider(null, c);

            Errors.processWithErrors(new Errors.Closure<Void>() {

                @Override

                public Void f() {

                    _rcp.init(getAbstractResource(c));

                    return null;

                }

            });

            providerMap.put(c, rcp);

        }

        return rcp;

    }

    /* package */ ResourceComponentProvider getResourceComponentProvider(final ComponentContext cc, final Class c) {

        assert c != null;

        if (cc == null || cc.getAnnotations().length == 0)

            return getResourceComponentProvider(c);

        if (cc.getAnnotations().length == 1) {

            final Annotation a = cc.getAnnotations()[0];

            if (a.annotationType() == Inject.class) {

                final Inject i = Inject.class.cast(a);

                final String value = (i.value() != null)

                        ? i.value().trim()

                        : "";

                if (value.isEmpty())

                    return getResourceComponentProvider(c);

            } else if (a.annotationType() == InjectParam.class) {

                final InjectParam i = InjectParam.class.cast(a);

                final String value = (i.value() != null)

                        ? i.value().trim()

                        : "";

                if (value.isEmpty())

                    return getResourceComponentProvider(c);

            }

        }

        final ClassAnnotationKey cak = new ClassAnnotationKey(c,

                cc.getAnnotations());

        // Try the non-blocking read, the most common operation

        ResourceComponentProvider rcp = providerWithAnnotationKeyMap.get(cak);

        if (rcp != null) {

            return rcp;

        }

        // Not present use a synchronized block to ensure that only one

        // instance is created and put to the map

        synchronized (abstractResourceMap) {

            // One or more threads may have been blocking on the synchronized

            // block, re-check the map

            rcp = providerWithAnnotationKeyMap.get(cak);

            if (rcp != null) {

                return rcp;

            }

            final ResourceComponentProvider _rcp = rcp = rcpFactory.getComponentProvider(cc, c);

            Errors.processWithErrors(new Errors.Closure<Void>() {

                @Override

                public Void f() {

                    _rcp.init(getAbstractResource(c));

                    return null;

                }

            });

            providerWithAnnotationKeyMap.put(cak, rcp);

        }

        return rcp;

    }

    /* package */ void initiateResource(AbstractResource ar) {

        initiateResource(ar.getResourceClass());

    }

    /* package */ void initiateResource(Class c) {

        getUriRules(c);

        getResourceComponentProvider(c);

    }

    /* package */ void initiateResource(AbstractResource ar, final Object resource) {

        final Class c = ar.getResourceClass();

        getUriRules(c);

        if (!providerMap.containsKey(c)) {

            providerMap.put(c, new ResourceComponentProvider() {

                @Override

                public void init(AbstractResource abstractResource) {

                }

                @Override

                public ComponentScope getScope() {

                    return ComponentScope.Singleton;

                }

                @Override

                public Object getInstance(HttpContext hc) {

                    return getInstance();

                }

                @Override

                public void destroy() {

                }

                @Override

                public Object getInstance() {

                    return resource;

                }

            });

        }

    }

    /* package */ Set<AbstractResource> getAbstractRootResources() {

        return abstractRootResources;

    }

    /* package */ Map<String, AbstractResource> getExplicitAbstractRootResources() {

        return explicitAbstractRootResources;

    }

    private ResourceUriRules newResourceUriRules(final AbstractResource ar) {

        assert null != ar;

        BasicValidator validator = new BasicValidator();

        validator.validate(ar);

        for (ResourceModelIssue issue : validator.getIssueList()) {

            Errors.error(issue.getMessage(), issue.isFatal());

        }

        return new ResourceUriRules(

                resourceConfig,

                getDispatchProvider(),

                injectableFactory,

                filterFactory,

                wadlFactory,

                dispatchingListener,

                ar);

    }

    protected ResourceMethodDispatchProvider getDispatchProvider() {

        return dispatcherFactory;

    }

    @Override

    public RequestListener getRequestListener() {

        return requestListener;

    }

    @Override

    public DispatchingListener getDispatchingListener() {

        return dispatchingListener;

    }

    @Override

    public ResponseListener getResponseListener() {

        return responseListener;

    }

    /* package */ AbstractResource getAbstractResource(Object o) {

        return getAbstractResource(o.getClass());

    }

    /* package */ AbstractResource getAbstractResource(Class c) {

        AbstractResource ar = abstractResourceMap.get(c);

        if (ar == null) {

            ar = IntrospectionModeller.createResource(c);

            abstractResourceMap.put(c, ar);

        }

        return ar;

    }

    private static class ContextInjectableProvider<T> extends

            SingletonTypeInjectableProvider<Context, T> {

        ContextInjectableProvider(Type type, T instance) {

            super(type, instance);

        }

    }

    @Override

    public boolean isInitiated () {

        return initiated;

    }

    @Override

    public void initiate(ResourceConfig resourceConfig) {

        initiate(resourceConfig, null);

    }

    @Override

    public void initiate(final ResourceConfig rc, final IoCComponentProviderFactory _provider) {

        Errors.processWithErrors(new Errors.Closure<Void>() {

            @Override

            public Void f() {

                Errors.setReportMissingDependentFieldOrMethod(false);

                _initiate(rc, _provider);

                return null;

            }

        });

    }

    private void _initiate(final ResourceConfig rc, final IoCComponentProviderFactory _provider) {

        if (rc == null) {

            throw new IllegalArgumentException("ResourceConfig instance MUST NOT be null");

        }

        if (initiated) {

            throw new ContainerException(ImplMessages.WEB_APP_ALREADY_INITIATED());

        }

        this.initiated = true;

        LOGGER.info("Initiating Jersey application, version '" + BuildId.getBuildId() + "'");

        // If there are components defined in jaxrs-components then

        // wrap resource config with appended set of classes

        Class<?>[] components = ServiceFinder.find("jersey-server-components").toClassArray();

        if (components.length > 0) {

            if (LOGGER.isLoggable(Level.INFO)) {

                StringBuilder b = new StringBuilder();

                b.append("Adding the following classes declared in META-INF/services/jersey-server-components to the resource configuration:");

                for (Class c : components)

                    b.append('\n').append("  ").append(c);

                LOGGER.log(Level.INFO, b.toString());

            }

            this.resourceConfig = rc.clone();

            this.resourceConfig.getClasses().addAll(Arrays.asList(components));

        } else {

            this.resourceConfig = rc;

        }

        this.provider = _provider;

        this.providerFactories = new ArrayList<IoCComponentProviderFactory>(2);

        for (Object o : resourceConfig.getProviderSingletons()) {

            if (o instanceof IoCComponentProviderFactory) {

                providerFactories.add((IoCComponentProviderFactory)o);

            }

        }

        if (_provider != null)

            providerFactories.add(_provider);

        // Set up the component provider factory to be

        // used with non-resource class components

        this.cpFactory = (providerFactories.isEmpty())

                ? new ProviderFactory(injectableFactory)

                : new IoCProviderFactory(injectableFactory, providerFactories);

        // Set up the resource component provider factory

        this.rcpFactory = (providerFactories.isEmpty())

                ? new ResourceFactory(this.resourceConfig, this.injectableFactory)

                : new IoCResourceFactory(this.resourceConfig, this.injectableFactory, providerFactories);

        // Initiate IoCComponentProcessorFactoryInitializer

        for (IoCComponentProviderFactory f : providerFactories) {

            IoCComponentProcessorFactory cpf;

            if (f instanceof IoCComponentProcessorFactoryInitializer) {

                cpf = new ComponentProcessorFactoryImpl();

                IoCComponentProcessorFactoryInitializer i = (IoCComponentProcessorFactoryInitializer)f;

                i.init(cpf);

            }

        }

        this.resourceContext = new ResourceContext() {

            @Override

            public ExtendedUriInfo matchUriInfo(URI u) throws ContainerException {

                try {

                    return handleMatchResourceRequest(u);

                } catch (ContainerException ex) {

                    throw ex;

                } catch (WebApplicationException ex) {

                    if (ex.getResponse().getStatus() == 404) {

                        return null;

                    } else {

                        throw new ContainerException(ex);

                    }

                } catch (RuntimeException ex) {

                    throw new ContainerException(ex);

                }

            }

            @Override

            public Object matchResource(URI u) throws ContainerException {

                ExtendedUriInfo ui = matchUriInfo(u);

                return (ui != null) ? ui.getMatchedResources().get(0) : null;

            }

            @Override

            public <T> T matchResource(URI u, Class<T> c) throws ContainerException, ClassCastException {

                return c.cast(matchResource(u));

            }

            @Override

            public <T> T getResource(Class<T> c) {

                return c.cast(getResourceComponentProvider(c).getInstance(context));

            }

        };

        final ProviderServices providerServices = new ProviderServices(

                ServerSide.class,

                this.cpFactory,

                resourceConfig.getProviderClasses(),

                resourceConfig.getProviderSingletons());

        injectableFactory.add(new ContextInjectableProvider<ProviderServices>(

                ProviderServices.class, providerServices));

        injectableFactory.add(new ContextInjectableProvider<ResourceMethodCustomInvokerDispatchFactory>(

                ResourceMethodCustomInvokerDispatchFactory.class, new ResourceMethodCustomInvokerDispatchFactory(providerServices)));

        // Add injectable provider for @ParentRef

        injectableFactory.add(

                new InjectableProvider<ParentRef, Type>() {

                    @Override

                    public ComponentScope getScope() {

                        return ComponentScope.PerRequest;

                    }

                    @Override

                    public Injectable<Object> getInjectable(ComponentContext cc, ParentRef a, Type t) {

                        if (!(t instanceof Class))

                            return null;

                        final Class target = ReflectionHelper.getDeclaringClass(cc.getAccesibleObject());

                        final Class inject = (Class)t;

                        return new Injectable<Object>() {

                            @Override

                            public Object getValue() {

                                final UriInfo ui = context.getUriInfo();

                                final List l = ui.getMatchedResources();

                                final Object parent = getParent(l, target);

                                if (parent == null) return null;

                                try {

                                    return inject.cast(parent);

                                } catch (ClassCastException ex) {

                                    throw new ContainerException(

                                            "The parent resource is expected to be of class " + inject.getName() +

                                                    " but is of class " + parent.getClass().getName(),

                                            ex);

                                }

                            }

                            private Object getParent(List l, Class target) {

                                if (l.isEmpty()) {

                                    return null;

                                } else if (l.size() == 1) {

                                    return (l.get(0).getClass() == target) ? null : l.get(0);

                                } else {

                                    return (l.get(0).getClass() == target) ? l.get(1) : l.get(0);

                                }

                            }

                        };

                    }

                });

        // Add injectable provider for @Inject

        injectableFactory.add(

                new InjectableProvider<Inject, Type>() {

                    @Override

                    public ComponentScope getScope() {

                        return ComponentScope.PerRequest;

                    }

                    @Override

                    public Injectable<Object> getInjectable(ComponentContext cc, Inject a, Type t) {

                        if (!(t instanceof Class))

                            return null;

                        final ResourceComponentProvider rcp = getResourceComponentProvider(cc, (Class)t);

                        return new Injectable<Object>() {

                            @Override

                            public Object getValue() {

                                return rcp.getInstance(context);

                            }

                        };

                    }

                });

        injectableFactory.add(

                new InjectableProvider<Inject, Type>() {

                    @Override

                    public ComponentScope getScope() {

                        return ComponentScope.Undefined;

                    }

                    @Override

                    public Injectable<Object> getInjectable(ComponentContext cc, Inject a, Type t) {

                        if (!(t instanceof Class))

                            return null;

                        final ResourceComponentProvider rcp = getResourceComponentProvider(cc, (Class)t);

                        if (rcp.getScope() == ComponentScope.PerRequest)

                            return null;

                        return new Injectable<Object>() {

                            @Override

                            public Object getValue() {

                                return rcp.getInstance(context);

                            }

                        };

                    }

                });

        injectableFactory.add(

                new InjectableProvider<Inject, Type>() {

                    @Override

                    public ComponentScope getScope() {

                        return ComponentScope.Singleton;

                    }

                    @Override

                    public Injectable<Object> getInjectable(ComponentContext cc, Inject a, Type t) {

                        if (!(t instanceof Class))

                            return null;

                        final ResourceComponentProvider rcp = getResourceComponentProvider(cc, (Class)t);

                        if (rcp.getScope() != ComponentScope.Singleton)

                            return null;

                        return new Injectable<Object>() {

                            @Override

                            public Object getValue() {

                                return rcp.getInstance(context);

                            }

                        };

                    }

                });

        // Add injectable provider for @ResourceRef

        injectableFactory.add(

                new InjectableProvider<InjectParam, Type>() {

                    @Override

                    public ComponentScope getScope() {

                        return ComponentScope.PerRequest;

                    }

                    @Override

                    public Injectable<Object> getInjectable(ComponentContext cc, InjectParam a, Type t) {

                        if (!(t instanceof Class))

                            return null;

                        final ResourceComponentProvider rcp = getResourceComponentProvider(cc, (Class)t);

                        return new Injectable<Object>() {

                            @Override

                            public Object getValue() {

                                return rcp.getInstance(context);

                            }

                        };

                    }

                });

        injectableFactory.add(

                new InjectableProvider<InjectParam, Type>() {

                    @Override

                    public ComponentScope getScope() {

                        return ComponentScope.Undefined;

                    }

                    @Override

                    public Injectable<Object> getInjectable(ComponentContext cc, InjectParam a, Type t) {

                        if (!(t instanceof Class))

                            return null;

                        final ResourceComponentProvider rcp = getResourceComponentProvider(cc, (Class)t);

                        if (rcp.getScope() == ComponentScope.PerRequest)

                            return null;

                        return new Injectable<Object>() {

                            @Override

                            public Object getValue() {

                                return rcp.getInstance(context);

                            }

                        };

                    }

                });

        injectableFactory.add(

                new InjectableProvider<InjectParam, Type>() {

                    @Override

                    public ComponentScope getScope() {

                        return ComponentScope.Singleton;

                    }

                    @Override

                    public Injectable<Object> getInjectable(ComponentContext cc, InjectParam a, Type t) {

                        if (!(t instanceof Class))

                            return null;

                        final ResourceComponentProvider rcp = getResourceComponentProvider(cc, (Class)t);

                        if (rcp.getScope() != ComponentScope.Singleton)

                            return null;

                        return new Injectable<Object>() {

                            @Override

                            public Object getValue() {

                                return rcp.getInstance(context);

                            }

                        };

                    }

                });

        // Allow injection of features and properties

        injectableFactory.add(new ContextInjectableProvider<FeaturesAndProperties>(

                FeaturesAndProperties.class, resourceConfig));

        // Allow injection of resource config

        // Since the resourceConfig reference can change refer to the

        // reference directly.

        injectableFactory.add(

                new InjectableProvider<Context, Type>() {

                    @Override

                    public ComponentScope getScope() {

                        return ComponentScope.Singleton;

                    }

                    @Override

                    public Injectable<ResourceConfig> getInjectable(ComponentContext cc, Context a, Type t) {

                        if (t != ResourceConfig.class)

                            return null;

                        return new Injectable<ResourceConfig>() {

                            @Override

                            public ResourceConfig getValue() {

                                return resourceConfig;

                            }

                        };

                    }

                });

        // Allow injection of resource context

        injectableFactory.add(new ContextInjectableProvider<ResourceContext>(

                ResourceContext.class, resourceContext));

        // Configure the injectable factory with declared providers

        injectableFactory.configure(providerServices);

        boolean updateRequired = false;

        // Create application-declared Application instance as a component

        if (rc instanceof DeferredResourceConfig) {

            final DeferredResourceConfig drc = (DeferredResourceConfig)rc;

            // Check if resource config has already been cloned

            if (resourceConfig == drc)

                resourceConfig = drc.clone();

            final DeferredResourceConfig.ApplicationHolder da = drc.getApplication(cpFactory);

            resourceConfig.add(da.getApplication());

            updateRequired = true;

            injectableFactory.add(new ContextInjectableProvider<Application>(

                    Application.class, da.getOriginalApplication()));

        } else {

            injectableFactory.add(new ContextInjectableProvider<FeaturesAndProperties>(

                    Application.class, resourceConfig));

        }

        // Pipelined, decentralized configuration

        for(ResourceConfigurator configurator : providerServices.getProviders(ResourceConfigurator.class)) {

            configurator.configure(this.resourceConfig);

            updateRequired = true;

        }

        // Validate the resource config

        this.resourceConfig.validate();

        if (updateRequired) {

            // Check if application modified provider classes or singletons

            providerServices.update(resourceConfig.getProviderClasses(),

                    resourceConfig.getProviderSingletons(), injectableFactory);

        }

        // Obtain all the templates

        this.templateContext = new TemplateFactory(providerServices);

        // Allow injection of template context

        injectableFactory.add(new ContextInjectableProvider<TemplateContext>(

                TemplateContext.class, templateContext));

        // Obtain all context resolvers

        final ContextResolverFactory crf = new ContextResolverFactory();

        // Obtain all the exception mappers

        this.exceptionFactory = new ExceptionMapperFactory();

        // Obtain all message body readers/writers

        this.bodyFactory = new MessageBodyFactory(providerServices,

                getFeaturesAndProperties().getFeature(FeaturesAndProperties.FEATURE_PRE_1_4_PROVIDER_PRECEDENCE));

        injectableFactory.add(

                new ContextInjectableProvider<MessageBodyWorkers>(

                        MessageBodyWorkers.class, bodyFactory));

        // Injection of Providers

        this.providers = new Providers() {

            @Override

            public <T> MessageBodyReader<T> getMessageBodyReader(Class<T> c, Type t,

                                                                 Annotation[] as, MediaType m) {

                return bodyFactory.getMessageBodyReader(c, t, as, m);

            }

            @Override

            public <T> MessageBodyWriter<T> getMessageBodyWriter(Class<T> c, Type t,

                                                                 Annotation[] as, MediaType m) {

                return bodyFactory.getMessageBodyWriter(c, t, as, m);

            }

            @Override

            public <T extends Throwable> ExceptionMapper<T> getExceptionMapper(Class<T> c) {

                if (Throwable.class.isAssignableFrom(c))

                    return exceptionFactory.find(c);

                else

                    return null;

            }

            @Override

            public <T> ContextResolver<T> getContextResolver(Class<T> ct, MediaType m) {

                return crf.resolve(ct, m);

            }

        };

        injectableFactory.add(

                new ContextInjectableProvider<Providers>(

                        Providers.class, providers));

        // Obtain all String readers

        this.stringReaderFactory = new StringReaderFactory();

        injectableFactory.add(

                new ContextInjectableProvider<StringReaderWorkers>(

                        StringReaderWorkers.class, stringReaderFactory));

        MultivaluedParameterExtractorProvider mpep =

                new MultivaluedParameterExtractorFactory(stringReaderFactory);

        // Add the multi-valued parameter extractor provider

        injectableFactory.add(

                new ContextInjectableProvider<MultivaluedParameterExtractorProvider>(

                        MultivaluedParameterExtractorProvider.class, mpep));

        // Add per-request-based injectable providers

        injectableFactory.add(new CookieParamInjectableProvider(mpep));

        injectableFactory.add(new HeaderParamInjectableProvider(mpep));

        injectableFactory.add(new HttpContextInjectableProvider());

        injectableFactory.add(new MatrixParamInjectableProvider(mpep));

        injectableFactory.add(new PathParamInjectableProvider(mpep));

        injectableFactory.add(new QueryParamInjectableProvider(mpep));

        injectableFactory.add(new FormParamInjectableProvider(mpep));

        // Create filter factory

        filterFactory = new FilterFactory(providerServices);

        // Initiate resource method dispatchers

        dispatcherFactory = ResourceMethodDispatcherFactory.create(providerServices);

        dispatchingListener = new DispatchingListenerProxy();

        // Initiate the WADL factory

        this.wadlFactory = new WadlFactory(resourceConfig);

        WadlApplicationContextInjectionProxy wadlApplicationContextInjectionProxy = null;

        if(!resourceConfig.getFeature(ResourceConfig.FEATURE_DISABLE_WADL)) {

            wadlApplicationContextInjectionProxy = new WadlApplicationContextInjectionProxy();

            injectableFactory.add(new SingletonTypeInjectableProvider<Context, WadlApplicationContext>(

                    WadlApplicationContext.class, wadlApplicationContextInjectionProxy) {});

            // In order for the application to properly marshall the Application

            // object we need to make sure that we provide a JAXBContext that

            // will work

            final WadlApplicationContext wac = wadlApplicationContextInjectionProxy;

            class WadlContextResolver implements ContextResolver<JAXBContext>

            {

                @Override

                public JAXBContext getContext(Class<?> type) {

                   

                    if (com.sun.research.ws.wadl.Application.class.isAssignableFrom(type)) {

                        return wac.getJAXBContext();

                    }

                    else {

                        return null;

                    }

                }

            }

           

            resourceConfig.getSingletons().add(new WadlContextResolver());

           

            // Update the provider services, so this is used

           

            providerServices.update(resourceConfig.getProviderClasses(),

                    resourceConfig.getProviderSingletons(), injectableFactory);

        }

        // Initiate filter

        filterFactory.init(resourceConfig);

        if (!resourceConfig.getMediaTypeMappings().isEmpty() ||

                !resourceConfig.getLanguageMappings().isEmpty()) {

            boolean present = false;

            for (ContainerRequestFilter f : filterFactory.getRequestFilters()) {

                present |= f instanceof UriConnegFilter;

            }

            if (!present) {

                filterFactory.getRequestFilters().add(new UriConnegFilter(

                        resourceConfig.getMediaTypeMappings(),

                        resourceConfig.getLanguageMappings()));

            } else {

                LOGGER.warning("The media type and language mappings " +

                        "declared in the ResourceConfig are ignored because " +

                        "there is an instance of " + UriConnegFilter.class.getName() +

                        "present in the list of request filters.");

            }

        }

        // Initiate context resolvers

        crf.init(providerServices, injectableFactory);

        // Initiate the exception mappers

        exceptionFactory.init(providerServices);

        // Initiate message body readers/writers

        bodyFactory.init();

        // Initiate string readers

        stringReaderFactory.init(providerServices);