Application: gvSIG desktop

package org.gvsig.fmap.dal.impl;

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

import java.io.File;

import java.io.InputStream;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.dal.DataFactory;

import org.gvsig.fmap.dal.DataManager;

import static org.gvsig.fmap.dal.DataManager.READ_STORE_AUTHORIZATION;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerFactory;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataServerExplorerPool;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreFactory_v2_4;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.ExpressionBuilder;

import org.gvsig.fmap.dal.ExpressionEvaluator;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.OpenErrorHandler;

import org.gvsig.fmap.dal.Register;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultEditableFeatureType;

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureIndex;

import org.gvsig.fmap.dal.feature.impl.FeatureStoreFactory;

import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;

import org.gvsig.fmap.dal.feature.paging.impl.FeaturePagingHelperImpl;

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

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

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

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProvider;

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProviderFactory;

import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProvider;

import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProviderServices;

import org.gvsig.fmap.dal.raster.impl.RasterStoreOldFactory;

import org.gvsig.fmap.dal.raster.impl.RasterStoreFactory;

import org.gvsig.fmap.dal.raster.spi.CoverageStoreProvider;

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

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

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

import org.gvsig.fmap.dal.store.memory.MemoryStoreParameters;

import org.gvsig.fmap.dal.store.memory.MemoryStoreProvider;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.DynStruct_v2;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.identitymanagement.SimpleIdentityManager;

import org.gvsig.tools.identitymanagement.UnauthorizedException;

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

public class DefaultDataManager

        implements DataManager, DataManagerProviderServices, Services {

    final static private String DATA_MANAGER_CACHE = "Data.manager.caches";

    final static private String DATA_MANAGER_CACHE_DESCRIPTION =

        "DAL cache providers";

    private class Registers {

        private final Register store;

        private final Register storeProvider;

        private final Register serverExplorer;

        private final Register featureIndexProvider;

        public Registers() {

            this.store = new RegisterImpl(

                    "Data.manager.stores.factory",

                    "DAL store factories"

            );

            this.storeProvider = new RegisterImpl(

                    "Data.manager.providers.factory",

                    "DAL store provider factories"

            );

            this.serverExplorer = new RegisterImpl(

                    "Data.manager.servereexplorer.factory",

                    "DAL server explorer factories"

            );

            this.featureIndexProvider = new RegisterImpl(

                    "Data.manager.feature.index.factory",

                    "DAL feature index factories"

            );

            this.store.register(new FeatureStoreFactory());

        }

    }

    private static final String TAG_DAL_OPENSTORE = "dal.openstore.";

    private final Registers registers;

    private final Map<Integer, String> defaultDataIndexProviders;

    private Class defaultEvaluatorClass = null;

    private OpenErrorHandler openErrorHandler = null;

    private DataServerExplorerPool dataServerExplorerPool = null;

    private List<DataType> dataTypes = null;

    private ClassLoader resourcesLoader = null;

    public DefaultDataManager() {

        this.registers = new Registers();

        this.defaultDataIndexProviders = new HashMap<>();

    }

    @Override

    public Register getStoreRegister() {

        return this.registers.store;

    }

    @Override

    public Register getStoreProviderRegister() {

        return this.registers.storeProvider;

    }

    @Override

    public Register getServerExplorerRegister() {

        return this.registers.serverExplorer;

    }

    @Override

    public Register getFeatureIndexRegister() {

        return this.registers.featureIndexProvider;

    }

    private String getStoreName(DataStoreParameters parameters) {

        for (DataFactory factory : this.getStoreRegister()) {

            DataStoreFactory_v2_4 storeFactory = (DataStoreFactory_v2_4) factory;

            if (storeFactory.canUse(parameters)) {

                return storeFactory.getName();

            }

        }

        return null;

    }

    /**

     * @deprecated

     */

    @Override

    public void registerDefaultRasterStore(Class rasterStoreClass) {

        // Metodo usado por el raster nuevo para regstrar su factoria de store

        this.getStoreRegister().register(new RasterStoreFactory(rasterStoreClass));

    }

    /**

     * @deprecated

     */

    @Override

    public void registerStoreFactory(String name, Class storeFactoryClass) {

        // Metodo usado por el raster viejo para registrar las factorias de sus stores

        this.getStoreRegister().register(new RasterStoreOldFactory(name, storeFactoryClass));

    }

    /**

     * @param name

     * @param storeProviderClass

     * @param parametersClass

     * @deprecated use registerStoreProviderFactory

     */

    @Override

    public void registerStoreProvider(String name, Class storeProviderClass,

            Class parametersClass) {

        if (name == null || storeProviderClass == null || parametersClass == null) {

            throw new IllegalArgumentException("Any parameters can be null");

        }

        if (!DataStoreParameters.class.isAssignableFrom(parametersClass)) {

            throw new IllegalArgumentException(parametersClass.getName()

                    + " must implement org.gvsig.fmap.dal.DataStoreParameters");

        }

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

            // Envuelve al proveedor en una factoria por defecto.

            this.registerStoreProviderFactory(new DataStoreProviderToCoverageProviderFactoryWrapper(

                    name, "", storeProviderClass, parametersClass));

            return;

        }

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

            // Envuelve al proveedor en una factoria por defecto.

            this.registerStoreProviderFactory(new DataStoreProviderToFeatureStoreProviderFactoryWrapper(

                    name, "", storeProviderClass, parametersClass));

            return;

        }

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

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

    }

    @Override

    public void registerExplorerProvider(String name, Class explorerClass, Class parametersClass) {

        if (name == null || explorerClass == null || parametersClass == null) {

            // FIXME Exception

            throw new IllegalArgumentException("Any parameters can be null");

        }

        if (!DataServerExplorerParameters.class

                .isAssignableFrom(parametersClass)) {

            // FIXME Exception

            throw new IllegalArgumentException(

                    parametersClass.getName()

                    + " must implement org.gvsig.fmap.dal.DataServerExplorerParameters");

        }

        if (!DataServerExplorer.class.isAssignableFrom(explorerClass)) {

            // FIXME Exception

            throw new IllegalArgumentException(explorerClass.getName()

                    + " must implement org.gvsig.fmap.dal.DataServerExplorer");

        }

        // Envuelve al proveedor en una factoria por defecto.

        this.registerServerExplorerFactory(

                new DataServerExplorerToDataExplorerFactoryWrapper(

                        name, "", explorerClass, parametersClass

                )

        );

    }

    @Override

    public void registerStoreFactory(DataStoreFactory_v2_4 factory) {

        this.getStoreRegister().register(factory);

    }

    @Override

    public void registerStoreProviderFactory(DataStoreProviderFactory factory) {

        this.getStoreProviderRegister().register(factory);

    }

    @Override

    public void registerServerExplorerFactory(DataServerExplorerFactory factory) {

        this.getServerExplorerRegister().register(factory);

    }

    @Override

    public DataStoreParameters createStoreParameters(String providerName) throws InitializeException, ProviderNotRegisteredException {

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        return (DataStoreParameters) providerFactory.createParameters();

    }

    @Override

    public NewDataStoreParameters createNewStoreParameters(String explorerName, String providerName) throws InitializeException, ProviderNotRegisteredException {

        try {

            DataServerExplorer explorer = this.openServerExplorer(explorerName, (DataServerExplorerParameters)null);

            return explorer.getAddParameters(providerName);

        } catch (Exception ex) {

            throw new InitializeException(ex);

        }

    }

    @Override

    public DataServerExplorerParameters createServerExplorerParameters(String explorerName) throws InitializeException, ProviderNotRegisteredException {

        DataFactory explorerFactory = this.getServerExplorerRegister().getFactory(explorerName);

        DataServerExplorerParameters params = (DataServerExplorerParameters) explorerFactory.createParameters();

        return params;

    }

    @Override

    public DataStoreParameters createMemoryStoreParameters(String autoOrderAttributeName) throws InitializeException {

        try {

            DataStoreParameters parameters = createStoreParameters(MemoryStoreProvider.NAME);

            if (autoOrderAttributeName != null) {

                parameters.setDynValue(

                        MemoryStoreParameters.ORDER_PARAMETER_NAME,

                        autoOrderAttributeName);

            }

            return parameters;

        } catch (Exception ex) {

            throw new InitializeException(ex);

        }

    }

    @Override

    public DataServerExplorer openServerExplorer(String explorerName, DataServerExplorerParameters parameters) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        DataFactory explorerFactory = this.getServerExplorerRegister().getFactory(explorerName);

        if (parameters == null) {

            parameters = (DataServerExplorerParameters) explorerFactory.createParameters();

        }

        DataServerExplorer explorer = (DataServerExplorer) explorerFactory.create(

                parameters,

                new DefaultDataServerExplorerProviderServices()

        );

        return explorer;

    }

    @Override

    public DataServerExplorer openServerExplorer(String explorerName, Object... arguments) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        if( (arguments.length % 2)!= 0 ) {

            throw new ValidateDataParametersException();

        }

        DataFactory explorerFactory = this.getServerExplorerRegister().getFactory(explorerName);

        DataServerExplorerParameters parameters = (DataServerExplorerParameters) explorerFactory.createParameters();

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

            String name = (String) arguments[i];

            Object value = arguments[i+1];

            parameters.setDynValue(name, value);

        }

        return this.openServerExplorer(explorerName, parameters);

    }

    /**

     * @param parameters

     * @return

     * @throws org.gvsig.fmap.dal.exception.InitializeException

     * @throws org.gvsig.fmap.dal.exception.ProviderNotRegisteredException

     * @throws org.gvsig.fmap.dal.exception.ValidateDataParametersException

     * @deprecated see openServerExplorer

     */

    @Override

    public DataServerExplorer createServerExplorer(

            DataServerExplorerParameters parameters) throws InitializeException,

            ProviderNotRegisteredException, ValidateDataParametersException {

        return openServerExplorer(parameters.getExplorerName(), parameters);

    }

    /**

     * @deprecated use openStore

     * @param parameters

     * @return

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     * @throws ValidateDataParametersException 

     */

    @Override

    public DataStore createStore(DataStoreParameters parameters)

        throws InitializeException, ProviderNotRegisteredException,

        ValidateDataParametersException {

        return openStore(parameters.getDataStoreName(), parameters);

    }

    @Override

    public DataStore openStore(String providerName, DataStoreParameters parameters) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        SimpleIdentityManager identityManager = ToolsLocator.getIdentityManager();

        if (!identityManager.getCurrentIdentity().isAuthorized(READ_STORE_AUTHORIZATION, parameters, providerName)) {

            throw new UnauthorizedException(READ_STORE_AUTHORIZATION, parameters, providerName);

        }

        parameters.validate();

        String storeName = this.getStoreName(parameters);

        DataStoreFactory_v2_4 storeFactory = (DataStoreFactory_v2_4) this.getStoreRegister().getFactory(storeName);

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        DataStore store = (DataStore) storeFactory.create(parameters, this);

        DataStoreProvider provider = (DataStoreProvider) providerFactory.create(parameters, store);

        storeFactory.setProvider(store, provider);

        return store;

    }

    @Override

    public DataStore openStore(String provider, DynObject parameters) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        DataStoreParameters params = toDataStoreParameters(provider, parameters);

        DataStore store = openStore(params.getDataStoreName(), params);

        return store;

    }

    @Override

    public DataStore openStore(String providerName, Object... arguments) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        if( (arguments.length % 2)!= 0 ) {

            throw new ValidateDataParametersException();

        }

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        DataStoreParameters parameters = (DataStoreParameters) providerFactory.createParameters();

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

            String name = (String) arguments[i];

            Object value = arguments[i+1];

            parameters.setDynValue(name, value);

        }

        return this.openStore(providerName, parameters);

    }

    @Override

    public FeatureStore createMemoryStore(String autoOrderAttributeName) throws InitializeException {

        try {

            DataStoreParameters parameters = createMemoryStoreParameters(autoOrderAttributeName);

            DataStore store = openStore(MemoryStoreProvider.NAME, parameters);

            return (FeatureStore) store;

        } catch (Exception ex) {

            throw new InitializeException(ex);

        }

    }

    @Override

    public DataStoreProviderFactory getStoreProviderFactory(String providerName) {

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        return (DataStoreProviderFactory) providerFactory;

    }

    @Override

    public List<String> getStoreProviders() {

        return this.getStoreProviderRegister().getFactoryNames();

    }

    @Override

    public List<String> getStoreProviders(String explorerName) {

        try {

            DataServerExplorer explorer = openServerExplorer(explorerName, (DataServerExplorerParameters)null);

            List names = explorer.getDataStoreProviderNames();

            return names;

        } catch (Exception ex) {

            throw new RuntimeException("Can't get stores availables for explorer '" + explorerName + "'.", ex);

        }

    }

    @Override

    public List<String> getExplorerProviders() {

        List<String> names = this.getServerExplorerRegister().getFactoryNames();

        return names;

    }

    @Override

    public DataStoreProvider createProvider(DataStoreProviderServices providerServices, DataStoreParameters parameters) throws InitializeException, ProviderNotRegisteredException {

        String providerName = parameters.getDataStoreName();

        DataFactory providerFactory = this.getStoreProviderRegister().getFactory(providerName);

        if (providerFactory == null) {

            throw new ProviderNotRegisteredException(providerName);

        }

        while (true) {

            try {

                DataStoreProvider provider = (DataStoreProvider) providerFactory.create(

                        parameters, providerServices

                );

                return provider;

            } catch (Exception e) {

                if (openErrorHandler == null) {

                    throw new InitializeException(providerName, e);

                }

                boolean retry = openErrorHandler.canRetryOpen(e, parameters);

                if (!retry) {

                    throw new InitializeException(providerName, e);

                }

            }

        }

    }

    @Override

    public List<String> getFeatureIndexProviders() {

        List<String> names = this.getFeatureIndexRegister().getFactoryNames();

        return names;

    }

    @Override

    public void setDefaultFeatureIndexProviderName(int dataType, String name) {

        this.defaultDataIndexProviders.put(dataType, name);

    }

    @Override

    public String getDefaultFeatureIndexProviderName(int dataType) {

        return this.defaultDataIndexProviders.get(dataType);

    }

    @Override

    public FeatureIndexProviderServices createFeatureIndexProvider(

            String name,

            FeatureStore store,

            FeatureType type,

            String indexName,

            FeatureAttributeDescriptor attr

    ) throws InitializeException, ProviderNotRegisteredException {

        if (name == null) {

            name = getDefaultFeatureIndexProviderName(attr.getType());

        }

        if (name == null) {

            throw new InitializeException(

                    "There not any index provider registered.", null);

        }

        DataFactory indexfactory = this.getFeatureIndexRegister().getFactory(name);

        if (indexfactory == null) {

            throw new InitializeException(

                    "There not any index provider registered with name '" + name + "'.", null);

        }

        FeatureIndexProvider provider = (FeatureIndexProvider) indexfactory.create(null, null);

        FeatureIndexProviderServices services = new DefaultFeatureIndex(

                (FeatureStoreProviderServices) store,

                type,

                provider,

                attr.getName(),

                indexName

        );

        services.initialize();

        return services;

    }

    @Override

    public String getTemporaryDirectory() {

        // FIXME Define a better tempdir solution

        String tmp = System.getProperty("TMP");

        if (tmp == null) {

            tmp = System.getProperty("TEMP");

        }

        if (tmp == null) {

            File tmp_file = new File(System.getProperty("HOME"), "_daltmp_");

            int i = 1;

            while (!tmp_file.exists() || !tmp_file.isDirectory()) {

                tmp_file = new File(tmp_file.getAbsolutePath() + i);

                i++;

            }

            if (!tmp_file.exists()) {

                tmp_file.mkdir();

            }

            tmp = tmp_file.getAbsolutePath();

        }

        return tmp;

    }

    @Override

    public DataStoreParameters createStoreParameters(DynStruct struct) throws InitializeException, ProviderNotRegisteredException {

        if (!(struct instanceof DynStruct_v2)) {

            throw new IllegalArgumentException("A DynStruct_v2 is required.");

        }

        Tags tags = ((DynStruct_v2) struct).getTags();

        return this.createStoreParameters(tags);

    }

    @Override

    public DataStoreParameters createStoreParameters(Tags tags) throws InitializeException, ProviderNotRegisteredException {

        String providerName = (String) tags.get(TAG_DAL_OPENSTORE + "provider");

        if (providerName == null) {

            throw new IllegalArgumentException("Tag DAL.OpenStore.provider is missing in struct.");

        }

        int prefixlen = TAG_DAL_OPENSTORE.length();

        DataStoreParameters parameters = this.createStoreParameters(providerName);

        for (String key : tags) {

            if (key.startsWith(TAG_DAL_OPENSTORE)) {

                parameters.setDynValue(key.substring(prefixlen), tags.get(key));

            }

        }

        return parameters;

    }

    @Override

    public DataStore openStore(DynStruct struct) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        DataStoreParameters paramters = this.createStoreParameters(struct);

        DataStore store = this.openStore(paramters.getDataStoreName(), paramters);

        return store;

    }

    @Override

    public void newStore(String explorerName, String providerName, NewDataStoreParameters parameters, boolean overwrite) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        SimpleIdentityManager identityManager = ToolsLocator.getIdentityManager();

        if (!identityManager.getCurrentIdentity().isAuthorized(CREATE_STORE_AUTHORIZATION, parameters, providerName)) {

            throw new UnauthorizedException(CREATE_STORE_AUTHORIZATION, parameters, providerName);

        }

        parameters.validate();

        try {

            DataServerExplorerParameters explorerParameters = this.createServerExplorerParameters(explorerName);

            DataServerExplorer server = this.openServerExplorer(explorerName, explorerParameters);

            server.add(providerName, parameters, overwrite);

        } catch (Exception e) {

            throw new InitializeException(e);

        }

    }

    @Override

    public void registerDefaultEvaluator(Class evaluatorClass) {

        if (!Evaluator.class.isAssignableFrom(evaluatorClass)) {

            throw new ClassCastException();

        }

        this.defaultEvaluatorClass = evaluatorClass;

    }

    @Override

    public Evaluator createExpresion(String expression) throws InitializeException {

        try {

            Evaluator eval = (Evaluator) this.defaultEvaluatorClass.

                    getConstructor(String.class).newInstance(expression);

            return eval;

        } catch (Exception ex) {

            throw new InitializeException(ex);

        }

    }

    @Override

    public  ExpressionEvaluator createExpresion() {

        return new ExpressionEvaluatorBase();

    }

    @Override

    public FeaturePagingHelper createFeaturePagingHelper(

            FeatureStore featureStore, int pageSize) throws BaseException {

        return new FeaturePagingHelperImpl(featureStore, pageSize);

    }

    @Override

    public FeaturePagingHelper createFeaturePagingHelper(

            FeatureStore featureStore, FeatureQuery featureQuery, int pageSize)

            throws BaseException {

        return new FeaturePagingHelperImpl(featureStore, featureQuery, pageSize);

    }

    @Override

    public void setOpenErrorHandler(OpenErrorHandler handler) {

        openErrorHandler = handler;

    }

    @Override

    public OpenErrorHandler getOpenErrorHandler() {

        return this.openErrorHandler;

    }

    @Override

    public EditableFeatureType createFeatureType() {

        return new DefaultEditableFeatureType();

    }

    @Override

    public DataServerExplorerPool getDataServerExplorerPool() {

        if (this.dataServerExplorerPool == null) {

            this.dataServerExplorerPool = new DefaultDataServerExplorerPool();

        }

        return this.dataServerExplorerPool;

    }

    @Override

    public void setDataServerExplorerPool(DataServerExplorerPool pool) {

        this.dataServerExplorerPool = pool;

    }

    public DataStoreParameters toDataStoreParameters(String provider, DynObject params) throws InitializeException, ProviderNotRegisteredException {

        if (params instanceof DataStoreParameters) {

            return (DataStoreParameters) params;

        }

        String providerName;

        try {

            providerName = (String) params.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

        } catch (Exception ex) {

            providerName = provider;

        }

        DataStoreParameters parameters = this.createStoreParameters(providerName);

        ToolsLocator.getDynObjectManager().copy(params, parameters);

        return parameters;

    }

    @Override

    public List<DataType> getDataTypes() {

        if (dataTypes == null) {

            DataTypesManager manager = ToolsLocator.getDataTypesManager();

            dataTypes = new ArrayList<>();

            dataTypes.add(manager.get(DataTypes.STRING));

            dataTypes.add(manager.get(DataTypes.BOOLEAN));

            dataTypes.add(manager.get(DataTypes.INT));

            dataTypes.add(manager.get(DataTypes.DOUBLE));

            dataTypes.add(manager.get(DataTypes.DATE));

            dataTypes.add(manager.get(DataTypes.GEOMETRY));

        }

        return dataTypes;

    }

    @Override

    public void setResourcesLoader(ClassLoader loader) {

        this.resourcesLoader = loader;

    }

    @Override

    public void setResourcesLoader(File folder) {

        if (folder == null) {

            this.resourcesLoader = null;

            return;

        }

        try {

            URL[] urls = new URL[]{folder.toURI().toURL()};

            this.resourcesLoader = new URLClassLoader(urls);

        } catch (Exception ex) {

            throw new IllegalArgumentException("Can't create a ClassLoader from '" + folder.toString() + "'.", ex);

        }

    }

    @Override

    public URL getResource(Object reourceLoader, String name) {

        URL x;

        if (this.resourcesLoader != null) {

            x = this.resourcesLoader.getResource(name);

            if (x != null) {

                return x;

            }

        }

        x = reourceLoader.getClass().getResource(name);

        return x;

    }

    @Override

    public InputStream getResourceAsStream(Object reourceLoader, String name) {

        InputStream x;

        if (this.resourcesLoader != null) {

            x = this.resourcesLoader.getResourceAsStream(name);

            if (x != null) {

                return x;

            }

        }

        x = reourceLoader.getClass().getResourceAsStream(name);

        return x;

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        return new ExpressionBuilderBase();

    }

    public void registerFeatureCacheProvider(

        FeatureCacheProviderFactory providerFactory) {

        ToolsLocator.getExtensionPointManager()

            .add(DATA_MANAGER_CACHE, DATA_MANAGER_CACHE_DESCRIPTION)

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

    }

    public FeatureCacheProvider createFeatureCacheProvider(String name,

        DynObject parameters) throws DataException {

        if (name == null) {

            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);

        }

        FeatureCacheProviderFactory featureCacheProviderFactory;

        try {

            featureCacheProviderFactory =

                (FeatureCacheProviderFactory) ToolsLocator

                    .getExtensionPointManager().get(DATA_MANAGER_CACHE)

                    .create(name);

            if (featureCacheProviderFactory == null) {

                throw new ProviderNotRegisteredException(name);

            }

            return featureCacheProviderFactory.createCacheProvider(parameters);

        } catch (InstantiationException e) {

            throw new InitializeException(e);

        } catch (IllegalAccessException e) {

            throw new InitializeException(e);

        }

    }

    @Override

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

        }

    }

    @Override

    public DynObject createCacheParameters(String name)

        throws InitializeException, ProviderNotRegisteredException {

        if (name == null) {

            throw new InitializeException(

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

        }

        FeatureCacheProviderFactory featureCacheProviderFactory;

        try {

            featureCacheProviderFactory =

                (FeatureCacheProviderFactory) ToolsLocator

                    .getExtensionPointManager().get(DATA_MANAGER_CACHE)

                    .create(name);

            if (featureCacheProviderFactory == null) {

                throw new ProviderNotRegisteredException(name);

            }

            return featureCacheProviderFactory.createParameters();

        } catch (InstantiationException e) {

            throw new InitializeException(e);

        } catch (IllegalAccessException e) {

            throw new InitializeException(e);

        }

    }

}