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 java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.NoSuchElementException;

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

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

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

import org.gvsig.fmap.dal.feature.impl.featurereference.FeatureReferenceFactory;

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

import org.gvsig.tools.util.Rewind;

import org.gvsig.tools.util.Size;

@SuppressWarnings("UseSpecificCatch")

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;

    private final Map<FeatureReference, Integer> original;

    private final FeatureStore store;

    public FeatureManager(FeatureStore store) {

        deltaSize = 0;

        expansionAdapter = new MemoryExpansionAdapter();

        deleted = new LinkedHashSet<>();

        added = new LinkedHashMap<>();

        addedAndDeleted = new LinkedHashMap<>();

        modifiedFromOriginal = new HashMap<>();

        original = new HashMap<>();

        this.store = store;

    }

    /**

     * 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(Feature feature) {

        FeatureReference id = feature.getReference();

        if(!original.containsKey(id)){

            int n = expansionAdapter.addObject(feature);

            original.put(id, n);

        }

        deleted.add(id);

        Integer num = added.remove(id);

        Feature previousFeature = null;

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

            num = modifiedFromOriginal.remove(id);

            if (num != null) {

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

            }

            // if num is null here, method returns null

        } else {

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

            addedAndDeleted.put(id, num);

        }

        deltaSize--;

        return previousFeature;

    }

    public void add(EditableFeature feature) {

        FeatureReference id = feature.getReference();

        if(!original.containsKey(id)){

            original.put(id, null);

        }

        int pos = expansionAdapter.addObject(feature);

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

        deleted.remove(feature.getReference());

        deltaSize++;

    }

    public void undoAdd(EditableFeature feature) {

        FeatureReference id = feature.getReference();

        if(added.remove(id)!=null){

            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;

    }

    public DefaultFeature get(FeatureProvider data){

        FeatureReference ref = FeatureReferenceFactory.createFromFeatureProvider(store, data);

        try {

            return get(ref, store);

        } catch (DataException ex) {

            return null;

        }

    }

    /**

     * 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 DefaultFeature 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 DefaultFeature 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.

        //

        boolean isNewFeature = false;

        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;

                }

            }

        } else {

            isNewFeature = true;

        }

        int num = intNum;

        if (num == -1) {

            return null;

        }

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

        if (featureType == null) {

            featureType = store.getDefaultFeatureType();

        }

        DefaultFeature feat = new DefaultFeature(featureType, feature);

        feat.getData().setNew(isNewFeature);

        return feat;

    }

    public int update(EditableFeature feature, Feature oldFeature) {

        FeatureReference id = feature.getReference();

        if(!original.containsKey(id)){

            int n = expansionAdapter.addObject(oldFeature);

            original.put(id, n);

        }

        int oldNum = -1;

        int num = expansionAdapter.addObject(feature);

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

        FeatureReference ref = FeatureReferenceFactory.createFromFeatureProvider(store, data);

        return deleted.contains(ref);

    }

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

        return deleted.size() > 0;

    }

    public long getPendingChangesCount() {

        long count = 0;

        if( this.added!=null ) {

            count += this.added.size();

        }

        if( this.deleted!=null ) {

            count += this.deleted.size();

        }

        if( this.modifiedFromOriginal!=null ) {

            count += this.modifiedFromOriginal.size();

        }

        return count;

    }

    public Iterator<FeatureReference> getDeleted() {

        return new DeletedsFeatureReferencesIterator();

    }

    private class DeletedsFeatureReferencesIterator implements Iterator<FeatureReference> {

        private Boolean hasnext = null;

        private final Iterator iter;

        private FeatureReference reference;

        public DeletedsFeatureReferencesIterator() {

            iter = deleted.iterator();

        }

        @Override

        public boolean hasNext() {

            if (hasnext != null) {

                return hasnext;

            }

            hasnext = false;

            while (iter.hasNext()) {

                reference = (FeatureReference) iter.next();

                if (!reference.isNewFeature()) {

                  hasnext = true;

                  break;

                }

            }

            return hasnext;

        }

        @Override

        public FeatureReference next() {

            if (!hasNext()) {

                throw new NoSuchElementException();

            }

            hasnext = null;

            return reference;

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException();

        }

    }

    public Iterator<FeatureProvider> getInserted() {

        Iterator<EditableFeature> it = new InsertedFeaturesIterator();

        return new Iterator<FeatureProvider>() {

          @Override

          public boolean hasNext() {

            return it.hasNext();

          }

          @Override

          public FeatureProvider next() {

            return ((DefaultFeature)it.next()).getData();

          }

        };

    }

    public Iterator<EditableFeature> getInsertedFeatures() {

        return new InsertedFeaturesIterator();

    }

    private class InsertedFeaturesIterator implements Iterator<EditableFeature>, Size, Rewind {

        private Iterator addedIter;

        private EditableFeature feature;

        private Boolean hasnext = null;

        public InsertedFeaturesIterator() {

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

        }

        @Override

        public boolean hasNext() {

            if (hasnext != null) {

                return hasnext;

            }

            hasnext = false;

            int pos;

            while (addedIter.hasNext()) {

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

                feature = (EditableFeature) expansionAdapter.getObject(pos);

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

                    hasnext = true;

                    break;

                }

            }

            return hasnext;

        }

        @Override

        public EditableFeature next() {

            if (!hasNext()) {

                throw new NoSuchElementException();

            }

            hasnext = null;

            return feature;

        }

        @Override

        public void remove() {

            addedIter.remove();

        }

        @Override

        public int size() {

            return added.size();

        }

        @Override

        public void rewind() {

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

            hasnext = null;

        }

    }

    public List<FeatureReference> getAddedAndUpdatedFeatures() {

        List<FeatureReference> references = new ArrayList<>();

        references.addAll(this.modifiedFromOriginal.keySet());

        references.addAll(this.added.keySet());

        return references;

    }

    public List<FeatureReference> getAddedAndUpdatedFeaturesNotValidated(DefaultFeatureRules rules, int checks) {

        List<FeatureReference> references = new ArrayList<>();

        for (FeatureReference ref : this.modifiedFromOriginal.keySet()) {

            Integer index = this.modifiedFromOriginal.get(ref);

            if( index!=null ) {

                EditableFeature feature = (EditableFeature) this.expansionAdapter.getObject(index);

                try {

                    rules.validate(feature, checks);

                } catch (DataException ex) {

                    references.add(ref);

                }

            }

        }

        for (FeatureReference ref : this.added.keySet()) {

            Integer index = this.added.get(ref);

            if( index!=null ) {

                EditableFeature feature = (EditableFeature) this.expansionAdapter.getObject(index);

                try {

                    rules.validate(feature, checks);

                } catch (Exception ex) {

                    references.add(ref);

                }

            }

        }

        return references;

    }

    public Iterator<EditableFeature> getUpdatedFeatures() {

        return new UpdatedFeaturesIterator();

    }

    public Iterator<FeatureProvider> getUpdated() {

        Iterator<EditableFeature> it = new UpdatedFeaturesIterator();

        return new Iterator<FeatureProvider>() {

          @Override

          public boolean hasNext() {

            return it.hasNext();

          }

          @Override

          public FeatureProvider next() {

            return ((DefaultFeature)it.next()).getData();

          }

        };

    }

    private class UpdatedFeaturesIterator implements Iterator<EditableFeature>, Size, Rewind {

        private Boolean hasnext = null;

        private Iterator iter;

        private EditableFeature feature;

        private int pos;

        public UpdatedFeaturesIterator() {

            iter = expansionAdapter.iterator();

            pos = -1;

        }

        @Override

        public boolean hasNext() {

            if (hasnext != null) {

                return hasnext;

            }

            hasnext = false;

            while (iter.hasNext()) {

                pos++;

                Feature f = (Feature) iter.next();

                if ( f != null &&

                     !deleted.contains(f.getReference()) &&

                     modifiedFromOriginal.containsValue(pos)) {

                    hasnext = true;

                    feature = (EditableFeature) f;

                    break;

                }

            }

            return hasnext;

        }

        @Override

        public EditableFeature next() {

            if (!hasNext()) {

                throw new NoSuchElementException();

            }

            hasnext = null;

            return feature;

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException();

        }

        @Override

        public int size() {

            return expansionAdapter.getSize();

        }

        @Override

        public void rewind() {

            iter = expansionAdapter.iterator();

            pos = -1;

            hasnext = null;

        }

    }

    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.isEmpty() || !added.isEmpty();

    }

    public Feature getOriginal(FeatureReference id){

        Integer n = original.get(id);

        if(n == null){

            return null;

        }

        return (Feature) this.expansionAdapter.getObject(n);

    }

    public boolean isFeatureModified(FeatureReference id) {

        return original.containsKey(id);

    }

}