Application: gvSIG desktop

package org.gvsig.fmap.dal.impl;

import java.io.File;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreFactory;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

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.spi.CoverageStoreProvider;

import org.gvsig.fmap.dal.resource.ResourceManager;

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

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

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

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.dynobject.DynObject;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension;

import org.gvsig.tools.operations.OperationManager;

public class DefaultDataManager implements DataManager,

DataManagerProviderServices {

    final static private String DATA_MANAGER_STORE = "Data.manager.stores";

    final static private String DATA_MANAGER_STORE_DESCRIPTION = "DAL stores providers";

    final static private String DATA_MANAGER_STORE_PARAMS = "Data.manager.stores.params";

    final static private String DATA_MANAGER_STORE_PARAMS_DESCRIPTION = "DAL stores providers parameters";

    final static private String DATA_MANAGER_EXPLORER = "Data.manager.explorers";

    final static private String DATA_MANAGER_EXPLORER_DESCRIPTION = "DAL explorers providers";

    final static private String DATA_MANAGER_EXPLORER_PARAMS = "Data.manager.explorers.params";

    final static private String DATA_MANAGER_EXPLORER_PARAMS_DESCRIPTION = "DAL explorer providers parameters";

    final static private String DATA_MANAGER_INDEX = "Data.manager.indexes";

    final static private String DATA_MANAGER_INDEX_DESCRIPTION = "DAL index providers";

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

    final static private String DATA_MANAGER_CACHE_DESCRIPTION = "DAL cache providers";

    final static private String DATA_MANAGER_EXPRESION_EVALUATOR = "Data.manager.expresion.evaluator";

    final static private String DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT = "default";

    final static private String DATA_MANAGER_EXPRESION_EVALUATOR_DESCRIPTION = "DAL expresion evaluators.";

    final static private String DATA_MANAGER_STORE_FACTORY = "Data.manager.stores.factory";

    final static private String DATA_MANAGER_STORE_FACTORY_DESCRIPTION = "DAL stores factories";

    final static private String DATA_MANAGER_FEATURE_ATTTRIBUTE_GETTER = "Data.manager.feature.attribute.getter";

    final static private String DATA_MANAGER_FEATURE_ATTTRIBUTE_GETTER_DESCRIPTION = "DAL feature attribute getters";

    /** This map contains the name of the default provider for each data type */

    private Map defaultDataIndexProviders;

    public DefaultDataManager() {

        /*

         * Create te extensions point in te registry.

         */

        ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_STORE,

            DATA_MANAGER_STORE_DESCRIPTION);

        ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_STORE_PARAMS,

            DATA_MANAGER_STORE_PARAMS_DESCRIPTION);

        ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_EXPLORER,

            DATA_MANAGER_EXPLORER_DESCRIPTION);

        ToolsLocator.getExtensionPointManager().add(

            DATA_MANAGER_EXPLORER_PARAMS,

            DATA_MANAGER_EXPLORER_PARAMS_DESCRIPTION);

        ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_INDEX,

            DATA_MANAGER_INDEX_DESCRIPTION);

        ToolsLocator.getExtensionPointManager().add(

            DATA_MANAGER_EXPRESION_EVALUATOR,

            DATA_MANAGER_EXPRESION_EVALUATOR_DESCRIPTION);

        initializeIndexes();

    }

    /**

     *

     * @return ResourceManager

     */

    public ResourceManager getResourceManager() {

        return DALLocator.getResourceManager();

    }

    public OperationManager getOperationManager() {

        return ToolsLocator.getOperationManager();

    }

    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;

    }

    /*

     * ====================================================================

     * 

     * Store related services

     */

    public void registerStoreProvider(String name, Class storeProviderClass,

        Class parametersClass) {

        if (name == null || storeProviderClass == null

            || parametersClass == null) {

            // FIXME Exception

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

        }

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

            // FIXME Exception

            throw new IllegalArgumentException(parametersClass.getName()

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

        }

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

        } else if (FeatureStoreProvider.class

            .isAssignableFrom(storeProviderClass)) {

        } else {

            // FIXME Exception

            throw new IllegalArgumentException(

                "Not supported implemtation: name=" + name

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

        }

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

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.fmap.dal.spi.DataManagerProviderServices#registerStoreFactory(java.lang.String, java.lang.Class)

     */

    public void registerStoreFactory(String name, Class storeProviderClass) {

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

            // FIXME Exception

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

        }

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

            // FIXME Exception

            throw new IllegalArgumentException(

                "Not supported implemtation: name=" + name

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

        }

        ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_STORE_FACTORY,

            DATA_MANAGER_STORE_FACTORY_DESCRIPTION).append(name, null,

                storeProviderClass);

    }

    public DataStoreParameters createStoreParameters(String name)

    throws InitializeException, ProviderNotRegisteredException {

        try {

            DataStoreParameters params = (DataStoreParameters) ToolsLocator

            .getExtensionPointManager().get(DATA_MANAGER_STORE_PARAMS)

            .create(name);

            if (params == null) {

                throw new ProviderNotRegisteredException(name);

            }

            return params;

        } catch (InstantiationException e) {

            throw new InitializeException(e);

        } catch (IllegalAccessException e) {

            throw new InitializeException(e);

        } catch (SecurityException e) {

            throw new InitializeException(e);

        } catch (IllegalArgumentException e) {

            throw new InitializeException(e);

        }

    }

    public DataStore openStore(String provider, DataStoreParameters parameters)

    throws InitializeException, ProviderNotRegisteredException,

    ValidateDataParametersException {

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

        parameters.validate();

        DataStore store;

        Extension storeProviderExtension = ToolsLocator

        .getExtensionPointManager().get(DATA_MANAGER_STORE).get(name);

        if (storeProviderExtension == null) {

            throw new ProviderNotRegisteredException(name);

        }

        Class providerClass = storeProviderExtension.getExtension();

        if (providerClass == null) {

            throw new ProviderNotRegisteredException(name);

        }

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

            ExtensionPoint.Extension point = ToolsLocator.getExtensionPointManager().

            get(DATA_MANAGER_STORE_FACTORY).get(name);

            DataStoreFactory factory = null;

            try {

                factory = (DataStoreFactory)point.create();

            } catch (InstantiationException e) {

                throw new InitializeException(e);

            } catch (IllegalAccessException e) {

                throw new InitializeException(e);

            }

            factory.setParameters(parameters);

            store = factory.createStore();

        } else if (FeatureStoreProvider.class.isAssignableFrom(providerClass)) {

            store = new DefaultFeatureStore();

        } else {

            // FIXME Exception

            throw new InitializeException(name, new RuntimeException(

                "Not supported implemtation: name=" + name

                + " provider class=" + providerClass.getName()));

        }

        this.intializeDataStore(store, parameters);

        return store;

    }

    /**

     * @deprecated see openStore

     */

    public DataStore createStore(DataStoreParameters parameters)

    throws InitializeException, ProviderNotRegisteredException,

    ValidateDataParametersException {

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

    }

    public List getStoreProviders() {

        return ToolsLocator.getExtensionPointManager().get(DATA_MANAGER_STORE)

        .getNames();

    }

    public List getStoreProviders(String name) {

        return getStoreProviders(); // FIXME: need filter from the name of

        // the explorer

    }

    public NewDataStoreParameters createNewStoreParameters(String explorer,

        String provider) throws InitializeException,

        ProviderNotRegisteredException {

        DataServerExplorerParameters parameters;

        DataServerExplorer server;

        try {

            parameters = this.createServerExplorerParameters(explorer);

            server = this.openServerExplorerWithoutValidate(explorer, parameters);

            return server.getAddParameters(provider);

        } catch (ValidateDataParametersException e) {

            throw new InitializeException(e);

        } catch (DataException e) {

            throw new InitializeException(e);

        }

    }

    public void newStore(String explorer, String provider, NewDataStoreParameters parameters, boolean overwrite)

    throws InitializeException, ProviderNotRegisteredException,

    ValidateDataParametersException {

        parameters.validate();

        DataServerExplorerParameters explorerParameters;

        DataServerExplorer server;

        explorerParameters = this.createServerExplorerParameters(explorer);

        server = this.openServerExplorerWithoutValidate(explorer, explorerParameters);

        try {

            server.add(provider, parameters, overwrite);

        } catch (DataException e) {

            throw new InitializeException(e);

        }

    }

    /*

     * ====================================================================

     *

     * Explorer related services

     */

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

        }

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

    }

    public DataServerExplorerParameters createServerExplorerParameters(

        String name) throws InitializeException,

        ProviderNotRegisteredException {

        try {

            DataServerExplorerParameters params = (DataServerExplorerParameters) ToolsLocator

            .getExtensionPointManager().get(

                DATA_MANAGER_EXPLORER_PARAMS).create(name);

            if (params == null) {

                throw new ProviderNotRegisteredException(name);

            }

            return params;

        } catch (InstantiationException e) {

            throw new InitializeException(e);

        } catch (IllegalAccessException e) {

            throw new InitializeException(e);

        } catch (SecurityException e) {

            throw new InitializeException(e);

        } catch (IllegalArgumentException e) {

            throw new InitializeException(e);

        }

    }

    public DataServerExplorer openServerExplorer(

        String explorer, 

        DataServerExplorerParameters parameters)

    throws InitializeException, ProviderNotRegisteredException,

    ValidateDataParametersException {

        if( parameters != null ) {

            parameters.validate();

        }

        return this.openServerExplorerWithoutValidate(explorer, parameters);

    }

    private DataServerExplorer openServerExplorerWithoutValidate(

        String explorerName, 

        DataServerExplorerParameters parameters)

    throws InitializeException, ProviderNotRegisteredException,

    ValidateDataParametersException {

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

        try {

            DataServerExplorerProvider server = (DataServerExplorerProvider) ToolsLocator

            .getExtensionPointManager()

            .get(DATA_MANAGER_EXPLORER)

            .create(

                name,

                new Object[] {

                    parameters,

                    new DefaultDataServerExplorerProviderServices() });

            if (server == null) {

                throw new ProviderNotRegisteredException(name);

            }

            return server;

        } catch (InstantiationException e) {

            throw new InitializeException(e);

        } catch (IllegalAccessException e) {

            throw new InitializeException(e);

        } catch (SecurityException e) {

            throw new InitializeException(e);

        } catch (IllegalArgumentException e) {

            throw new InitializeException(e);

        } catch (NoSuchMethodException e) {

            throw new InitializeException(e);

        } catch (InvocationTargetException e) {

            throw new InitializeException(e);

        }

    }

    /**

     * @deprecated see openServerExplorer

     */

    public DataServerExplorer createServerExplorer(

        DataServerExplorerParameters parameters)

    throws InitializeException, ProviderNotRegisteredException,

    ValidateDataParametersException {

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

    }

    public List getExplorerProviders() {

        return ToolsLocator.getExtensionPointManager().get(

            DATA_MANAGER_EXPLORER).getNames();

    }

    /*

     * ====================================================================

     *

     * Expresion evaluation related services

     */

    public Evaluator createExpresion(String expresion)

    throws InitializeException {

        try {

            return (Evaluator) ToolsLocator.getExtensionPointManager().get(

                DATA_MANAGER_EXPRESION_EVALUATOR).create(

                    DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT,

                    new Object[] { expresion });

        } catch (SecurityException e) {

            throw new InitializeException(e);

        } catch (IllegalArgumentException e) {

            throw new InitializeException(e);

        } catch (NoSuchMethodException e) {

            throw new InitializeException(e);

        } catch (InstantiationException e) {

            throw new InitializeException(e);

        } catch (IllegalAccessException e) {

            throw new InitializeException(e);

        } catch (InvocationTargetException e) {

            throw new InitializeException(e);

        }

    }

    public void registerDefaultEvaluator(Class evaluatorClass) {

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

            throw new ClassCastException();

        }

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

    }

    /*

     * ====================================================================

     *

     * Index related services

     */

    public List getFeatureIndexProviders() {

        return ToolsLocator.getExtensionPointManager().get(DATA_MANAGER_INDEX)

        .getNames();

    }

    public void setDefaultFeatureIndexProviderName(int dataType, String name) {

        defaultDataIndexProviders.put(new Integer(dataType), name);

    }

    public String getDefaultFeatureIndexProviderName(int dataType) {

        return (String) defaultDataIndexProviders.get(new Integer(dataType));

    }

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

        }

        try {

            FeatureIndexProvider provider = (FeatureIndexProvider) ToolsLocator

            .getExtensionPointManager().get(DATA_MANAGER_INDEX).create(

                name);

            if (provider == null) {

                throw new ProviderNotRegisteredException(name);

            }

            FeatureIndexProviderServices services = new DefaultFeatureIndex(

                (FeatureStoreProviderServices) store, type, provider, attr

                .getName(), indexName);

            services.initialize();

            return services;

        } catch (InstantiationException e) {

            throw new InitializeException(e);

        } catch (IllegalAccessException e) {

            throw new InitializeException(e);

        } catch (SecurityException e) {

            throw new InitializeException(e);

        } catch (IllegalArgumentException e) {

            throw new InitializeException(e);

        }

    }

    public void registerFeatureIndexProvider(String name, String description,

        Class clazz, int dataType) {

        ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_INDEX,

            DATA_MANAGER_INDEX_DESCRIPTION).append(name, null, clazz);

        if (getDefaultFeatureIndexProviderName(dataType) == null) {

            setDefaultFeatureIndexProviderName(dataType, name);

        }

    }

    private void initializeIndexes() {

        this.defaultDataIndexProviders = new HashMap();

    }

    public void intializeDataStore(DataStore store,

        DataStoreParameters parameters) throws InitializeException,

        ProviderNotRegisteredException {

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

        try {

            provider = (DataStoreProvider) ToolsLocator

            .getExtensionPointManager().get(DATA_MANAGER_STORE).create(

                name,

                new Object[] { parameters, providerServices });

        } catch (Exception e) {

            throw new InitializeException(parameters.getDataStoreName(), e);

        }

        if (provider == null) {

            throw new ProviderNotRegisteredException(name);

        }

        return provider;

    }

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

        }       

    }

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

        }  

    }

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

        }       

    }

    public DataStoreParameters createMemoryStoreParameters(

        String autoOrderAttributeName) throws InitializeException {

        DataStoreParameters parameters;

        try {

            parameters = createStoreParameters(MemoryStoreProvider.NAME);

            if (autoOrderAttributeName != null) {

                parameters.setDynValue(

                    MemoryStoreParameters.ORDER_PARAMETER_NAME,

                    autoOrderAttributeName);

            }

            return parameters;

        } catch (ProviderNotRegisteredException e) {

            throw new InitializeException("MemoryStoreProvider", e);

        }

    }

    public FeatureStore createMemoryStore(String autoOrderAttributeName)

    throws InitializeException {

        DataStoreParameters parameters = createMemoryStoreParameters(autoOrderAttributeName);

        try {

            return (FeatureStore) createStore(parameters);

        } catch (ValidateDataParametersException e) {

            throw new InitializeException("MemoryStoreProvider", e);

        } catch (ProviderNotRegisteredException e) {

            throw new InitializeException("MemoryStoreProvider", e);

        }

    }

    public FeaturePagingHelper createFeaturePagingHelper(

        FeatureStore featureStore, int pageSize) throws BaseException {

        return new FeaturePagingHelperImpl(featureStore, pageSize);

    }

    public FeaturePagingHelper createFeaturePagingHelper(

        FeatureStore featureStore, FeatureQuery featureQuery, int pageSize)

    throws BaseException {

        return new FeaturePagingHelperImpl(featureStore, featureQuery, pageSize);

    }

    public void registerFeatureAttributeGetter(String name, Class clazz) {

        if (name == null || clazz == null) {           

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

        }

        if(!(FeatureAttributeGetter.class.isAssignableFrom(clazz))) {            

            throw new IllegalArgumentException(

                "Not supported implemtation: name=" + name

                + " class=" + clazz.getName());

        }

        ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_FEATURE_ATTTRIBUTE_GETTER,

            DATA_MANAGER_FEATURE_ATTTRIBUTE_GETTER_DESCRIPTION).append(name, null,

                clazz);

    }

    public FeatureAttributeGetter createFeatureAttributeGetter(String name) throws InitializeException {

        if (name == null) {           

            throw new IllegalArgumentException("The parameter can not be null");

        }

        try{

            return (FeatureAttributeGetter) ToolsLocator.getExtensionPointManager().get(DATA_MANAGER_FEATURE_ATTTRIBUTE_GETTER).create(name);

        } catch (InstantiationException e) {

            throw new InitializeException("FeatureAttributeGetter", e);

        } catch (IllegalAccessException e) {

            throw new InitializeException("FeatureAttributeGetter", e);

        }

    }

}