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

import java.util.List;

import java.util.Set;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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 NewLayerProviderFactory type;

    private NewLayerProvider provider;

    private boolean addTableToProject = true;

    private IProjection defaultProjection;

    /**

     * {@link DefaultNewLayerService} constructor

     * @param manager

     */

    public DefaultNewLayerService(NewLayerManager manager) {

        this.newLayerManager = manager;

    }

    @Override

    public NewLayerProvider getProvider() {

        return provider;

    }

    @Override

    public void createTable() throws NewLayerServiceException {

        try {

            this.getExplorer().add(

                    this.getStoreProviderName(),

                    this.getNewStoreParameters(), 

                    true

            );

            firePostCreateTable();

        } catch (Exception e) {

            throw new CantCreateNewLayerException(e);

        }

    }

//    @Override

//    public void loadTable() throws NewLayerServiceException {

//        try {

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

//                return;

//            }

//            String providerName = this.getStoreProviderName();

//            DataStoreParameters storeParameters = this.getOpenStoreParameters();

//            DataManager dataManager = DALLocator.getDataManager();

//            DataStore store = dataManager.openStore(providerName, 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 getStoreProviderName() {

        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 setAddTableToProject(boolean b) {

        this.addTableToProject = b;

    }

    @Override

    public boolean isAddTableToProject() {

        return this.addTableToProject;

    }

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

    }

    private Set<NewLayerServiceListener> listeners = null;

    @Override

    public void addNewLayerServiceListener(NewLayerServiceListener listener) {

        if( listener == null ) {

            return;

        }

        if( this.listeners==null ) {

            this.listeners = new LinkedHashSet<>();

        }

        this.listeners.add(listener);

    }

    protected void firePostCreateTable() {

        if( this.listeners==null ) {

            return;

        }

        for (NewLayerServiceListener listener : this.listeners) {

            if( listener==null ) {

                continue;

            }

            try {

                listener.postCreateTable(this);

            } catch(Throwable t) {

                // Do nothing.

            }

        }

    }

    @Override

    public void setDefaultProjection(IProjection projection) {

        this.defaultProjection = projection;

    }

    @Override

    public IProjection getDefaultProjection() {

        return this.defaultProjection;

    }

}