Application: gvSIG desktop

/*

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 gvSIG Association.

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

 * along with this program. If not, see <https://www.gnu.org/licenses/>.

 *

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

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

 */

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

import java.util.Iterator;

import java.util.List;

import java.util.Set;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.exception.BaseException;

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.util.Size64;

import org.gvsig.tools.visitor.Visitor;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class LargeFeatureReferenceSelection extends AbstractDisposable

        implements FeatureReferenceSelection {

        public static final String DYNCLASS_PERSISTENT_NAME = "LargeFeatureReferenceSelection";

    private Set<String> selection;

    private DefaultFeatureStore featureStore;

    private Boolean available = null;

    private DelegateWeakReferencingObservable delegateObservable

            = new DelegateWeakReferencingObservable(this);

    public LargeFeatureReferenceSelection(DefaultFeatureStore featureStore) {

        super();

        this.featureStore = featureStore;

        DisposeUtils.bind(this.featureStore);

        this.selection = featureStore.getManager().createLargeSet();

    }

    LargeFeatureReferenceSelection(FeatureStore featureStore, FeatureSelectionHelper helper) {

        super();

        this.featureStore = (DefaultFeatureStore) featureStore;

        DisposeUtils.bind(this.featureStore);

        this.selection = this.featureStore.getManager().createLargeSet();

    }

    /**

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

     */

    LargeFeatureReferenceSelection() {

        super();

    }

    public FeatureStore getFeatureStore() {

        return featureStore;

    }

    @Override

    public boolean select(FeatureReference reference) {

        return this.selection.add(reference.getCode());

    }

    @Override

    public boolean deselect(FeatureReference reference) {

        boolean change;

        change = this.selection.contains(reference.getCode());

        this.selection.remove(reference.getCode());

        if (change) {

            notifyObservers(DataStoreNotification.SELECTION_CHANGE);

        }

        return change;

    }

    @Override

    public void selectAll() throws DataException {

        try {

            this.featureStore.accept((Object obj) -> {

                selection.add(((Feature) obj).getReference().getCode());

            });

        } catch (BaseException ex) {

            throw new RuntimeException("Can't select all", ex);

        }

    }

    @Override

    public void deselectAll() throws DataException {

        this.selection.clear();

    }

    @Override

    public boolean isSelected(FeatureReference reference) {

        return this.selection.contains(reference.getCode());

    }

    @Override

    public void reverse() {

        try {

            this.featureStore.accept((Object obj) -> {

                String key = ((Feature) obj).getReference().getCode();

                if(selection.contains(key)) {

                    selection.remove(key);

                } else {

                    selection.add(key);

                }

            });

        } catch (BaseException ex) {

            throw new RuntimeException("Can't reverse selection", ex);

        }

    }

    public boolean isEmpty() {

        if (this.selection == null) {

            return true;

        }

        return this.getSelectedCount() == 0;

    }

    @Override

    public long getSelectedCount() {

        try {

            return ((Size64)selection).size64();

        } catch(Exception ex) {

            return selection.size();

        }

    }

    @Override

    public Iterator<FeatureReference> referenceIterator() {

        Iterator<String> it = selection.iterator();

        Iterator<FeatureReference> itFeatureReferences = new Iterator<FeatureReference>() {

            @Override

            public boolean hasNext() {

                return it.hasNext();

            }

            @Override

            public FeatureReference next() {

                String code = it.next();

                FeatureReference fref = featureStore.getFeatureReference(code);

                return fref;

            }

        };

        return itFeatureReferences;

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public Iterable<FeatureReference> referenceIterable() {

        return new Iterable<FeatureReference>() {

            @Override

            public Iterator<FeatureReference> iterator() {

                Iterator<String> it = selection.iterator();

                return new Iterator<FeatureReference>() {

                    @Override

                    public boolean hasNext() {

                        return it.hasNext();

                    }

                    @Override

                    public FeatureReference next() {

                        String code = it.next();

                        FeatureReference fref = featureStore.getFeatureReference(code);

                        return fref;

                    }

                };

            }

        };

    }

    @Override

    public boolean isAvailable() {

        if (this.available == null) {

            this.available = false;

            if(this.featureStore != null){

                try {

                    FeatureType type = this.featureStore.getDefaultFeatureType();

                    this.available = type.supportReferences();

                } catch (DataException ex) {

                    this.available = false;

                }

            }

        }

        return this.available;

    }

    @Override

    public boolean isFromStore(DataStore store) {

        return featureStore.equals(store);

    }

    @Override

    public void accept(Visitor visitor) throws BaseException {

        for (String string : selection) {

            FeatureReference fref = featureStore.getFeatureReference(string);

            visitor.visit(fref);

        }

    }

    @Override

    protected void doDispose() throws BaseException {

        delegateObservable.deleteObservers();

        deselectAll();

        DisposeUtils.dispose(this.featureStore);

        DisposeUtils.dispose(this.selection);

        this.delegateObservable = null;

        this.featureStore = null;

        this.selection = null;

    }

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

//        LargeFeatureReferenceSelection clone = (LargeFeatureReferenceSelection) super.clone();

//        // Original observers aren't cloned

//        clone.delegateObservable = new DelegateWeakReferencingObservable(clone);

//        // Clone internal data

//        clone.selection = new LargeMapImpl<>();

//        for (Map.Entry<String, Boolean> entry : selection.entrySet()) {

//            String key = entry.getKey();

//            Boolean val = entry.getValue();

//            clone.selection.put(key, val);

//        }

//        return clone;

//    }

    @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.deselect(storeNotif.getFeature().getReference());

            }

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("store", featureStore);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

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

        if(selection != null) {

            this.selection.clear();

        } else {

            this.selection = this.featureStore.getManager().createLargeSet();

        }

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

        while (it!=null && it.hasNext()) {

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

            this.select(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);

    }

    protected void clearFeatureReferences() {

        if (this.selection == null) {

            return;

        }

        this.selection.clear();

    }

    public List<FeatureType> getFeatureTypes() {

        try {

            return featureStore.getFeatureTypes();

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

        public static void registerPersistent() {

        DynStruct definition = ToolsLocator.getPersistenceManager().addDefinition(

                DefaultFeatureReferenceSelection.class,

                DYNCLASS_PERSISTENT_NAME,

                "LargeFeatureReferenceSelection Persistent definition",

                null,

                null

        );

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

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

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

    }

}