39  * A registry for service provider instances.
42  * abstract) classes.  A <i>service provider</i> is a specific
43  * implementation of a service.  The classes in a provider typically
62  * the previous instance.  In practice, service provider objects are
65  * <p> To declare a service provider, a <code>services</code>
68  * for each service provider interface that has one or more
82  * <p> The service provider classes should be to be lightweight and
140      * into a provider-configuration filename as described in the
144      * produce a list of provider-class names.  The iterator that is
156      * provider-configuration files and instantiate provider classes,
160      * @return An <code>Iterator</code> that yields provider objects
162      * will throw an <code>Error</code> if a provider-configuration
163      * file violates the specified format or if a provider class
191      * @return An <code>Iterator</code> that yields provider objects
193      * will throw an <code>Error</code> if a provider-configuration
194      * file violates the specified format or if a provider class
222      * provider belongs.
224     private Iterator getSubRegistries(Object provider) {
229             if (c.isAssignableFrom(provider.getClass())) {
237      * Adds a service provider object to the registry.  The provider
240      * <p> If <code>provider</code> implements the
247      * @param provider the service provide object to be registered.
249      * provider.
251      * @return true if no provider of the same class was previously
254      * @exception IllegalArgumentException if <code>provider</code> is
258      * @exception ClassCastException if provider does not implement
261     public <T> boolean registerServiceProvider(T provider,
263         if (provider == null) {
264             throw new IllegalArgumentException("provider == null!");
270         if (!category.isAssignableFrom(provider.getClass())) {
274         return reg.registerServiceProvider(provider);
278      * Adds a service provider object to the registry.  The provider
282      * <p> If <code>provider</code> implements the
290      * @param provider the service provider object to be registered.
293      * <code>provider</code> is <code>null</code>.
295     public void registerServiceProvider(Object provider) {
296         if (provider == null) {
297             throw new IllegalArgumentException("provider == null!");
299         Iterator regs = getSubRegistries(provider);
302             reg.registerServiceProvider(provider);
307      * Adds a set of service provider objects, taken from an
308      * <code>Iterator</code> to the registry.  Each provider is
320      * @param providers an Iterator containing service provider
328             throw new IllegalArgumentException("provider == null!");
336      * Removes a service provider object from the given category.  If
337      * the provider was not previously registered, nothing happens and
340      * <code>provider</code> but not equal (using <code>==</code>) to
341      * <code>provider</code> is registered, it will not be
344      * <p> If <code>provider</code> implements the
348      * @param provider the service provider object to be deregistered.
350      * provider.
352      * @return <code>true</code> if the provider was previously
356      * @exception IllegalArgumentException if <code>provider</code> is
360      * @exception ClassCastException if provider does not implement
363     public <T> boolean deregisterServiceProvider(T provider,
365         if (provider == null) {
366             throw new IllegalArgumentException("provider == null!");
372         if (!category.isAssignableFrom(provider.getClass())) {
375         return reg.deregisterServiceProvider(provider);
379      * Removes a service provider object from all categories that
382      * @param provider the service provider object to be deregistered.
384      * @exception IllegalArgumentException if <code>provider</code> is
387     public void deregisterServiceProvider(Object provider) {
388         if (provider == null) {
389             throw new IllegalArgumentException("provider == null!");
391         Iterator regs = getSubRegistries(provider);
394             reg.deregisterServiceProvider(provider);
399      * Returns <code>true</code> if <code>provider</code> is currently
402      * @param provider the service provider object to be queried.
404      * @return <code>true</code> if the given provider has been
407      * @exception IllegalArgumentException if <code>provider</code> is
410     public boolean contains(Object provider) {
411         if (provider == null) {
412             throw new IllegalArgumentException("provider == null!");
414         Iterator regs = getSubRegistries(provider);
417             if (reg.contains(provider)) {
429      * will return all of the server provider objects in an arbitrary
439      * @return an <code>Iterator</code> containing service provider
468          * <code>provider</code> object matches the criterion defined
471          * @param provider a service provider <code>Object</code>.
473          * @return true if the provider matches the criterion.
475         boolean filter(Object provider);
479      * Returns an <code>Iterator</code> containing service provider
494      * @return an <code>Iterator</code> containing service provider
512      * Returns the currently registered service provider object that
519      * service provider object.
521      * @return a currently registered service provider object with the
537                 T provider = reg.getServiceProviderByClass(providerClass);
538                 if (provider != null) {
539                     return provider;
547      * Sets a pairwise ordering between two service provider objects
561      * @param firstProvider the preferred provider.
562      * @param secondProvider the provider to which
568      * @exception IllegalArgumentException if either provider is
577             throw new IllegalArgumentException("provider is null!");
594      * Sets a pairwise ordering between two service provider objects
606      * @param firstProvider the formerly preferred provider.
607      * @param secondProvider the provider to which
613      * @exception IllegalArgumentException if either provider is
622             throw new IllegalArgumentException("provider is null!");
639      * Deregisters all service provider object currently registered
704     public boolean registerServiceProvider(Object provider) {
705         Object oprovider = map.get(provider.getClass());
711         map.put(provider.getClass(), provider);
712         poset.add(provider);
713         if (provider instanceof RegisterableService) {
714             RegisterableService rs = (RegisterableService)provider;
722      * If the provider was not previously registered, do nothing.
724      * @return true if the provider was previously registered.
726     public boolean deregisterServiceProvider(Object provider) {
727         Object oprovider = map.get(provider.getClass());
729         if (provider == oprovider) {
730             map.remove(provider.getClass());
731             poset.remove(provider);
732             if (provider instanceof RegisterableService) {
733                 RegisterableService rs = (RegisterableService)provider;
742     public boolean contains(Object provider) {
743         Object oprovider = map.get(provider.getClass());
744         return oprovider == provider;
772             Object provider = iter.next();
775             if (provider instanceof RegisterableService) {
776                 RegisterableService rs = (RegisterableService)provider;

Indexes created Tue Jul 24 14:28:13 CEST 2018