/*
* 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.
*
* @since Android 1.0
*/
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
* 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.
*
* @since Android 1.0
*/
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 true, 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;
}
}
}
}
}
|
