Application: gvSIG desktop

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.feature.spi.BaseFeatureStoreProviderFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

	private static Logger LOG = LoggerFactory

			.getLogger(DefaultDataManager.class);

	final static private String DATA_MANAGER_STORE_PROVIDER_FACTORY = "Data.manager.providers.factory";

	final static private String DATA_MANAGER_STORE_PROVIDER_FACTORY_DESCRIPTION = "DAL store provider factories";

			ToolsLocator.getExtensionPointManager()

					.add(DATA_MANAGER_STORE, DATA_MANAGER_STORE_DESCRIPTION)

					.append(name, null, storeProviderClass);

			ToolsLocator

					.getExtensionPointManager()

					.add(DATA_MANAGER_STORE_PARAMS,

							DATA_MANAGER_STORE_PARAMS_DESCRIPTION)

					.append(name, null, parametersClass);

			return;

		}

		if (FeatureStoreProvider.class.isAssignableFrom(storeProviderClass)) {

			// Envuelbe alproveedor en una factoria por defecto.

			this.registerStoreProviderFactory(new BaseFeatureStoreProviderFactory(name, "", storeProviderClass, parametersClass));

			return;

		throw new IllegalArgumentException("Not supported implemtation: name="

				+ name + " provider class=" + storeProviderClass.getName());

	public void registerStoreProviderFactory(DataStoreProviderFactory factory) {

		ExtensionPoint factories = ToolsLocator.getExtensionPointManager().add(

				DATA_MANAGER_STORE_PROVIDER_FACTORY,

				DATA_MANAGER_STORE_PROVIDER_FACTORY_DESCRIPTION);

		factories.append(factory.getName(), factory.getDescription(), factory);

	}

		if (!(DataStoreFactory.class.isAssignableFrom(storeProviderClass))) {

		ToolsLocator

				.getExtensionPointManager()

				.add(DATA_MANAGER_STORE_FACTORY,

						DATA_MANAGER_STORE_FACTORY_DESCRIPTION)

				.append(name, null, storeProviderClass);

			// Si hay una factoria para ese proveedor se los pedimos a la factoria

			DataStoreProviderFactory providerFactory = (DataStoreProviderFactory) ToolsLocator

					.getExtensionPointManager().get(DATA_MANAGER_STORE_PROVIDER_FACTORY)

					.create(name);

			if( providerFactory != null ) {

				return (DataStoreParameters) providerFactory.createParameters();

			}

			// Si no hay factoria lo hacemos como se hacia antes por mantener

			// compatibilidad.

 			DataStoreParameters params = (DataStoreParameters) ToolsLocator

	private DataStore localOpenStore(String provider,

			DataStoreParameters parameters) throws InitializeException,

			ProviderNotRegisteredException, ValidateDataParametersException {

		String name = provider; // parameters.getDataStoreName();

			ExtensionPoint.Extension point = ToolsLocator

					.getExtensionPointManager().get(DATA_MANAGER_STORE_FACTORY)

					.get(name);

				factory = (DataStoreFactory) point.create();

		return localOpenStore(provider, parameters);

		try {

			int i = 1 / 0;

		} catch (Throwable e) {

			LOG.info(

					"Use of deprcated method. Replace calling to it by calling to openStore",

					e);

		}

	public DataStoreProviderFactory getStoreProviderFactory(String name) {

		try {

			return (DataStoreProviderFactory) ToolsLocator

					.getExtensionPointManager()

					.get(DATA_MANAGER_STORE_PROVIDER_FACTORY).create(name);

		} catch (InstantiationException e) {

			return null;

		} catch (IllegalAccessException e) {

			return null;

		}

	}

			server = this.openServerExplorerWithoutValidate(explorer,

					parameters);

	public void newStore(String explorer, String provider,

			NewDataStoreParameters parameters, boolean overwrite)

		parameters.validate();

		server = this.openServerExplorerWithoutValidate(explorer,

				explorerParameters);

	 * 

		ToolsLocator.getExtensionPointManager()

				.add(DATA_MANAGER_EXPLORER, DATA_MANAGER_EXPLORER_DESCRIPTION)

				.append(name, null, explorerClass);

		ToolsLocator

				.getExtensionPointManager()

				.add(DATA_MANAGER_EXPLORER_PARAMS,

						DATA_MANAGER_EXPLORER_PARAMS_DESCRIPTION)

				.append(name, null, parametersClass);

					.getExtensionPointManager()

					.get(DATA_MANAGER_EXPLORER_PARAMS).create(name);

	public DataServerExplorer openServerExplorer(String explorer,

		if (parameters != null) {

			String explorerName, DataServerExplorerParameters parameters)

		String name = explorerName; // parameters.getExplorerName();

					.create(name,

		return ToolsLocator.getExtensionPointManager()

				.get(DATA_MANAGER_EXPLORER).getNames();

	 * 

			return (Evaluator) ToolsLocator

					.getExtensionPointManager()

					.get(DATA_MANAGER_EXPRESION_EVALUATOR)

					.create(DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT,

							new Object[] { expresion });

		ToolsLocator

				.getExtensionPointManager()

				.add(DATA_MANAGER_EXPRESION_EVALUATOR,

						DATA_MANAGER_EXPRESION_EVALUATOR_DESCRIPTION)

				.append(DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT,

						"Default expresion evaluator for use in DAL",

						evaluatorClass);

	 * 

					.getExtensionPointManager().get(DATA_MANAGER_INDEX)

					.create(name);

					(FeatureStoreProviderServices) store, type, provider,

					attr.getName(), indexName);

		ToolsLocator.getExtensionPointManager()

				.add(DATA_MANAGER_INDEX, DATA_MANAGER_INDEX_DESCRIPTION)

				.append(name, null, clazz);

		((DataStoreInitializer) store).intializePhase1(this, parameters);

		DataStoreProvider provider = this.createProvider(

				(DataStoreProviderServices) store, parameters);

		((DataStoreInitializer) store).intializePhase2(provider);

	public DataStoreProvider createProvider(

			DataStoreProviderServices providerServices,

			DataStoreParameters parameters) throws InitializeException,

			ProviderNotRegisteredException {

		String name = parameters.getDataStoreName();

		DataStoreProvider provider = null;

		boolean retry = true;

		while (retry) {

			try {

				DataStoreProviderFactory providerFactory = (DataStoreProviderFactory) ToolsLocator

				.getExtensionPointManager()

				.get(DATA_MANAGER_STORE_PROVIDER_FACTORY).create(name);

				if( providerFactory!=null ) {

					provider = (DataStoreProvider) providerFactory.createProvider(parameters, providerServices);

				} else {

					provider = (DataStoreProvider) ToolsLocator

							.getExtensionPointManager()

							.get(DATA_MANAGER_STORE)

							.create(name,

									new Object[] { parameters, providerServices });

				}

				retry = false;

			} catch (Exception e) {

				if (openErrorHandler != null) {

					retry = openErrorHandler.canRetryOpen(e, parameters);

				} else {

					retry = false;

				}

				if (!retry) {

					throw new InitializeException(

							parameters.getDataStoreName(), e);

				}

			}

		}

		if (provider == null) {

			throw new ProviderNotRegisteredException(name);

		}

		return provider;

		ToolsLocator.getExtensionPointManager()

				.add(DATA_MANAGER_CACHE, DATA_MANAGER_CACHE_DESCRIPTION)

				.append(providerFactory.getName(), "", providerFactory);

	public FeatureCacheProvider createFeatureCacheProvider(String name,

			DynObject parameters) throws DataException {

			throw new InitializeException(

					"It is necessary to provide a cache name", null);

		if (parameters == null) {

			throw new InitializeException(

					"It is necessary to provide parameters to create the explorer",

					null);

					.getExtensionPointManager().get(DATA_MANAGER_CACHE)

					.create(name);

			return featureCacheProviderFactory.createCacheProvider(parameters);

		}

	public List getFeatureCacheProviders() {

		ExtensionPoint extensionPoint = ToolsLocator.getExtensionPointManager()

				.get(DATA_MANAGER_CACHE);

		if (extensionPoint != null) {

			return ToolsLocator.getExtensionPointManager()

					.get(DATA_MANAGER_CACHE).getNames();

		} else {

			return new ArrayList();

		}

	}

			throw new InitializeException(

					"It is necessary to provide a cache name", null);

					.getExtensionPointManager().get(DATA_MANAGER_CACHE)

					.create(name);

			return featureCacheProviderFactory.createParameters();

		}

			FeatureStore featureStore, int pageSize) throws BaseException {

			throws BaseException {

package org.gvsig.fmap.dal;

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

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

import org.gvsig.tools.service.spi.ProviderFactory;

public interface DataStoreProviderFactory extends ProviderFactory {

	public static final int UNKNOWN = 0;

	public static final int YES = 1;

	public static final int NO = 2;

	/**

	 * Returns the name of the provider

	 * 

	 * @return name of the provider

	 */

	public String getName();

	/**

	 * Return a short descripion about the provider

	 * 

	 * @return description about the provider

	 */

	public String getDescription();

	/**

	 * The provider has read support

	 * 

	 * @return YES if has read support

	 */

	public int allowRead();

	/**

	 * The provider has write support

	 * 

	 * @return YES if has write support

	 */

	public int allowWrite();

	/**

	 * The provider can create new stores.

	 * 

	 * @return YES if has creation support

	 */

	public int allowCreate();

	/**

	 * The provider has tabular support.

	 * This support is the minimum requisite for a FeatureStore.

	 * 

	 * @return YES if has write support

	 */

	public int hasTabularSupport();

	/**

	 * The provider has vectorial support.

	 * 

	 * @return YES if has vectorial support

	 */

	public int hasVectorialSupport();

	/**

	 * The provider has raster support.

	 * 

	 * @return YES if has raster support

	 */

	public int hasRasterSupport();

	/**

	 * Builds a specific provider

	 * 

	 * @return the provider

	 */

	public DataStoreProvider createProvider(DataParameters parameters, DataStoreProviderServices providerServices) throws InitializeException;

}

package org.gvsig.fmap.dal;

public interface DataStoreProvider {

}

package org.gvsig.fmap.dal.spi;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.Provider;

import org.gvsig.tools.service.spi.ProviderServices;

public abstract class AbstractDataStoreProviderFactory implements

		DataStoreProviderFactory {

	private String name = null;

	private String description = "";

	protected AbstractDataStoreProviderFactory(String name, String description) {

		this.name = name;

		this.description = description;

	}

	public final Provider create(DynObject parameters, ProviderServices services)

			throws ServiceException {

		throw new UnsupportedOperationException();

	}

	public final void initialize() {

		throw new UnsupportedOperationException();

	}

	public final String getName() {

		return this.name;

	}

	public final String getDescription() {

		return this.description;

	}

	public int allowRead() {

		return UNKNOWN;

	}

	public int allowWrite() {

		return UNKNOWN;

	}

	public int allowCreate() {

		return UNKNOWN;

	}

	public int hasTabularSupport() {

		return UNKNOWN;

	}

	public int hasVectorialSupport() {

		return UNKNOWN;

	}

	public int hasRasterSupport() {

		return UNKNOWN;

	}

}

public interface DataStoreProvider extends org.gvsig.fmap.dal.DataStoreProvider, DynObject, Disposable {

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

import java.lang.reflect.Constructor;

import java.util.List;

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.AbstractDataStoreProviderFactory;

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

import org.gvsig.tools.dynobject.DynObject;

public class BaseFeatureStoreProviderFactory extends

		AbstractDataStoreProviderFactory implements FeatureStoreProviderFactory {

	private Class providerClass = null;

	private Class parametersClass = null;

	public BaseFeatureStoreProviderFactory(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);

		}

	}

	public List getGeomtriesSupporteds() {

		return null;

	}

	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 defined.isAssignableFrom(current);

		}

	}

}

package org.gvsig.fmap.dal.feature;

import java.util.List;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

public interface FeatureStoreProviderFactory extends DataStoreProviderFactory {

	/**

	 * Return a list of geometry types (Geometry.TYPES) supported

	 * by this provider. If the provider has not vectorial support

	 * or has not restrictions over geometry types return null.

	 * 

	 * @return List of Geometry.TYPES or null

	 */

	public List getGeomtriesSupporteds();

}