Initial Contribution
diff --git a/awt/javax/imageio/spi/ServiceRegistry.java b/awt/javax/imageio/spi/ServiceRegistry.java
new file mode 100644
index 0000000..1a18b02
--- /dev/null
+++ b/awt/javax/imageio/spi/ServiceRegistry.java
@@ -0,0 +1,516 @@
+/*
+ * 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;
+ }
+ }
+ }
+ }
+}