Application: gvSIG desktop

package org.gvsig.fmap.dal.feature.spi;

import java.lang.reflect.Constructor;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataStoreProvider;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.feature.FeatureStoreProviderFactory;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.tools.dynobject.DynObject;

public class DataStoreProviderToFeatureStoreProviderFactoryWrapper extends

                AbstractFeatureStoreProviderFactory implements FeatureStoreProviderFactory {

        private Class providerClass = null;

        private Class parametersClass = null;

        public DataStoreProviderToFeatureStoreProviderFactoryWrapper(String name, String description,

                        Class provider, Class parametersClass) {

                super(name, description);

                this.providerClass = provider;

                this.parametersClass = parametersClass;

        }

        public DataStoreProvider createProvider(DataParameters parameters,

                        DataStoreProviderServices providerServices)

                        throws InitializeException {

                try {

                        Class[] argsTypes = new Class[] { DataParameters.class,

                                        DataStoreProviderServices.class };

                        Object[] args = new Object[] { parameters, providerServices };

                        Constructor contructor;

                        contructor = findConstructor(providerClass, argsTypes);

                        return (DataStoreProvider) contructor.newInstance(args);

                } catch (Throwable e) {

                        throw new InitializeException(e);

                }

        }

        public final DynObject createParameters() {

                try {

                        return (DynObject) parametersClass.newInstance();

                } catch (Exception e) {

                        throw new RuntimeException(e);

                }

        }

        protected Constructor findConstructor(Class clazz, Class[] types)

                        throws SecurityException, NoSuchMethodException {

                try {

                        return clazz.getConstructor(types);

                } catch (NoSuchMethodException e) {

                        // Nothing to do

                }

                // search for the required constructor

                Constructor[] constrs = clazz.getConstructors();

                boolean allMatch;

                for (int i = 0; i < constrs.length; i++) {

                        Class[] paramTypes = constrs[i].getParameterTypes();

                        if (paramTypes.length == types.length) { // a general candidate

                                allMatch = true;

                                for (int j = 0; j < paramTypes.length; j++) {

                                        if (!isParameterCompatible(types[j], paramTypes[j])) {

                                                allMatch = false;

                                                break;

                                        }

                                }

                                if (allMatch) {

                                        return constrs[i];

                                }

                        }

                }

                StringBuffer strb = new StringBuffer();

                strb.append(clazz.getName());

                strb.append('(');

                if (types.length > 0) {

                        for (int i = 0; i < types.length - 1; i++) {

                                strb.append(types[i].getName());

                                strb.append(',');

                        }

                        strb.append(types[types.length - 1].getName());

                }

                strb.append(')');

                throw new NoSuchMethodException(strb.toString());

        }

        private boolean isParameterCompatible(Class current, Class defined) {

                if (current == null) {

                        return !defined.isPrimitive();

                } else {

                        return current.isAssignableFrom(defined);

                }

        }

}