Revision 45989 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/impl/featureset/EditedIterator.java

View differences:

EditedIterator.java
23 23
 */
24 24
package org.gvsig.fmap.dal.feature.impl.featureset;
25 25

  
26
import java.util.HashSet;
26 27
import java.util.Iterator;
28
import java.util.Set;
27 29
import java.util.logging.Level;
28 30
import java.util.logging.Logger;
29 31
import org.gvsig.fmap.dal.exception.DataException;
......
35 37
import org.gvsig.fmap.dal.feature.impl.editing.memory.FeatureManager;
36 38
import org.gvsig.fmap.dal.feature.impl.featurereference.FeatureReferenceFactory;
37 39
import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
40
import org.gvsig.fmap.dal.feature.spi.FeatureSetProvider;
38 41
import org.gvsig.tools.exception.BaseException;
39 42
import org.gvsig.tools.util.ChainedIterator;
40 43

  
......
49 52

  
50 53
    private DefaultFeatureStore store;
51 54
    protected FeatureManager featureManager;
52

  
55
    private Set<FeatureReference> visitedReferences;
56
    
53 57
    public EditedIterator(DefaultFeatureSet featureSet) {
54 58
        super(featureSet);
55 59
        this.store = featureSet.store;
56 60
        this.featureManager = this.store.getFeatureManager();
61
        this.visitedReferences = new HashSet<>();
57 62
    }
58 63

  
59
    public EditedIterator(DefaultFeatureSet featureSet, long index)
64
    public EditedIterator(DefaultFeatureSet featureSet, long index, long elements)
60 65
        throws DataException {
61 66
        this(featureSet);
62 67

  
63 68
        Iterator<EditableFeature> insertedFeatures = this.featureManager.getInsertedFeatures();//Don't use getInserteds because referenceFeature will be missed
64 69
        Iterator<EditableFeature> updatedFeatures = this.featureManager.getUpdatedFeatures();
65
        final Iterator<FeatureProvider> providerIterator = featureSet.provider.iterator();
70
        final Iterator<FeatureProvider> providerIterator;
71
        FeatureSetProvider provider = featureSet.provider;
72
        boolean canDelegateInProvider = provider.canFilter() && provider.canIterateFromIndex() && !featureManager.hasDeleteds();
73
        if (canDelegateInProvider) {
74
            providerIterator = provider.iterator(index, elements);
75
        } else {
76
            providerIterator = provider.iterator();
77
        }
78

  
79

  
66 80
        Iterator<FeatureProvider> wrappedProviderIterator = new Iterator<FeatureProvider>() {
67 81
            @Override
68 82
            public boolean hasNext() {
......
80 94
                    return data;
81 95
                }
82 96
                if (modified != null) {
97
                    visitedReferences.add(ref);
83 98
                    return modified.getData();
84 99
                }
85 100
                return data;
......
90 105
                EditedIterator.super.remove();
91 106
            }
92 107
        };
93
        this.iterator = new ChainedIterator(wrappedProviderIterator, insertedFeatures);
94
        if (index > 0) {
95
            skypto(index);
108
        this.iterator = new ChainedIterator(wrappedProviderIterator, insertedFeatures, updatedFeatures);
109
        if (!canDelegateInProvider) {
110
            if (index > 0) {
111
                skypto(index);
112
            }
96 113
        }
97 114
    }
98 115
    
......
152 169
    @Override
153 170
    protected boolean skipFeature(FeatureProvider data) {
154 171
        try {
155
            if (getIterator().getCurrent() == 0) {
156
                if (this.featureManager.isDeleted(data)) {
157
                    return true;
158
                };
159
//                FeatureReference ref = FeatureReferenceFactory.createFromFeatureProvider(store, data);
160
//                if (this.featureManager.get(ref, store) != null) {
161
//                    return true;
162
//                };
172
            switch (getIterator().getCurrent()) {
173
                case 0:
174
                    if (this.featureManager.isDeleted(data)) {
175
                        return true;
176
                    }
177
                    break;
178
                case 2:
179
                    FeatureReference ref = FeatureReferenceFactory.createFromFeatureProvider(store, data);
180
                    if (visitedReferences.contains(ref)){
181
                        return true;
182
                    }
183
                    break;
163 184
            }
164 185
        } catch (Exception ex) {
165 186
            LOGGER.warn("Can't check if must skip feature.", ex);

Also available in: Unified diff