Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.
  */
 
 package com.sun.jersey.core.spi.component;
 
 import java.util.List;
 import java.util.Set;
Combines access to provider instances given a set of provider classes, a set of provider instances and providers registered in META-INF/services.

Author(s):
Paul.Sandoz@Sun.Com
 
 public class ProviderServices {
     private static final Logger LOGGER = Logger.getLogger(ProviderServices.class.getName());
 
     private final Class<? extends ConstrainedToTypeconstraintToType;
     
     private final ProviderFactory componentProviderFactory;
     
     private final Set<Class<?>> providers;
     
     private final Set providerInstances;

    
Create the provider services.

Parameters:
componentProviderFactory
providers
providerInstances
 
     public ProviderServices(
             ProviderFactory componentProviderFactory,
             Set<Class<?>> providers,
             Set<?> providerInstances) {
         this(ConstrainedToType.classcomponentProviderFactoryprovidersproviderInstances);
     }

    
Create the provider services.

Parameters:
constraintToType
componentProviderFactory
providers
providerInstances
 
     public ProviderServices(
             Class<? extends ConstrainedToTypeconstraintToType,
             ProviderFactory componentProviderFactory,
             Set<Class<?>> providers,
             Set<?> providerInstances) {
        this. = constraintToType;
        this. = componentProviderFactory;
        this. = providers;
        this. = providerInstances;
    }
    public void update(Set<Class<?>> providersSet<?> providerInstancesInjectableProviderFactory ipf) {
        final Set<Class<?>> addedProviders = diff(this.providers);
        final Set<?> addedProviderInstances = diff(this.providerInstances);
        this..clear();
        this..addAll(providers);
        this..clear();
        this..addAll(providerInstances);
        final ProviderServices _ps = new ProviderServices(addedProvidersaddedProviderInstances);
        final InjectableProviderFactory _ipf = new InjectableProviderFactory();
        _ipf.configureProviders(_ps);
        ipf.update(_ipf);
    }
    private <T> Set<T> diff(Set<T> s1Set<T> s2) {
        Set<T> diff = new LinkedHashSet<T>();
        for (T t : s1) {
            if (!s2.contains(t)) {
                diff.add(t);
            }
        }
        for (T t : s2) {
            if (!s1.contains(t)) {
                diff.add(t);
            }
        }
        return diff;
    }
        return ;
    }
    
    public <T> Set<T> getProviders(Class<T> provider) {
        Set<T> ps = new LinkedHashSet<T>();
        ps.addAll(getProviderInstances(provider));
        for (Class pc : getProviderClasses(provider)) {
            Object o = getComponent(pc);
            if (o != null) {
                ps.add(provider.cast(o));
            }
        }
        return ps;
    }
    public <T> Set<T> getServices(Class<T> provider) {
        Set<T> ps = new LinkedHashSet<T>();
        for (ProviderClass pc : getServiceClasses(provider)) {
            Object o = getComponent(pc);
            if (o != null) {
                ps.add(provider.cast(o));
            }
        }
        return ps;
    }
    public <T> Set<T> getProvidersAndServices(Class<T> provider) {
        Set<T> ps = new LinkedHashSet<T>();
        ps.addAll(getProviderInstances(provider));
        for (ProviderClass pc : getProviderAndServiceClasses(provider)) {
            Object o = getComponent(pc);
            if (o != null) {
                ps.add(provider.cast(o));
            }
        }
        return ps;
    }
    public static interface ProviderListener<T> {
        void onAdd(T t);
    }
    
    public <T> void getProviders(Class<T> providerProviderListener listener) {
        for (T t : getProviderInstances(provider)) {
            listener.onAdd(t);
        }
        for (ProviderClass pc : getProviderOnlyClasses(provider)) {
            Object o = getComponent(pc);
            if (o != null) {
                listener.onAdd(provider.cast(o));
            }
        }
    }
    public <T> void getProvidersAndServices(Class<T> providerProviderListener listener) {
        for (T t : getProviderInstances(provider)) {
            listener.onAdd(t);
        }
        for (ProviderClass pc : getProviderAndServiceClasses(provider)) {
            Object o = getComponent(pc);
            if (o != null) {
                listener.onAdd(provider.cast(o));
            }
        }
    }
    public <T> List<T> getInstances(Class<T> providerString[] classNames) {
        List<T> ps = new LinkedList<T>();
        for (String className : classNames) {
            try {
               Class<?> c = ReflectionHelper.classForNameWithException(className);
               if (provider.isAssignableFrom(c)) {
                   Object o = getComponent(c);
                   if (o != null)
                       ps.add(provider.cast(o));
               } else {
                   .severe("The class " + 
                           className +
                           " is not assignable to the class " +
                           provider.getName() + 
                           ". This class is ignored.");
               }
            } catch (ClassNotFoundException e) {
               .severe("The class " + 
                       className +
                       " could not be found" +
                       ". This class is ignored.");                
            }
        }
        
        return ps;
    }
        
    public <T> List<T> getInstances(Class<T> providerClass<? extends T>[] classes) {
        List<T> ps = new LinkedList<T>();
        for (Class<? extends T> c : classes) {
           Object o = getComponent(c);
           if (o != null)
               ps.add(provider.cast(o));
        }
        return ps;
    }
    private Object getComponent(Class provider) {
        return (cp != null) ? cp.getInstance() : null;
    }
    
    private Object getComponent(ProviderClass provider) {
        return (cp != null) ? cp.getInstance() : null;
    }
    private <T> Set<T> getProviderInstances(Class<T> service) {
        Set<T> sp = new LinkedHashSet<T>();
        for (Object p : ) {
            if (service.isInstance(p) && constrainedTo(p.getClass()))
                sp.add(service.cast(p));
        }
        return sp;
    }
    private Set<ClassgetProviderClasses(Class<?> service) {
        Set<Classsp = new LinkedHashSet<Class>();
        for (Class p : ) {
            if (service.isAssignableFrom(p) && constrainedTo(p))
                sp.add(p);
        }
        
        return sp;
    }
    public class ProviderClass {
        final boolean isServiceClass;
        final Class c;
        
        ProviderClass(Class c) {
            this. = c;
            this. = false;
        }
        ProviderClass(Class cboolean isServiceClass) {
            this. = c;
            this. = isServiceClass;
        }
    }
    private Set<ProviderClassgetProviderAndServiceClasses(Class<?> service) {
        Set<ProviderClasssp = getProviderOnlyClasses(service);
        getServiceClasses(servicesp);
        return sp;
    }    
    
    private Set<ProviderClassgetProviderOnlyClasses(Class<?> service) {
        Set<ProviderClasssp = new LinkedHashSet<ProviderClass>();
        for(Class c : getProviderClasses(service)) {
            sp.add(new ProviderClass(c));
        }
        return sp;
    }
    private Set<ProviderClassgetServiceClasses(Class<?> service) {
        Set<ProviderClasssp = new LinkedHashSet<ProviderClass>();
        getServiceClasses(servicesp);
        return sp;
    }    
    
    private void getServiceClasses(Class<?> serviceSet<ProviderClasssp) {
        // Get the service-defined provider classes that implement serviceClass
        .log(."Searching for providers that implement: " + service);
        Class<?>[] pca = ServiceFinder.find(servicetrue).toClassArray();
        for (Class pc : pca) {
            if (constrainedTo(pc)) {
                .log(."    Provider found: " + pc);
            }
        }
        // Add service-defined providers to the set after application-defined
        for (Class pc : pca) {
            if (constrainedTo(pc)) {
                if(service.isAssignableFrom(pc)) {
                    sp.add(new ProviderClass(pctrue));
                } else {
                    .log(."Provider " + pc.getName() +
                            " won't be used because its not assignable to " +
                            service.getName() + ". This might be caused by clashing " +
                            "container-provided and application-bundled Jersey classes.");
                }
            }
        }
    }
    private boolean constrainedTo(Class<?> p) {
        final ConstrainedTo ct = p.getAnnotation(ConstrainedTo.class);
        return (ct != null)
                ? ct.value().isAssignableFrom()
                : true;
    }
New to GrepCode? Check out our FAQ X