Application: gvSIG desktop

package org.gvsig.fmap.mapcontext.layers;

import java.util.HashMap;

import java.util.Map;

import org.apache.log4j.Logger;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.data.DataManager;

import org.gvsig.fmap.data.DataStore;

import org.gvsig.fmap.data.DataStoreParameters;

import org.gvsig.fmap.data.exceptions.InitializeException;

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

import org.gvsig.fmap.data.impl.DefaultDataManager;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.layers.operations.SingleLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

/**

 * Crea un adaptador del driver que se le pasa como par?metro en los m?todos

 * createLayer. Si hay memoria suficiente se crea un FLyrMemory que pasa todas

 * las features del driver a memoria

 */

public class LayerFactory {

        private static Logger logger = Logger.getLogger(LayerFactory.class

                        .getName());

        private static LayerFactory instance = null;

        public static LayerFactory getInstance() {

                if (instance == null) {

                        instance = new LayerFactory();

                }

                return instance;

        }

        /**

         * Guarda registro de que clase de capa debe usar para un determinado Store

         *

         * como clave usamos el nombre de registro del dataStore

         */

        private Map layersToUseForStore = new HashMap();

        /**

         * Registra que clase tiene que usar para un {@link DataStore} determinado. <br>

         * Por defecto, si el

         *

         *

         * @param dataStoreName

         *            Nombre de registro del {@link DataStore} dentro del

         *            {@link DefaultDataManager}

         * @param layerClassToUse

         *            clase que implementa {@link SingleLayer}

         * @return

         */

        public boolean registerLayerToUseForStore(String dataStoreName,

                        Class layerClassToUse) {

                DataManager dm = DefaultDataManager.getManager();

                DataStoreParameters dsparams;

                try {

                        dsparams = dm

                                        .createDataStoreParameters(dataStoreName);

                } catch (InitializeException e) {

                        return false;

                }

                if (!layerClassToUse.isAssignableFrom(SingleLayer.class)) {

                        return false;

                }

                this.layersToUseForStore.put(dsparams.getDataStoreName(),

                                layerClassToUse);

                return true;

        }

        private Class getLayerClassFor(DataStoreParameters params) {

                Class result = (Class) this.layersToUseForStore.get(params

                                .getDataStoreName());

                return result;

        }

        /*

         * TODO Documentation

         *

         * @param layerName Nombre de la capa. @param driverName Nombre del driver.

         *

         * @param f fichero. @param proj Proyecci?n.

         *

         * @return FLayer. @throws DriverException

         *

         * @throws DriverException @throws DriverIOException

         */

        public FLayer createLayer(String layerName,

                        DataStoreParameters storeParameters,

                        IProjection proj) throws LoadLayerException  {

                // Se obtiene el driver que lee

                try{

                        DataManager dataManager=DefaultDataManager.getManager();

                        DataStore dataStore=dataManager.createDataStore(storeParameters);

                        Class layerClass = this.getLayerClassFor(storeParameters);

                        if (layerClass == null) {

                                if (dataStore instanceof FeatureStore) {

                                        layerClass = FLyrVect.class;

                                } else {

                                        throw new LoadLayerException("No_layer_class_to_use",

                                                        new Exception());

                                }

                        }

                        FLayer layer;

                        try {

                                layer = (FLayer) layerClass.newInstance();

                        } catch (InstantiationException e) {

                                throw new LoadLayerException(layerName, e);

                        } catch (IllegalAccessException e) {

                                throw new LoadLayerException(layerName, e);

                        }

                        ((SingleLayer) layer).setDataStore(dataStore);

                        layer.setProjection(proj);

                        layer.setName(layerName);

                        return layer;

                } catch (InitializeException e1) {

                        throw new LoadLayerException(layerName,e1);

                }

        }

}