Application: gvSIG desktop

package org.gvsig.fmap.mapcontext.layers;

import java.util.HashMap;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 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 {

        final static private Logger logger = LoggerFactory.getLogger(LayerFactory.class);

        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 DataManager}

     * @param layerClassToUse

     *            clase que implementa {@link SingleLayer}

     * @return

     */

        public boolean registerLayerToUseForStore(String dataStoreName,

                        Class layerClassToUse) {

                DataManager dm = DALLocator.getDataManager();

                DataStoreParameters dsparams;

                try {

                        dsparams = dm

                                        .createStoreParameters(dataStoreName);

                } catch (InitializeException e) {

                        e.printStackTrace();

                        return false;

                } catch (ProviderNotRegisteredException e) {

                        e.printStackTrace();

                        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) throws LoadLayerException {

                // Se obtiene el driver que lee

                try{

                        DataManager dataManager=DALLocator.getDataManager();

                        DataStore dataStore=dataManager.createStore(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.setName(layerName);

                        Object srsObj = dataStore.getDynValue("DefaultSRS");

                        if (srsObj != null) {

                                IProjection proj = null;

                                if (srsObj instanceof IProjection) {

                                        proj = (IProjection) srsObj;

                                } else if (srsObj instanceof String) {

                                        proj = CRSFactory.getCRS((String) srsObj);

                                }

                                if (proj != null) {

                                        layer.setProjection(proj);

                                }

                        }

                        return layer;

                } catch (InitializeException e1) {

                        throw new LoadLayerException(layerName,e1);

                } catch (ProviderNotRegisteredException e) {

                        throw new LoadLayerException(layerName,e);

                }

        }

}