Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

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

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

 */

package org.gvsig.fmap.dal.feature.impl.editing.memory;

import org.gvsig.fmap.dal.feature.impl.editing.memory.ExpansionAdapter;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

/**

 * Implementaci?n en memoria de ExpansionAdapter.

 *

 * @author Vicente Caballero Navarro

 */

public class MemoryExpansionAdapter implements ExpansionAdapter {

	private List objects = new ArrayList();

	public MemoryExpansionAdapter(){

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.expansionadapter.ExpansionAdapter#addFeature(org.gvsig.fmap.dal.feature.Feature)

	 */

	public int addObject(Object obj) {

//		Feature feature=(Feature)obj;

		int newIndex = objects.size();

		objects.add(obj);

		return newIndex;

	}

//	/* (non-Javadoc)

//	 * @see org.gvsig.fmap.dal.feature.expansionadapter.ExpansionAdapter#modifyFeature(int, org.gvsig.fmap.dal.feature.Feature)

//	 */

//	public int updateObject(Object obj) {

////		Feature feature=(Feature)obj;

//		objects.add(obj);

//		return objects.size() - 1;

//	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.expansionadapter.ExpansionAdapter#getFeature(int)

	 */

	public Object getObject(int index){

		return objects.get(index);

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.expansionadapter.ExpansionAdapter#compact(java.util.HashMap)

	 */

	public void compact(HashMap relations) {

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.expansionadapter.ExpansionAdapter#deleteLastFeature()

	 */

	public void deleteLastObject() {

		objects.remove(objects.size()-1);

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.expansionadapter.ExpansionAdapter#open()

	 */

	public void open() {

		// TODO Auto-generated method stub

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.expansionadapter.ExpansionAdapter#close()

	 */

	public void close() {

		objects.clear();

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.expansionadapter.ExpansionAdapter#getSize()

	 */

	public int getSize() {

		return objects.size();

	}

	public Iterator iterator() {

		return objects.iterator();

	}

}

/**

 * 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.fmap.dal.feature.impl.editing.memory;

import java.util.HashMap;

import java.util.Iterator;

/**

 * Maneja el fichero de extensi?n en el que se almacenan las modificacionesy adici?nes

 * durante la edici?n. Los ?ndices que devuelve esta clase en sus m?todos

 * addFeature y modifyFeature son invariables, es decir, que si se invoca un

 * m?todo addFeature que retorna un 8, independientemente de las operaciones

 * que se realicen posteriormente, una llamada a getFeature(8) retornar?

 * dicha fila. Si esta geometr?a es eliminada posteriormente, se retornar? un

 * null. Esto ?ltimo se cumple mientras no se invoque el m?todo compact, mediante

 * el que se reorganizan las geometr?as dejando en el fichero s?lo las que tienen

 * validez en el momento de realizar la invocaci?n.

 *

 * @author Vicente Caballero Navarro

 *

 */

public interface ExpansionAdapter {

	/**

	 * A?ade una geometria al final del fichero y retorna el ?ndice que ocupa

	 * esta geometria en el mismo

	 *

	 * @param feature

	 * @param status TODO

	 * @param indexInternalFields fields that where valid when this feature was added.

	 *

	 * @return calculated index of the new feature.

	 */

	int addObject(Object obj);

	/**

	 * Modifica la index-?sima geometr?a del fichero devolviendo la posici?n en

	 * la que se pone la geometria modificada.

	 *

	 * @param calculated index of feature to be modified

	 * @param feature newFeature that replaces the old feature.

	 *

	 * @return new calculated index of the modified feature.

	 */

//	int updateObject(Object obj);

	/**

	 * Obtiene la geometria que hay en el ?ndice 'index' o null si la geometr?a

	 * ha sido invalidada.

	 *

	 * @param index caculatedIndex of the feature to be read.

	 * @return feature

	 */

	Object getObject(int index);

	/**

	 * Realiza una compactaci?n del fichero que maneja esta clase

	 *

	 * @param relations DOCUMENT ME!

	 */

	void compact(HashMap relations);

	/**

     * Mueve el puntero de escritura de manera que las siguientes escrituras

     * machacar?n la ?ltima fila

     */

    void deleteLastObject();

    /**

     * Abre el fichero de expansi?n para comenzar la edici?n

     */

    void open();

    /**

     * Cierra el fichero de expansi?n al terminar la edici?n

     */

    void close();

    int getSize();

    Iterator iterator();

}

/**

 * 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.fmap.dal.feature.impl.editing.memory;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.NoSuchElementException;

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeature;

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureReference;

public class FeatureManager {

    private int deltaSize;

    private final ExpansionAdapter expansionAdapter;

    private final Collection<FeatureReference> deleted;

    private final Map<FeatureReference, Integer> added;

    private final Map<FeatureReference, Integer> addedAndDeleted;

    private final Map<FeatureReference, Integer> modifiedFromOriginal;

    public FeatureManager() {

        deltaSize = 0;

        expansionAdapter = new MemoryExpansionAdapter();

        deleted = new LinkedHashSet<>();

        added = new LinkedHashMap<>();

        addedAndDeleted = new LinkedHashMap<>();

        modifiedFromOriginal = new HashMap<>();

    }

    /**

     * Deletes feature from this manager.

     *

     * @param id

     * @return The deleted feature or null if the feature had not been edited or

     * previously added in the editing session

     */

    public Feature delete(FeatureReference id) {

        deleted.add(id);

        Integer num = added.remove(id);

        Feature feature = null;

        if (num == null || num == -1) {

            num = modifiedFromOriginal.remove(id);

            if (num != null) {

                feature = (Feature) expansionAdapter.getObject(num);

            }

            // if num is null here, method returns null

        } else {

            feature = (Feature) expansionAdapter.getObject(num);

            addedAndDeleted.put(id, num);

        }

        deltaSize--;

        return feature;

    }

    public void add(Feature feature) {

        int pos = expansionAdapter.addObject(feature);

        added.put(feature.getReference(), pos);

        deleted.remove(feature.getReference());

        deltaSize++;

    }

    public Feature deleteLastFeature() {

        expansionAdapter.deleteLastObject();

        Feature feature = (Feature) expansionAdapter.getObject(expansionAdapter.getSize() - 1);

        added.remove(feature.getReference());

        modifiedFromOriginal.remove(feature.getReference());

        deltaSize--;

        return feature;

    }

    /**

     * Returns a Feature of the default type.

     *

     * @param id the feature reference

     * @param store the store to get the feature from

     * @return a Feature with the given reference

     * @throws DataException if there is an error getting the Feature

     */

    public Feature get(FeatureReference id, FeatureStore store)

            throws DataException {

        return get(id, store, null);

    }

    /**

     * Returns a Feature of the given type.

     *

     * @param id the feature reference

     * @param store the store to get the feature from

     * @param featureType the type of the feature to return

     * @return a Feature with the given reference

     * @throws DataException if there is an error getting the Feature

     */

    public Feature get(FeatureReference id, FeatureStore store,

            FeatureType featureType) throws DataException {

        // FIXME: y si el featuretype que paso esta modificado.

        //        Deberia buscarlo en el featuretypemanager ?

        //

        //        Si no existe feature con ese id... ? retorna null ?

        //        en EditedDefaultIterator se hace uso de ese comportamiento.

        //

        Integer intNum = (added.get(id));

        if (intNum == null) {

            intNum = (modifiedFromOriginal.get(id));

            if (intNum == null) {

                //If the feature has been added and deleted

                intNum = addedAndDeleted.get(id);

                if (intNum == null) {

                    return null;

                }

            }

        }

        int num = intNum;

        if (num == -1) {

            return null;

        }

        Feature feature = (Feature) expansionAdapter.getObject(num);

        if (featureType == null) {

            featureType = store.getDefaultFeatureType();

        }

        return new DefaultFeature(featureType, feature);

    }

    public int update(Feature feature, Feature oldFeature) {

        int oldNum = -1;

        int num = expansionAdapter.addObject(feature);

        FeatureReference id = feature.getReference();

        if (added.containsKey(id)) {

            oldNum = (added.get(id));

            added.put(id, num);

        } else {

            if (modifiedFromOriginal.get(id) != null) {

                oldNum = (modifiedFromOriginal.get(id));

            }

            modifiedFromOriginal.put(id, num);

        }

        return oldNum;

    }

    public void restore(FeatureReference id) {

        deleted.remove(id);

        deltaSize++;

    }

    public void restore(FeatureReference id, int num) {

        if (added.containsKey(id)) {

            added.put(id, num);

        } else {

            modifiedFromOriginal.put(id, num);

        }

    }

    public boolean isDeleted(Feature feature) {

        return deleted.contains(feature.getReference());

    }

    public boolean isDeleted(FeatureReference featureID) {

        return deleted.contains(featureID);

    }

    public void clear() {

        added.clear();

        modifiedFromOriginal.clear();

        expansionAdapter.close();

        deleted.clear();

        addedAndDeleted.clear();

        deltaSize = 0;

    }

    public boolean hasChanges() {

        return added.size() > 0 || modifiedFromOriginal.size() > 0 || deleted.size() > 0;

    }

    public Iterator getDeleted() {

        return new DeletedIterator();

    }

    private class DeletedIterator implements Iterator {

        private Boolean hasnext = null;

        private final Iterator iter;

        private DefaultFeatureReference obj;

        public DeletedIterator() {

            iter = deleted.iterator();

        }

        @Override

        public boolean hasNext() {

            if (hasnext != null) {

                return hasnext;

            }

            hasnext = false;

            while (iter.hasNext()) {

                obj = (DefaultFeatureReference) iter.next();

                if (obj.isNewFeature()) {

                    continue;

                }

                hasnext = false;

                break;

            }

            return hasnext;

        }

        @Override

        public Object next() {

            if (!hasNext()) {

                throw new NoSuchElementException();

            }

            hasnext = null;

            return obj;

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException();

        }

    }

    public Iterator getInserted() {

        return new InsertedIterator();

    }

    private class InsertedIterator implements Iterator {

        private final Iterator addedIter;

        private DefaultFeature obj;

        private Boolean hasnext = null;

        public InsertedIterator() {

            addedIter = added.values().iterator();

        }

        @Override

        public boolean hasNext() {

            if (hasnext != null) {

                return hasnext;

            }

            hasnext = false;

            int pos;

            while (addedIter.hasNext()) {

                pos = ((Integer) addedIter.next());

                obj = (DefaultFeature) expansionAdapter.getObject(pos);

                if (!deleted.contains(obj.getReference())) {

                    hasnext = true;

                    break;

                }

            }

            return hasnext;

        }

        @Override

        public Object next() {

            if (!hasNext()) {

                throw new NoSuchElementException();

            }

            hasnext = null;

            return obj.getData();

        }

        @Override

        public void remove() {

            addedIter.remove();

        }

    }

    public Iterator getUpdated() {

        return new UpdatedIterator();

    }

    private class UpdatedIterator implements Iterator {

        private Boolean hasnext = null;

        private final Iterator iter;

        private DefaultFeature obj;

        private int pos;

        public UpdatedIterator() {

            iter = expansionAdapter.iterator();

            pos = -1;

        }

        @Override

        public boolean hasNext() {

            if (hasnext != null) {

                return hasnext;

            }

            hasnext = false;

            while (iter.hasNext()) {

                pos++;

                obj = (DefaultFeature) iter.next();

                if (deleted.contains(obj.getReference())) {

                    continue;

                } else if (!modifiedFromOriginal.containsValue(pos)) {

                    continue;

                } else {

                    hasnext = true;

                    break;

                }

            }

            return hasnext;

        }

        @Override

        public Object next() {

            if (!hasNext()) {

                throw new NoSuchElementException();

            }

            hasnext = null;

            return obj.getData();

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException();

        }

    }

    public boolean hasNews() {

        return !added.isEmpty();

    }

    public long getDeltaSize() {

        return deltaSize;

    }

    /**

     * Indicates if any operation has comprimised the selected features.

     *

     * @return

     */

    public boolean isSelectionCompromised() {

        //Only deleted features can change order, as added features are added at the end.

        return deleted.size() > 0;

    }

}

package org.gvsig.fmap.dal.feature.impl.editing.memory;

import java.util.Iterator;

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.EditingManager;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider;

import org.gvsig.fmap.geom.primitive.Envelope;

public class MemoryEditingManager implements EditingManager {

    private final FeatureTypeManager featureTypeManager;

    private final FeatureManager featureManager;

    private final SpatialManager spatialManager;

    public MemoryEditingManager(FeatureStore store, Envelope envelope) throws DataException {

        this.featureManager = new FeatureManager();

        this.featureTypeManager = new FeatureTypeManager(store);

        this.spatialManager = new SpatialManager(store, envelope);

    }

    @Override

    public void dispose() {

        this.featureTypeManager.dispose();

        this.spatialManager.clear();

        this.featureManager.clear();

    }

    @Override

    public void delete(Feature feature) {

        this.featureManager.delete(feature.getReference());

        this.spatialManager.deleteFeature(feature);

    }

    @Override

    public void delete(FeatureReference featureReference) {

        // ????????

        this.featureManager.delete(featureReference);

    }

    @Override

    public void add(Feature newFeature) {

        this.featureManager.add(newFeature);

        this.spatialManager.insertFeature(newFeature);

    }

    @Override

    public int update(Feature newFeature, Feature oldFeature) {

        int code = featureManager.update(newFeature, oldFeature);

        spatialManager.updateFeature(newFeature, oldFeature);

        return code;

    }    

    @Override

    public int update(FeatureType newFeatureType, FeatureType oldFeatureType) {

        int code = featureTypeManager.update(oldFeatureType, oldFeatureType);

        return code;

    }

    @Override

    public boolean isSelectionCompromised() {

        return this.featureManager.isSelectionCompromised();

    }

    @Override

    public Iterator<FeatureProvider> getDeletedFeatures() {

        return this.featureManager.getDeleted();

    }

    @Override

    public Iterator<FeatureProvider> getInsertedFeatures() {

        return this.featureManager.getInserted();

    }

    @Override

    public Iterator<FeatureProvider> getUpdatedFeatures() {

        return this.featureManager.getUpdated();

    }

    @Override

    public Iterator<FeatureStoreProvider.FeatureTypeChanged> getFeatureTypesChanged() throws DataException {

        return this.featureTypeManager.getFeatureTypesChanged();

    }

    @Override

    public FeatureType getFeatureType(String id) throws DataException {

        return this.featureTypeManager.getType(id);

    }

    @Override

    public Feature getFeature(FeatureReference reference, FeatureStore store, FeatureType type) throws DataException {

        return this.featureManager.get(reference, store, type);

    }

    @Override

    public void restore(FeatureReference featureReference) {

        this.featureManager.restore(featureReference);

    }

    @Override

    public void restore(FeatureReference featureReference, int code) {

        this.featureManager.restore(featureReference, code);

    }

    @Override

    public void restore(String featureTypeId) {

        this.featureTypeManager.restore(featureTypeId);

    }

    @Override

    public void restore(String featureTypeId, int code) {

        this.featureTypeManager.restore(featureTypeId, code);

    }

    @Override

    public boolean isDeleted(Feature feature) {

        return this.featureManager.isDeleted(feature);

    }

    @Override

    public boolean isDeleted(FeatureReference featureReference) {

        return this.featureManager.isDeleted(featureReference);

    }

    @Override

    public boolean isDeleted(FeatureType type) {

        return this.featureTypeManager.isDeleted(type);

    }

    @Override

    public boolean isDeleted(String featureTypeId) {

        return this.featureTypeManager.isDeleted(featureTypeId);

    }

}

/**

 * 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.fmap.dal.feature.impl.editing.memory;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureStoreTransforms;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider.FeatureTypeChanged;

import org.gvsig.tools.persistence.PersistentState;

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

public class FeatureTypeManager {

    private final ExpansionAdapter expansionAdapter;

    private final Map<String,Integer> added = new HashMap();

    private final Map<String,Integer> modifiedFromOriginal = new HashMap();

    private final List<String> deleted = new ArrayList();

    private final FeatureTypeManagerFeatureStoreTransforms transforms;

    private final FeatureStore store;

    private int deltaSize = 0;

    private boolean first = true;

    private FeatureType originalType = null;

    public FeatureTypeManager(FeatureStore store) {

        this.expansionAdapter = new MemoryExpansionAdapter();

        this.store = store;

        this.transforms = new FeatureTypeManagerFeatureStoreTransforms();

        this.transforms.setFeatureStore(store);

    }

    public void dispose() {

        this.expansionAdapter.close();

        this.deleted.clear();

        this.transforms.clear();

        this.added.clear();

        this.modifiedFromOriginal.clear();

    }

    public FeatureType getType(String id) throws DataException {

        Integer num = added.get(id);

        if (num == null) {

            num = modifiedFromOriginal.get(id);

            if (num == null) {

                return null;

            }

        }

        if (num == -1) {

            /*

             * This happens for example when we are going back to the

             * original feature type which is not managed by

             * expansionAdapter

             */

            return null;

        }

        FeatureType type = (FeatureType) expansionAdapter.getObject(num);

        return type;

    }

    public int update(FeatureType type, FeatureType oldType) {

        // deleted.add(oldType.getId());

        if (first) {

            originalType = oldType;

            first = false;

        }

        int oldNum = -1;

        int num = expansionAdapter.addObject(type);

        String id = type.getId();

        if (added.containsKey(id)) {

            oldNum = added.get(id);

            added.put(id, num);

        } else {

            if (modifiedFromOriginal.get(id) != null) {

                oldNum = modifiedFromOriginal.get(id);

            }

            modifiedFromOriginal.put(id, num);

        }

        try {

            this.transforms.add(new UpdateFeatureTypeTransform(this.store,

                    oldType, type));

        } catch (DataException e) {

            throw new RuntimeException(); // FIXME (pero esto no deberia de

            // pasar nunca)

        }

        return oldNum;

    }

    private class UpdateFeatureTypeTransform extends AbstractFeatureStoreTransform {

        private final FeatureType ftSource;

        private EditableFeatureType ftTarget_editable;

        private final FeatureType ftTarget_non_editable;

        private WeakReference wkRefStore;

        private List ftypes = null;

        private List attrInSourceToUse;

        UpdateFeatureTypeTransform(FeatureStore featureStore,

                FeatureType ftSource, FeatureType ftTarget) {

            this.ftSource = ftSource;

            if (ftTarget instanceof EditableFeatureType) {

                ftTarget_editable = (EditableFeatureType) ftTarget;

                ftTarget_non_editable = ftTarget_editable.getNotEditableCopy();

            } else {

                ftTarget_non_editable = ftTarget;

            }

            this.wkRefStore = new WeakReference(featureStore);

            this.initializeAttributesToUse();

        }

        private void initializeAttributesToUse() {

            attrInSourceToUse = new ArrayList();

            Iterator iter;

            if (ftTarget_editable != null) {

                iter = ftTarget_editable.iterator();

            } else {

                iter = ftTarget_non_editable.iterator();

            }

            FeatureAttributeDescriptor tAttr, sAttr;

            EditableFeatureAttributeDescriptor ead;

            while (iter.hasNext()) {

                tAttr = (FeatureAttributeDescriptor) iter.next();

                sAttr = this.ftSource.getAttributeDescriptor(tAttr.getName());

                if (sAttr == null) {

                    if (tAttr instanceof EditableFeatureAttributeDescriptor) {

                        ead = (EditableFeatureAttributeDescriptor) tAttr;

                        if (ead.getOriginalName() != null) {

                            sAttr = this.ftSource.getAttributeDescriptor(ead.getOriginalName());

                            if (sAttr == null) {

                                continue;

                            }

                        } else {

                            continue;

                        }

                    } else {

                        continue;

                    }

                }

                if (tAttr.getType() != sAttr.getType()) {

                    /*

                     * Ignore if type is not the same (user removed field

                     * and added another with same name but different type)

                     */

                    continue;

                }

                attrInSourceToUse.add(sAttr.getName());

            }

        }

        @Override

        public void setUp() throws Exception {

        }

        @Override

        public void applyTransform(Feature source, EditableFeature target)

                throws DataException {

            Iterator iter = target.getType().iterator();

            FeatureAttributeDescriptor tAttr;

            FeatureAttributeDescriptor tAttr_edi;

            FeatureAttributeDescriptor srcAtt;

            /*

             * field name in source feature

             */

            String s_name;

            /*

             * field name in target feature (the same as in source

             * except if renamed)

             */

            String t_name;

            EditableFeatureAttributeDescriptor eatd;

            while (iter.hasNext()) {

                tAttr = (FeatureAttributeDescriptor) iter.next();

                if (ftTarget_editable != null) {

                    /*

                     * If target FT is editable, try to get original name

                     */

                    t_name = tAttr.getName();

                    s_name = t_name;

                    tAttr_edi = ftTarget_editable.getAttributeDescriptor(t_name);

                    if (tAttr_edi instanceof EditableFeatureAttributeDescriptor) {

                        eatd = (EditableFeatureAttributeDescriptor) tAttr_edi;

                        s_name = eatd.getOriginalName();

                    }

                    /*

                     * If not found, use normal name

                     */

                    if (s_name == null) {

                        s_name = tAttr.getName();

                    }

                } else {

                    /*

                     * If target FT is not editable, use normal name

                     */

                    t_name = tAttr.getName();

                    s_name = t_name;

                }

                srcAtt = source.getType().getAttributeDescriptor(s_name);

                if (srcAtt != null

                        && /*

                         * This prevents the case when user has removed field and

                         * added new field with same name and different type.

                         * In that case, value will be the default value (else below)

                         */ srcAtt.getType() == tAttr.getType()) {

                    target.set(t_name, source.get(s_name));

                } else {

                    target.set(t_name, tAttr.getDefaultValue());

                }

            }

        }

        @Override

        public FeatureType getDefaultFeatureType() throws DataException {

            return this.ftTarget_non_editable;

        }

        @Override

        public FeatureStore getFeatureStore() {

            return (FeatureStore) this.wkRefStore.get();

        }

        @Override

        public List getFeatureTypes() throws DataException {

            if (this.ftypes == null) {

                this.ftypes = Arrays

                        .asList(new FeatureType[]{this.ftTarget_non_editable});

            }

            return this.ftypes;

        }

        @Override

        public FeatureType getSourceFeatureTypeFrom(

                FeatureType targetFeatureType) {

            EditableFeatureType orgType = ftSource.getEditable();

            Iterator iter = orgType.iterator();

            FeatureAttributeDescriptor attr;

            EditableFeatureAttributeDescriptor efad;

            while (iter.hasNext()) {

                attr = (FeatureAttributeDescriptor) iter.next();

                if (!attrInSourceToUse.contains(attr.getName())) {

                    if (attr instanceof EditableFeatureAttributeDescriptor) {

                        efad = (EditableFeatureAttributeDescriptor) attr;

                        if (efad.getOriginalName() != null

                                && !attrInSourceToUse.contains(efad.getOriginalName())) {

                            iter.remove();

                        }

                    } else {

                        iter.remove();

                    }

                }

            }

            return orgType.getNotEditableCopy();

        }

        @Override

        public void setFeatureStore(FeatureStore featureStore) {

            this.wkRefStore = new WeakReference(featureStore);

        }

        @Override

        public boolean isTransformsOriginalValues() {

            return false;

        }

    }

    public void restore(String id) {

        deleted.remove(id);

        deltaSize++;

    }

    public void restore(String id, int num) {

        if (added.containsKey(id)) {

            added.put(id, num);

        } else {

            modifiedFromOriginal.put(id, num);

        }

    }

    public boolean isDeleted(FeatureType type) {

        return deleted.contains(type.getId());

    }

    public boolean isDeleted(String id) {

        return deleted.contains(id);

    }

    public void clear() {

        added.clear();

        modifiedFromOriginal.clear();

        expansionAdapter.close();

        deleted.clear();

        deltaSize = 0;

    }

    public boolean hasChanges() {

        return added.size() > 0 || modifiedFromOriginal.size() > 0

                || deleted.size() > 0;

    }

    public Iterator newsIterator() {

        return added.values().iterator();

    }

    public boolean hasNews() {

        return !added.isEmpty();

    }

    public long getDeltaSize() {

        return deltaSize;

    }

    public FeatureType getOriginalFeatureType() {

        return originalType;

    }

    public DefaultFeatureStoreTransforms getTransforms() {

        return this.transforms;

    }

    public class FeatureTypeManagerFeatureStoreTransforms extends

            DefaultFeatureStoreTransforms {

        private FeatureTypeManagerFeatureStoreTransforms() {

        }

        @Override

        protected void checkEditingMode() {

        }

        @Override

        protected void notifyChangeToStore() {

        }

        public PersistentState getState() throws PersistenceException {

            // FIXME

            throw new UnsupportedOperationException();

        }

        public void loadState(PersistentState state)

                throws PersistenceException {

            // FIXME

            throw new UnsupportedOperationException();

        }

        @Override

        public void loadFromState(PersistentState state) throws PersistenceException {

            // FIXME

            throw new UnsupportedOperationException();

        }

        @Override

        public FeatureStoreTransform add(FeatureStoreTransform transform)

                throws DataException {

            if (!(transform instanceof UpdateFeatureTypeTransform)) {

                // FIXME

                throw new IllegalArgumentException();

            }

            return super.add(transform);

        }

    }

    public class FeatureTypesChangedItem implements FeatureTypeChanged {

        private final FeatureType source;

        private final FeatureType target;

        public FeatureTypesChangedItem(FeatureType source, FeatureType target) {

            this.source = source;

            this.target = target;

        }

        @Override

        public FeatureType getSource() {

            return source;

        }

        @Override

        public FeatureType getTarget() {

            return target;

        }

    }

    public Iterator getFeatureTypesChanged() throws DataException {

        // FIXME this don't work for Store.fType.size() > 1

        List list = new ArrayList();

        if (modifiedFromOriginal.size() > 0) {

            FeatureType src = this.getOriginalFeatureType();

            list.add(new FeatureTypesChangedItem(src, this.store

                    .getFeatureType(src.getId())));

        }

        return list.iterator();

    }

}

/**

 * 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.fmap.dal.feature.impl.editing.memory;

import java.util.ArrayList;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;

import org.gvsig.fmap.dal.feature.impl.DefaultFeature;

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureIndex;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.tools.dispose.DisposableIterator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * DOCUMENT ME!

 *

 * @author Vicente Caballero Navarro

 */

public class SpatialManager {

    private static final Logger LOG = LoggerFactory.getLogger(SpatialManager.class);

    protected boolean isFullExtentDirty = true;

    private FeatureStore featureStore;

    private FeatureIndex featureIndex = null;

    private Envelope originalEnvelope = null;

    private Envelope fullEnvelope = null;

    private ArrayList feaOperation=new ArrayList();

    private boolean noSpatialData = false;

    public SpatialManager(FeatureStore featureStore, Envelope originalEnvelope)

            throws DataException {

        this.featureStore=featureStore;

        FeatureIndexes findexes=featureStore.getIndexes();

        // Comprobamos si hay algun campo espacial a manejar

        FeatureType fType = this.featureStore.getDefaultFeatureType();

        // TODO Multy FType !!

        if (fType.getDefaultGeometryAttributeIndex() < 0) {

            noSpatialData = true;

            return;

        }

        FeatureAttributeDescriptor attr = fType.getAttributeDescriptor(fType

                .getDefaultGeometryAttributeIndex());

        this.originalEnvelope = originalEnvelope;

        if ((originalEnvelope != null) && (!originalEnvelope.isEmpty())) {

            this.fullEnvelope = originalEnvelope.getGeometry().getEnvelope();

        } else {

            FeatureAttributeDescriptor geoAttr = fType.getAttributeDescriptor(fType.getDefaultGeometryAttributeIndex());

            try {

                this.fullEnvelope = GeometryLocator.getGeometryManager()

                        .createEnvelope(geoAttr.getGeometrySubType());

            } catch (Exception e) {

                // FIXME Excpetion

                throw new RuntimeException(e);

            }

        }

        if (!fType.hasOID()) {

            return;

        }

        Iterator iterator = findexes.iterator();

        FeatureIndex index;

        while (iterator.hasNext()) {

            index = (FeatureIndex) iterator.next();

            if (index.getAttributeNames().size() == 1

                    && index.getAttributeNames().contains(attr.getName())) {

                featureIndex = index;

                break;

            }

        }

        if (featureIndex instanceof DefaultFeatureIndex) {

            ((DefaultFeatureIndex) featureIndex).setValid(true);

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @param feature DOCUMENT ME!

     * @param oldFeature DOCUMENT ME!

     */

    public void updateFeature(Feature feature, Feature oldFeature) {

        if (noSpatialData) {

            return;

        }

            try {

            	if (featureIndex != null) {

            		featureIndex.delete(oldFeature);

            	}

                feaOperation.add(new FeatureOperation(((DefaultFeature) oldFeature)

                        .getReference(), FeatureOperation.DELETE));

            	if (featureIndex != null) {

            		featureIndex.insert(feature);

            	}

                feaOperation.add(new FeatureOperation(((DefaultFeature) feature)

                        .getReference(), FeatureOperation.INSERT));

            } catch (DataException e) {

                throw new RuntimeException("Exception updating feature: "

                    + feature, e);

            }

            // } else {

            // fullEnvelope.add(feature.getDefaultEnvelope());

        isFullExtentDirty = true;

    }

    /**

     * DOCUMENT ME!

     *

     * @param feature DOCUMENT ME!

     */

    public void insertFeature(Feature feature) {

        if (noSpatialData) {

            return;

        }

            try {

            	if (featureIndex != null) {

            		featureIndex.insert(feature);

            	}

                feaOperation.add(new FeatureOperation(

                    ((DefaultFeature) feature).getReference(),

                    FeatureOperation.INSERT));

            } catch (DataException e) {

                throw new RuntimeException("Exception inserting feature: "

                    + feature, e);

            }

            isFullExtentDirty = true;

//        } else if (!isFullExtentDirty) {

//            fullEnvelope.add(feature.getDefaultEnvelope());

//        }

    }

    /**

     * DOCUMENT ME!

     *

     * @param feature DOCUMENT ME!

     */

    public void deleteFeature(Feature feature) {

        if (noSpatialData) {

            return;

        }

            try {

            	if (featureIndex != null) {

            		featureIndex.delete(feature);

            	}

                feaOperation.add(new FeatureOperation(((DefaultFeature) feature)

                        .getReference(), FeatureOperation.DELETE));

            } catch (DataException e) {

                throw new RuntimeException("Exception deleting feature: "

                    + feature, e);

            }

        isFullExtentDirty = true;

    }

    public void clear() {

    }

    public Envelope getEnvelope() throws DataException {

        if (noSpatialData) {

            return null;

        }

        if (!isFullExtentDirty){

            return this.fullEnvelope;

        }

        // FIXME in every changes when anyone ask for envelope it was regenerated.

        //       if we assume that the envelope may not be the minimum in edit mode

        //       this call must be very much faster

        FeatureAttributeDescriptor attr = featureStore.getDefaultFeatureType()

                .getAttributeDescriptor(

                        featureStore.getDefaultFeatureType()

                                .getDefaultGeometryAttributeIndex());

        Envelope fullEnvelope = null;

        FeatureSet set = null;

        DisposableIterator iterator = null;

        try {

            set = featureStore.getFeatureSet();

            iterator = set.fastIterator();

            //First while to initialize the feature envelope

            while (iterator.hasNext()) {

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

                Envelope envelope = feature.getDefaultEnvelope();

                if (envelope != null){

                    fullEnvelope = (Envelope)envelope.clone();

                    break;

                }

            }           

            //Second while to add new evelopes tho the full envelope

            while (iterator.hasNext()) {

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

                Envelope envelope = feature.getDefaultEnvelope();           

                if(envelope!=null){

                    fullEnvelope.add(envelope);

                }

            }

            //Creating an empty envelope by default

            if (fullEnvelope == null){

                fullEnvelope = GeometryLocator.getGeometryManager().createEnvelope(

                    attr.getGeometrySubType());

            }

        } catch (ConcurrentModificationException e) {

            throw e;

        } catch (ConcurrentDataModificationException e) {

            throw e;

        } catch (Exception e) {

            throw new RuntimeException(e);

        } finally {

            if (iterator != null) {

                iterator.dispose();

            }

            if (set != null) {

                set.dispose();

            }

        }

        this.fullEnvelope = fullEnvelope;

        this.isFullExtentDirty = false;

        return fullEnvelope;

    }

    public void cancelModifies() {

        if (noSpatialData) {

            return;

        }

        if (featureIndex != null){

            for (int i = feaOperation.size()-1 ; i>=0 ; i--){

                try {