replicant-frameworks_native/awt/javax/imageio/spi/ServiceRegistry.java

517 lines
16 KiB
Java
Raw Normal View History

2008-10-21 14:00:00 +00:00
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Rustem V. Rafikov
* @version $Revision: 1.3 $
*/
package javax.imageio.spi;
import java.util.*;
import java.util.Map.Entry;
/**
* The ServiceRegistry class provides ability to register,
* deregister, look up and obtain service provider instances (SPIs).
* A service means a set of interfaces and classes, and a service
* provider is an implementation of a service. Service providers can
* be associated with one or more categories. Each category is defined
* by a class or interface. Only a single instance of a each class is
* allowed to be registered as a category.
*/
public class ServiceRegistry {
/** The categories. */
CategoriesMap categories = new CategoriesMap(this);
/**
* Instantiates a new ServiceRegistry with the specified categories.
*
* @param categoriesIterator an Iterator of Class objects
* for defining of categories.
*/
public ServiceRegistry(Iterator<Class<?>> categoriesIterator) {
if (null == categoriesIterator) {
throw new IllegalArgumentException("categories iterator should not be NULL");
}
while(categoriesIterator.hasNext()) {
Class<?> c = categoriesIterator.next();
categories.addCategory(c);
}
}
/**
* Looks up and instantiates the available providers of this service using
* the specified class loader.
*
* @param providerClass the Class object of the provider to be looked up.
* @param loader the class loader to be used.
*
* @return the iterator of providers objects for this service.
*/
public static <T> Iterator<T> lookupProviders(Class<T> providerClass, ClassLoader loader) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Looks up and instantiates the available providers of this service using
* the context class loader.
*
* @param providerClass the Class object of the provider to be looked up.
*
* @return the iterator of providers objects for this service.
*/
public static <T> Iterator<T> lookupProviders(Class<T> providerClass) {
return lookupProviders(providerClass, Thread.currentThread().getContextClassLoader());
}
/**
* Registers the specified service provider object in the
* specified categories.
*
* @param provider the specified provider to be registered.
* @param category the category.
*
* @return true if no provider of the same class is registered
* in this category, false otherwise.
*/
public <T> boolean registerServiceProvider(T provider, Class<T> category) {
return categories.addProvider(provider, category);
}
/**
* Registers a list of service providers.
*
* @param providers the list of service providers.
*/
public void registerServiceProviders(Iterator<?> providers) {
for (Iterator<?> iterator = providers; iterator.hasNext();) {
categories.addProvider(iterator.next(), null);
}
}
/**
* Registers the specified service provider object in all
* categories.
*
* @param provider the service provider.
*/
public void registerServiceProvider(Object provider) {
categories.addProvider(provider, null);
}
/**
* Deregisters the specifies service provider from the
* specified category.
*
* @param provider the service provider to be deregistered.
* @param category the specified category.
*
* @return true if the provider was already registered
* in the specified category, false otherwise.
*/
public <T> boolean deregisterServiceProvider(T provider, Class<T> category) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Deregisters the specified service provider from all
* categories.
*
* @param provider the specified service provider.
*/
public void deregisterServiceProvider(Object provider) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Gets an Iterator of registered service providers
* in the specified category which satisfy the specified Filter.
* The useOrdering parameter indicates whether the iterator will
* return all of the server provider objects in a set order.
*
* @param category the specified category.
* @param filter the specified filter.
* @param useOrdering the flag indicating that providers are ordered
* in the returned Iterator.
*
* @return the iterator of registered service providers.
*/
@SuppressWarnings("unchecked")
public <T> Iterator<T> getServiceProviders(Class<T> category, Filter filter, boolean useOrdering) {
return new FilteredIterator<T>(filter, (Iterator<T>)categories.getProviders(category, useOrdering));
}
/**
* Gets an Iterator of all registered service providers
* in the specified category. The useOrdering parameter
* indicates whether the iterator will return all of the server
* provider objects in a set order.
*
* @param category the specified category.
* @param useOrdering the flag indicating that providers are ordered
* in the returned Iterator.
*
* @return the Iterator of service providers.
*/
@SuppressWarnings("unchecked")
public <T> Iterator<T> getServiceProviders(Class<T> category, boolean useOrdering) {
return (Iterator<T>)categories.getProviders(category, useOrdering);
}
/**
* Gets the registered service provider object that has the
* specified class type.
*
* @param providerClass the specified provider class.
*
* @return the service provider object.
*/
public <T> T getServiceProviderByClass(Class<T> providerClass) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Sets an ordering between two service provider objects
* within the specified category.
*
* @param category the specified category.
* @param firstProvider the first provider.
* @param secondProvider the second provider.
*
* @return true if a previously unset order was set.
*/
public <T> boolean setOrdering(Class<T> category, T firstProvider, T secondProvider) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Unsets an ordering between two service provider objects
* within the specified category.
*
* @param category the specified category.
* @param firstProvider the first provider.
* @param secondProvider the second provider.
*
* @return true if a previously unset order was removed.
*/
public <T> boolean unsetOrdering(Class<T> category, T firstProvider, T secondProvider) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Deregisters all providers from the specified category.
*
* @param category the specified category.
*/
public void deregisterAll(Class<?> category) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Deregister all providers from all categories.
*/
public void deregisterAll() {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Finalizes this object.
*
* @throws Throwable throws if an error occurs during
* finalization.
*/
@Override
public void finalize() throws Throwable {
//TODO uncomment when deregisterAll is implemented
//deregisterAll();
}
/**
* Checks whether the specified provider has been already registered.
*
* @param provider the provider to be checked.
*
* @return true, if the specified provider has been already registered,
* false otherwise.
*/
public boolean contains(Object provider) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Gets an iterator of Class objects representing the current
* categories.
*
* @return the Iterator of Class objects.
*/
public Iterator<Class<?>> getCategories() {
return categories.list();
}
/**
* The ServiceRegistry.Filter interface is used by
* ServiceRegistry.getServiceProviders to filter providers according
* to the specified criterion.
*/
public static interface Filter {
/**
* Returns true if the specified provider satisfies the
* criterion of this Filter.
*
* @param provider the provider.
*
* @return true if the specified provider satisfies the
* criterion of this Filter, false otherwise.
*/
boolean filter(Object provider);
}
/**
* The Class CategoriesMap.
*/
private static class CategoriesMap {
/** The categories. */
Map<Class<?>, ProvidersMap> categories = new HashMap<Class<?>, ProvidersMap>();
/** The registry. */
ServiceRegistry registry;
/**
* Instantiates a new categories map.
*
* @param registry the registry
*/
public CategoriesMap(ServiceRegistry registry) {
this.registry = registry;
}
//-- TODO: useOrdering
/**
* Gets the providers.
*
* @param category the category
* @param useOrdering the use ordering
*
* @return the providers
*/
Iterator<?> getProviders(Class<?> category, boolean useOrdering) {
ProvidersMap providers = categories.get(category);
if (null == providers) {
throw new IllegalArgumentException("Unknown category: " + category);
}
return providers.getProviders(useOrdering);
}
/**
* List.
*
* @return the iterator< class<?>>
*/
Iterator<Class<?>> list() {
return categories.keySet().iterator();
}
/**
* Adds the category.
*
* @param category the category
*/
void addCategory(Class<?> category) {
categories.put(category, new ProvidersMap());
}
/**
* Adds a provider to the category. If <code>category</code> is
* <code>null</code> then the provider will be added to all categories
* which the provider is assignable from.
*
* @param provider provider to add
* @param category category to add provider to
*
* @return if there were such provider in some category
*/
boolean addProvider(Object provider, Class<?> category) {
if (provider == null) {
throw new IllegalArgumentException("provider should be != NULL");
}
boolean rt;
if (category == null) {
rt = findAndAdd(provider);
} else {
rt = addToNamed(provider, category);
}
if (provider instanceof RegisterableService) {
((RegisterableService) provider).onRegistration(registry, category);
}
return rt;
}
/**
* Adds the to named.
*
* @param provider the provider
* @param category the category
*
* @return true, if successful
*/
private boolean addToNamed(Object provider, Class<?> category) {
Object obj = categories.get(category);
if (null == obj) {
throw new IllegalArgumentException("Unknown category: " + category);
}
return ((ProvidersMap) obj).addProvider(provider);
}
/**
* Find and add.
*
* @param provider the provider
*
* @return true, if successful
*/
private boolean findAndAdd(Object provider) {
boolean rt = false;
for (Entry<Class<?>, ProvidersMap> e : categories.entrySet()) {
if (e.getKey().isAssignableFrom(provider.getClass())) {
rt |= e.getValue().addProvider(provider);
}
}
return rt;
}
}
/**
* The Class ProvidersMap.
*/
private static class ProvidersMap {
//-- TODO: providers ordering support
/** The providers. */
Map<Class<?>, Object> providers = new HashMap<Class<?>, Object>();
/**
* Adds the provider.
*
* @param provider the provider
*
* @return true, if successful
*/
boolean addProvider(Object provider) {
return providers.put(provider.getClass(), provider) != null;
}
/**
* Gets the provider classes.
*
* @return the provider classes
*/
Iterator<Class<?>> getProviderClasses() {
return providers.keySet().iterator();
}
//-- TODO ordering
/**
* Gets the providers.
*
* @param userOrdering the user ordering
*
* @return the providers
*/
Iterator<?> getProviders(boolean userOrdering) {
return providers.values().iterator();
}
}
/**
* The Class FilteredIterator.
*/
private static class FilteredIterator<E> implements Iterator<E> {
/** The filter. */
private Filter filter;
/** The backend. */
private Iterator<E> backend;
/** The next obj. */
private E nextObj;
/**
* Instantiates a new filtered iterator.
*
* @param filter the filter
* @param backend the backend
*/
public FilteredIterator(Filter filter, Iterator<E> backend) {
this.filter = filter;
this.backend = backend;
findNext();
}
/**
* Next.
*
* @return the e
*/
public E next() {
if (nextObj == null) {
throw new NoSuchElementException();
}
E tmp = nextObj;
findNext();
return tmp;
}
/**
* Checks for next.
*
* @return true, if successful
*/
public boolean hasNext() {
return nextObj != null;
}
/**
* Removes the.
*/
public void remove() {
throw new UnsupportedOperationException();
}
/**
* Sets nextObj to a next provider matching the criterion given by the filter.
*/
private void findNext() {
nextObj = null;
while (backend.hasNext()) {
E o = backend.next();
if (filter.filter(o)) {
nextObj = o;
return;
}
}
}
}
}