1 files changed, 0 insertions, 179 deletions
diff --git a/java/sca/modules/contribution/src/main/java/org/apache/tuscany/sca/contribution/resolver/ExtensibleModelResolver.java b/java/sca/modules/contribution/src/main/java/org/apache/tuscany/sca/contribution/resolver/ExtensibleModelResolver.java
deleted file mode 100644
index 72e4b03c7f..0000000000
--- a/java/sca/modules/contribution/src/main/java/org/apache/tuscany/sca/contribution/resolver/ExtensibleModelResolver.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * 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.    
- */
-
-package org.apache.tuscany.sca.contribution.resolver;
-
-import java.lang.reflect.Constructor;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.apache.tuscany.sca.contribution.Contribution;
-import org.apache.tuscany.sca.contribution.processor.ProcessorContext;
-import org.apache.tuscany.sca.core.FactoryExtensionPoint;
-
-/**
- * An implementation of an extensible model resolver which delegates to the
- * proper resolver extension based on the class of the model to resolve.
- * 
- * @version $Rev$ $Date$
- */
-public class ExtensibleModelResolver implements ModelResolver {
-    private final ModelResolverExtensionPoint resolverExtensions;
-    private final FactoryExtensionPoint modelFactories;
-    private final Contribution contribution;
-    private ModelResolver defaultResolver;
-    private final Map<Class<?>, ModelResolver> resolversByModelType = new HashMap<Class<?>, ModelResolver>();
-    private final Map<Class<?>, ModelResolver> resolversByImplementationClass = new HashMap<Class<?>, ModelResolver>();
-    private Map<Object, Object> map = new HashMap<Object, Object>();
-    private Object lastUnresolved;
-
-    /**
-     * Constructs an extensible model resolver
-     * 
-     * @param resolverExtensions
-     * @param contribution
-     * @param modelFactories
-     */
-    public ExtensibleModelResolver(Contribution contribution,
-                                   ModelResolverExtensionPoint resolverExtensions,
-                                   FactoryExtensionPoint modelFactories) {
-        this.contribution = contribution;
-        this.resolverExtensions = resolverExtensions;
-        this.modelFactories = modelFactories;
-    }
-
-    /**
-     * Returns the proper resolver instance based on the interfaces of the model
-     * If one is not available on the registry, instantiate on demand
-     * 
-     * @param modelType
-     * @return
-     */
-    private ModelResolver getModelResolverInstance(Class<?> modelType) {
-        // Look up a model resolver instance for the model class or
-        // each implemented interface
-        Class<?>[] interfaces = modelType.getInterfaces();
-        Class<?>[] classes = new Class<?>[interfaces.length + 1];
-        classes[0] = modelType;
-        if (interfaces.length != 0) {
-            System.arraycopy(interfaces, 0, classes, 1, interfaces.length);
-        }
-        for (Class<?> c : classes) {
-
-            // Look up an existing model resolver instance
-            ModelResolver resolverInstance = resolversByModelType.get(c);
-            if (resolverInstance != null) {
-                return resolverInstance;
-            }
-
-            // We don't have an instance, lookup a model resolver class
-            // and instantiate it
-            Class<? extends ModelResolver> resolverClass = resolverExtensions.getResolver(c);
-            if (resolverClass != null) {
-
-                // Construct the model resolver instance and cache it
-                resolverInstance = resolversByImplementationClass.get(resolverClass);
-                if (resolverInstance != null) {
-                    resolversByModelType.put(c, resolverInstance);
-                    return resolverInstance;
-                }
-                try {
-                    Constructor<? extends ModelResolver> constructor =
-                        resolverClass
-                            .getConstructor(new Class[] {Contribution.class, FactoryExtensionPoint.class});
-                    if (constructor != null) {
-
-                        resolverInstance = constructor.newInstance(contribution, modelFactories);
-                        resolversByImplementationClass.put(resolverClass, resolverInstance);
-                        resolversByModelType.put(c, resolverInstance);
-                        return resolverInstance;
-                    }
-                } catch (Exception e) {
-                    throw new IllegalStateException(e);
-                }
-            }
-        }
-
-        return null;
-    }
-
-    public void addModel(Object resolved, ProcessorContext context) {
-        ModelResolver resolver = getModelResolverInstance(resolved.getClass());
-        if (resolver != null) {
-            resolver.addModel(resolved, context);
-        } else {
-            map.put(resolved, resolved);
-        }
-    }
-
-    public Object removeModel(Object resolved, ProcessorContext context) {
-        ModelResolver resolver = getModelResolverInstance(resolved.getClass());
-        if (resolver != null) {
-            return resolver.removeModel(resolved, context);
-        } else {
-            return map.remove(resolved);
-        }
-    }
-
-    public <T> T resolveModel(Class<T> modelClass, T unresolved, ProcessorContext context) {
-        // Protect against dependency cycles causing infinite recursion
-        // Save the current unresolved object and check later if we are trying
-        // to resolve the same object again
-        if (unresolved == lastUnresolved) {
-            return unresolved;
-        }
-        lastUnresolved = unresolved;
-        
-        ModelResolver resolver = getModelResolverInstance(unresolved.getClass());
-        if (resolver != null) {
-            Object resolved = resolver.resolveModel(modelClass, unresolved, context);
-            if (resolved != null && resolved != unresolved) {
-                lastUnresolved = null;
-                return modelClass.cast(resolved);
-            }
-        } else {
-            //FIXME Remove this default resolver, this is currently used to resolve policy declarations
-            // but they should be handled by the contribution import/export mechanism instead of this
-            // defaultResolver hack.
-            if (defaultResolver != null) {
-                Object resolved = defaultResolver.resolveModel(modelClass, unresolved, context);
-                if (resolved != null && resolved != unresolved) {
-                    lastUnresolved = null;
-                    return modelClass.cast(resolved);
-                }
-            }
-            
-            Object resolved = map.get(unresolved);
-            if (resolved != null) {
-                // Return the resolved object
-                lastUnresolved = null;
-                return modelClass.cast(resolved);
-            }
-        }
-
-        return unresolved;
-    }
-    
-    // FIXME: TUSCANY-2499: temporarily  give access to the defaultResolver to get the jms binding
-    //  use of definitions.xml working while the definitions.xml processing is being refactored
-    public ModelResolver getDefaultModelResolver() {
-        return defaultResolver;
-    }
-
-}