Application: gvSIG desktop

    @Override

    public FeatureSelection createLargeFeatureSelection() throws DataException {

        return null;

    }

    @Override

    public FeatureSelection createMemoryFeatureSelection() throws DataException {

        return null;

    }

    public FeatureSelection createLargeFeatureSelection() throws DataException;

    /**

     * Creates a {@link FeatureSelection}

     *

     * @return

     *         a {@link FeatureSelection}

     *

     * @throws DataException

     */

    public FeatureSelection createMemoryFeatureSelection() throws DataException;

import java.util.Map;

import java.util.Set;

    public void setMaxSizeForSmallFeatureSelection(long size);

    public long getMaxSizeForSmallFeatureSelection();

    public Map createLargeMap();

    public Set createLargeSet();

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.fmap.dal.impl;

import java.io.File;

import java.util.Collection;

import java.util.Iterator;

import java.util.Set;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.Disposable;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.util.Size;

import org.gvsig.tools.util.Size64;

import org.h2.mvstore.MVMap;

import org.h2.mvstore.MVStore;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 * @param <K>

 */

public class LargeSetImpl<K> extends AbstractDisposable implements Set<K>, Size64, Size, Disposable {

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

    private MVStore mvstore;

    private MVMap<K, Boolean> mvMap;

    public LargeSetImpl() {

        super();

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        File f = folderManager.getUniqueTemporaryFile("MinLargeSet.mv");

        this.mvstore = MVStore.open(f.getAbsolutePath());

        this.mvMap = mvstore.openMap("DefaultMap");

    }

    @Override

    protected void doDispose() throws BaseException {

        this.mvstore.close();

        this.mvMap = null;

        this.mvstore = null;

    }

    @Override

    public int size() {

        return this.mvMap.size();

    }

    @Override

    public boolean isEmpty() {

        return this.mvMap.isEmpty();

    }

    @Override

    public boolean contains(Object o) {

        return this.mvMap.containsKey((K)o);

    }

    @Override

    public Iterator<K> iterator() {

        return this.mvMap.keySet().iterator();

    }

    @Override

    public Object[] toArray() {

        //FIXME: Ojo, si el set es grande, esto puede puede provocar un desbordamiento de memoria.

        //duda ?implementarlo o lanzar UnsupportedOperationException?

//        LOGGER.warn("Access to LargeSet's toArray() method.");

//        return this.mvMap.entrySet().toArray();

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public <T> T[] toArray(T[] a) {

        //FIXME: Ojo, si el set es grande, esto puede puede provocar un desbordamiento de memoria.

        //duda ?implementarlo o lanzar UnsupportedOperationException?

//        LOGGER.warn("Access to LargeSet's toArray(T[] a) method.");

//        return this.mvMap.keySet().toArray((T[]) new K[this.size()]);

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public boolean add(K e) {

        return this.mvMap.put(e, Boolean.TRUE)!=null;

    }

    @Override

    public boolean remove(Object o) {

        return this.mvMap.remove((K)o)!=null;

    }

    @Override

    public boolean containsAll(Collection<?> c) {

        //FIXME: Comprobar que esto no lo haga en memoria

        return this.mvMap.keySet().containsAll(c);

        //Si lo hace en memoria, usar lo siguiente;

//        if (!c.stream().noneMatch(object -> (!contains((K)object)))) {

//            return false;

//        }

//        return true;

    }

    @Override

    public boolean addAll(Collection<? extends K> c) {

        boolean result = false;

        for (K k : c) {

            result |= this.add(k);

        }

        return result;

    }

    @Override

    public boolean retainAll(Collection<?> c) {

        boolean result = false;

        for (Object next : this) {

            if(!c.contains(next)){

                result |= remove((K)next);

            }

        }

        return result;

    }

    @Override

    public boolean removeAll(Collection<?> c) {

        boolean result = false;

        for (Object object : c) {

            result |= remove((K)object);

        }

        return result;

    }

    @Override

    public void clear() {

        this.mvMap.clear();

    }

    @Override

    public long size64() {

        return this.mvMap.sizeAsLong();

    }

}

import org.gvsig.fmap.dal.DatabaseWorkspaceManager.DatabaseWorkspaceListener;

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

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

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultFeatureAttributeEmulatorExpression;

import org.gvsig.fmap.dal.spi.DataServerExplorerPoolImpl;

import static org.gvsig.fmap.dal.spi.DataStoreProviderServices.PROVIDER_PARAMTER_NAME;

import org.gvsig.json.Json;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.observer.Observer;

    public static final long DEFAULT_MAX_SIZE_FOR_SMALL_FEATURE_SELECTION = 10000;

    private long maxSizeForSmallFeatureSelection;

        this.maxSizeForSmallFeatureSelection = DEFAULT_MAX_SIZE_FOR_SMALL_FEATURE_SELECTION;

    @Override

    public void setMaxSizeForSmallFeatureSelection(long size){

        this.maxSizeForSmallFeatureSelection = size;

    }

    @Override

    public long getMaxSizeForSmallFeatureSelection() {

        return this.maxSizeForSmallFeatureSelection;

    }

    @Override

    public Map createLargeMap() {

        return new LargeMapImpl();

    }

    @Override

    public Set createLargeSet() {

        return new LargeSetImpl();

    }

/*

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

import java.io.File;

import java.util.AbstractList;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.Disposable;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.util.GetItemByKey;

import org.gvsig.tools.util.GetKeys;

import org.gvsig.tools.util.Size;

import org.gvsig.tools.util.Size64;

import org.h2.mvstore.MVMap;

import org.h2.mvstore.MVStore;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class LargeMapImpl<K, V> extends AbstractDisposable implements Map<K, V>, GetItemByKey<K, V>, Size64, Size, GetKeys<K>, Disposable {

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

    private MVStore mvstore;

    private MVMap<K, V> mvMap;

    public LargeMapImpl() {

        super();

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        File f = folderManager.getUniqueTemporaryFile("MinLargeMap.mv");

        this.mvstore = MVStore.open(f.getAbsolutePath());

        this.mvMap = mvstore.openMap("DefaultMap");

    }

    @Override

    public long size64() {

        return this.mvMap.sizeAsLong();

    }

    @Override

    protected void doDispose() throws BaseException {

        this.mvstore.close();

        this.mvMap = null;

        this.mvstore = null;

    }

    @Override

    public Set<Entry<K, V>> entrySet() {

        return this.mvMap.entrySet();

    }

    @Override

    public List<K> getKeys() {

        List<K> keys = new AbstractList<K>() {

            @Override

            public K get(int index) {

                K key = mvMap.getKey(index);

                return key;

            }

            @Override

            public int size() {

                return mvMap.size();

            }

        };

        return keys;

    }

    @Override

    public int size() {

        return this.mvMap.size();

    }

    @Override

    public boolean isEmpty() {

        return this.mvMap.isEmpty();

    }

    @Override

    public boolean containsKey(Object key) {

        return this.mvMap.containsKey(key);

    }

    @Override

    public boolean containsValue(Object value) {

        return this.mvMap.containsValue(value);

    }

    @Override

    public V get(Object key) {

        return this.mvMap.get(key);

    }

    @Override

    public V put(K key, V value) {

        return this.mvMap.put(key, value);

    }

    @Override

    public V remove(Object key) {

        return this.mvMap.remove(key);

    }

    @Override

    public void putAll(Map<? extends K, ? extends V> m) {

        this.mvMap.putAll(m);

    }

    @Override

    public void clear() {

        this.mvMap.clear();

    }

    @Override

    public Set<K> keySet() {

        return this.mvMap.keySet();

    }

    @Override

    public Collection<V> values() {

        return this.mvMap.values();

    }

}

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

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

        LargeFeatureReferenceSelection.registerPersistent();

        LargeFeatureSelection.registerPersistent();

/**

 * 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.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.exception.DataRuntimeException;

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

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

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

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

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

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

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.featureset.AbstractFeatureSet;

import org.gvsig.fmap.dal.feature.impl.featureset.DefaultFeatureSet;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

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.persistence.PersistenceManager;

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 the FeatureSelection interface. Internally, only

 * FeatureReference values are stored.

 *

 * This implementation performs better if used with the selection related

 * methods: select, deselect and isSelected ones.

 *

 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

 */

public class LargeFeatureSelection extends AbstractFeatureSet

        implements FeatureSelection {

    private static final String DYNCLASS_PERSISTENT_NAME = "LargeFeatureSelection";

    public class RemoveFromFeatureSelectionException extends DataRuntimeException {

        /**

         *

         */

        private static final long serialVersionUID = 2636692469445838928L;

        private final static String MESSAGE_FORMAT = "Can't remove feature from reversed selection.";

        private final static String MESSAGE_KEY = "_RemoveFromFeatureSelectionException";

        public RemoveFromFeatureSelectionException(Throwable cause) {

            super(MESSAGE_FORMAT, cause, MESSAGE_KEY, serialVersionUID);

            //setValue("store", store);

        }

    }

    /**

     * Facade over a Iterator of FeatureReferences, to return Features instead.

     *

     * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

     */

    private class FeatureIteratorFacade implements DisposableIterator {

        private final Logger LOGGER = LoggerFactory

                .getLogger(FeatureIteratorFacade.class);

        private java.util.Iterator refIterator;

        private FeatureStore featureStore;

        private Feature currentFeature = null;

        public FeatureIteratorFacade(java.util.Iterator iter,

                FeatureStore featureStore) {

            this.refIterator = iter;

            this.featureStore = featureStore;

        }

        @Override

        public boolean hasNext() {

            return refIterator.hasNext();

        }

        @Override

        public Object next() {

            FeatureReference ref = nextFeatureReference();

            try {

                currentFeature = featureStore.getFeatureByReference(ref);

                return currentFeature;

            } catch (DataException ex) {

                LOGGER.error(

                        "Error loading the Feature with FeatureReference: "

                        + ref, ex);

                return null;

            }

        }

        /**

         * Returns the next FeatureReference.

         *

         * @return the next FeatureReference

         */

        public FeatureReference nextFeatureReference() {

            return (FeatureReference) refIterator.next();

        }

        @Override

        public void remove() {

            try {

                featureStore.delete(currentFeature);

                refIterator.remove();

            } catch (DataException e) {

                throw new RemoveFromFeatureSelectionException(e);

            }

        }

        public class RemoveFromFeatureSelectionException extends DataRuntimeException {

            /**

             *

             */

            private static final long serialVersionUID = 2636692469445838928L;

            private final static String MESSAGE_FORMAT = "Can't remove feature from selection.";

            private final static String MESSAGE_KEY = "_RemoveFromFeatureSelectionException";

            public RemoveFromFeatureSelectionException(Throwable cause) {

                super(MESSAGE_FORMAT, cause, MESSAGE_KEY, serialVersionUID);

                //setValue("store", store);

            }

        }

        @Override

        public void dispose() {

            if (refIterator instanceof DisposableIterator) {

                ((DisposableIterator) refIterator).dispose();

            }

            refIterator = null;

            featureStore = null;

        }

    }

//    /**

//     * Facade over a Iterator of FeatureReferences, to return Features instead,

//     * when the Selection is reversed

//     *

//     * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

//     */

//    private class ReversedFeatureIteratorFacade implements DisposableIterator {

//

//        private SelectionData selectionData;

//

//        private DisposableIterator iterator;

//

//        private Feature nextFeature = null;

//        private Feature currentFeature = null;

//

//        private FeatureSet featureSet;

//

//        public ReversedFeatureIteratorFacade(SelectionData selectionData,

//                FeatureStore featureStore, boolean fastIterator) {

//            this.selectionData = selectionData;

//

//            // Load a Set with all the store features

//            try {

//                featureSet = new IgnoreInsertAndUpdateFeatureSet(

//                        (DefaultFeatureStore) featureStore, 

//                        new DefaultFeatureQuery(featureStore.getDefaultFeatureType())

//                );

//                iterator = featureSet.fastIterator();

//            } catch (DataException ex) {

//                throw new ReversedSelectionIteratorException(ex);

//            }

//

//            // Filter the features not selected and position in the next

//            // selected feature

//            positionInNextElement();

//        }

//

//        @Override

//        public boolean hasNext() {

//            return nextFeature != null;

//        }

//

//        @Override

//        public Object next() {

//            featureIterators.remove(currentFeature);

//            currentFeature = nextFeature.getCopy();

//            featureIterators.put(currentFeature, this);

//            positionInNextElement();

//            return currentFeature;

//        }

//

//        @Override

//        public void remove() {

//            try {

//                featureSet.delete(currentFeature);

//            } catch (DataException e) {

//                throw new RemoveFromFeatureSelectionException(e);

//

//            }

//        }

//

//        private void positionInNextElement() {

//            nextFeature = null;

//            while (iterator.hasNext()) {

//                nextFeature = (Feature) iterator.next();

//                if (selectionData.contains(nextFeature.getReference())) {

//                    nextFeature = null;

//                } else {

//                    break;

//                }

//            }

//        }

//

//        @Override

//        public void dispose() {

//            this.featureSet.dispose();

//            this.iterator.dispose();

//            this.selectionData = null;

//            this.nextFeature = null;

//        }

//    }

//    private Map featureTypeCounts = new HashMap(1);

    private final Map<Feature, Iterator> featureIterators = new HashMap<>();

    private final LargeFeatureReferenceSelection featureReferenceSelection;

    /**

     * Creates a DefaultFeatureSelection, with a FeatureStore.

     *

     * @param featureStore the FeatureStore to load Features from

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

     * of Features of the Store.

     * @see AbstractSetBasedDataSelection#DefaultSelection(int)

     */

    public LargeFeatureSelection(DefaultFeatureStore featureStore)

            throws DataException {

        this.featureReferenceSelection = new LargeFeatureReferenceSelection(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 LargeFeatureSelection(FeatureStore featureStore,

            FeatureSelectionHelper helper) throws DataException {

        this.featureReferenceSelection = new LargeFeatureReferenceSelection(featureStore, 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 LargeFeatureSelection() {

        this.featureReferenceSelection = new LargeFeatureReferenceSelection();

    }

    @Override

    public FeatureStore getFeatureStore() {

        return this.featureReferenceSelection.getFeatureStore();

    }

    private void notifyObservers(String notificationType) {

        this.featureReferenceSelection.notifyObservers(notificationType);

    }

    @Override

    public void enableNotifications() {

        this.featureReferenceSelection.enableNotifications();

    }

    @Override

    public void disableNotifications() {

        this.featureReferenceSelection.disableNotifications();

    }

//    public boolean isReversed() {

//        return this.featureReferenceSelection.isReversed();

//    }

    @Override

    public long getSelectedCount() {

        return this.featureReferenceSelection.getSelectedCount();

    }

    @Override

    public boolean select(FeatureReference reference) {

        return this.featureReferenceSelection.select(reference);

    }

    @Override

    public boolean deselect(FeatureReference reference) {

        return this.featureReferenceSelection.deselect(reference);

    }

    @Override

    public Iterator referenceIterator() {

        return this.featureReferenceSelection.referenceIterator();

    }

    @Override

    public void selectAll() throws DataException {

        this.featureReferenceSelection.selectAll();

    }

    @Override

    public void deselectAll() throws DataException {

        this.featureReferenceSelection.deselectAll();

    }

    @Override

    public boolean isSelected(FeatureReference reference) {

        return this.featureReferenceSelection.isSelected(reference);

    }

    @Override

    public void reverse() {

        this.featureReferenceSelection.reverse();

    }

    @Override

    public void dispose() {

        this.featureReferenceSelection.dispose();

    }

    @Override

    public void update(Observable o, Object o1) {

        this.featureReferenceSelection.update(o, o1);

    }

    @Override

    public void addObserver(Observer obsrvr) {

        this.featureReferenceSelection.addObserver(obsrvr);

    }

    @Override

    public void deleteObserver(Observer obsrvr) {

        this.featureReferenceSelection.deleteObserver(obsrvr);

    }

    @Override

    public void deleteObservers() {

        this.featureReferenceSelection.deleteObservers();

    }

    @Override

    public void beginComplexNotification() {

        this.featureReferenceSelection.beginComplexNotification();

    }

    @Override

    public void endComplexNotification() {

        this.featureReferenceSelection.endComplexNotification();

    }

    @Override

    public void saveToState(PersistentState ps) throws PersistenceException {

        this.featureReferenceSelection.saveToState(ps);

    }

    @Override

    public boolean select(Feature feature) {

        return this.featureReferenceSelection.select(feature.getReference());

    }

    @Override

    public boolean select(FeatureSet features) throws DataException {

        boolean change = false;

        boolean inComplex = false;

        disableNotifications();

        DisposableIterator iter = null;

        try {

            for (iter = features.fastIterator(); iter.hasNext();) {

                change |= this.featureReferenceSelection.select(((Feature) iter.next()).getReference());

            }

        } finally {

            DisposeUtils.disposeQuietly(iter);

        }

        enableNotifications();

        return change;

    }

    @Override

    public boolean deselect(Feature feature) {

        return this.featureReferenceSelection.deselect(feature.getReference()); //, true);

    }

    @Override

    public boolean deselect(FeatureSet features) throws DataException {

        boolean change = false;

        disableNotifications();

        DisposableIterator iter = null;

        try {

            for (iter = features.fastIterator(); iter.hasNext();) {

                change |= deselect((Feature) iter.next());

            }

        } finally {

            DisposeUtils.disposeQuietly(iter);

        }

        enableNotifications();

        return change;

    }

    @Override

    public boolean isSelected(Feature feature) {

        if (feature == null) {

            return false;

        }

        if( this.featureReferenceSelection.isEmpty() ) {

            return false;

        }

        return this.featureReferenceSelection.isSelected(feature.getReference());

    }

    @Override

    public FeatureType getDefaultFeatureType() {

        try {

            return getFeatureStore().getDefaultFeatureType();

        } catch (DataException ex) {

            LOG.error("Error getting the default feature type "

                    + "of the FeatureStore: " + getFeatureStore(), ex);

        }

        return null;

    }

    @Override

    public List getFeatureTypes() {

        return this.featureReferenceSelection.getFeatureTypes();

//        // Go through the map of FeatureTypes, and return only the ones that

//        // have at least a Feature.

//        List types = new ArrayList();

//        for (java.util.Iterator iterator = featureTypeCounts.entrySet()

//                .iterator(); iterator.hasNext();) {

//            Map.Entry entry = (Entry) iterator.next();

//            FeatureType type = (FeatureType) entry.getKey();

//            Long count = (Long) entry.getValue();

//

//            if (count > 0) {

//                types.add(type);

//            }

//        }

//

//        return types;

    }

    @Override

    public long getSize() throws DataException {

        return getSelectedCount();

    }

    /**

     * Returns the list of selected values, or the deselected ones if the

     * selection has been reversed.

     *

     * WARN: not very good performance implementation.

     */

    @Override

	public DisposableIterator iterator(long index) {

		return iterator(index, 0, false);

	}

    @Override

        public DisposableIterator iterator(long index, long elements) {

		return iterator(index, elements, false);

        }

    /**

     * Returns the list of selected values, or the deselected ones if the

     * selection has been reversed.

     *

     * WARN: not really a fast implementation.

     */

    @Override

	public DisposableIterator fastIterator(long index) {

            return fastIterator(index, 0);

	}

    @Override

    public DisposableIterator fastIterator(long index, long elements) {

        return iterator(index, elements, true);

    }

    protected void clearFeatureReferences() {

        this.featureReferenceSelection.clearFeatureReferences();

//        featureTypeCounts.clear();

    }

    /**

     * Creates an iterator for the Selection.

     */

    private DisposableIterator iterator(long index, long elements, boolean fastIterator) {

        Iterator iter = this.featureReferenceSelection.referenceIterator();

            for (long l = 0; l < index && iter.hasNext(); l++) {

                iter.next();

            }

            return new FeatureIteratorFacade(iter, getFeatureStore());

//        if (isReversed()) {

//            DisposableIterator iter = new ReversedFeatureIteratorFacade(

//                    getData(), getFeatureStore(), fastIterator);

//            for (long l = 0; l < index && iter.hasNext(); l++) {

//                iter.next();

//            }

//            return iter;

//

//        } else {

//            // TODO: maybe we could add a new referenceIterator(int index)

//            // method that could be implemented in a more performant way

//

//            java.util.Iterator iter = getData().getSelected().iterator();

//            for (long l = 0; l < index && iter.hasNext(); l++) {

//                iter.next();

//            }

//            return new FeatureIteratorFacade(iter, getFeatureStore());

//        }

    }

//    private Long removeFeatureTypeCount(FeatureType featureType) {

//        Long count = (Long) featureTypeCounts.get(featureType);

//        if (count == null) {

//            count = new Long(-1);

//        } else {

//            count = count - 1;

//        }

//        featureTypeCounts.put(featureType, count);

//        return count;

//    }

//

//    private Long addFeatureTypeCount(FeatureType featureType) {

//        Long count = (Long) featureTypeCounts.get(featureType);

//        if (count == null) {

//            count = new Long(1);

//        } else {

//            count = count + 1;

//        }

//        featureTypeCounts.put(featureType, count);

//        return count;

//    }

    @Override

    public void delete(Feature feature) throws DataException {

        Iterator it = this.featureIterators.get(feature);

        if (it != null) {

            it.remove();

            return;

        }

        feature.getStore().delete(feature);

    }

    @Override

    public void insert(EditableFeature feature) throws DataException {

        feature.getStore().insert(feature);

    }

    @Override

    public void update(EditableFeature feature) throws DataException {

        feature.getStore().update(feature);

    }

    @Override

    public void commitChanges() throws DataException {

    }

    /*

     * (non-Javadoc)

     *

     * @seeorg.gvsig.fmap.dal.feature.impl.DefaultFeatureReferenceSelection#

     * loadFromState(org.gvsig.tools.persistence.PersistentState)

     */

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        this.featureReferenceSelection.loadFromState(state);

    }

    protected void doDispose() throws BaseException {

        this.featureReferenceSelection.doDispose();

//        featureTypeCounts.clear();

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        DynStruct definition = manager.addDefinition(LargeFeatureSelection.class, DYNCLASS_PERSISTENT_NAME,

                "LargeFeatureSelection Persistent definition", null, null);

        definition.extend(manager.getDefinition(LargeFeatureReferenceSelection.DYNCLASS_PERSISTENT_NAME));

//        definition.addDynFieldMap("featureTypeCounts")

//                .setClassOfItems(Long.class).setMandatory(false);

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        LargeFeatureSelection clone = (LargeFeatureSelection) super.clone();

//        clone.featureTypeCounts = new HashMap(featureTypeCounts);

        return clone;

    }

    @Override

    protected void doAccept(Visitor visitor, long firstValueIndex, long elements) throws BaseException {

        if( this.featureReferenceSelection.isEmpty() ) {

            return;

        }

        DisposableIterator iterator = fastIterator(firstValueIndex, elements);

        if (iterator != null) {

            try {

                while (iterator.hasNext()) {

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

                    visitor.visit(feature);

                }

            } finally {

                iterator.dispose();

            }

        }

    }

    private static class IgnoreInsertAndUpdateFeatureSet extends DefaultFeatureSet {

        public IgnoreInsertAndUpdateFeatureSet(DefaultFeatureStore store, FeatureQuery query) throws DataException {

            super(store, query);

        }

        @Override

        public void update(Observable obsevable, Object notification) {

            String type = ((FeatureStoreNotification) notification).getType();

            if (type.equalsIgnoreCase(FeatureStoreNotification.AFTER_INSERT)

                    || type.equalsIgnoreCase(FeatureStoreNotification.AFTER_UPDATE)) {

                return;

            }

            super.update(obsevable, notification);

        }

    }

    @Override

    public boolean isAvailable() {

        return this.featureReferenceSelection.isAvailable();

    }

}

        long maxSize = dataManager.getMaxSizeForSmallFeatureSelection();

        if(this.provider.getFeatureCount()>maxSize) {

            return createLargeFeatureSelection();

        }

    @Override

    public FeatureSelection createLargeFeatureSelection() throws DataException {

        return new LargeFeatureSelection(this);

    }

    @Override

    public FeatureSelection createMemoryFeatureSelection() throws DataException {

        return this.provider.createFeatureSelection();

    }

/*

 * 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.fmap.dal.impl.LargeSetImpl;

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.visitor.Visitor;

/**

 *

 * @author gvSIG Team

 */

public class LargeFeatureReferenceSelection extends AbstractDisposable

        implements FeatureReferenceSelection {

        public static final String DYNCLASS_PERSISTENT_NAME = "LargeFeatureReferenceSelection";

    private Set<String> selection;

    private FeatureStore 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 = new LargeSetImpl<>();

    }

    LargeFeatureReferenceSelection(FeatureStore featureStore, FeatureSelectionHelper helper) {

        super();

        this.featureStore = featureStore;

        DisposeUtils.bind(this.featureStore);

        this.selection = new LargeSetImpl<>();

    }

    /**

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

        return ((LargeSetImpl)selection).size64();

    }

    @Override

    public Iterator 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

    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();

    }