Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.newlayer.impl;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.newlayer.NewLayerException;

import org.gvsig.newlayer.NewLayerManager;

import org.gvsig.newlayer.NewLayerProvider;

import org.gvsig.newlayer.NewLayerProviderFactory;

import org.gvsig.newlayer.NewLayerService;

import org.gvsig.newlayer.NewLayerServiceException;

import org.gvsig.tools.service.ServiceException;

/**

 * Default {@link NewLayerService} implementation.

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultNewLayerService implements NewLayerService {

    private final NewLayerManager newLayerManager;

    private final MapContext mapContext;

    private NewLayerProviderFactory type;

    private NewLayerProvider provider;

    private boolean addLayerToView = true;

    /**

     * {@link DefaultNewLayerService} constructor

     * @param manager

     * @param mapContext

     */

    public DefaultNewLayerService(NewLayerManager manager, MapContext mapContext) {

        this.newLayerManager = manager;

        this.mapContext = mapContext;

    }

    @Override

    public NewLayerProvider getProvider() {

        return provider;

    }

    @Override

    public void createTable() throws NewLayerServiceException {

        try {

            this.getExplorer().add(

                    this.getStoreName(),

                    this.getNewStoreParameters(), 

                    true

            );

        } catch (Exception e) {

            throw new CantCreateNewLayerException(e);

        }

    }

    @Override

    public void loadTable() throws NewLayerServiceException {

        try {

            if( this.getFeatureType().getDefaultGeometryAttribute()==null ) {

                return;

            }

            String storeName = this.getStoreName();

            DataStoreParameters storeParameters = this.getOpenStoreParameters();

            DataManager dataManager = DALLocator.getDataManager();

            DataStore store = dataManager.openStore(storeName, storeParameters);

            String layerName = store.getName();

            MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

            FLayer lyr = mapContextManager.createLayer(layerName, store);

            lyr.setActive(true);

            lyr.setVisible(true);

            mapContext.getLayers().addLayer(lyr);

            lyr.dispose();

        } catch (DataException | ValidateDataParametersException e) {

            throw new CantOpenStoreException(e);

        } catch (LoadLayerException e) {

            throw new CantLoadNewLayerException(e);

        } catch (Exception e) {

            throw new NewLayerServiceException(e);

        }

    }

    public class CantCreateNewLayerException extends NewLayerServiceException {

        /**

         *

         */

        private static final long serialVersionUID = 4208215791054246118L;

        public CantCreateNewLayerException(Throwable cause) {

            super("Can't create the layer", cause, "_cant_create_the_layer",

                    serialVersionUID);

        }

    }

    public class CantOpenStoreException extends NewLayerServiceException {

        /**

         *

         */

        private static final long serialVersionUID = -2245228621032918630L;

        public CantOpenStoreException(Throwable cause) {

            super("Can't open store", cause, "_cant_open_store",

                    serialVersionUID);

        }

    }

    public class CantLoadNewLayerException extends NewLayerServiceException {

        /**

         *

         */

        private static final long serialVersionUID = -1711950651766745963L;

        public CantLoadNewLayerException(Throwable cause) {

            super("Can't load the new layer", cause,

                    "_cant_load_the_new_layer", serialVersionUID);

        }

    }

    @Override

    public void setType(String type) {

        try {

            setProviderFactory(this.newLayerManager.getNewLayerProviderFactory(type));

        } catch (ServiceException e) {

            throw new RuntimeException(e);

        }

    }

    @Override

    public DataServerExplorer getExplorer() throws NewLayerException {

        return getProvider().getExplorer();

    }

    @Override

    public String getStoreName() {

        return getProvider().getStoreName();

    }

    @Override

    public EditableFeatureType getFeatureType() {

        return getProvider().getFeatureType();

    }

    @Override

    public NewFeatureStoreParameters getNewStoreParameters() throws NewLayerException {

        return getProvider().getNewStoreParameters();

    }

    @Override

    public DataStoreParameters getOpenStoreParameters() throws NewLayerException {

        return getProvider().getOpenStoreParameters();

    }

    @Override

    public NewFeatureStoreParameters getNewStoreParametersQuietly() {

        try {

            return getProvider().getNewStoreParameters();

        } catch(Exception ex) {   

            return null;

        }

    }

    @Override

    public DataStoreParameters getOpenStoreParametersQuietly() {

        try {

            return getProvider().getOpenStoreParameters();

        } catch(Exception ex) {

            return null;

        }

    }

    @Override

    public List<String> getTypes() {

        List<String> types = new ArrayList<>();

        List<NewLayerProviderFactory> providers = getProviderFactories();

        Iterator<NewLayerProviderFactory> it = providers.iterator();

        while (it.hasNext()) {

            NewLayerProviderFactory newLayerProviderFactory = it.next();

            types.add(newLayerProviderFactory.getName());

        }

        return types;

    }

    @Override

    public String getType() {

        return this.type.getName();

    }

    @Override

    public void addLayerToView(boolean b) {

        this.addLayerToView = b;

    }

    @Override

    public MapContext getMapContext() {

        return mapContext;

    }

    @Override

    public void setProviderFactory(NewLayerProviderFactory type) {

        this.type = type;

        this.provider = type.create(this);

    }

    @Override

    public NewLayerProviderFactory getProviderFactory() {

        return type;

    }

    @Override

    public List<NewLayerProviderFactory> getProviderFactories() {

        List<NewLayerProviderFactory> providers = new ArrayList<>(

                this.newLayerManager.getProviders(NewLayerManager.STORETYPE.ANY)

        );

        for (Iterator<NewLayerProviderFactory> iterator = providers.iterator(); iterator.hasNext();) {

            NewLayerProviderFactory newLayerProviderFactory = iterator.next();

            if (!newLayerProviderFactory.isEnabled()) {

                iterator.remove();

            }

        }

        return providers;

    }

}