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.

package org.gvsig.export;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

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

/**

 *

 * @author jjdelcerro

 */

public interface ExportParametersGeometry extends ExportParameters {

    public static final int CHECKGEOMETRY_NONE = 0;

    public static final int CHECKGEOMETRY_CHECK_IF_CORRUPT = 1;

    public static final int CHECKGEOMETRY_CHECK_IF_VALID = 2;

    public static final int CHECKGEOMETRYACTION_SET_GEOMETRY_TO_NULL = 0;

    public static final int CHECKGEOMETRYACTION_SKIP_FEATURE = 1;

    public static final int CHECKGEOMETRYACTION_ABORT = 2;

    public void setContextProjection(IProjection projection);

    public IProjection getContextProjection();

    public void setSourceProjection(IProjection projection);

    public IProjection getSourceProjection();

    public void setSourceTransformation(ICoordTrans transformation);

    public ICoordTrans getSourceTransformation();

    public void setTargetProjection(IProjection targetProjection);

    public IProjection getTargetProjection();

    public void setTargetTransformation(ICoordTrans transformation);

    public ICoordTrans getTargetTransformation();

    public ICoordTrans getTransformationToUse();

    public int getGeometryChecks();

    public int getGeometryChecksAction();

    public boolean getTryToFixGeometry();

    public void setGeometryChecks(int geometryChecks);

    public void setGeometryChecksAction(int geometryChecksAction);

    public void setTryToFixGeometry(boolean tryToFixGeometry);

    public String getSourceGeometryFieldName();

    public void setSourceGeometryFieldName(String geometryFieldName);

    public GeometryType getTargetGeometryType();

    public int getTargetGeometryTypeAsInt();

    public int getTargetGeometrySubtype();

    public void setTargetGeometryType(GeometryType type);

    public void setTargetGeometryType(int type);

    public void setTargetGeometrySubtype(int subtype);

}

/**

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

import org.gvsig.tools.locator.BaseLocator;

import org.gvsig.tools.locator.Locator;

import org.gvsig.tools.locator.LocatorException;

/**

 * This locator is the entry point for the Exportto library, providing

 * access to all Exportto services through the {@link ExportManager} .

 * 

 * @author gvSIG team

 * @version $Id$

 */

public class ExportLocator extends BaseLocator {

    public static final String MANAGER_NAME = "Export.manager";

    public static final String MANAGER_DESCRIPTION = "Export Manager";

    public static final String ENTRIES_MANAGER_NAME = "Export.entriesManager";

    public static final String ENTRIES_MANAGER_DESCRIPTION = "Export Entries Manager";

    public static final String SERVICE_MANAGER_NAME = "Export.serviceManager";

    public static final String SERVICE_MANAGER_DESCRIPTION = "Export Service Manager";

    private static final String LOCATOR_NAME = "Export.locator";

    /**

     * Unique instance.

     */

    private static final ExportLocator INSTANCE = new ExportLocator();

    /**

     * Return the singleton instance.

     * 

     * @return the singleton instance

     */

    public static ExportLocator getInstance() {

        return INSTANCE;

    }

    /**

     * Return the Locator's name.

     * 

     * @return a String with the Locator's name

     */

    @Override

    public final String getLocatorName() {

        return LOCATOR_NAME;

    }

    /**

     * Return a reference to the ExportManager.

     * 

     * @return a reference to the ExportManager

     * @throws LocatorException

     *             if there is no access to the class or the class cannot be

     *             instantiated

     * @see Locator#get(String)

     */

    public static ExportManager getManager() throws LocatorException {

        return (ExportManager) getInstance().get(MANAGER_NAME);

    }

    /**

     * Registers the Class implementing the ExportManager interface.

     * 

     * @param clazz

     *            implementing the ExportManager interface

     */

    public static void registerManager(Class<? extends ExportManager> clazz) {

        getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    /**

     * Return a reference to the ExportServiceMnager.

     * 

     * @return a reference to the ExportServiceMnager

     * @throws LocatorException

     *             if there is no access to the class or the class cannot be

     *             instantiated

     * @see Locator#get(String)

     */

    public static ExportServiceManager getServiceManager() throws LocatorException {

        return (ExportServiceManager) getInstance().get(SERVICE_MANAGER_NAME);

    }

    /**

     * Registers the Class implementing the ExportServiceManager interface.

     * 

     * @param clazz

     *            implementing the ExportServiceManager interface

     */

    public static void registerServiceManager(Class<? extends ExportServiceManager> clazz) {

        getInstance().register(SERVICE_MANAGER_NAME, SERVICE_MANAGER_DESCRIPTION, clazz);

    }

}

package org.gvsig.export;

import java.util.Date;

import org.gvsig.export.spi.ExportServiceFactory;

import org.gvsig.expressionevaluator.Expression;

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

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

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

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.util.LabeledValue;

/**

 *

 * @author jjdelcerro

 */

public interface ExportParameters extends Cloneable, LabeledValue, Persistent  {

    public static final int USE_ALL_FEATURES = 0;

    public static final int USE_SELECTED_FEATURES = 1;

    public static final int USE_FILTERED_FEATURES = 2;

    public String getServiceName();

    public boolean needsSelectTargetProjection();

    public FeatureType getSourceFeatureType();

    public void setSourceFeatureType(FeatureType sourceFeatureType);

    public void setSourceFeatureStore(FeatureStore sourceFeatureStore);

    public FeatureStore getSourceFeatureStore();

    public int getFeaturesToUse();

    public void setFeaturesToUse(int feturesToUse);

    public Expression getFilterExpresion();

    public void setFilterExpresion(Expression expression);

    public FeatureQuery getFeatureQuery();

    public void setFeatureQuery(FeatureQuery query);

    public Object getContext();

    public void setContext(Object context);

    public ExportAttributes getExportAttributes();

    public void setExportAttributes(ExportAttributes exportAttributes);

    public Date getCreationDate();

    public void setCreationDate(Date date);

    public ExportParameters clone() throws CloneNotSupportedException;

    public ExportServiceFactory getFactory();

    public FeatureType getTargetFeatureType();

    public void resetVolatileValues();

}

package org.gvsig.export;

import java.io.File;

import org.gvsig.tools.util.HasAFile;

/**

 *

 * @author jjdelcerro

 */

public interface ExportParametersFile extends HasAFile {

    @Override

    public File getFile();

    @Override

    public void setFile(File file);

    public File getEvaluatedFile();

    public String getFileExtension();

}

package org.gvsig.export;

/**

 *

 * @author jjdelcerro

 */

public interface Filter<T> {

    public boolean apply(T obj);

}

/**

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

import org.gvsig.export.spi.AbstractExportParametersFile;

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

import org.gvsig.export.spi.AbstractExportParametersGeometry;

import org.gvsig.export.spi.AbstractExportParametersGeometryFile;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

/**

 * Library for API initialization and configuration.

 * 

 * @author gvSIG team

 * @version $Id$

 */

public class ExportLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsAPI(ExportLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        // Do nothing

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        // Validate there is any implementation registered.

        ExportManager manager = ExportLocator.getManager();

        if (manager == null) {

            throw new ReferenceNotRegisteredException(

                ExportLocator.MANAGER_NAME, ExportLocator.getInstance());

        }

        AbstractExportParameters.registerPersistence();

        AbstractExportParametersGeometry.registerPersistence();

        AbstractExportParametersFile.registerPersistence();

        AbstractExportParametersGeometryFile.registerPersistence();

        ExportParametersFileHelper.registerPersistence();

    }

}

/*

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

import java.util.List;

import org.gvsig.export.ExportAttributes.ExportAttribute;

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

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

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

import org.gvsig.tools.namestranslator.NamesTranslator;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.util.UnmodifiableBasicList;

/**

 *

 * @author osc

 */

public interface ExportAttributes extends UnmodifiableBasicList<ExportAttribute>, Cloneable, Persistent {

    public ExportAttributes clone() throws CloneNotSupportedException;

    public void setActive(boolean b);

    public boolean isActive();

    public interface ExportAttribute extends Cloneable, Persistent {

        public FeatureAttributeDescriptor getDescriptor();

        public String getName();

        public String getNewName();

        public int getDataType();

        public int getNewDataType();

        public boolean isExported();

        public boolean isComputed();

        public int getSize();

        public void setSize(int size);

        public int setNewName(String name);

        public void setNewType(int dataType);

        public void setExported(boolean exported);

        public void setComputed(boolean computed);

        public boolean isFromQuery();

        public ExportAttribute clone() throws CloneNotSupportedException;

    }

    public ExportAttribute getExportAttribute(String name);

    public FeatureType getTargetFeatureType();

    public void setSourceFeatureType(FeatureType sourceFeatureType, FeatureQuery query);

    public FeatureType getSourceFeatureType();

    public String getTargetName(String name);

    public String getSourceName(String name);

    public int getTargetType(String name);

    public int getSourceType(String name);

    public void setNamesTranslator(NamesTranslator attnt);

    public NamesTranslator getNamesTranslator();

    public void setExportAttributes(List<ExportAttribute>  exportAttributes);

    public boolean isQueryAttribute(FeatureAttributeDescriptor attr);

}

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

            FeatureStore.cancelEditingQuietly(target);

            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.getAttributeDescriptorFromAll(sourceAttrName);

            } else {

                sourceAttrName = targetAttrName;

                sourceAttr = sourceType.getAttributeDescriptorFromAll(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);

                }

            }

        }

    }

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