svn-gvsig-desktop / tags / v2_0_0_Build_2020 / libraries / libFMap_dalfile / src / org / gvsig / fmap / dal / store / dbf / DBFStoreProvider.java @ 33844
History | View | Annotate | Download (20.4 KB)
1 | 24498 | jmvivo | package org.gvsig.fmap.dal.store.dbf; |
---|---|---|---|
2 | 23912 | jmvivo | |
3 | import java.io.File; |
||
4 | 24199 | jmvivo | import java.io.IOException; |
5 | 28148 | jmvivo | import java.nio.charset.Charset; |
6 | 23912 | jmvivo | import java.text.DateFormat; |
7 | import java.text.ParseException; |
||
8 | import java.util.ArrayList; |
||
9 | import java.util.Date; |
||
10 | import java.util.Iterator; |
||
11 | import java.util.List; |
||
12 | import java.util.Locale; |
||
13 | |||
14 | 24710 | jmvivo | import org.gvsig.fmap.dal.DALLocator; |
15 | import org.gvsig.fmap.dal.DataManager; |
||
16 | 24898 | jmvivo | import org.gvsig.fmap.dal.DataServerExplorer; |
17 | 25789 | jmvivo | import org.gvsig.fmap.dal.DataStoreNotification; |
18 | 24498 | jmvivo | import org.gvsig.fmap.dal.DataTypes; |
19 | 32880 | jjdelcerro | import org.gvsig.fmap.dal.FileHelper; |
20 | 24502 | jmvivo | import org.gvsig.fmap.dal.exception.CloseException; |
21 | import org.gvsig.fmap.dal.exception.DataException; |
||
22 | import org.gvsig.fmap.dal.exception.FileNotFoundException; |
||
23 | import org.gvsig.fmap.dal.exception.InitializeException; |
||
24 | import org.gvsig.fmap.dal.exception.OpenException; |
||
25 | import org.gvsig.fmap.dal.exception.ReadException; |
||
26 | import org.gvsig.fmap.dal.exception.UnsupportedVersionException; |
||
27 | 27723 | jmvivo | import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
28 | 33205 | cordinyana | import org.gvsig.tools.dispose.DisposableIterator; |
29 | 25667 | jmvivo | import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor; |
30 | 24498 | jmvivo | import org.gvsig.fmap.dal.feature.EditableFeatureType; |
31 | import org.gvsig.fmap.dal.feature.Feature; |
||
32 | import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor; |
||
33 | import org.gvsig.fmap.dal.feature.FeatureQuery; |
||
34 | 24710 | jmvivo | import org.gvsig.fmap.dal.feature.FeatureSet; |
35 | 25789 | jmvivo | import org.gvsig.fmap.dal.feature.FeatureStore; |
36 | 24498 | jmvivo | import org.gvsig.fmap.dal.feature.FeatureType; |
37 | 24502 | jmvivo | import org.gvsig.fmap.dal.feature.exception.PerformEditingException; |
38 | 26790 | jmvivo | import org.gvsig.fmap.dal.feature.exception.UnknownDataTypeException; |
39 | 24498 | jmvivo | import org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider; |
40 | 29289 | jmvivo | import org.gvsig.fmap.dal.feature.spi.FeatureProvider; |
41 | 24498 | jmvivo | import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices; |
42 | import org.gvsig.fmap.dal.feature.spi.FeatureSetProvider; |
||
43 | 31022 | cordinyana | import org.gvsig.fmap.dal.resource.ResourceAction; |
44 | 24498 | jmvivo | import org.gvsig.fmap.dal.resource.exception.AccessResourceException; |
45 | 27875 | vcaballero | import org.gvsig.fmap.dal.resource.exception.ResourceException; |
46 | 31022 | cordinyana | import org.gvsig.fmap.dal.resource.exception.ResourceExecuteException; |
47 | 24498 | jmvivo | import org.gvsig.fmap.dal.resource.exception.ResourceNotifyChangesException; |
48 | import org.gvsig.fmap.dal.resource.exception.ResourceNotifyCloseException; |
||
49 | import org.gvsig.fmap.dal.resource.exception.ResourceNotifyOpenException; |
||
50 | import org.gvsig.fmap.dal.resource.file.FileResource; |
||
51 | import org.gvsig.fmap.dal.resource.spi.ResourceConsumer; |
||
52 | import org.gvsig.fmap.dal.resource.spi.ResourceProvider; |
||
53 | 24893 | jmvivo | import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer; |
54 | import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters; |
||
55 | 29326 | jmvivo | import org.gvsig.fmap.dal.spi.DataStoreProviderServices; |
56 | 24498 | jmvivo | import org.gvsig.fmap.dal.store.dbf.utils.DbaseFile; |
57 | 32880 | jjdelcerro | import org.gvsig.metadata.MetadataLocator; |
58 | import org.gvsig.metadata.MetadataManager; |
||
59 | import org.gvsig.metadata.exceptions.MetadataException; |
||
60 | 25789 | jmvivo | import org.gvsig.tools.dynobject.DynObject; |
61 | import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException; |
||
62 | 31284 | cordinyana | import org.gvsig.tools.exception.BaseException; |
63 | 33029 | jjdelcerro | import org.slf4j.Logger; |
64 | import org.slf4j.LoggerFactory; |
||
65 | 23912 | jmvivo | |
66 | public class DBFStoreProvider extends AbstractFeatureStoreProvider implements |
||
67 | ResourceConsumer { |
||
68 | 24205 | jmvivo | |
69 | 33718 | jjdelcerro | // private static final Logger LOG = LoggerFactory.getLogger(DBFStoreProvider.class);
|
70 | 33029 | jjdelcerro | |
71 | 29289 | jmvivo | public static String NAME = "DBF"; |
72 | 24193 | jmvivo | public static String DESCRIPTION = "DBF file"; |
73 | 23912 | jmvivo | private static final Locale ukLocale = new Locale("en", "UK"); |
74 | 32880 | jjdelcerro | |
75 | public static final String METADATA_DEFINITION_NAME = NAME; |
||
76 | private static final String METADATA_ENCODING = "Encoding"; |
||
77 | private static final String METADATA_CODEPAGE = "CodePage"; |
||
78 | |||
79 | 28145 | jmvivo | private DbaseFile dbfFile = null; |
80 | private ResourceProvider dbfResource;
|
||
81 | 24432 | jmvivo | private long counterNewsOIDs = -1; |
82 | 25752 | vcaballero | private DBFFeatureWriter writer;
|
83 | 25977 | jmvivo | |
84 | 32880 | jjdelcerro | |
85 | protected static void registerMetadataDefinition() throws MetadataException { |
||
86 | MetadataManager manager = MetadataLocator.getMetadataManager(); |
||
87 | if( manager.getDefinition(METADATA_DEFINITION_NAME)==null ) { |
||
88 | manager.addDefinition( |
||
89 | METADATA_DEFINITION_NAME, |
||
90 | DBFStoreParameters.class.getResourceAsStream("DBFStoreMetadata.xml"),
|
||
91 | DBFStoreParameters.class.getClassLoader() |
||
92 | ); |
||
93 | } |
||
94 | } |
||
95 | |||
96 | 29326 | jmvivo | public DBFStoreProvider(DBFStoreParameters params,
|
97 | DataStoreProviderServices storeServices) |
||
98 | throws InitializeException {
|
||
99 | 32880 | jjdelcerro | super(
|
100 | params, |
||
101 | storeServices, |
||
102 | FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME) |
||
103 | ); |
||
104 | this.init(params, storeServices);
|
||
105 | 24710 | jmvivo | } |
106 | |||
107 | 29326 | jmvivo | protected DBFStoreProvider(DBFStoreParameters params,
|
108 | DataStoreProviderServices storeServices, DynObject metadata) |
||
109 | 23912 | jmvivo | throws InitializeException {
|
110 | 29326 | jmvivo | super(params, storeServices, metadata);
|
111 | this.init(params, storeServices);
|
||
112 | 24959 | jmvivo | } |
113 | |||
114 | 29326 | jmvivo | protected void init(DBFStoreParameters params, |
115 | DataStoreProviderServices storeServices) throws InitializeException {
|
||
116 | 33029 | jjdelcerro | if( params == null ) { |
117 | throw new InitializeException( new NullPointerException("params is null") ); |
||
118 | } |
||
119 | 24710 | jmvivo | File theFile = getDBFParameters().getDBFFile();
|
120 | 33029 | jjdelcerro | if( theFile == null ) { |
121 | throw new InitializeException( new NullPointerException("dbf file is null") ); |
||
122 | } |
||
123 | 31022 | cordinyana | initResource(params, storeServices); |
124 | 23912 | jmvivo | |
125 | 29326 | jmvivo | Charset charset = params.getEncoding();
|
126 | 28148 | jmvivo | this.dbfFile = new DbaseFile(theFile, charset); |
127 | 23912 | jmvivo | |
128 | 33718 | jjdelcerro | writer = new DBFFeatureWriter(this.getProviderName()); |
129 | 28148 | jmvivo | |
130 | 23912 | jmvivo | this.initFeatureType();
|
131 | 29326 | jmvivo | |
132 | 23912 | jmvivo | } |
133 | |||
134 | 32880 | jjdelcerro | public Object getDynValue(String name) throws DynFieldNotFoundException { |
135 | try {
|
||
136 | this.open();
|
||
137 | } catch (OpenException e) {
|
||
138 | throw new RuntimeException(e); |
||
139 | } |
||
140 | if( METADATA_ENCODING.equalsIgnoreCase(name) ) {
|
||
141 | return this.dbfFile.getOriginalCharset(); |
||
142 | } else if( METADATA_CODEPAGE.equalsIgnoreCase(name) ) { |
||
143 | return new Byte(this.dbfFile.getCodePage()); |
||
144 | } |
||
145 | return super.getDynValue(name); |
||
146 | } |
||
147 | |||
148 | 31022 | cordinyana | protected void initResource(DBFStoreParameters params, |
149 | DataStoreProviderServices storeServices) throws InitializeException {
|
||
150 | 29326 | jmvivo | |
151 | 31022 | cordinyana | File theFile = getDBFParameters().getDBFFile();
|
152 | dbfResource = |
||
153 | this.createResource(FileResource.NAME,
|
||
154 | new Object[] { theFile.getAbsolutePath() }); |
||
155 | dbfResource.addConsumer(this);
|
||
156 | } |
||
157 | |||
158 | 33718 | jjdelcerro | public String getProviderName() { |
159 | 24205 | jmvivo | return NAME;
|
160 | } |
||
161 | 23912 | jmvivo | |
162 | 24447 | jmvivo | protected DBFStoreParameters getDBFParameters() {
|
163 | 29326 | jmvivo | return (DBFStoreParameters) super.getParameters(); |
164 | 24205 | jmvivo | } |
165 | |||
166 | |||
167 | 24876 | jmvivo | public DataServerExplorer getExplorer() throws ReadException { |
168 | 24710 | jmvivo | DataManager manager = DALLocator.getDataManager(); |
169 | 24893 | jmvivo | FilesystemServerExplorerParameters params; |
170 | 24710 | jmvivo | try {
|
171 | 24893 | jmvivo | params = (FilesystemServerExplorerParameters) manager |
172 | .createServerExplorerParameters(FilesystemServerExplorer.NAME); |
||
173 | 24710 | jmvivo | params.setRoot(this.getDBFParameters().getDBFFile().getParent());
|
174 | 32880 | jjdelcerro | return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);
|
175 | 24710 | jmvivo | } catch (DataException e) {
|
176 | 33718 | jjdelcerro | throw new ReadException(this.getProviderName(), e); |
177 | 27723 | jmvivo | } catch (ValidateDataParametersException e) {
|
178 | // TODO Auto-generated catch block
|
||
179 | 33718 | jjdelcerro | throw new ReadException(this.getProviderName(), e); |
180 | 24710 | jmvivo | } |
181 | 23912 | jmvivo | } |
182 | |||
183 | 31022 | cordinyana | protected FeatureProvider internalGetFeatureProviderByReference(
|
184 | 24248 | jjdelcerro | FeatureReferenceProviderServices reference, FeatureType featureType) |
185 | 23912 | jmvivo | throws DataException {
|
186 | 31022 | cordinyana | return this.getFeatureProviderByIndex( |
187 | ((Long) reference.getOID()).longValue(), featureType);
|
||
188 | 23912 | jmvivo | } |
189 | |||
190 | 29289 | jmvivo | public void performChanges(Iterator deleteds, Iterator inserteds, |
191 | 28098 | jmvivo | Iterator updateds, Iterator originalFeatureTypesUpdated) |
192 | 24791 | jmvivo | throws PerformEditingException {
|
193 | 23912 | jmvivo | |
194 | 24710 | jmvivo | try {
|
195 | 31022 | cordinyana | final FeatureStore store =
|
196 | this.getStoreServices().getFeatureStore();
|
||
197 | getResource().execute(new ResourceAction() {
|
||
198 | 25997 | jmvivo | |
199 | 31022 | cordinyana | public Object run() throws Exception { |
200 | 31074 | cordinyana | FeatureSet set = null;
|
201 | DisposableIterator iter = null;
|
||
202 | try {
|
||
203 | set = store.getFeatureSet(); |
||
204 | DBFStoreParameters tmpParams = |
||
205 | (DBFStoreParameters) getDBFParameters().getCopy(); |
||
206 | 25997 | jmvivo | |
207 | 32880 | jjdelcerro | tmpParams.setDBFFile(tmpParams.getDBFFileName() |
208 | 31074 | cordinyana | + ".tmp");
|
209 | 24710 | jmvivo | |
210 | 31074 | cordinyana | writer.begin(tmpParams, store.getDefaultFeatureType(), |
211 | set.getSize()); |
||
212 | 24710 | jmvivo | |
213 | 31074 | cordinyana | iter = set.fastIterator(); |
214 | while (iter.hasNext()) {
|
||
215 | Feature feature = (Feature) iter.next(); |
||
216 | writer.append(feature); |
||
217 | } |
||
218 | 27525 | jmvivo | |
219 | 31074 | cordinyana | writer.end(); |
220 | 24791 | jmvivo | |
221 | 31074 | cordinyana | try {
|
222 | close(); |
||
223 | } catch (CloseException e1) {
|
||
224 | 33718 | jjdelcerro | throw new PerformEditingException(getProviderName(), e1); |
225 | 31074 | cordinyana | } |
226 | getDBFParameters().getDBFFile().delete(); |
||
227 | tmpParams.getDBFFile().renameTo( |
||
228 | getDBFParameters().getDBFFile()); |
||
229 | 25997 | jmvivo | |
230 | 31074 | cordinyana | resourcesNotifyChanges(); |
231 | initFeatureType(); |
||
232 | } finally {
|
||
233 | if (set != null) { |
||
234 | set.dispose(); |
||
235 | } |
||
236 | if (iter != null) { |
||
237 | iter.dispose(); |
||
238 | } |
||
239 | 31022 | cordinyana | } |
240 | return null; |
||
241 | } |
||
242 | }); |
||
243 | } catch (ResourceExecuteException e) {
|
||
244 | 33718 | jjdelcerro | throw new PerformEditingException(this.getProviderName(), e); |
245 | 24710 | jmvivo | } |
246 | |||
247 | 24432 | jmvivo | this.counterNewsOIDs = -1; |
248 | 23912 | jmvivo | } |
249 | |||
250 | /*
|
||
251 | * ==================================================
|
||
252 | */
|
||
253 | |||
254 | 29292 | jmvivo | public FeatureProvider createFeatureProvider(FeatureType type) throws DataException { |
255 | return new DBFFeatureProvider(this, type); |
||
256 | 23912 | jmvivo | } |
257 | |||
258 | |||
259 | /*
|
||
260 | * ===================================================
|
||
261 | */
|
||
262 | |||
263 | |||
264 | |||
265 | 24447 | jmvivo | protected void initFeatureType() throws InitializeException { |
266 | 31022 | cordinyana | try {
|
267 | FeatureType defaultType = |
||
268 | this.getTheFeatureType().getNotEditableCopy();
|
||
269 | List types = new ArrayList(1); |
||
270 | types.add(defaultType); |
||
271 | this.getStoreServices().setFeatureTypes(types, defaultType);
|
||
272 | } catch (OpenException e) {
|
||
273 | throw new InitializeException(getResource().toString(), e); |
||
274 | } |
||
275 | 24447 | jmvivo | } |
276 | |||
277 | 31022 | cordinyana | protected EditableFeatureType getTheFeatureType()
|
278 | throws InitializeException, OpenException {
|
||
279 | 23912 | jmvivo | try {
|
280 | this.open();
|
||
281 | } catch (DataException e) {
|
||
282 | 33718 | jjdelcerro | throw new InitializeException(this.getProviderName(), e); |
283 | 23912 | jmvivo | } |
284 | 31022 | cordinyana | return (EditableFeatureType) getResource().execute(
|
285 | new ResourceAction() {
|
||
286 | 23912 | jmvivo | |
287 | 31022 | cordinyana | public Object run() throws Exception { |
288 | int fieldCount = -1; |
||
289 | fieldCount = dbfFile.getFieldCount(); |
||
290 | 23912 | jmvivo | |
291 | 31022 | cordinyana | EditableFeatureType fType = |
292 | getStoreServices().createFeatureType(); |
||
293 | 23912 | jmvivo | |
294 | 31022 | cordinyana | fType.setHasOID(true);
|
295 | int precision;
|
||
296 | for (int i = 0; i < fieldCount; i++) { |
||
297 | char fieldType = dbfFile.getFieldType(i);
|
||
298 | EditableFeatureAttributeDescriptor attr; |
||
299 | 23912 | jmvivo | |
300 | 31022 | cordinyana | if (fieldType == 'L') { |
301 | attr = |
||
302 | fType.add(dbfFile.getFieldName(i), |
||
303 | DataTypes.BOOLEAN); |
||
304 | attr.setDefaultValue(new Boolean(false)); |
||
305 | attr.setAllowNull(false);
|
||
306 | 25981 | jmvivo | |
307 | 31022 | cordinyana | } else if ((fieldType == 'F') || (fieldType == 'N')) { |
308 | precision = dbfFile.getFieldDecimalLength(i); |
||
309 | if (precision > 0) { |
||
310 | attr = |
||
311 | fType.add(dbfFile.getFieldName(i), |
||
312 | DataTypes.DOUBLE, |
||
313 | dbfFile.getFieldLength(i)); |
||
314 | attr.setPrecision(precision); |
||
315 | attr.setDefaultValue(new Double(0)); |
||
316 | 25667 | jmvivo | |
317 | 31022 | cordinyana | } else {
|
318 | attr = |
||
319 | fType.add(dbfFile.getFieldName(i), |
||
320 | 33337 | jpiera | DataTypes.INT, |
321 | dbfFile.getFieldLength(i)); |
||
322 | 31022 | cordinyana | attr.setDefaultValue(new Integer(0)); |
323 | } |
||
324 | attr.setAllowNull(false);
|
||
325 | 25667 | jmvivo | |
326 | 31022 | cordinyana | } else if (fieldType == 'C') { |
327 | attr = |
||
328 | fType.add(dbfFile.getFieldName(i), |
||
329 | DataTypes.STRING); |
||
330 | attr.setSize(dbfFile.getFieldLength(i)); |
||
331 | attr.setDefaultValue("");
|
||
332 | attr.setAllowNull(false);
|
||
333 | |||
334 | } else if (fieldType == 'D') { |
||
335 | attr = |
||
336 | fType.add(dbfFile.getFieldName(i), |
||
337 | DataTypes.DATE); |
||
338 | attr.setDefaultValue(null);
|
||
339 | attr.setAllowNull(true);
|
||
340 | } else {
|
||
341 | 33718 | jjdelcerro | throw new InitializeException(getProviderName(), |
342 | 31022 | cordinyana | new UnknownDataTypeException(
|
343 | dbfFile.getFieldName(i), ""
|
||
344 | 33718 | jjdelcerro | + fieldType, getProviderName())); |
345 | 31022 | cordinyana | } |
346 | } |
||
347 | return fType;
|
||
348 | } |
||
349 | }); |
||
350 | 23912 | jmvivo | } |
351 | |||
352 | |||
353 | 29292 | jmvivo | protected void loadValue(FeatureProvider featureProvider, int rowIndex, |
354 | 23912 | jmvivo | FeatureAttributeDescriptor descriptor) throws ReadException {
|
355 | if (descriptor.getEvaluator() != null) { |
||
356 | // Nothing to do
|
||
357 | return;
|
||
358 | } |
||
359 | |||
360 | 25245 | jmvivo | |
361 | 26359 | jmvivo | int dbfIndex = this.dbfFile.getFieldIndex(descriptor.getName()); |
362 | 23912 | jmvivo | String value = null; |
363 | try {
|
||
364 | 26359 | jmvivo | value = this.dbfFile.getStringFieldValue(rowIndex, dbfIndex);
|
365 | 23912 | jmvivo | } catch (DataException e) {
|
366 | 33718 | jjdelcerro | throw new ReadException(this.getProviderName(), e); |
367 | 23912 | jmvivo | } |
368 | value = value.trim(); |
||
369 | 33331 | jjdelcerro | int fieldType = descriptor.getType();
|
370 | 23912 | jmvivo | switch (fieldType) {
|
371 | case DataTypes.STRING:
|
||
372 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), value); |
373 | 23912 | jmvivo | break;
|
374 | |||
375 | case DataTypes.DOUBLE:
|
||
376 | try {
|
||
377 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), new Double(value)); |
378 | 23912 | jmvivo | } catch (NumberFormatException e) { |
379 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), null);
|
380 | 23912 | jmvivo | } |
381 | break;
|
||
382 | |||
383 | case DataTypes.INT:
|
||
384 | try {
|
||
385 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), new Integer(value)); |
386 | 23912 | jmvivo | } catch (NumberFormatException e) { |
387 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), null);
|
388 | 23912 | jmvivo | } |
389 | break;
|
||
390 | |||
391 | case DataTypes.FLOAT:
|
||
392 | try {
|
||
393 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), new Float(value)); |
394 | 23912 | jmvivo | } catch (NumberFormatException e) { |
395 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), null);
|
396 | 23912 | jmvivo | } |
397 | break;
|
||
398 | |||
399 | case DataTypes.LONG:
|
||
400 | try {
|
||
401 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), new Long(value)); |
402 | 23912 | jmvivo | } catch (NumberFormatException e) { |
403 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), null);
|
404 | 23912 | jmvivo | } |
405 | break;
|
||
406 | |||
407 | case DataTypes.BOOLEAN:
|
||
408 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), new Boolean(value)); |
409 | 23912 | jmvivo | break;
|
410 | |||
411 | case DataTypes.BYTE:
|
||
412 | try {
|
||
413 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), new Byte(value)); |
414 | 23912 | jmvivo | } catch (NumberFormatException e) { |
415 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), null);
|
416 | 23912 | jmvivo | } |
417 | break;
|
||
418 | |||
419 | case DataTypes.DATE:
|
||
420 | 28001 | vcaballero | if (value.equals("")){ |
421 | value=null;
|
||
422 | return;
|
||
423 | } |
||
424 | 23912 | jmvivo | String year = value.substring(0, 4); |
425 | String month = value.substring(4, 6); |
||
426 | String day = value.substring(6, 8); |
||
427 | DateFormat df;
|
||
428 | if (descriptor.getDateFormat() == null){ |
||
429 | df = DateFormat.getDateInstance(DateFormat.SHORT, |
||
430 | ukLocale); |
||
431 | } else{
|
||
432 | df = descriptor.getDateFormat(); |
||
433 | } |
||
434 | /*
|
||
435 | * Calendar c = Calendar.getInstance(); c.clear();
|
||
436 | * c.set(Integer.parseInt(year), Integer.parseInt(month),
|
||
437 | * Integer.parseInt(day)); c.set(Calendar.MILLISECOND, 0);
|
||
438 | */
|
||
439 | String strAux = month + "/" + day + "/" + year; |
||
440 | Date dat = null; |
||
441 | try {
|
||
442 | dat = df.parse(strAux); |
||
443 | } catch (ParseException e) { |
||
444 | 33718 | jjdelcerro | throw new ReadException(this.getProviderName(), e); |
445 | 23912 | jmvivo | } |
446 | 29292 | jmvivo | featureProvider.set(descriptor.getIndex(), dat); |
447 | 23912 | jmvivo | break;
|
448 | |||
449 | |||
450 | default:
|
||
451 | 29292 | jmvivo | featureProvider |
452 | 26359 | jmvivo | .set(descriptor.getIndex(), descriptor.getDefaultValue()); |
453 | 23912 | jmvivo | break;
|
454 | } |
||
455 | } |
||
456 | |||
457 | |||
458 | /***
|
||
459 | * NOT supported in Alter Mode
|
||
460 | *
|
||
461 | * @param index
|
||
462 | * @return
|
||
463 | * @throws ReadException
|
||
464 | */
|
||
465 | 29292 | jmvivo | protected FeatureProvider getFeatureProviderByIndex(long index) throws DataException { |
466 | 23912 | jmvivo | return this |
467 | 29326 | jmvivo | .getFeatureProviderByIndex(index, this.getStoreServices()
|
468 | 23912 | jmvivo | .getDefaultFeatureType()); |
469 | } |
||
470 | |||
471 | 28017 | jmvivo | public long getFeatureCount() throws ReadException, OpenException, |
472 | 23912 | jmvivo | ResourceNotifyChangesException { |
473 | this.open();
|
||
474 | 31022 | cordinyana | return ((Long) getResource().execute(new ResourceAction() { |
475 | public Object run() throws Exception { |
||
476 | return Long.valueOf(dbfFile.getRecordCount()); |
||
477 | } |
||
478 | })).longValue(); |
||
479 | 23912 | jmvivo | } |
480 | |||
481 | 27274 | jmvivo | public FeatureSetProvider createSet(FeatureQuery query, FeatureType featureType)
|
482 | 23912 | jmvivo | throws DataException {
|
483 | 27274 | jmvivo | return new DBFSetProvider(this, query, featureType); |
484 | 23912 | jmvivo | } |
485 | |||
486 | public boolean canCreate() { |
||
487 | return true; |
||
488 | } |
||
489 | |||
490 | 29289 | jmvivo | public boolean canWriteGeometry(int geometryType, int geometrySubType) throws DataException { |
491 | 23912 | jmvivo | return false; |
492 | } |
||
493 | |||
494 | public void open() throws OpenException { |
||
495 | if (this.dbfFile.isOpen()) { |
||
496 | return;
|
||
497 | } |
||
498 | 23996 | jmvivo | try {
|
499 | 31022 | cordinyana | getResource().execute(new ResourceAction() {
|
500 | public Object run() throws Exception { |
||
501 | openFile(); |
||
502 | resourcesOpen(); |
||
503 | return null; |
||
504 | } |
||
505 | }); |
||
506 | 25789 | jmvivo | |
507 | 31022 | cordinyana | } catch (ResourceExecuteException e) {
|
508 | 33718 | jjdelcerro | throw new OpenException(this.getProviderName(), e); |
509 | 23996 | jmvivo | } |
510 | 23912 | jmvivo | } |
511 | |||
512 | 26252 | jmvivo | protected void openFile() throws FileNotFoundException, |
513 | UnsupportedVersionException, IOException, DataException {
|
||
514 | this.dbfFile.open();
|
||
515 | } |
||
516 | |||
517 | 23912 | jmvivo | public void close() throws CloseException { |
518 | 31284 | cordinyana | if (dbfFile == null || !this.dbfFile.isOpen()) { |
519 | 23912 | jmvivo | return;
|
520 | } |
||
521 | 25997 | jmvivo | super.close();
|
522 | 23912 | jmvivo | //Cerrar recurso
|
523 | try {
|
||
524 | 31022 | cordinyana | getResource().execute(new ResourceAction() {
|
525 | public Object run() throws Exception { |
||
526 | closeFile(); |
||
527 | resourcesNotifyClose(); |
||
528 | return null; |
||
529 | } |
||
530 | }); |
||
531 | } catch (ResourceExecuteException e) {
|
||
532 | 33718 | jjdelcerro | throw new CloseException(this.getProviderName(), e); |
533 | 23912 | jmvivo | } |
534 | } |
||
535 | |||
536 | 26252 | jmvivo | protected void closeFile() throws CloseException { |
537 | this.dbfFile.close();
|
||
538 | 25997 | jmvivo | } |
539 | |||
540 | 31284 | cordinyana | @Override
|
541 | protected void doDispose() throws BaseException { |
||
542 | 23912 | jmvivo | this.close();
|
543 | dbfFile = null;
|
||
544 | 31022 | cordinyana | disposeResource(); |
545 | 31284 | cordinyana | super.doDispose();
|
546 | 31022 | cordinyana | } |
547 | |||
548 | protected void disposeResource() { |
||
549 | 24447 | jmvivo | this.dbfResource.removeConsumer(this); |
550 | dbfResource = null;
|
||
551 | 23912 | jmvivo | } |
552 | |||
553 | public boolean closeResourceRequested(ResourceProvider resource) { |
||
554 | try {
|
||
555 | this.close();
|
||
556 | } catch (CloseException e) {
|
||
557 | return false; |
||
558 | } |
||
559 | return true; |
||
560 | } |
||
561 | |||
562 | public boolean allowWrite() { |
||
563 | File file;
|
||
564 | try {
|
||
565 | 25213 | jmvivo | file = new File((String) this.dbfResource.get()); |
566 | 23912 | jmvivo | } catch (AccessResourceException e) {
|
567 | return false; |
||
568 | } |
||
569 | 25579 | vcaballero | return file.canWrite();
|
570 | 23912 | jmvivo | } |
571 | |||
572 | public void refresh() throws OpenException { |
||
573 | try {
|
||
574 | this.close();
|
||
575 | } catch (CloseException e) {
|
||
576 | 33718 | jjdelcerro | throw new OpenException(this.getProviderName(), e); |
577 | 23912 | jmvivo | } |
578 | this.open();
|
||
579 | try {
|
||
580 | 26289 | jmvivo | this.initFeatureType();
|
581 | 23912 | jmvivo | } catch (InitializeException e) {
|
582 | 33718 | jjdelcerro | throw new OpenException(this.getProviderName(), e); |
583 | 23912 | jmvivo | } |
584 | } |
||
585 | |||
586 | 24432 | jmvivo | /**
|
587 | 24447 | jmvivo | *
|
588 | 24432 | jmvivo | * @param index
|
589 | * @param featureType
|
||
590 | * @return
|
||
591 | * @throws ReadException
|
||
592 | */
|
||
593 | 29292 | jmvivo | protected FeatureProvider getFeatureProviderByIndex(long index, |
594 | 24432 | jmvivo | FeatureType featureType) throws DataException {
|
595 | 29292 | jmvivo | FeatureProvider featureProvider = this.createFeatureProvider(featureType);
|
596 | featureProvider.setOID(new Long(index)); |
||
597 | return featureProvider;
|
||
598 | 24123 | jmvivo | } |
599 | 23912 | jmvivo | |
600 | 29292 | jmvivo | protected void initFeatureProviderByIndex(FeatureProvider featureProvider, |
601 | 24447 | jmvivo | long index, FeatureType featureType) throws DataException { |
602 | 29292 | jmvivo | featureProvider.setOID(new Long(index)); |
603 | 24447 | jmvivo | } |
604 | |||
605 | 24432 | jmvivo | /**
|
606 | 24447 | jmvivo | *
|
607 | 29292 | jmvivo | * @param featureProvider
|
608 | 24447 | jmvivo | * @throws DataException
|
609 | 24432 | jmvivo | */
|
610 | 29292 | jmvivo | protected void loadFeatureProviderByIndex(FeatureProvider featureProvider) |
611 | 24432 | jmvivo | throws DataException {
|
612 | 29292 | jmvivo | long index = ((Long) featureProvider.getOID()).longValue(); |
613 | 31022 | cordinyana | if (index >= this.dbfFile.getRecordCount()) { |
614 | // FIXME
|
||
615 | throw new ArrayIndexOutOfBoundsException("" + index); |
||
616 | 24432 | jmvivo | } |
617 | 31022 | cordinyana | Iterator iterator = featureProvider.getType().iterator();
|
618 | while (iterator.hasNext()) {
|
||
619 | FeatureAttributeDescriptor descriptor = |
||
620 | (FeatureAttributeDescriptor) iterator.next(); |
||
621 | this.loadValue(featureProvider, (int) index, descriptor); |
||
622 | } |
||
623 | 24432 | jmvivo | } |
624 | |||
625 | 29289 | jmvivo | public int getOIDType() { |
626 | 24123 | jmvivo | return DataTypes.LONG;
|
627 | } |
||
628 | |||
629 | 24432 | jmvivo | public Object createNewOID() { |
630 | if (this.counterNewsOIDs < 0) { |
||
631 | try {
|
||
632 | this.counterNewsOIDs = this.getFeatureCount(); |
||
633 | } catch (DataException e) {
|
||
634 | e.printStackTrace(); |
||
635 | } |
||
636 | |||
637 | 25752 | vcaballero | }else{
|
638 | this.counterNewsOIDs++;
|
||
639 | 24432 | jmvivo | } |
640 | 25610 | vcaballero | return new Long(counterNewsOIDs); |
641 | 24432 | jmvivo | } |
642 | |||
643 | 24710 | jmvivo | public boolean supportsAppendMode() { |
644 | 25752 | vcaballero | return true; |
645 | 24177 | jmvivo | } |
646 | |||
647 | 24710 | jmvivo | |
648 | 31022 | cordinyana | public void append(final FeatureProvider featureProvider) |
649 | throws DataException {
|
||
650 | getResource().execute(new ResourceAction() {
|
||
651 | public Object run() throws Exception { |
||
652 | writer.append(getStoreServices().createFeature(featureProvider)); |
||
653 | return null; |
||
654 | } |
||
655 | }); |
||
656 | 24177 | jmvivo | } |
657 | |||
658 | 25955 | jmvivo | public void beginAppend() throws DataException { |
659 | this.close();
|
||
660 | 31022 | cordinyana | getResource().execute(new ResourceAction() {
|
661 | public Object run() throws Exception { |
||
662 | writer.begin(getDBFParameters(), |
||
663 | getStoreServices().getDefaultFeatureType(), |
||
664 | 31284 | cordinyana | getStoreServices().getFeatureStore().getFeatureCount()); |
665 | 31022 | cordinyana | return null; |
666 | } |
||
667 | }); |
||
668 | 24177 | jmvivo | } |
669 | |||
670 | 25955 | jmvivo | public void endAppend() throws DataException { |
671 | 31022 | cordinyana | getResource().execute(new ResourceAction() {
|
672 | public Object run() throws Exception { |
||
673 | resourcesNotifyChanges(); |
||
674 | counterNewsOIDs = -1;
|
||
675 | return null; |
||
676 | } |
||
677 | }); |
||
678 | 24177 | jmvivo | } |
679 | |||
680 | 25789 | jmvivo | /*
|
681 | * (non-Javadoc)
|
||
682 | 25977 | jmvivo | *
|
683 | 25789 | jmvivo | * @see
|
684 | * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.
|
||
685 | * gvsig.fmap.dal.resource.spi.ResourceProvider)
|
||
686 | */
|
||
687 | public void resourceChanged(ResourceProvider resource) { |
||
688 | 29326 | jmvivo | this.getStoreServices().notifyChange(
|
689 | DataStoreNotification.RESOURCE_CHANGED, |
||
690 | 25789 | jmvivo | resource); |
691 | } |
||
692 | 26252 | jmvivo | |
693 | /**
|
||
694 | *
|
||
695 | * @throws ResourceNotifyChangesException
|
||
696 | */
|
||
697 | protected void resourcesNotifyChanges() |
||
698 | throws ResourceNotifyChangesException {
|
||
699 | this.dbfResource.notifyChanges();
|
||
700 | } |
||
701 | |||
702 | /**
|
||
703 | * @throws ResourceNotifyCloseException
|
||
704 | *
|
||
705 | */
|
||
706 | protected void resourcesNotifyClose() throws ResourceNotifyCloseException { |
||
707 | this.dbfResource.notifyClose();
|
||
708 | } |
||
709 | |||
710 | /**
|
||
711 | * @throws ResourceNotifyOpenException
|
||
712 | *
|
||
713 | */
|
||
714 | protected void resourcesOpen() throws ResourceNotifyOpenException { |
||
715 | this.dbfResource.notifyOpen();
|
||
716 | } |
||
717 | 26837 | jmvivo | |
718 | public Object getSourceId() { |
||
719 | return this.getDBFParameters().getFile(); |
||
720 | } |
||
721 | 33718 | jjdelcerro | |
722 | public String getName() { |
||
723 | String name = this.getDBFParameters().getFile().getName(); |
||
724 | int n = name.lastIndexOf("."); |
||
725 | if( n<1 ) { |
||
726 | return name;
|
||
727 | } |
||
728 | return name.substring(0, n); |
||
729 | } |
||
730 | |||
731 | public String getFullName() { |
||
732 | return this.getDBFParameters().getFile().getAbsolutePath(); |
||
733 | } |
||
734 | 27875 | vcaballero | |
735 | protected void resourceCloseRequest() throws ResourceException { |
||
736 | this.dbfResource.closeRequest();
|
||
737 | } |
||
738 | 31022 | cordinyana | |
739 | public ResourceProvider getResource() {
|
||
740 | return dbfResource;
|
||
741 | } |
||
742 | } |