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, 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.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

import org.apache.commons.lang3.builder.ToStringBuilder;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.undo.FeatureCommandsStack;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.lang.Cloneable;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.observer.impl.DelegateWeakReferencingObservable;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementation of a FeatureReferenceSelection, based on the usage of

 * a java.util.Set to store individual selected or not selected

 * FeatureReferences, depending on the usage of the {@link #reverse()} method.

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureReferenceSelection extends AbstractDisposable

        implements FeatureReferenceSelection {

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

    public static final String DYNCLASS_PERSISTENT_NAME = "DefaultFeatureReferenceSelection";

    private Boolean available = null;

    protected SelectionData selectionData = null;

    private FeatureStore featureStore;

    private FeatureSelectionHelper helper;

    private DelegateWeakReferencingObservable delegateObservable

            = new DelegateWeakReferencingObservable(this);

    /**

     * Creates a new Selection with the total size of Features from which the

     * selection will be performed.

     *

     * @param featureStore the FeatureStore of the selected FeatureReferences

     * @throws DataException if there is an error while getting the total number

     * of Features of the Store.

     */

    public DefaultFeatureReferenceSelection(DefaultFeatureStore featureStore)

            throws DataException {

        super();

        this.featureStore = featureStore;

        this.helper = new DefaultFeatureSelectionHelper(featureStore);

    }

    /**

     * Creates a new Selection with the total size of Features from which the

     * selection will be performed.

     *

     * @param featureStore the FeatureStore of the selected FeatureReferences

     * @param helper to get some information of the Store

     * @throws DataException if there is an error while getting the total number

     * of Features of the Store.

     */

    public DefaultFeatureReferenceSelection(FeatureStore featureStore,

            FeatureSelectionHelper helper)

            throws DataException {

        super();

        this.featureStore = featureStore;

        this.helper = helper;

    }

    /**

     * Constructor used by the persistence manager. Don't use directly. After to

     * invoke this method, the persistence manager calls the the method

     * {@link #loadFromState(PersistentState)} to set the values of the internal

     * attributes that this class needs to work.

     */

    public DefaultFeatureReferenceSelection() {

        super();

    }

    @Override

    public boolean select(FeatureReference reference) {

        return select(reference, true);

    }

    /**

     * @param reference

     * @param undoable if the action must be undoable

     * @return

     * @see #select(FeatureReference)

     */

    public boolean select(FeatureReference reference, boolean undoable) {

        if (reference == null) {

            throw new IllegalArgumentException("reference");

        }

        if (isSelected(reference)) {

            return false;

        }

        if (undoable && getFeatureStore().isEditing()) {

            getCommands().select(this, reference);

        }

        boolean change;

        if (this.getData().isReversed()) {

            change = this.getData().remove(reference);

        } else {

            change = this.getData().add(reference);

        }

        if (change) {

            notifyObservers(DataStoreNotification.SELECTION_CHANGE);

        }

        return change;

    }

    @Override

    public boolean deselect(FeatureReference reference) {

        return deselect(reference, true);

    }

    /**

     * @param reference

     * @param undoable if the action must be undoable

     * @return

     * @see #deselect(FeatureReference)

     */

    public boolean deselect(FeatureReference reference, boolean undoable) {

        if (!isSelected(reference)) {

            return false;

        }

        if (undoable && getFeatureStore().isEditing()) {

            getCommands().deselect(this, reference);

        }

        boolean change;

        if (this.getData().isReversed()) {

            change = this.getData().add(reference);

        } else {

            change = this.getData().remove(reference);

        }

        if (change) {

            notifyObservers(DataStoreNotification.SELECTION_CHANGE);

        }

        return change;

    }

    @Override

    public void selectAll() throws DataException {

        selectAll(true);

    }

    /**

     * @see #selectAll()

     * @param undoable if the action must be undoable

     * @throws org.gvsig.fmap.dal.exception.DataException

     */

    public void selectAll(boolean undoable) throws DataException {

        if (undoable && getFeatureStore().isEditing()) {

            getCommands().startComplex("_selectionSelectAll");

            getCommands().selectAll(this);

        }

        if (!this.getData().isReversed()) {

            this.getData().setReversed(true);

        }

        clearFeatureReferences();

        if (undoable && getFeatureStore().isEditing()) {

            getCommands().endComplex();

        }

        notifyObservers(DataStoreNotification.SELECTION_CHANGE);

    }

    @Override

    public void deselectAll() throws DataException {

        deselectAll(false);

    }

    /**

     * @param undoable if the action must be undoable

     * @throws org.gvsig.fmap.dal.exception.DataException

     * @see #deselectAll()

     */

    public void deselectAll(boolean undoable) throws DataException {

        if (this.selectionData == null) {

            return;

        }

        if (undoable && getFeatureStore().isEditing()) {

            getCommands().startComplex("_selectionDeselectAll");

            getCommands().deselectAll(this);

        }

        if (this.getData().isReversed()) {

            this.getData().setReversed(false);

        }

        clearFeatureReferences();

        if (undoable && getFeatureStore().isEditing()) {

            getCommands().endComplex();

        }

        notifyObservers(DataStoreNotification.SELECTION_CHANGE);

    }

    @Override

    public boolean isSelected(FeatureReference reference) {

        if (this.selectionData == null) {

            return false;

        }

        if (this.getData().isReversed()) {

            return !this.getData().contains(reference);

        } else {

            return this.getData().contains(reference);

        }

    }

    @Override

    public void reverse() {

        reverse(true);

    }

    /**

     * @see #reverse()

     * @param undoable if the action must be undoable

     */

    public void reverse(boolean undoable) {

        if (undoable && getFeatureStore().isEditing()) {

            getCommands().selectionReverse(this);

        }

        this.getData().setReversed(!this.getData().isReversed());

        notifyObservers(DataStoreNotification.SELECTION_CHANGE);

    }

    public boolean isEmpty() {

        if (this.selectionData == null) {

            return true;

        }

        return this.getSelectedCount() == 0;

    }

    @Override

    public long getSelectedCount() {

        if (this.selectionData == null) {

            return 0;

        }

        if (this.getData().isReversed()) {

            return this.getData().getTotalSize() - this.getData().getSize()

                    + helper.getFeatureStoreDeltaSize();

        } else {

            return this.getData().getSize();

        }

    }

    @Override

    public FeatureReferenceIterator referenceIterator() {

        Iterator<FeatureReference> it = this.getData().getSelected().iterator();

        return new FeatureReferenceIterator() {

            @Override

            public boolean hasNext() {

                return it.hasNext();

            }

            @Override

            public FeatureReference next() {

                return it.next();

            }

        };

    }

    @Override

    public Iterable<FeatureReference> referenceIterable() {

        return new Iterable<FeatureReference>() {

            @Override

            public Iterator<FeatureReference> iterator() {

                return referenceIterator();

            }

        };

//        Set<FeatureReference> s = Collections.unmodifiableSet(this.getData().getSelected());        

//        return s;

    }

    @Override

    protected void doDispose() throws BaseException {

        deselectAll(false);

        delegateObservable.deleteObservers();

    }

    @Override

    public boolean isFromStore(DataStore store) {

        return featureStore.equals(store);

    }

    @Override

    public void accept(Visitor visitor) throws BaseException {

        if (this.selectionData == null) {

            return;

        }

        for (Iterator iter = this.getData().getSelected().iterator(); iter.hasNext();) {

            visitor.visit(iter.next());

        }

    }

    @Override

    public void update(Observable observable, Object notification) {

        // If a Feature is deleted, remove it from the selection Set.

        if (notification instanceof FeatureStoreNotification) {

            FeatureStoreNotification storeNotif = (FeatureStoreNotification) notification;

            if (FeatureStoreNotification.AFTER_DELETE

                    .equalsIgnoreCase(storeNotif.getType())) {

                this.getData().remove(storeNotif.getFeature().getReference());

            }

        }

    }

    public SelectionData getData() {

        if (selectionData == null) {

            selectionData = new SelectionData();

            try {

                selectionData.setTotalSize(featureStore.getFeatureCount());

            } catch (DataException ex) {

                throw new RuntimeException("Can't initialize SelectionData, don't get the feature count.", ex);

            }

        }

        return selectionData;

    }

    public void setData(SelectionData selectionData) {

        this.selectionData = selectionData;

        notifyObservers(DataStoreNotification.SELECTION_CHANGE);

    }

    @Override

    public String toString() {

        try {

            ToStringBuilder builder = new ToStringBuilder(this);

            builder.append("featureStore", this.featureStore, true);

            builder.append("SelectedCount", this.getSelectedCount());

            builder.append("isReversed", this.isReversed());

            builder.append("featureIdsContained", selectionData==null?0:this.selectionData.getSelected());

            return builder.toString();

        } catch (Exception e) {

            return super.toString();

        }

    }

    protected boolean isReversed() {

        if (this.selectionData == null) {

            return false;

        }

        return this.getData().isReversed();

    }

    /**

     * Removes all the stored FeatureRefence objects.

     */

    protected void clearFeatureReferences() {

        if (this.selectionData == null) {

            return;

        }

        this.getData().clear();

    }

    /**

     * Returns the FeatureStore of the selected FeatureReferences.

     *

     * @return the featureStore

     */

    public FeatureStore getFeatureStore() {

        return featureStore;

    }

    /**

     * Returns the reference to the commands record.

     *

     * @return the reference to the commands record

     */

    protected FeatureCommandsStack getCommands() {

        return helper.getFeatureStoreCommandsStack();

    }

    public static class SelectionData implements Cloneable {

        private Set<FeatureReference> selected = new HashSet();

        /**

         * Sets how the Set of selected values has to be dealt.

         * <p>

         * If selected is FALSE, then values into the Set are the selected ones,

         * anything else is not selected.

         * </p>

         * <p>

         * If selected is TRUE, then values into the Set are values not

         * selected, anything else is selected.

         * </p>

         */

        private boolean reversed = false;

        private long totalSize;

        /**

         * @return the selected

         */

        public Set<FeatureReference> getSelected() {

            return selected;

        }

        /**

         * @param selected the selected to set

         */

        public void setSelected(Set<FeatureReference> selected) {

            this.selected = selected;

        }

        /**

         * @return the reversed

         */

        public boolean isReversed() {

            return reversed;

        }

        /**

         * @param reversed the reversed to set

         */

        public void setReversed(boolean reversed) {

            this.reversed = reversed;

        }

        /**

         * @return the totalSize

         */

        public long getTotalSize() {

            return totalSize;

        }

        /**

         * @param totalSize the totalSize to set

         */

        public void setTotalSize(long totalSize) {

            this.totalSize = totalSize;

        }

        public boolean add(FeatureReference reference) {

            return selected.add(reference);

        }

        public boolean remove(FeatureReference reference) {

            return selected.remove(reference);

        }

        public void clear() {

            selected.clear();

        }

        public boolean contains(FeatureReference reference) {

            return selected.contains(reference);

        }

        public int getSize() {

            return selected.size();

        }

        @Override

        public Object clone() throws CloneNotSupportedException {

            SelectionData clone = (SelectionData) super.clone();

            // reversed and totalSize already cloned by parent.

            // clone the selected Set

            clone.selected = new HashSet(selected);

            return clone;

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("store", featureStore);

        state.set("reversed", this.getData().isReversed());

        state.set("totalSize", this.getData().getTotalSize());

        state.set("selected", this.getData().getSelected().iterator());

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        SelectionData data = new SelectionData(); // Do not use this.getData()

        featureStore = (FeatureStore) state.get("store");

        helper = new DefaultFeatureSelectionHelper((DefaultFeatureStore) featureStore);

        data.setReversed(state.getBoolean("reversed"));

        data.setTotalSize(state.getLong("totalSize"));

        Iterator it = state.getIterator("selected");

        while (it.hasNext()) {

            FeatureReference ref = (FeatureReference) it.next();

            data.add(ref);

        }

        /*

             * If we do not do this, feature store will not listen

             * to changes in selection after instantiating a

             * persisted selection. For non-persisted instances,

             * this line corresponds to the line found in method:

             * getFeatureSelection() in DefaultFeatureStore.

             * This is not dangerous because "addObserver" only adds

             * if they were not already added, so future invocations

             * with same instances will have no effect.

         */

        this.addObserver((DefaultFeatureStore) featureStore);

    }

    public static void registerPersistent() {

        DynStruct definition = ToolsLocator.getPersistenceManager().addDefinition(

                DefaultFeatureReferenceSelection.class,

                DYNCLASS_PERSISTENT_NAME,

                "DefaultFeatureReferenceSelection Persistent definition",

                null,

                null

        );

        definition.addDynFieldObject("store").setClassOfValue(FeatureStore.class).setMandatory(true);

        definition.addDynFieldBoolean("reversed").setMandatory(true);

        definition.addDynFieldLong("totalSize").setMandatory(true);

        definition.addDynFieldList("selected").setClassOfItems(FeatureReference.class).setMandatory(true);

    }

    @Override

    public void addObserver(Observer observer) {

        delegateObservable.addObserver(observer);

    }

    @Override

    public void beginComplexNotification() {

        delegateObservable.beginComplexNotification();

    }

    @Override

    public void deleteObserver(Observer observer) {

        delegateObservable.deleteObserver(observer);

    }

    @Override

    public void deleteObservers() {

        delegateObservable.deleteObservers();

    }

    @Override

    public void disableNotifications() {

        delegateObservable.disableNotifications();

    }

    @Override

    public void enableNotifications() {

        delegateObservable.enableNotifications();

    }

    @Override

    public void endComplexNotification() {

        // We don't want to notify many times in a complex notification

        // scenario, so ignore notifications if in complex.

        // Only one notification will be sent when the complex notification

        // ends.

        delegateObservable.notifyObservers(DataStoreNotification.SELECTION_CHANGE);

        delegateObservable.endComplexNotification();

    }

    public boolean inComplex() {

        return delegateObservable.inComplex();

    }

    public boolean isEnabledNotifications() {

        return delegateObservable.isEnabledNotifications();

    }

    public void notifyObservers() {

        // We don't want to notify many times in a complex notification

        // scenario, so ignore notifications if in complex.

        // Only one notification will be sent when the complex notification

        // ends.

        if (!delegateObservable.inComplex()) {

            delegateObservable.notifyObservers();

        }

    }

    public void notifyObservers(Object arg) {

        if (!delegateObservable.inComplex()) {

            delegateObservable.notifyObservers(arg);

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DefaultFeatureReferenceSelection clone = (DefaultFeatureReferenceSelection) super.clone();

        // Original observers aren't cloned

        clone.delegateObservable = new DelegateWeakReferencingObservable(clone);

        // Clone internal data

        clone.selectionData = (SelectionData) this.getData().clone();

        // featureStore and helper are already swallow cloned by our parent

        return clone;

    }

    @Override

    public boolean isAvailable() {

        if (this.available == null) {

            try {

                FeatureType type = this.featureStore.getDefaultFeatureType();

                this.available = type.supportReferences();

            } catch (DataException ex) {

                this.available = false;

            }

        }

        return this.available;

    }

}