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;

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.expansionadapter.ExpansionAdapter;

public class FeatureManager {

    private int deltaSize = 0;

    private final ExpansionAdapter expansionAdapter;

    private final Collection<FeatureReference> deleted = new LinkedHashSet();

    private final Map<FeatureReference, Integer> added = new LinkedHashMap();

    private final Map<FeatureReference, Integer> addedAndDeleted = new LinkedHashMap();

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

    public FeatureManager(ExpansionAdapter expansionAdapter) {

        this.expansionAdapter = expansionAdapter;

    }

    /**

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

    }

}