Application: gvSIG desktop

package org.gvsig.data;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.data.operation.DataStoreOperation;

import org.gvsig.data.operation.DataStoreOperationContext;

import org.gvsig.data.operation.DataStoreOperationException;

import org.gvsig.data.operation.DataStoreOperationNotSupportedException;

import org.gvsig.data.vectorial.AbstractFeatureStore;

public class DataManager {

        private static ArrayList registers = new ArrayList();

        private static DataManager manager = null;

        public static DataManager getManager() {

                if( manager == null ) {

                        manager = new DataManager();

                }

                return manager;

        }

        public static ResourceManager getResourceManager() {

                return ResourceManager.getResourceManager();

        }

        private List dataStoreOperations = new ArrayList();

        public DataManager() {

//                org.gvsig.data.datastores.vectorial.driver.shp.Register.selfRegister();

//                org.gvsig.data.datastores.vectorial.driver.Register.selfRegister();

//                org.gvsig.data.datastores.gml.Register.selfRegister();

        }

        public void registerGeometryHandler(String dataStoreID, Class geometryHandlerClass) {

        }

        public void registerDataStore(String name, Class dataStoreClass, Class parametersClass) {

                RegisterInfo register=new RegisterInfo(name,dataStoreClass,parametersClass);

                if (registers.contains(register)){

                        return;

                }

                registers.add(register);

        }

        /**

         * Levanta una instancia de los parametros solicitados

         * inicializa el nombre en la instancia

         * y la devuelve.

         * @throws InitializeException TODO

         **/

        public DataStoreParameters createDataStoreParameters(String name) throws InitializeException{

                RegisterInfo registerInfo = this.getRegisterByName(name);

                if (registerInfo == null){

                        throw new InitializeException("Not registered in manager",name);

                }

                try {

                        return (DataStoreParameters)registerInfo.parametersClazz.newInstance();

                } catch (InstantiationException e) {

                        throw new InitializeException(name,e);

                } catch (IllegalAccessException e) {

                        throw new InitializeException(name,e);

                }

        }

        /**

         * Levanta la instancia del datasource,

         * levanta una instancia del driver que precisa el datasource

         * y por ultimo invoca al metodo init del datasource.

         * @throws InitializeException

         **/

        public DataStore createDataStore(DataStoreParameters parameters) throws InitializeException {

                String name = parameters.getDataStoreName();

                RegisterInfo registerInfo = this.getRegisterByName(name);

                if (registerInfo == null){

                        throw new InitializeException("Not registered in manager",name);

                }

                try {

                        DataStore dataStore= (DataStore)registerInfo.clazz.newInstance();

                        dataStore.init(parameters);

                        return dataStore;

                } catch (InstantiationException e) {

                        throw new InitializeException(name,e);

                } catch (IllegalAccessException e) {

                        throw new InitializeException(name,e);

                }

        }

        /* Como conjunto de propiedades genericas a un tipo de DataStore

         * a las que se puede acceder sin tener que crear un DataStore/Driver.

         *

         * Por ejemplo para "DriverDataSource.shp" podria tener el

         * tamaño de identificador de campo.

         *

         * En "DriverDataSource.postgres" podria aportar informacion sobre

         * las tablas disponibles o cosas asi. Hay que ver que precisa

         * GeoDB y de donde lo puede obtener.

         *

         * Hay que pensarlo bien.

         *

         */

        public void registerDataExplorer(String name, Class dataSourceClass, Class parametersClass) {

                RegisterInfo register=new RegisterInfo(name,dataSourceClass,parametersClass);

                if (registers.contains(register)){

                        return;

                }

                registers.add(register);

        }

        /**

         * Levanta una instancia de los parametros solicitados

         * inicializa el nombre en la instancia

         * y la devuelve.

         * @throws InitializeException TODO

         **/

        public DataExplorerParameters createDataExplorerParameters(String name) throws InitializeException {

                RegisterInfo registerInfo = this.getRegisterByName(name);

                if (registerInfo == null){

                        throw new InitializeException("Not registered in manager",name);

                }

                try {

                        return (DataExplorerParameters)registerInfo.parametersClazz.newInstance();

                } catch (InstantiationException e) {

                        throw new InitializeException(name,e);

                } catch (IllegalAccessException e) {

                        throw new InitializeException(name,e);

                }

        }

        public DataExplorer createDataExplorer(DataExplorerParameters parameters) throws InitializeException {

                RegisterInfo registerInfo = this.getRegisterByName(parameters.getDataExplorerName());

                if (registerInfo == null){

                        throw new InitializeException("Not registered in manager",parameters.getDataExplorerName());

                }

                try {

                        DataExplorer dataSource= (DataExplorer)registerInfo.clazz.newInstance();

                        dataSource.init(parameters);

                        return dataSource;

                } catch (InstantiationException e) {

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

                } catch (IllegalAccessException e) {

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

                }

        }

        private RegisterInfo getRegisterByName(String name){

                Iterator iterator=registers.iterator();

                while (iterator.hasNext()) {

                        RegisterInfo registerInfo = (RegisterInfo) iterator.next();

                        if (name.equals(registerInfo.name)){

                                return registerInfo;

                        }

                }

                return null;

        }

        public int registerDataStoreOperation(String storeName, String operationName, DataStoreOperation operation) {

                if (operationName == null){

                        throw new IllegalArgumentException("operationName cannot be null.");

                }

                if (operation == null){

                        throw new IllegalArgumentException("operation cannot be null.");

                }

                RegisterInfo register = this.getRegisterByName(storeName);

                if (register == null){

                        throw new IllegalArgumentException(storeName + " not registered");

                }

                int index = registerGeometryOperationName(operationName);

                register.registerOperation(index, operation);

                return index;

        }

        private int registerGeometryOperationName(String operationName) {

                if (operationName == null)

                        throw new IllegalArgumentException("operationName cannot be null.");

                int index = dataStoreOperations .indexOf(operationName);

                if (index == -1) {

                        dataStoreOperations.add(operationName);

                        index = dataStoreOperations.indexOf(operationName);

                }

                return index;

        }

        private int getOperationIndex(String operationName) {

                return  dataStoreOperations .indexOf(operationName);

        }

        public Object invokeDataStoreOperation(DataStore store,int code,DataStoreOperationContext context) throws DataStoreOperationException, DataStoreOperationNotSupportedException{

                if (code < 0 || code >= dataStoreOperations.size()){

                        throw new DataStoreOperationNotSupportedException(code,"{not registered}",store.getName());

                }

                RegisterInfo register = this.getRegisterByName(store.getName());

                DataStoreOperation operation = register.getOperation(code);

                if (operation == null){

                        throw new DataStoreOperationNotSupportedException(code,(String)this.dataStoreOperations.get(code),store.getName());

                }

                return operation.invoke(store, context);

        }

        public Object invokeDataStoreOperation(DataStore store,String operationName,DataStoreOperationContext context) throws DataStoreOperationException, DataStoreOperationNotSupportedException{

                return this.invokeDataStoreOperation(store, this.getOperationIndex(operationName), context);

        }

        private class RegisterInfo{

                private String name;

                private Class clazz;

                private Class parametersClazz;

                private List operations = new ArrayList();

                public RegisterInfo(String name, Class dsc, Class pc){

                        this.name=name;

                        this.clazz=dsc;

                        this.parametersClazz=pc;

                }

                public boolean equals(Object obj) {

                        if (obj instanceof RegisterInfo){

                                RegisterInfo ri = (RegisterInfo)obj;

                                return ri.name.equals(this.name) &&

                                        ri.clazz.equals(this.clazz) &&

                                        ri.parametersClazz.equals(this.parametersClazz);

                        }

                        return super.equals(obj);

                }

                public void registerOperation(int index, DataStoreOperation operation){

                        while (index > operations.size()) {

                                operations.add(null);

                        }

                        if (index == operations.size()) {

                                operations.add(operation);

                        } else {                                

                                operations.set(index, operation);

                        }

                }

                public DataStoreOperation getOperation(int index){

                        try{

                                return (DataStoreOperation) this.operations.get(index);

                        }catch (IndexOutOfBoundsException  e) {

                                return null;

                        }

                }

        }

        public boolean implementsDataStoreOperation(

                        String storeName, String operationName) {

                return this.implementsDataStoreOperation(storeName, this.getOperationIndex(operationName));

        }

        public boolean implementsDataStoreOperation(

                        String storeName, int operationCode) {

                RegisterInfo register = this.getRegisterByName(storeName);

                DataStoreOperation operation = register.getOperation(operationCode);

                if (operation == null){

                        return false;

                }

                return true;

        }

}