Application: gvSIG desktop

package org.gvsig.export.spi;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.export.ExportException;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.ExportParameters;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractExportService 

        implements ExportService

    {

    protected static final Logger LOG = LoggerFactory.getLogger(AbstractExportService.class);

    private final ExportParameters parameters;

    private final Set<ExportFinishListener> finishListeners;

    protected AttributeNamesTranslator attributeNamesTranslator;

    private SimpleTaskStatus taskStatus;

    private final ExportServiceFactory factory;

    protected AbstractExportService(ExportServiceFactory factory, ExportParameters parameters) {

        this.factory = factory;

        this.parameters = parameters;

        this.finishListeners = new HashSet<>();

    }

    @Override

    public ExportParameters getParameters() {

        return this.parameters;

    }

    @Override

    public ExportServiceFactory getFactory() {

        return factory;

    }

    @Override

    public void addFinishListener(ExportFinishListener listener) {

        this.finishListeners.add(listener);

    }   

    protected void fireFinishedListener() {

        for (ExportFinishListener listener : finishListeners) {

            try {

                listener.finished(this);

            } catch(Exception ex) {

            }

        }

    }

    protected void fireCancelledListeners() {

        for (ExportFinishListener listener : finishListeners) {

            try {

                listener.cancelled(this);

            } catch(Exception ex) {

            }

        }

    }

    @Override

    public SimpleTaskStatus getTaskStatus() {

        if( this.taskStatus== null ) {

            this.taskStatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Export");

        }

        return this.taskStatus;

    }

    @Override

    public boolean isCancellationRequested() {

        return this.getTaskStatus().isCancellationRequested();

    }

    @Override

    public void cancelRequest() {

        this.getTaskStatus().cancelRequest();

    }

    @Override

    public AttributeNamesTranslator getAttributeNamesTranslator() {

        if( attributeNamesTranslator==null ) {

            this.attributeNamesTranslator = ExportLocator.getServiceManager().createAttributeNamesTranslator();

        }

        return this.attributeNamesTranslator;

    }

    @Override

    public List<OpenDataStoreParameters> getTargetOpenStoreParameters() throws ExportException {

        List<OpenDataStoreParameters> r = new ArrayList<>();

        r.add(this.createTargetOpenStoreParameters());

        return r;

    }

    abstract protected DataServerExplorer createServerExplorer() throws ExportException;

    abstract protected NewDataStoreParameters createTargetNewStoreParameters() throws ExportException;

    abstract protected OpenDataStoreParameters createTargetOpenStoreParameters() throws ExportException;     

    @Override

    public void export(FeatureSet featureSet) throws ExportException {

        DataServerExplorer explorer = createServerExplorer();

        NewDataStoreParameters newStoreParameters = createTargetNewStoreParameters();

        OpenDataStoreParameters openStoreParameters = createTargetOpenStoreParameters();

        String providerName = newStoreParameters.getDataStoreName();

        String explorerName = explorer.getProviderName();

        DisposableIterator it = null;

        FeatureStore target = null;

        EditableFeature newfeature = null;

        try {

            this.getTaskStatus().setRangeOfValues(0, featureSet.getSize());

            DataManager dataManager = DALLocator.getDataManager();

            dataManager.newStore(explorerName, providerName, newStoreParameters, true);

            target = (FeatureStore) dataManager.openStore(providerName, openStoreParameters);

            FeatureType targetType = target.getDefaultFeatureType();

            target.edit(FeatureStore.MODE_APPEND);

            it = featureSet.fastIterator();

            IProjection targetProjection;

            FeatureAttributeDescriptor defaultGeom = target.getDefaultFeatureType().getDefaultGeometryAttribute();

            if (defaultGeom!=null) {

                    targetProjection = defaultGeom.getSRS();

            } else {

                    targetProjection = null;

            }

            long featureCount = 0;

            while (it.hasNext()) {

                Feature feature = (Feature) it.next();

                newfeature = target.createNewFeature(targetType, true);

                copyValues(feature, newfeature);

                // ================================================

                // Reprojection stuff

                Geometry reproj_geom;

                IProjection sourceProjection = feature.getDefaultSRS();

                ICoordTrans coord_trans;

                // this comparison is perhaps too preventive

                // we could  have two instances of same projection

                // so we would do more computations than needed

                if (sourceProjection != null

                        && targetProjection != null

                        && sourceProjection != targetProjection) {

                    coord_trans = sourceProjection.getCT(targetProjection);

                    reproj_geom = feature.getDefaultGeometry();

                    reproj_geom = reproj_geom.cloneGeometry();

                    reproj_geom.reProject(coord_trans);

                    newfeature.setDefaultGeometry(reproj_geom);

                }

                // ================================================

                target.insert(newfeature);

                featureCount++;

                this.getTaskStatus().setCurValue(featureCount);

                if (this.getTaskStatus().isCancellationRequested()) {

                    return;

                }

            }

            target.finishEditing();

            this.getTaskStatus().terminate();

            this.getTaskStatus().remove();

            fireFinishedListener();

        } catch (Exception e) {

            fireCancelledListeners();

            throw new ExportException(e, newfeature);

        } finally {

            DisposeUtils.dispose(it);

            DisposeUtils.dispose(featureSet);

            DisposeUtils.dispose(target);

        }

    }

    protected void copyValues(Feature source, EditableFeature target) {

        FeatureType sourceType= source.getType();

        FeatureType targetType = target.getType();

        for( FeatureAttributeDescriptor targetAttr : targetType) {

            String targetAttrName = targetAttr.getName();

            String sourceAttrName = getAttributeNamesTranslator().getSourceName(targetAttrName);

            FeatureAttributeDescriptor sourceAttr = sourceType.getAttributeDescriptor(sourceAttrName);

            if( sourceAttr!=null ) {

                Object value = source.get(sourceAttrName);

                if( value == null ) {

                    if( targetAttr.allowNull() ) {

                        target.set(targetAttrName, null);

                    }

                } else {

                    target.set(targetAttrName, value);

                }

            }

        }

    }

}