Revision 36202 branches/v2_0_0_prep/libraries/libFMap_dal/src/org/gvsig/fmap/dal/impl/DefaultDataManager.java
DefaultDataManager.java | ||
---|---|---|
14 | 14 |
import org.gvsig.fmap.dal.DataStore; |
15 | 15 |
import org.gvsig.fmap.dal.DataStoreFactory; |
16 | 16 |
import org.gvsig.fmap.dal.DataStoreParameters; |
17 |
import org.gvsig.fmap.dal.DataStoreProviderFactory; |
|
17 | 18 |
import org.gvsig.fmap.dal.NewDataStoreParameters; |
18 | 19 |
import org.gvsig.fmap.dal.OpenErrorHandler; |
19 | 20 |
import org.gvsig.fmap.dal.exception.DataException; |
... | ... | |
28 | 29 |
import org.gvsig.fmap.dal.feature.impl.DefaultFeatureStore; |
29 | 30 |
import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper; |
30 | 31 |
import org.gvsig.fmap.dal.feature.paging.impl.FeaturePagingHelperImpl; |
32 |
import org.gvsig.fmap.dal.feature.spi.BaseFeatureStoreProviderFactory; |
|
31 | 33 |
import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider; |
32 | 34 |
import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices; |
33 | 35 |
import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProvider; |
... | ... | |
50 | 52 |
import org.gvsig.tools.extensionpoint.ExtensionPoint; |
51 | 53 |
import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension; |
52 | 54 |
import org.gvsig.tools.operations.OperationManager; |
55 |
import org.slf4j.Logger; |
|
56 |
import org.slf4j.LoggerFactory; |
|
53 | 57 |
|
54 | 58 |
public class DefaultDataManager implements DataManager, |
55 | 59 |
DataManagerProviderServices { |
56 | 60 |
|
61 |
private static Logger LOG = LoggerFactory |
|
62 |
.getLogger(DefaultDataManager.class); |
|
63 |
|
|
57 | 64 |
final static private String DATA_MANAGER_STORE = "Data.manager.stores"; |
58 | 65 |
final static private String DATA_MANAGER_STORE_DESCRIPTION = "DAL stores providers"; |
59 | 66 |
|
... | ... | |
75 | 82 |
final static private String DATA_MANAGER_EXPRESION_EVALUATOR = "Data.manager.expresion.evaluator"; |
76 | 83 |
final static private String DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT = "default"; |
77 | 84 |
final static private String DATA_MANAGER_EXPRESION_EVALUATOR_DESCRIPTION = "DAL expresion evaluators."; |
78 |
|
|
85 |
|
|
79 | 86 |
final static private String DATA_MANAGER_STORE_FACTORY = "Data.manager.stores.factory"; |
80 | 87 |
final static private String DATA_MANAGER_STORE_FACTORY_DESCRIPTION = "DAL stores factories"; |
81 | 88 |
|
89 |
final static private String DATA_MANAGER_STORE_PROVIDER_FACTORY = "Data.manager.providers.factory"; |
|
90 |
final static private String DATA_MANAGER_STORE_PROVIDER_FACTORY_DESCRIPTION = "DAL store provider factories"; |
|
91 |
|
|
82 | 92 |
/** This map contains the name of the default provider for each data type */ |
83 | 93 |
private Map defaultDataIndexProviders; |
84 | 94 |
|
... | ... | |
165 | 175 |
} |
166 | 176 |
|
167 | 177 |
if (CoverageStoreProvider.class.isAssignableFrom(storeProviderClass)) { |
178 |
ToolsLocator.getExtensionPointManager() |
|
179 |
.add(DATA_MANAGER_STORE, DATA_MANAGER_STORE_DESCRIPTION) |
|
180 |
.append(name, null, storeProviderClass); |
|
168 | 181 |
|
169 |
} else if (FeatureStoreProvider.class |
|
170 |
.isAssignableFrom(storeProviderClass)) { |
|
182 |
ToolsLocator |
|
183 |
.getExtensionPointManager() |
|
184 |
.add(DATA_MANAGER_STORE_PARAMS, |
|
185 |
DATA_MANAGER_STORE_PARAMS_DESCRIPTION) |
|
186 |
.append(name, null, parametersClass); |
|
187 |
return; |
|
188 |
} |
|
171 | 189 |
|
172 |
} else { |
|
173 |
// FIXME Exception |
|
174 |
throw new IllegalArgumentException( |
|
175 |
"Not supported implemtation: name=" + name |
|
176 |
+ " provider class=" + storeProviderClass.getName()); |
|
190 |
if (FeatureStoreProvider.class.isAssignableFrom(storeProviderClass)) { |
|
191 |
// Envuelbe alproveedor en una factoria por defecto. |
|
192 |
this.registerStoreProviderFactory(new BaseFeatureStoreProviderFactory(name, "", storeProviderClass, parametersClass)); |
|
193 |
return; |
|
177 | 194 |
} |
178 | 195 |
|
179 |
ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_STORE, |
|
180 |
DATA_MANAGER_STORE_DESCRIPTION).append(name, null, |
|
181 |
storeProviderClass); |
|
196 |
throw new IllegalArgumentException("Not supported implemtation: name=" |
|
197 |
+ name + " provider class=" + storeProviderClass.getName()); |
|
182 | 198 |
|
183 |
ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_STORE_PARAMS, |
|
184 |
DATA_MANAGER_STORE_PARAMS_DESCRIPTION).append(name, null, |
|
185 |
parametersClass); |
|
186 | 199 |
} |
187 |
|
|
188 |
/* |
|
189 |
* (non-Javadoc) |
|
190 |
* @see org.gvsig.fmap.dal.spi.DataManagerProviderServices#registerStoreFactory(java.lang.String, java.lang.Class) |
|
191 |
*/ |
|
200 |
|
|
201 |
public void registerStoreProviderFactory(DataStoreProviderFactory factory) { |
|
202 |
ExtensionPoint factories = ToolsLocator.getExtensionPointManager().add( |
|
203 |
DATA_MANAGER_STORE_PROVIDER_FACTORY, |
|
204 |
DATA_MANAGER_STORE_PROVIDER_FACTORY_DESCRIPTION); |
|
205 |
factories.append(factory.getName(), factory.getDescription(), factory); |
|
206 |
|
|
207 |
} |
|
208 |
|
|
192 | 209 |
public void registerStoreFactory(String name, Class storeProviderClass) { |
193 | 210 |
if (name == null || storeProviderClass == null) { |
194 | 211 |
// FIXME Exception |
195 | 212 |
throw new IllegalArgumentException("Any parameters can be null"); |
196 | 213 |
} |
197 | 214 |
|
198 |
if(!(DataStoreFactory.class.isAssignableFrom(storeProviderClass))) { |
|
215 |
if (!(DataStoreFactory.class.isAssignableFrom(storeProviderClass))) {
|
|
199 | 216 |
// FIXME Exception |
200 | 217 |
throw new IllegalArgumentException( |
201 | 218 |
"Not supported implemtation: name=" + name |
202 | 219 |
+ " provider class=" + storeProviderClass.getName()); |
203 | 220 |
} |
204 | 221 |
|
205 |
ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_STORE_FACTORY, |
|
206 |
DATA_MANAGER_STORE_FACTORY_DESCRIPTION).append(name, null, |
|
207 |
storeProviderClass); |
|
222 |
ToolsLocator |
|
223 |
.getExtensionPointManager() |
|
224 |
.add(DATA_MANAGER_STORE_FACTORY, |
|
225 |
DATA_MANAGER_STORE_FACTORY_DESCRIPTION) |
|
226 |
.append(name, null, storeProviderClass); |
|
208 | 227 |
} |
209 | 228 |
|
210 | 229 |
public DataStoreParameters createStoreParameters(String name) |
211 | 230 |
throws InitializeException, ProviderNotRegisteredException { |
212 | 231 |
try { |
213 |
DataStoreParameters params = (DataStoreParameters) ToolsLocator |
|
232 |
|
|
233 |
// Si hay una factoria para ese proveedor se los pedimos a la factoria |
|
234 |
DataStoreProviderFactory providerFactory = (DataStoreProviderFactory) ToolsLocator |
|
235 |
.getExtensionPointManager().get(DATA_MANAGER_STORE_PROVIDER_FACTORY) |
|
236 |
.create(name); |
|
237 |
if( providerFactory != null ) { |
|
238 |
return (DataStoreParameters) providerFactory.createParameters(); |
|
239 |
} |
|
240 |
|
|
241 |
// Si no hay factoria lo hacemos como se hacia antes por mantener |
|
242 |
// compatibilidad. |
|
243 |
DataStoreParameters params = (DataStoreParameters) ToolsLocator |
|
214 | 244 |
.getExtensionPointManager().get(DATA_MANAGER_STORE_PARAMS) |
215 | 245 |
.create(name); |
216 | 246 |
if (params == null) { |
... | ... | |
228 | 258 |
} |
229 | 259 |
} |
230 | 260 |
|
231 |
private DataStore localOpenStore(String provider, DataStoreParameters parameters)
|
|
232 |
throws InitializeException, ProviderNotRegisteredException,
|
|
233 |
ValidateDataParametersException { |
|
234 |
String name = provider; //parameters.getDataStoreName(); |
|
261 |
private DataStore localOpenStore(String provider, |
|
262 |
DataStoreParameters parameters) throws InitializeException,
|
|
263 |
ProviderNotRegisteredException, ValidateDataParametersException {
|
|
264 |
String name = provider; // parameters.getDataStoreName();
|
|
235 | 265 |
|
236 | 266 |
parameters.validate(); |
237 | 267 |
|
... | ... | |
249 | 279 |
} |
250 | 280 |
|
251 | 281 |
if (CoverageStoreProvider.class.isAssignableFrom(providerClass)) { |
252 |
ExtensionPoint.Extension point = ToolsLocator.getExtensionPointManager(). |
|
253 |
get(DATA_MANAGER_STORE_FACTORY).get(name); |
|
282 |
ExtensionPoint.Extension point = ToolsLocator |
|
283 |
.getExtensionPointManager().get(DATA_MANAGER_STORE_FACTORY) |
|
284 |
.get(name); |
|
254 | 285 |
DataStoreFactory factory = null; |
255 | 286 |
try { |
256 |
factory = (DataStoreFactory)point.create(); |
|
287 |
factory = (DataStoreFactory) point.create();
|
|
257 | 288 |
} catch (InstantiationException e) { |
258 | 289 |
throw new InitializeException(e); |
259 | 290 |
} catch (IllegalAccessException e) { |
... | ... | |
281 | 312 |
throws InitializeException, ProviderNotRegisteredException, |
282 | 313 |
ValidateDataParametersException { |
283 | 314 |
|
284 |
// try { |
|
285 |
return localOpenStore(provider, parameters); |
|
286 |
// } catch (Exception e) { |
|
287 |
// // TODO: handle exception |
|
288 |
// } |
|
289 |
|
|
315 |
return localOpenStore(provider, parameters); |
|
290 | 316 |
} |
291 | 317 |
|
292 | 318 |
/** |
... | ... | |
295 | 321 |
public DataStore createStore(DataStoreParameters parameters) |
296 | 322 |
throws InitializeException, ProviderNotRegisteredException, |
297 | 323 |
ValidateDataParametersException { |
324 |
try { |
|
325 |
int i = 1 / 0; |
|
326 |
} catch (Throwable e) { |
|
327 |
LOG.info( |
|
328 |
"Use of deprcated method. Replace calling to it by calling to openStore", |
|
329 |
e); |
|
330 |
} |
|
298 | 331 |
return openStore(parameters.getDataStoreName(), parameters); |
299 | 332 |
} |
300 | 333 |
|
... | ... | |
303 | 336 |
.getNames(); |
304 | 337 |
} |
305 | 338 |
|
339 |
public DataStoreProviderFactory getStoreProviderFactory(String name) { |
|
340 |
try { |
|
341 |
return (DataStoreProviderFactory) ToolsLocator |
|
342 |
.getExtensionPointManager() |
|
343 |
.get(DATA_MANAGER_STORE_PROVIDER_FACTORY).create(name); |
|
344 |
} catch (InstantiationException e) { |
|
345 |
return null; |
|
346 |
} catch (IllegalAccessException e) { |
|
347 |
return null; |
|
348 |
} |
|
349 |
} |
|
350 |
|
|
306 | 351 |
public List getStoreProviders(String name) { |
307 | 352 |
return getStoreProviders(); // FIXME: need filter from the name of |
308 | 353 |
// the explorer |
... | ... | |
316 | 361 |
DataServerExplorer server; |
317 | 362 |
try { |
318 | 363 |
parameters = this.createServerExplorerParameters(explorer); |
319 |
server = this.openServerExplorerWithoutValidate(explorer, parameters); |
|
364 |
server = this.openServerExplorerWithoutValidate(explorer, |
|
365 |
parameters); |
|
320 | 366 |
return server.getAddParameters(provider); |
321 | 367 |
} catch (ValidateDataParametersException e) { |
322 | 368 |
throw new InitializeException(e); |
... | ... | |
325 | 371 |
} |
326 | 372 |
} |
327 | 373 |
|
328 |
public void newStore(String explorer, String provider, NewDataStoreParameters parameters, boolean overwrite) |
|
374 |
public void newStore(String explorer, String provider, |
|
375 |
NewDataStoreParameters parameters, boolean overwrite) |
|
329 | 376 |
throws InitializeException, ProviderNotRegisteredException, |
330 | 377 |
ValidateDataParametersException { |
331 | 378 |
|
332 |
parameters.validate();
|
|
333 |
|
|
379 |
parameters.validate();
|
|
380 |
|
|
334 | 381 |
DataServerExplorerParameters explorerParameters; |
335 | 382 |
DataServerExplorer server; |
336 | 383 |
explorerParameters = this.createServerExplorerParameters(explorer); |
337 |
server = this.openServerExplorerWithoutValidate(explorer, explorerParameters); |
|
384 |
server = this.openServerExplorerWithoutValidate(explorer, |
|
385 |
explorerParameters); |
|
338 | 386 |
try { |
339 | 387 |
server.add(provider, parameters, overwrite); |
340 | 388 |
} catch (DataException e) { |
... | ... | |
344 | 392 |
|
345 | 393 |
/* |
346 | 394 |
* ==================================================================== |
347 |
* |
|
395 |
*
|
|
348 | 396 |
* Explorer related services |
349 | 397 |
*/ |
350 | 398 |
public void registerExplorerProvider(String name, Class explorerClass, |
... | ... | |
369 | 417 |
+ " must implement org.gvsig.fmap.dal.DataServerExplorer"); |
370 | 418 |
} |
371 | 419 |
|
372 |
ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_EXPLORER,
|
|
373 |
DATA_MANAGER_EXPLORER_DESCRIPTION).append(name, null,
|
|
374 |
explorerClass); |
|
420 |
ToolsLocator.getExtensionPointManager() |
|
421 |
.add(DATA_MANAGER_EXPLORER, DATA_MANAGER_EXPLORER_DESCRIPTION)
|
|
422 |
.append(name, null, explorerClass);
|
|
375 | 423 |
|
376 |
ToolsLocator.getExtensionPointManager().add( |
|
377 |
DATA_MANAGER_EXPLORER_PARAMS, |
|
378 |
DATA_MANAGER_EXPLORER_PARAMS_DESCRIPTION).append(name, null, |
|
379 |
parametersClass); |
|
424 |
ToolsLocator |
|
425 |
.getExtensionPointManager() |
|
426 |
.add(DATA_MANAGER_EXPLORER_PARAMS, |
|
427 |
DATA_MANAGER_EXPLORER_PARAMS_DESCRIPTION) |
|
428 |
.append(name, null, parametersClass); |
|
380 | 429 |
} |
381 | 430 |
|
382 | 431 |
public DataServerExplorerParameters createServerExplorerParameters( |
... | ... | |
384 | 433 |
ProviderNotRegisteredException { |
385 | 434 |
try { |
386 | 435 |
DataServerExplorerParameters params = (DataServerExplorerParameters) ToolsLocator |
387 |
.getExtensionPointManager().get(
|
|
388 |
DATA_MANAGER_EXPLORER_PARAMS).create(name);
|
|
436 |
.getExtensionPointManager() |
|
437 |
.get(DATA_MANAGER_EXPLORER_PARAMS).create(name);
|
|
389 | 438 |
if (params == null) { |
390 | 439 |
throw new ProviderNotRegisteredException(name); |
391 | 440 |
} |
... | ... | |
401 | 450 |
} |
402 | 451 |
} |
403 | 452 |
|
404 |
public DataServerExplorer openServerExplorer( |
|
405 |
String explorer, |
|
453 |
public DataServerExplorer openServerExplorer(String explorer, |
|
406 | 454 |
DataServerExplorerParameters parameters) |
407 | 455 |
throws InitializeException, ProviderNotRegisteredException, |
408 | 456 |
ValidateDataParametersException { |
409 | 457 |
|
410 |
if( parameters != null ) {
|
|
458 |
if (parameters != null) {
|
|
411 | 459 |
parameters.validate(); |
412 | 460 |
} |
413 | 461 |
return this.openServerExplorerWithoutValidate(explorer, parameters); |
414 | 462 |
} |
415 | 463 |
|
416 | 464 |
private DataServerExplorer openServerExplorerWithoutValidate( |
417 |
String explorerName, |
|
418 |
DataServerExplorerParameters parameters) |
|
465 |
String explorerName, DataServerExplorerParameters parameters) |
|
419 | 466 |
throws InitializeException, ProviderNotRegisteredException, |
420 | 467 |
ValidateDataParametersException { |
421 | 468 |
|
422 |
String name = explorerName; //parameters.getExplorerName(); |
|
469 |
String name = explorerName; // parameters.getExplorerName();
|
|
423 | 470 |
|
424 | 471 |
try { |
425 | 472 |
DataServerExplorerProvider server = (DataServerExplorerProvider) ToolsLocator |
426 | 473 |
.getExtensionPointManager() |
427 | 474 |
.get(DATA_MANAGER_EXPLORER) |
428 |
.create( |
|
429 |
name, |
|
475 |
.create(name, |
|
430 | 476 |
new Object[] { |
431 | 477 |
parameters, |
432 | 478 |
new DefaultDataServerExplorerProviderServices() }); |
... | ... | |
460 | 506 |
} |
461 | 507 |
|
462 | 508 |
public List getExplorerProviders() { |
463 |
return ToolsLocator.getExtensionPointManager().get(
|
|
464 |
DATA_MANAGER_EXPLORER).getNames(); |
|
509 |
return ToolsLocator.getExtensionPointManager() |
|
510 |
.get(DATA_MANAGER_EXPLORER).getNames();
|
|
465 | 511 |
} |
466 | 512 |
|
467 | 513 |
/* |
468 | 514 |
* ==================================================================== |
469 |
* |
|
515 |
*
|
|
470 | 516 |
* Expresion evaluation related services |
471 | 517 |
*/ |
472 | 518 |
public Evaluator createExpresion(String expresion) |
473 | 519 |
throws InitializeException { |
474 | 520 |
try { |
475 |
return (Evaluator) ToolsLocator.getExtensionPointManager().get( |
|
476 |
DATA_MANAGER_EXPRESION_EVALUATOR).create( |
|
477 |
DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT, |
|
478 |
new Object[] { expresion }); |
|
521 |
return (Evaluator) ToolsLocator |
|
522 |
.getExtensionPointManager() |
|
523 |
.get(DATA_MANAGER_EXPRESION_EVALUATOR) |
|
524 |
.create(DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT, |
|
525 |
new Object[] { expresion }); |
|
479 | 526 |
} catch (SecurityException e) { |
480 | 527 |
throw new InitializeException(e); |
481 | 528 |
} catch (IllegalArgumentException e) { |
... | ... | |
495 | 542 |
if (!Evaluator.class.isAssignableFrom(evaluatorClass)) { |
496 | 543 |
throw new ClassCastException(); |
497 | 544 |
} |
498 |
ToolsLocator.getExtensionPointManager().add( |
|
499 |
DATA_MANAGER_EXPRESION_EVALUATOR, |
|
500 |
DATA_MANAGER_EXPRESION_EVALUATOR_DESCRIPTION).append( |
|
501 |
DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT, |
|
502 |
"Default expresion evaluator for use in DAL", evaluatorClass); |
|
545 |
ToolsLocator |
|
546 |
.getExtensionPointManager() |
|
547 |
.add(DATA_MANAGER_EXPRESION_EVALUATOR, |
|
548 |
DATA_MANAGER_EXPRESION_EVALUATOR_DESCRIPTION) |
|
549 |
.append(DATA_MANAGER_EXPRESION_EVALUATOR_DEFAULT, |
|
550 |
"Default expresion evaluator for use in DAL", |
|
551 |
evaluatorClass); |
|
503 | 552 |
} |
504 | 553 |
|
505 | 554 |
/* |
506 | 555 |
* ==================================================================== |
507 |
* |
|
556 |
*
|
|
508 | 557 |
* Index related services |
509 | 558 |
*/ |
510 | 559 |
|
... | ... | |
537 | 586 |
|
538 | 587 |
try { |
539 | 588 |
FeatureIndexProvider provider = (FeatureIndexProvider) ToolsLocator |
540 |
.getExtensionPointManager().get(DATA_MANAGER_INDEX).create(
|
|
541 |
name);
|
|
589 |
.getExtensionPointManager().get(DATA_MANAGER_INDEX) |
|
590 |
.create(name);
|
|
542 | 591 |
if (provider == null) { |
543 | 592 |
throw new ProviderNotRegisteredException(name); |
544 | 593 |
} |
545 | 594 |
FeatureIndexProviderServices services = new DefaultFeatureIndex( |
546 |
(FeatureStoreProviderServices) store, type, provider, attr
|
|
547 |
.getName(), indexName);
|
|
595 |
(FeatureStoreProviderServices) store, type, provider, |
|
596 |
attr.getName(), indexName);
|
|
548 | 597 |
services.initialize(); |
549 | 598 |
return services; |
550 | 599 |
} catch (InstantiationException e) { |
... | ... | |
560 | 609 |
|
561 | 610 |
public void registerFeatureIndexProvider(String name, String description, |
562 | 611 |
Class clazz, int dataType) { |
563 |
ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_INDEX, |
|
564 |
DATA_MANAGER_INDEX_DESCRIPTION).append(name, null, clazz); |
|
612 |
ToolsLocator.getExtensionPointManager() |
|
613 |
.add(DATA_MANAGER_INDEX, DATA_MANAGER_INDEX_DESCRIPTION) |
|
614 |
.append(name, null, clazz); |
|
565 | 615 |
|
566 | 616 |
if (getDefaultFeatureIndexProviderName(dataType) == null) { |
567 | 617 |
setDefaultFeatureIndexProviderName(dataType, name); |
... | ... | |
576 | 626 |
DataStoreParameters parameters) throws InitializeException, |
577 | 627 |
ProviderNotRegisteredException { |
578 | 628 |
|
579 |
((DataStoreInitializer)store).intializePhase1(this, parameters); |
|
580 |
DataStoreProvider provider = this.createProvider((DataStoreProviderServices) store, parameters); |
|
581 |
((DataStoreInitializer)store).intializePhase2(provider); |
|
629 |
((DataStoreInitializer) store).intializePhase1(this, parameters); |
|
630 |
DataStoreProvider provider = this.createProvider( |
|
631 |
(DataStoreProviderServices) store, parameters); |
|
632 |
((DataStoreInitializer) store).intializePhase2(provider); |
|
582 | 633 |
|
583 | 634 |
} |
584 |
|
|
585 |
public DataStoreProvider createProvider(DataStoreProviderServices providerServices, DataStoreParameters parameters) throws InitializeException, ProviderNotRegisteredException { |
|
586 |
String name = parameters.getDataStoreName(); |
|
587 |
DataStoreProvider provider = null; |
|
588 |
boolean retry = true; |
|
589 |
while (retry){ |
|
590 |
try { |
|
591 |
provider = (DataStoreProvider) ToolsLocator |
|
592 |
.getExtensionPointManager().get(DATA_MANAGER_STORE).create( |
|
593 |
name, |
|
594 |
new Object[] { parameters, providerServices }); |
|
595 |
retry = false; |
|
596 |
} catch (Exception e) { |
|
597 |
if (openErrorHandler != null){ |
|
598 |
retry = openErrorHandler.canRetryOpen(e, parameters); |
|
599 |
} else { |
|
600 |
retry = false; |
|
601 |
} |
|
602 |
if (!retry){ |
|
603 |
throw new InitializeException(parameters.getDataStoreName(), e); |
|
604 |
} |
|
605 |
} |
|
606 |
} |
|
607 |
if (provider == null) { |
|
608 |
throw new ProviderNotRegisteredException(name); |
|
609 |
} |
|
610 |
return provider; |
|
635 |
|
|
636 |
public DataStoreProvider createProvider( |
|
637 |
DataStoreProviderServices providerServices, |
|
638 |
DataStoreParameters parameters) throws InitializeException, |
|
639 |
ProviderNotRegisteredException { |
|
640 |
String name = parameters.getDataStoreName(); |
|
641 |
DataStoreProvider provider = null; |
|
642 |
boolean retry = true; |
|
643 |
while (retry) { |
|
644 |
try { |
|
645 |
DataStoreProviderFactory providerFactory = (DataStoreProviderFactory) ToolsLocator |
|
646 |
.getExtensionPointManager() |
|
647 |
.get(DATA_MANAGER_STORE_PROVIDER_FACTORY).create(name); |
|
648 |
if( providerFactory!=null ) { |
|
649 |
provider = (DataStoreProvider) providerFactory.createProvider(parameters, providerServices); |
|
650 |
} else { |
|
651 |
provider = (DataStoreProvider) ToolsLocator |
|
652 |
.getExtensionPointManager() |
|
653 |
.get(DATA_MANAGER_STORE) |
|
654 |
.create(name, |
|
655 |
new Object[] { parameters, providerServices }); |
|
656 |
} |
|
657 |
retry = false; |
|
658 |
} catch (Exception e) { |
|
659 |
if (openErrorHandler != null) { |
|
660 |
retry = openErrorHandler.canRetryOpen(e, parameters); |
|
661 |
} else { |
|
662 |
retry = false; |
|
663 |
} |
|
664 |
if (!retry) { |
|
665 |
throw new InitializeException( |
|
666 |
parameters.getDataStoreName(), e); |
|
667 |
} |
|
668 |
} |
|
669 |
} |
|
670 |
if (provider == null) { |
|
671 |
throw new ProviderNotRegisteredException(name); |
|
672 |
} |
|
673 |
return provider; |
|
611 | 674 |
} |
612 | 675 |
|
613 | 676 |
public void registerFeatureCacheProvider( |
614 | 677 |
FeatureCacheProviderFactory providerFactory) { |
615 |
ToolsLocator.getExtensionPointManager().add(DATA_MANAGER_CACHE, |
|
616 |
DATA_MANAGER_CACHE_DESCRIPTION).append( |
|
617 |
providerFactory.getName(), "", |
|
618 |
providerFactory); |
|
678 |
ToolsLocator.getExtensionPointManager() |
|
679 |
.add(DATA_MANAGER_CACHE, DATA_MANAGER_CACHE_DESCRIPTION) |
|
680 |
.append(providerFactory.getName(), "", providerFactory); |
|
619 | 681 |
} |
620 | 682 |
|
621 |
public FeatureCacheProvider createFeatureCacheProvider(String name,
|
|
622 |
DynObject parameters) throws DataException {
|
|
683 |
public FeatureCacheProvider createFeatureCacheProvider(String name, |
|
684 |
DynObject parameters) throws DataException { |
|
623 | 685 |
if (name == null) { |
624 |
throw new InitializeException("It is necessary to provide a cache name", null); |
|
686 |
throw new InitializeException( |
|
687 |
"It is necessary to provide a cache name", null); |
|
625 | 688 |
} |
626 |
if (parameters == null){ |
|
627 |
throw new InitializeException("It is necessary to provide parameters to create the explorer", null); |
|
689 |
if (parameters == null) { |
|
690 |
throw new InitializeException( |
|
691 |
"It is necessary to provide parameters to create the explorer", |
|
692 |
null); |
|
628 | 693 |
} |
629 | 694 |
FeatureCacheProviderFactory featureCacheProviderFactory; |
630 | 695 |
try { |
631 | 696 |
featureCacheProviderFactory = (FeatureCacheProviderFactory) ToolsLocator |
632 |
.getExtensionPointManager().get(DATA_MANAGER_CACHE).create(name); |
|
697 |
.getExtensionPointManager().get(DATA_MANAGER_CACHE) |
|
698 |
.create(name); |
|
633 | 699 |
if (featureCacheProviderFactory == null) { |
634 | 700 |
throw new ProviderNotRegisteredException(name); |
635 | 701 |
} |
636 |
return featureCacheProviderFactory.createCacheProvider(parameters);
|
|
702 |
return featureCacheProviderFactory.createCacheProvider(parameters); |
|
637 | 703 |
} catch (InstantiationException e) { |
638 | 704 |
throw new InitializeException(e); |
639 | 705 |
} catch (IllegalAccessException e) { |
640 | 706 |
throw new InitializeException(e); |
641 |
}
|
|
707 |
} |
|
642 | 708 |
} |
643 | 709 |
|
644 |
public List getFeatureCacheProviders() { |
|
645 |
ExtensionPoint extensionPoint = ToolsLocator.getExtensionPointManager().get(DATA_MANAGER_CACHE); |
|
646 |
if (extensionPoint != null){ |
|
647 |
return ToolsLocator.getExtensionPointManager().get( |
|
648 |
DATA_MANAGER_CACHE).getNames(); |
|
649 |
}else{ |
|
650 |
return new ArrayList(); |
|
651 |
} |
|
652 |
} |
|
710 |
public List getFeatureCacheProviders() { |
|
711 |
ExtensionPoint extensionPoint = ToolsLocator.getExtensionPointManager() |
|
712 |
.get(DATA_MANAGER_CACHE); |
|
713 |
if (extensionPoint != null) { |
|
714 |
return ToolsLocator.getExtensionPointManager() |
|
715 |
.get(DATA_MANAGER_CACHE).getNames(); |
|
716 |
} else { |
|
717 |
return new ArrayList(); |
|
718 |
} |
|
719 |
} |
|
653 | 720 |
|
654 | 721 |
public DynObject createCacheParameters(String name) |
655 | 722 |
throws InitializeException, ProviderNotRegisteredException { |
656 | 723 |
if (name == null) { |
657 |
throw new InitializeException("It is necessary to provide a cache name", null); |
|
724 |
throw new InitializeException( |
|
725 |
"It is necessary to provide a cache name", null); |
|
658 | 726 |
} |
659 | 727 |
FeatureCacheProviderFactory featureCacheProviderFactory; |
660 | 728 |
try { |
661 | 729 |
featureCacheProviderFactory = (FeatureCacheProviderFactory) ToolsLocator |
662 |
.getExtensionPointManager().get(DATA_MANAGER_CACHE).create(name); |
|
730 |
.getExtensionPointManager().get(DATA_MANAGER_CACHE) |
|
731 |
.create(name); |
|
663 | 732 |
if (featureCacheProviderFactory == null) { |
664 | 733 |
throw new ProviderNotRegisteredException(name); |
665 | 734 |
} |
666 |
return featureCacheProviderFactory.createParameters();
|
|
735 |
return featureCacheProviderFactory.createParameters(); |
|
667 | 736 |
} catch (InstantiationException e) { |
668 | 737 |
throw new InitializeException(e); |
669 | 738 |
} catch (IllegalAccessException e) { |
670 | 739 |
throw new InitializeException(e); |
671 |
}
|
|
740 |
} |
|
672 | 741 |
} |
673 | 742 |
|
674 | 743 |
public DataStoreParameters createMemoryStoreParameters( |
675 | 744 |
String autoOrderAttributeName) throws InitializeException { |
676 |
|
|
745 |
|
|
677 | 746 |
DataStoreParameters parameters; |
678 | 747 |
try { |
679 | 748 |
parameters = createStoreParameters(MemoryStoreProvider.NAME); |
... | ... | |
702 | 771 |
} |
703 | 772 |
|
704 | 773 |
public FeaturePagingHelper createFeaturePagingHelper( |
705 |
FeatureStore featureStore, int pageSize) throws BaseException {
|
|
774 |
FeatureStore featureStore, int pageSize) throws BaseException {
|
|
706 | 775 |
return new FeaturePagingHelperImpl(featureStore, pageSize); |
707 | 776 |
} |
708 | 777 |
|
709 | 778 |
public FeaturePagingHelper createFeaturePagingHelper( |
710 | 779 |
FeatureStore featureStore, FeatureQuery featureQuery, int pageSize) |
711 |
throws BaseException {
|
|
780 |
throws BaseException {
|
|
712 | 781 |
return new FeaturePagingHelperImpl(featureStore, featureQuery, pageSize); |
713 | 782 |
} |
714 | 783 |
|
715 | 784 |
public void setOpenErrorHandler(OpenErrorHandler handler) { |
716 | 785 |
openErrorHandler = handler; |
717 |
|
|
786 |
|
|
718 | 787 |
} |
719 | 788 |
|
720 | 789 |
} |
Also available in: Unified diff