553 lines
16 KiB
Java
553 lines
16 KiB
Java
/*
|
|
* 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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|