Statistics
| Revision:

root / branches / v2_0_0_prep / libraries / libFMap_dal / src / org / gvsig / fmap / dal / feature / impl / FeatureManager.java @ 24496

History | View | Annotate | Download (10.6 KB)

1

    
2
/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
3
 *
4
 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.
5
 *
6
 * This program is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU General Public License
8
 * as published by the Free Software Foundation; either version 2
9
 * of the License, or (at your option) any later version.
10
 *
11
 * This program is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 * GNU General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU General Public License
17
 * along with this program; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
19
 *
20
 * For more information, contact:
21
 *
22
 *  Generalitat Valenciana
23
 *   Conselleria d'Infraestructures i Transport
24
 *   Av. Blasco Ib??ez, 50
25
 *   46010 VALENCIA
26
 *   SPAIN
27
 *
28
 *      +34 963862235
29
 *   gvsig@gva.es
30
 *      www.gvsig.gva.es
31
 *
32
 *    or
33
 *
34
 *   IVER T.I. S.A
35
 *   Salamanca 50
36
 *   46005 Valencia
37
 *   Spain
38
 *
39
 *   +34 963163400
40
 *   dac@iver.es
41
 */
42

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

    
45
import java.util.ArrayList;
46
import java.util.HashMap;
47
import java.util.Iterator;
48

    
49
import org.gvsig.fmap.dal.exceptions.DataException;
50
import org.gvsig.fmap.dal.feature.EditableFeature;
51
import org.gvsig.fmap.dal.feature.Feature;
52
import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
53
import org.gvsig.fmap.dal.feature.FeatureReference;
54
import org.gvsig.fmap.dal.feature.FeatureStore;
55
import org.gvsig.fmap.dal.feature.FeatureType;
56
import org.gvsig.fmap.dal.feature.impl.expansionadapter.ExpansionAdapter;
57

    
58

    
59
/**
60
 * DOCUMENT ME!
61
 *
62
 * @author Vicente Caballero Navarro
63
 */
64
public class FeatureManager {
65
    private ExpansionAdapter expansionAdapter;
66
    private ArrayList deleted = new ArrayList();//<FeatureID>
67
    private int deltaSize=0;
68
        private HashMap added=new HashMap();
69
        private HashMap modifiedFromOriginal=new HashMap();
70
    public FeatureManager(ExpansionAdapter expansionAdapter){
71
            this.expansionAdapter=expansionAdapter;
72
    }
73

    
74

    
75
    public Feature delete(FeatureReference id) {
76
        deleted.add(id);
77
        Feature feature=(Feature)added.remove(id);
78
        if (feature==null) {
79
                        feature = (Feature)modifiedFromOriginal.remove(id);
80
                }
81
        deltaSize--;
82
        return feature;
83
    }
84

    
85
    /**
86
     * DOCUMENT ME!
87
     *
88
     * @param feature DOCUMENT ME!
89
     */
90
    public void add(Feature feature) {
91
        int pos = expansionAdapter.addObject(feature);
92
        added.put(feature.getReference(),new Integer(pos));
93
        deltaSize++;
94
    }
95

    
96
    /**
97
     * DOCUMENT ME!
98
     *@deprecated
99
     * @param id DOCUMENT ME!
100
     */
101
    public Feature deleteLastFeature() {
102
        expansionAdapter.deleteLastObject();
103
        Feature feature=(Feature)expansionAdapter.getObject(expansionAdapter.getSize()-1);
104
        added.remove(feature.getReference());
105
        modifiedFromOriginal.remove(feature.getReference());
106
        deltaSize--;
107
        return feature;
108
    }
109

    
110
    /**
111
     * Returns a Feature of the default type.
112
     *
113
     * @param id
114
     *            the feature reference
115
     * @param store
116
     *            the store to get the feature from
117
     * @return a Feature with the given reference
118
     * @throws DataException
119
     *             if there is an error getting the Feature
120
     */
121
    public Feature get(FeatureReference id, FeatureStore store)
122
            throws DataException {
123
        return get(id, store, null);
124
    }
125

    
126
    /**
127
     * Returns a Feature of the given type.
128
     *
129
     * @param id
130
     *            the feature reference
131
     * @param store
132
     *            the store to get the feature from
133
     * @param featureType
134
     *            the type of the feature to return
135
     * @return a Feature with the given reference
136
     * @throws DataException
137
     *             if there is an error getting the Feature
138
     */
139
    public Feature get(FeatureReference id, FeatureStore store,
140
                        FeatureType featureType) throws DataException {
141
            // FIXME: y si el featuretype que paso esta modificado.
142
            //        Deberia buscarlo en el featuretypemanager ?
143
                //
144
            //        Si no existe feature con ese id... ? retorna null ?
145
            //        en EditedDefaultIterator se hace uso de ese comportamiento.
146
            //
147
            Integer intNum =((Integer) added.get(id));
148
            if (intNum == null){
149
                    intNum =((Integer) modifiedFromOriginal.get(id));
150
                if (intNum == null){
151
                        return null;
152
                }
153
            }
154
        int num = intNum.intValue();
155

    
156
        Feature feature=(Feature)expansionAdapter.getObject(num);
157
        if (featureType== null){
158
                featureType = store.getDefaultFeatureType();
159
        }
160
               return getCorrectFeature(feature, store,featureType);
161
    }
162

    
163
    private Feature getCorrectFeature(Feature feature, FeatureStore store,
164
                        FeatureType featureType) throws DataException {
165
             Iterator iterator=featureType.iterator();
166
         EditableFeature newFeature=store.createNewFeature(featureType, false);
167
         FeatureType orgType = feature.getType();
168
         int orgIndex;
169
         while (iterator.hasNext()) {
170
                         FeatureAttributeDescriptor fad = (FeatureAttributeDescriptor) iterator.next();
171
                         orgIndex = orgType.getIndex(fad.getName());
172
                         if (orgIndex<0){
173
                                 continue;
174
                         }
175
                         if (featureType.getDefaultGeometryAttributeName().equals(
176
                                                                        fad.getName())){
177
                                 newFeature.setGeometry(fad.getIndex(), feature.getGeometry(orgIndex));
178
                         } else{
179
                                 newFeature.set(fad.getIndex(), feature.get(orgIndex));
180
                         }
181
                 }
182
         return newFeature.getNotEditableCopy();
183
        }
184

    
185
        /**
186
     * DOCUMENT ME!
187
     *
188
     * @param feature DOCUMENT ME!
189
     * @param oldFeature DOCUMENT ME!
190
     */
191
    public int update(Feature feature, Feature oldFeature) {
192
            int oldNum=-1;
193
        int num = expansionAdapter.addObject(feature);
194
        FeatureReference id=feature.getReference();
195
        if (added.containsKey(id)){
196
                oldNum=((Integer)added.get(id)).intValue();
197
                added.put(id,new Integer(num));
198
        }else{
199
                oldNum=((Integer)modifiedFromOriginal.get(id)).intValue();
200
                modifiedFromOriginal.put(id,new Integer(num));
201
        }
202
        return oldNum;
203
    }
204

    
205
    /**
206
     * DOCUMENT ME!
207
     *
208
     * @param id DOCUMENT ME!
209
     */
210
    public void restore(FeatureReference id) {
211
        deleted.remove(id);
212
        deltaSize++;
213
    }
214
    public void restore(FeatureReference id,int num){
215
            if (added.containsKey(id)){
216
                added.put(id,new Integer(num));
217
        }else{
218
                modifiedFromOriginal.put(id,new Integer(num));
219
        }
220
    }
221

    
222

    
223
    public boolean isDeleted(Feature feature){
224
            return deleted.contains(feature.getReference());
225
    }
226

    
227
    public boolean isDeleted(FeatureReference featureID) {
228
                return deleted.contains(featureID);
229
        }
230

    
231
        public void clear() {
232
                added.clear();
233
                modifiedFromOriginal.clear();
234
            expansionAdapter.close();
235
            deleted.clear();//<FeatureID>
236
            deltaSize=0;
237
        }
238

    
239

    
240
        public boolean hasChanges() {
241
                return added.size()>0 || modifiedFromOriginal.size() > 0 || deleted.size() > 0;
242
        }
243

    
244

    
245
//        public Iterator newsFeaturesIterator(long index) {
246
//                if (index==0)
247
//                        return newsFeaturesIterator();
248
//
249
//                return Arrays.asList(added.values()).listIterator((int)index);
250
//        }
251
//
252
//        public Iterator newsFeaturesIterator() {
253
//                return added.values().iterator();
254
//        }
255
        public Iterator getDeleted() {
256
                return new DeletedIterator();
257

    
258
        }
259
class DeletedIterator implements Iterator{
260
        private int pos=-1;
261
        private int size=expansionAdapter.getSize();
262
        private boolean hasnext=false;
263

    
264
        public boolean hasNext() {
265
                hasnext=true;
266
                if (size > pos){
267
                        pos++;
268
                        if (deleted.contains(expansionAdapter.getObject(pos))){
269
                                return true;
270
                        }else{
271
                                return hasNext();
272

    
273
                        }
274
                }
275
                return false;
276
        }
277

    
278
        public Object next() {
279
                if (!hasnext){
280
                        pos++;
281
                        hasnext=false;
282
                }
283
                if (size > pos){
284
                        if (deleted.contains(expansionAdapter.getObject(pos))){
285
                                Object obj=expansionAdapter.getObject(pos);
286
                                return obj;
287
                        }else{
288
                                if (hasNext()){
289
                                        return next();
290
                                }
291
                        }
292
                }
293
                return null;
294
        }
295

    
296
        public void remove() {
297
                throw new UnsupportedOperationException();
298

    
299
        }
300
}
301
        public Iterator getInserted() {
302
                return new InsertedIterator();
303
        }
304
        class InsertedIterator implements Iterator{
305
                private int pos=-1;
306
                private int size=expansionAdapter.getSize();
307
                private boolean hasnext=false;
308

    
309
                public boolean hasNext() {
310
                        hasnext=true;
311
                        if (size > pos){
312
                                pos++;
313
                                if (deleted.contains(expansionAdapter.getObject(pos))){
314
                                        return hasNext();
315
                                }else if (!added.containsValue(new Integer(pos))){
316
                                        return hasNext();
317
                                }else {
318
                                        return true;
319
                                }
320
                        }
321
                        return false;
322
                }
323

    
324
                public Object next() {
325
                        if (!hasnext){
326
                                pos++;
327
                                hasnext=false;
328
                        }
329
                        if (size > pos){
330
                                if (deleted.contains(expansionAdapter.getObject(pos))){
331
                                        if (hasNext()){
332
                                                return next();
333
                                        }
334
                                }else if (!added.containsValue(new Integer(pos))){
335
                                        if (hasNext()){
336
                                                return next();
337
                                        }
338
                                }else {
339
                                        Object obj=expansionAdapter.getObject(pos);
340
                                        return obj;
341
                                }
342
                        }
343
                        return null;
344
                }
345

    
346
                public void remove() {
347
                        throw new UnsupportedOperationException();
348

    
349
                }
350
        }
351
        public Iterator getUpdated() {
352
                return new UpdatedIterator();
353
        }
354
        class UpdatedIterator implements Iterator{
355
                private int pos=-1;
356
                private int size=expansionAdapter.getSize();
357
                private boolean hasnext=false;
358

    
359
                public boolean hasNext() {
360
                        hasnext=true;
361
                        if (size > pos){
362
                                pos++;
363
                                if (deleted.contains(expansionAdapter.getObject(pos))){
364
                                        return hasNext();
365
                                }else if (!modifiedFromOriginal.containsValue(new Integer(pos))){
366
                                        return hasNext();
367
                                }else {
368
                                        return true;
369
                                }
370
                        }
371
                        return false;
372
                }
373

    
374
                public Object next() {
375
                        if (!hasnext){
376
                                pos++;
377
                                hasnext=false;
378
                        }
379
                        if (size > pos){
380
                                if (deleted.contains(expansionAdapter.getObject(pos))){
381
                                        if (hasNext()){
382
                                                return next();
383
                                        }
384
                                }else if (!modifiedFromOriginal.containsValue(new Integer(pos))){
385
                                        if (hasNext()){
386
                                                return next();
387
                                        }
388
                                }else {
389
                                        Object obj=expansionAdapter.getObject(pos);
390
                                        return obj;
391
                                }
392
                        }
393
                        return null;
394
                }
395

    
396
                public void remove() {
397
                        throw new UnsupportedOperationException();
398

    
399
                }
400
        }
401

    
402
        public boolean hasNews() {
403
                return !added.isEmpty();
404
        }
405

    
406
        public long getDeltaSize() {
407
                return deltaSize;
408
        }
409
}