Application: gvSIG desktop

gvSIG. Desktop Geographic Information System.

Copyright (C) 2007-2020 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, see <https://www.gnu.org/licenses/>. 

For any additional information, do not hesitate to contact us

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

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <artifactId>org.gvsig.exportto</artifactId>

  <packaging>pom</packaging>

  <name>${project.artifactId}</name>

  <description>Exportto project</description>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.desktop.library</artifactId>

    <version>2.0.354</version>

  </parent>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

      <type>test-jar</type>

      <scope>test</scope>

    </dependency>

  </dependencies>

  <modules>

    <module>org.gvsig.exportto.lib</module>

    <module>org.gvsig.exportto.swing</module>

  </modules>

</project>

package org.gvsig.export.spi;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.Date;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportLocator;

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

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

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

import org.gvsig.export.ExportParameters;

import org.gvsig.expressionevaluator.Expression;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractExportParameters implements ExportParameters {

    private FeatureStore sourceFeatureStore;

    private Expression filterExpression;

    private int featuresToUse;

    private Object context;

    protected ExportAttributes exportAttributes = null;

    private Date date = new Date();

    public ExportServiceFactory factory;

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractExportParameters.class);

    private FeatureQuery featureQuery;

    public AbstractExportParameters(ExportServiceFactory factory) {

        this.factory = factory;

        this.exportAttributes = ExportLocator.getServiceManager().createExportAttributes();

    }

    @Override

    public boolean needsSelectTargetProjection() {

        return false;

    }

    @Override

    public FeatureType getSourceFeatureType() {

        if (!(this.exportAttributes == null)) {

            return this.exportAttributes.getSourceFeatureType();

        } else {

            return null;

        }

    }

    @Override

    public void setSourceFeatureType(FeatureType sourceFeatureType) {

        this.exportAttributes.setSourceFeatureType(sourceFeatureType, this.featureQuery);

    }

    @Override

    public void setSourceFeatureStore(FeatureStore sourceFeatureStore) {

        this.sourceFeatureStore = sourceFeatureStore;

        try {

            FeatureType sourceFeatureType = sourceFeatureStore.getDefaultFeatureType();

            this.exportAttributes.setSourceFeatureType(sourceFeatureType, this.featureQuery);

        } catch (DataException ex) {

            throw new RuntimeException("Can't set feature type", ex);

        }

    }

    @Override

    public FeatureStore getSourceFeatureStore() {

        return this.sourceFeatureStore;

    }

    @Override

    public Expression getFilterExpresion() {

        return this.filterExpression;

    }

    @Override

    public void setFilterExpresion(Expression expression) {

        this.filterExpression = expression;

    }

    @Override

    public FeatureQuery getFeatureQuery() {

        return this.featureQuery;

    }

    @Override

    public void setFeatureQuery(FeatureQuery query) {

        this.featureQuery = query;

    }

    @Override

    public int getFeaturesToUse() {

        return featuresToUse;

    }

    @Override

    public void setFeaturesToUse(int featuresToUse) {

        this.featuresToUse = featuresToUse;

    }

    @Override

    public Object getContext() {

        return context;

    }

    @Override

    public void setContext(Object context) {

        this.context = context;

    }

    @Override

    public ExportAttributes getExportAttributes() {

        return this.exportAttributes;

    }

    @Override

    public void setExportAttributes(ExportAttributes export) {

        this.exportAttributes = export;

    }

    @Override

    public ExportParameters clone() throws CloneNotSupportedException {

        ExportParameters clone = (ExportParameters) super.clone();

        if (this.filterExpression != null) {

            clone.setFilterExpresion(this.filterExpression.clone());

        }

        if (this.featureQuery!=null) {

            clone.setFeatureQuery(this.featureQuery.getCopy());

        }

        if (this.exportAttributes != null) {

            clone.setExportAttributes(this.exportAttributes.clone());

        }

        return clone;

    }

    @Override

    public Date getCreationDate() {

        return this.date;

    }

    public void setCreationDate(Date date) {

        this.date = date;

    }

    @Override

    public String getLabel() {

        StringBuilder builder = new StringBuilder();

        DateFormat df = new SimpleDateFormat("dd/MM/yy HH:mm:ss");

        String dateName;

        dateName = df.format(this.getCreationDate());

        builder.append(dateName);

        builder.append(": ");

        String serviceName;

        if (this.getServiceName() != null) {

            serviceName = this.getServiceName();

        } else {

            serviceName = "Null service";

        }

        builder.append(serviceName);

        if (this.getSourceFeatureStore() != null) {

            String storeName = this.getSourceFeatureStore().getName();

            builder.append(" - ");

            builder.append(storeName);

        }

        return builder.toString();

    }

    @Override

    public Object getValue() {

        return this;

    }

    @Override

    public String toString() {

        return this.getLabel();

    }

    @Override

    public ExportServiceFactory getFactory() {

        return this.factory;

    }

    @Override

    public FeatureType getTargetFeatureType() {

        if (this.getExportAttributes() == null) {

            LOGGER.warn("Not been able to get target feature type from export attributes because it's null");

            return null;

        }

        return this.getExportAttributes().getTargetFeatureType();

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("AbstractExportParameters") == null) {

            DynStruct definition = manager.addDefinition(AbstractExportParameters.class,

                    "AbstractExportParameters", "AbstractExportParameters persistence definition", null, null);

            definition.addDynFieldInt("featuresToUse").setMandatory(false);

            definition.addDynFieldObject("filterExpression").setClassOfValue(Expression.class).setMandatory(false);

            definition.addDynFieldObject("exportAttributes").setClassOfValue(ExportAttributes.class).setMandatory(false);

            definition.addDynFieldDate("dateCreation").setMandatory(false);

            definition.addDynFieldString("factory");

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("featuresToUse", this.featuresToUse);

        state.set("filterExpression", this.filterExpression);

        state.set("exportAttributes", this.exportAttributes);

        state.set("dateCreation", this.date);

        state.set("factory", this.factory.getName());

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.featuresToUse = state.getInt("featuresToUse");

        this.filterExpression = (Expression) state.get("filterExpression");

        this.exportAttributes = (ExportAttributes) state.get("exportAttributes");

        this.date = state.getDate("dateCreation");

        String nameFactory = state.getString("factory");

        ExportServiceFactory statefactory = ExportLocator.getServiceManager().getServiceFactory(nameFactory);

        this.factory = statefactory;

    }

    @Override

    public void resetVolatileValues() {

    }

}

package org.gvsig.export.spi;

import java.io.File;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.export.ExportParametersFile;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.util.HasAFile;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractExportParametersFile

        extends AbstractExportParameters

        implements ExportParametersFile {

    public static class ExportParametersFileHelper implements HasAFile, Persistent {

        private File file;

        private File evaluatedFile;

        private String fileExtension; // Ej: ".shp" o ".dbf"

        public ExportParametersFileHelper() {

            this.fileExtension = "";

            this.file = null;

            this.evaluatedFile = null;

        }

        @Override

        public File getFile() {

            return this.file;

        }

        @Override

        public void setFile(File file) {

            this.evaluatedFile = null;

            if (file == null) {

                this.file = null;

                return;

            }

            if (ExpressionUtils.isDynamicFilename(file)) {

                this.file = file;

                return;

            }

            if (file.isAbsolute()) {

                this.file = new File(FilenameUtils.removeExtension(file.getAbsolutePath()) + this.fileExtension);

                return;

            }

            FoldersManager fm = ToolsLocator.getFoldersManager();

            this.file = new File(fm.getHome(), FilenameUtils.removeExtension(file.getPath()) + this.fileExtension);

        }

        public File getEvaluatedFile() {

            if (this.file == null) {

                return null;

            }

            if (this.evaluatedFile == null) {

                this.evaluatedFile = ExpressionUtils.evaluateFilename(this.file);

            }

            return this.evaluatedFile;

        }

        public String getFileExtension() {

            return this.fileExtension;

        }

        public void setFileExtension(String fileExtension) {

            if( StringUtils.isBlank(fileExtension) ) {

                this.fileExtension = "";

                return;

            }

            if( fileExtension.startsWith(".") ) {

                this.fileExtension = fileExtension;

                return;

            }

            this.fileExtension = "." + fileExtension;

        }

        @Override

        public void saveToState(PersistentState state) throws PersistenceException {

            state.set("file", this.file);

            state.set("fileExtension", this.fileExtension);

        }

        @Override

        public void loadFromState(PersistentState state) throws PersistenceException {

            this.file = state.getFile("file");

            this.fileExtension = state.getString("fileExtension");

            this.evaluatedFile = null;

        }

        public static void registerPersistence() {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition("ExportParametersFileHelper") == null) {

                DynStruct definition = manager.addDefinition(ExportParametersFileHelper.class,

                        "ExportParametersFileHelper", "ExportParametersFileHelper persistence definition", null, null);

                definition.addDynFieldString("fileExtension");

                definition.addDynFieldFile("file");

            }

        }

        void resetVolatileValues() {

            this.evaluatedFile = null;

        }

    }

    protected ExportParametersFileHelper fileHelper;

    public AbstractExportParametersFile(ExportServiceFactory factory) {

        super(factory);

        this.fileHelper = new ExportParametersFileHelper();

    }

    @Override

    public File getFile() {

        return this.fileHelper.getFile();

    }

    @Override

    public void setFile(File file) {

        this.fileHelper.setFile(file);

    }

    @Override

    public File getEvaluatedFile() {

        return this.fileHelper.getEvaluatedFile();

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("fileHelper", this.fileHelper);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        this.fileHelper = (ExportParametersFileHelper) state.get("fileHelper");

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("AbstractExportParametersFile") == null) {

            DynStruct definition = manager.addDefinition(AbstractExportParametersFile.class,

                    "AbstractExportParametersFile", "AbstractExportParametersFile persistence definition", null, null);

            definition.addDynFieldObject("fileHelper");

            definition.extend(manager.getDefinition("AbstractExportParameters"));

        }

    }

    public final String getFileExtension() {

        return this.fileHelper.getFileExtension();

    }

    @Override

    public void resetVolatileValues() {

        this.fileHelper.resetVolatileValues();

    }

}

package org.gvsig.export.spi;

import org.gvsig.export.ExportParameters;

/**

 *

 * @author jjdelcerro

 */

public interface ExportServiceFactory  {

    public String getName();

    public String getLabel();

    public String getDescription();

    public ExportService createService(ExportParameters parameters);

    public ExportParameters createParameters();

    public void setEnabled(boolean enabled);

    public boolean isEnabled();

    public boolean hasTabularSupport();

    public boolean hasVectorialSupport();

}

package org.gvsig.export.spi;

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

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

/**

 *

 * @author jjdelcerro

 */

public interface ExportGeometryHelper {

    boolean canProcessGeometry();

    int copyGeometry(Feature sourceFeature, EditableFeature targetFeature);

    String getLastErrorMessage();

}

package org.gvsig.export.spi;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.ExportParametersGeometry;

import org.gvsig.export.Filter;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

/**

 *

 * @author jjdelcerro

 */

public interface ExportServiceManager {

    public interface FixGeometryStatus {

        public static final int STATE_OK = 0;

        public static final int STATE_SKIP = 1;

        public static final int STATE_ABORT = 2;

        public Geometry getGeometry();

        public int getState();

        public String getMessage();

    }

    public List<ExportServiceFactory> getAllServiceFactories();

    public List<ExportServiceFactory> getServiceFactories(Filter<ExportServiceFactory> filter);

    public ExportServiceFactory getServiceFactory(String name);

    public ExportService createService(ExportParameters paramaters);

    public ExportParameters createServiceParameters(String name);

    public void register(ExportServiceFactory factory);

    public FixGeometryStatus fixGeometry(

            ExportParametersGeometry parameters,

            ICoordTrans coord_trans,

            Geometry geometry

    );

    public ExportGeometryHelper createGeometryHelper(

            ExportParametersGeometry parameters,

            FeatureType theTargetFeatureType,

            FeatureType theSourceFeatureType

    );

    public ExportAttributes createExportAttributes();

}

package org.gvsig.export.spi;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractExportServiceFactory implements ExportServiceFactory {

    private final String name;

    private final String description;

    private static final Map<ExportServiceFactory, Boolean>serviceEnabled = new HashMap<>();

    private final String label;

    public AbstractExportServiceFactory(

            String name,

            String label,

            String description

        ) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        this.name = name;

        this.label = i18n.getTranslation(label);

        this.description = i18n.getTranslation(description);

    }

    @Override

    public String getName() {

        return name;

    }

    @Override

    public String getLabel() {

        return label;

    }

    @Override

    public String getDescription() {

        return description;

    }

    @Override

    public boolean isEnabled() {

        Boolean enabled = serviceEnabled.getOrDefault(this, true);

        return enabled;

    }

    @Override

    public void setEnabled(boolean value) {

        serviceEnabled.put(this, value);

    }

}

/**

 * 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.export.spi;

import java.util.List;

import org.gvsig.export.ExportException;

import org.gvsig.export.ExportParameters;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

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

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

import org.gvsig.tools.task.MonitorableTask;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 * <p>

 * This service is used to export a source {@link FeatureStore} to a target

 * {@link FeatureStore}.

 * </p>

 * <p>

 * It inherits if {@link MonitorableTask}, and it means that the export process

 * can be monitorized by one or more observers that can listen all the export

 * events.

 * <p>

 * 

 * @author gvSIG team

 * @version $Id$

 */

public interface ExportService extends MonitorableTask {

    public interface ExportFinishListener {

        public void cancelled(ExportService exportService);

        public void finished(ExportService exportService);

    }

    public ExportServiceFactory getFactory();

    public ExportParameters getParameters() ;

    public void addFinishListener(ExportFinishListener listener);

//    public AttributeNamesTranslator getAttributeNamesTranslator();

    public void export(FeatureSet featureSet) throws ExportException;

    public List<OpenDataStoreParameters> getTargetOpenStoreParameters() throws ExportException;     

    public void setTaskStatus(SimpleTaskStatus taskStatus);

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.export.spi;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.export.ExportParameters;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.export.ExportParametersGeometry;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractExportParametersGeometry

        extends AbstractExportParameters

        implements ExportParametersGeometry {

    private IProjection contextProjection;

    private IProjection sourceProjection;

    private IProjection targetProjection;

    private ICoordTrans sourceTransformation;

    private ICoordTrans targetTransformation;

    private int geometryChecks;

    private int geometryChecksAction;

    private boolean tryToFixGeometry;

    private String geometryFieldName;

    private int geometryType;

    private int geometrySubtype;

    public AbstractExportParametersGeometry(ExportServiceFactory factory) {

        super(factory);

    }

    @Override

    public boolean needsSelectTargetProjection() {

        return true;

    }

    @Override

    public void setContextProjection(IProjection projection) {

        this.contextProjection = projection;

    }

    @Override

    public IProjection getContextProjection() {

        return this.contextProjection;

    }

    @Override

    public void setSourceProjection(IProjection sourceProjection) {

        this.sourceProjection = sourceProjection;

    }

    @Override

    public IProjection getSourceProjection() {

        return sourceProjection;

    }

    @Override

    public ICoordTrans getSourceTransformation() {

        return sourceTransformation;

    }

    @Override

    public void setSourceTransformation(ICoordTrans contextTransformation) {

        this.sourceTransformation = contextTransformation;

    }

    @Override

    public void setTargetProjection(IProjection targetProjection) {

        this.targetProjection = targetProjection;

    }

    @Override

    public IProjection getTargetProjection() {

        if (this.targetProjection == null) {

            return this.sourceProjection;

        }

        return this.targetProjection;

    }

    @Override

    public void setTargetTransformation(ICoordTrans transformation) {

        this.targetTransformation = transformation;

    }

    @Override

    public ICoordTrans getTargetTransformation() {

        return targetTransformation;

    }

    @Override

    public int getGeometryChecks() {

        return this.geometryChecks;

    }

    @Override

    public int getGeometryChecksAction() {

        return this.geometryChecksAction;

    }

    @Override

    public boolean getTryToFixGeometry() {

        return this.tryToFixGeometry;

    }

    @Override

    public void setGeometryChecks(int geometryChecks) {

        this.geometryChecks = geometryChecks;

    }

    @Override

    public void setGeometryChecksAction(int geometryChecksAction) {

        this.geometryChecksAction = geometryChecksAction;

    }

    @Override

    public void setTryToFixGeometry(boolean tryToFixGeometry) {

        this.tryToFixGeometry = tryToFixGeometry;

    }

    @Override

    public String getSourceGeometryFieldName() {

        return this.geometryFieldName;

    }

    @Override

    public void setSourceGeometryFieldName(String geometryFieldName) {

        this.geometryFieldName = geometryFieldName;

    }

    @Override

    public int getTargetGeometryTypeAsInt() {

        return geometryType;

    }

    @Override

    public int getTargetGeometrySubtype() {

        return geometrySubtype;

    }

    @Override

    public void setTargetGeometryType(int geometryType) {

        this.geometryType = geometryType;

    }

    @Override

    public void setTargetGeometrySubtype(int subtype) {

        this.geometrySubtype = subtype;

    }

    @Override

    public void setTargetGeometryType(GeometryType type) {

        this.geometryType = type.getType();

        this.geometrySubtype = type.getSubType();

    }

    @Override

    public GeometryType getTargetGeometryType() {

        try {

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            GeometryType type = geomManager.getGeometryType(

                    geometryType,

                    geometrySubtype

            );

            return type;

        } catch (Exception ex) {

            throw new RuntimeException("Can't create geoemtry type from type " + geometryType + ", subtype " + geometrySubtype + ".", ex);

        }

    }

    @Override

    public ExportParameters clone() throws CloneNotSupportedException {

        AbstractExportParametersGeometry clone = (AbstractExportParametersGeometry) super.clone();

        clone.setContextProjection(this.contextProjection);

        clone.setSourceProjection(this.sourceProjection);

        clone.setTargetProjection(this.targetProjection);

        clone.setSourceTransformation(this.sourceTransformation);

        clone.setTargetTransformation(this.targetTransformation);

        clone.setSourceGeometryFieldName(this.geometryFieldName);

        clone.setGeometryChecks(this.geometryChecks);

        clone.setGeometryChecksAction(this.geometryChecksAction);

        clone.setTryToFixGeometry(this.tryToFixGeometry);

        clone.setTargetGeometryType(this.geometryType);

        clone.setTargetGeometrySubtype(this.geometrySubtype);

        return clone;

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("AbstractExportParametersGeometry") == null) {

            DynStruct definition = manager.addDefinition(AbstractExportParametersGeometry.class,

                    "AbstractExportParametersGeometry", "AbstractExportParametersGeometry persistence definition", null, null);

            definition.addDynFieldObject("contextProjection").setClassOfValue(IProjection.class);

            definition.addDynFieldObject("sourceProjection").setClassOfValue(IProjection.class);

            definition.addDynFieldObject("targetProjection").setClassOfValue(IProjection.class);

            definition.addDynFieldObject("sourceTransformation").setClassOfValue(ICoordTrans.class);

            definition.addDynFieldObject("targetTransformation").setClassOfValue(ICoordTrans.class);

            definition.addDynFieldInt("geometryChecks");

            definition.addDynFieldInt("geometryChecksAction");

            definition.addDynFieldBoolean("tryToFixGeometry");

            definition.addDynFieldString("geometryFieldName");

            definition.addDynFieldInt("geometryType");

            definition.addDynFieldInt("geometrySubtype");

            definition.extend(manager.getDefinition("AbstractExportParameters"));

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("contextProjection", this.contextProjection);

        state.set("sourceProjection", this.sourceProjection);

        state.set("targetProjection", this.targetProjection);

        state.set("sourceTransformation", this.sourceTransformation);

        state.set("targetTransformation", this.targetTransformation);

        state.set("geometryChecks", this.geometryChecks);

        state.set("geometryChecksAction", this.geometryChecksAction);

        state.set("tryToFixGeometry", this.tryToFixGeometry);

        state.set("geometryFieldName", this.geometryFieldName);

        state.set("geometryType", this.geometryType);

        state.set("geometrySubtype", this.geometrySubtype);

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        this.contextProjection = (IProjection) state.get("contextProjection");

        this.sourceProjection = (IProjection) state.get("sourceProjection");

        this.targetProjection = (IProjection) state.get("targetProjection");

        this.sourceTransformation = (ICoordTrans) state.get("sourceTransformation");

        this.targetTransformation = (ICoordTrans) state.get("targetTransformation");

        this.geometryChecks = state.getInt("geometryChecks");

        this.geometryChecksAction = state.getInt("geometryChecksAction");

        this.tryToFixGeometry = state.getBoolean("tryToFixGeometry");

        this.geometryFieldName = state.getString("geometryFieldName");

        this.geometryType = state.getInt("geometryType");

        this.geometrySubtype = state.getInt("geometrySubtype");

    }

    @Override

    public ICoordTrans getTransformationToUse() {

        FeatureAttributeDescriptor geo_att = this.getSourceFeatureType().getDefaultGeometryAttribute();

        IProjection sourceProjection;

        ICoordTrans coord_trans = null;

        Geometry reproj_geom;

        IProjection targetProjection = this.getTargetProjection();

        if (geo_att != null) {

            sourceProjection = geo_att.getSRS();

            // 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) {

                if (this.getTargetTransformation() != null) {

                    coord_trans = this.getTargetTransformation();

                } else {

                    coord_trans = sourceProjection.getCT(targetProjection);

                }

            }

        }

        return coord_trans;

    }

}

package org.gvsig.export.spi;

import java.io.File;

import org.gvsig.export.ExportParametersFile;

import org.gvsig.export.spi.AbstractExportParametersFile.ExportParametersFileHelper;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractExportParametersGeometryFile 

        extends AbstractExportParametersGeometry

        implements ExportParametersFile 

    {

    protected AbstractExportParametersFile.ExportParametersFileHelper fileHelper;

    public AbstractExportParametersGeometryFile(ExportServiceFactory factory) {

        super(factory);

        this.fileHelper = new ExportParametersFileHelper();

    }

    @Override

    public File getFile() {

        return this.fileHelper.getFile();

    }

    @Override

    public void setFile(File file) {

        this.fileHelper.setFile(file);

    }

    @Override

    public File getEvaluatedFile() {

        return this.fileHelper.getEvaluatedFile();

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("fileHelper", this.fileHelper);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        this.fileHelper = (ExportParametersFileHelper) state.get("fileHelper");

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("AbstractExportParametersGeometryFile") == null) {

            DynStruct definition = manager.addDefinition(AbstractExportParametersGeometryFile.class,

                    "AbstractExportParametersGeometryFile", "AbstractExportParametersGeometryFile persistence definition", null, null);

            definition.addDynFieldObject("fileHelper");

            definition.extend(manager.getDefinition("AbstractExportParametersGeometry"));

        }

    }

    @Override

    public final String getFileExtension() {

        return this.fileHelper.getFileExtension();

    }

    @Override

    public void resetVolatileValues() {

        this.fileHelper.resetVolatileValues();

    }

}

package org.gvsig.export.spi;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportException;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.ExportParametersGeometry;

import org.gvsig.export.spi.ExportServiceManager.FixGeometryStatus;

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.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 void setTaskStatus(SimpleTaskStatus taskStatus) {

        this.taskStatus = 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;

    protected static class InvalidGeometryException extends ExportException {

        public InvalidGeometryException(Feature feature, String checkMessage) {

            super(checkMessage, feature);

        }

    }

    @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 targetFeature = 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 theTargetFeatureType;

            if (this.getParameters().getExportAttributes().isActive()) {

                theTargetFeatureType = this.getParameters().getExportAttributes().getTargetFeatureType();

            } else {

                theTargetFeatureType = target.getDefaultFeatureType();

            }

            FeatureType theSourceFeatureType = featureSet.getDefaultFeatureType();

            ExportGeometryHelper geomHelper = null;

            if (this.getParameters() instanceof ExportParametersGeometry) {

                geomHelper = ExportLocator.getServiceManager().createGeometryHelper(

                        (ExportParametersGeometry) this.getParameters(),

                        theTargetFeatureType,

                        theSourceFeatureType

                );

                if (!geomHelper.canProcessGeometry()) {

                    geomHelper = null;

                }

            }

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

            target.edit(FeatureStore.MODE_APPEND);

            it = featureSet.fastIterator();

            long featureCount = 1;

            while (it.hasNext()) {

                this.getTaskStatus().setCurValue(featureCount);

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

                targetFeature = target.createNewFeature(true); //theTargetFeatureType, true);

                copyValues(sourceFeature, targetFeature);

                if (geomHelper != null) {

                    switch (geomHelper.copyGeometry(sourceFeature, targetFeature)) {

                        case FixGeometryStatus.STATE_OK:

                            break;

                        case FixGeometryStatus.STATE_SKIP:

                            continue;

                        case FixGeometryStatus.STATE_ABORT:

                            throw new InvalidGeometryException(targetFeature, geomHelper.getLastErrorMessage());

                    }

                }

                target.insert(targetFeature);

                featureCount++;

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

                    return;

                }

            }

            target.finishEditing();

            this.getTaskStatus().terminate();

            this.getTaskStatus().remove();

            fireFinishedListener();

        } catch (Exception e) {

            fireCancelledListeners();

            throw new ExportException(e, targetFeature);

        } 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();

        ExportAttributes exp = this.getParameters().getExportAttributes();

        boolean isActive = exp.isActive();

        for (FeatureAttributeDescriptor targetAttr : targetType) {

            if (targetAttr.isReadOnly() || targetAttr.isComputed()) {

                continue;

            }

            String targetAttrName = targetAttr.getName();

            //translate field

            FeatureAttributeDescriptor sourceAttr;

            String sourceAttrName;            

            if (isActive) {

                sourceAttrName = exp.getSourceName(targetAttrName);

                for (ExportAttributes.ExportAttribute exportAttribute : exp) {

                    if (StringUtils.equals(exportAttribute.getNewName(), targetAttrName)) {

                        sourceAttrName = exportAttribute.getName();

                        break;

                    }

                }

                sourceAttr = sourceType.getAttributeDescriptor(sourceAttrName);

            } else {

                sourceAttrName = targetAttrName;

                sourceAttr = sourceType.getAttributeDescriptor(targetAttrName);

            }            

            if (sourceAttr != null) {

                Object value = source.get(sourceAttrName);                

                if (value == null) {

                    if (targetAttr.allowNull()) {

                        target.set(targetAttrName, null);

                    }

                } else {

                    target.set(targetAttrName, value);

                }

            } else if (sourceAttr==null && source.hasValue(sourceAttrName)) {

                    Object value = source.get(sourceAttrName);

                    target.set(targetAttrName, value);

                }

            }

        }

    }

/**

 * 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.export;

import java.io.File;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.export.spi.ExportServiceManager;

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

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

public interface ExportManager {

    public interface ExportFilter {

        public String getName();

        public String getExpression();

    }

    public void setHomeFolder(File homeFolder);

    public ExportProcess createProcess();

    public ExportProcess createProcess(FeatureStore store);

    public ExportProcess createProcess(FeatureStore store, IProjection contextProjection);

    public List<ExportFilter> getFilters();

    public ExportFilter getFilter(String name);