1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19 package org.apache.openjpa.conf;
20
21 import java.util.Collection;
22 import java.util.HashSet;
23 import java.util.Map;
24
25 import org.apache.commons.lang.StringUtils;
26 import org.apache.openjpa.datacache.ConcurrentDataCache;
27 import org.apache.openjpa.datacache.ConcurrentQueryCache;
28 import org.apache.openjpa.datacache.DataCacheManager;
29 import org.apache.openjpa.datacache.DataCacheManagerImpl;
30 import org.apache.openjpa.ee.ManagedRuntime;
31 import org.apache.openjpa.event.OrphanedKeyAction;
32 import org.apache.openjpa.event.RemoteCommitEventManager;
33 import org.apache.openjpa.event.RemoteCommitProvider;
34 import org.apache.openjpa.event.BrokerFactoryEventManager;
35 import org.apache.openjpa.kernel.AutoClear;
36 import org.apache.openjpa.kernel.BrokerImpl;
37 import org.apache.openjpa.kernel.ConnectionRetainModes;
38 import org.apache.openjpa.kernel.InverseManager;
39 import org.apache.openjpa.kernel.LockLevels;
40 import org.apache.openjpa.kernel.LockManager;
41 import org.apache.openjpa.kernel.QueryFlushModes;
42 import org.apache.openjpa.kernel.RestoreState;
43 import org.apache.openjpa.kernel.SavepointManager;
44 import org.apache.openjpa.kernel.Seq;
45 import org.apache.openjpa.kernel.exps.AggregateListener;
46 import org.apache.openjpa.kernel.exps.FilterListener;
47 import org.apache.openjpa.lib.conf;
48 import org.apache.openjpa.lib.log.Log;
49 import org.apache.openjpa.lib.util.Localizer;
50 import org.apache.openjpa.meta.MetaDataFactory;
51 import org.apache.openjpa.meta.MetaDataRepository;
52 import org.apache.openjpa.util.ClassResolver;
53 import org.apache.openjpa.util.ImplHelper;
54 import org.apache.openjpa.util.ProxyManager;
55 import org.apache.openjpa.util.StoreFacadeTypeRegistry;
56 import org.apache.openjpa.enhance.RuntimeUnenhancedClasssesModes;
57
58 /**
59 * Implementation of the {@link OpenJPAConfiguration} interface.
60 *
61 * @see ConfigurationImpl
62 * @author Marc Prud'hommeaux
63 * @author Abe White
64 */
65 public class OpenJPAConfigurationImpl
66 extends ConfigurationImpl
67 implements OpenJPAConfiguration {
68
69 private static final Localizer _loc =
70 Localizer.forPackage(OpenJPAConfigurationImpl.class);
71
72 // cached state; some of this is created in getter methods, so make
73 // protected in case subclasses want to access without creating
74 protected MetaDataRepository metaRepository = null;
75 protected RemoteCommitEventManager remoteEventManager = null;
76
77 // openjpa properties
78 public ObjectValue classResolverPlugin;
79 public BrokerValue brokerPlugin;
80 public ObjectValue dataCachePlugin;
81 public ObjectValue dataCacheManagerPlugin;
82 public IntValue dataCacheTimeout;
83 public ObjectValue queryCachePlugin;
84 public BooleanValue dynamicDataStructs;
85 public ObjectValue managedRuntimePlugin;
86 public BooleanValue transactionMode;
87 public IntValue connectionRetainMode;
88 public IntValue fetchBatchSize;
89 public IntValue maxFetchDepth;
90 public StringListValue fetchGroups;
91 public IntValue flushBeforeQueries;
92 public IntValue lockTimeout;
93 public IntValue readLockLevel;
94 public IntValue writeLockLevel;
95 public ObjectValue seqPlugin;
96 public PluginListValue filterListenerPlugins;
97 public PluginListValue aggregateListenerPlugins;
98 public BooleanValue retryClassRegistration;
99 public ObjectValue proxyManagerPlugin;
100 public StringValue connectionUserName;
101 public StringValue connectionPassword;
102 public StringValue connectionURL;
103 public StringValue connectionDriverName;
104 public ObjectValue connectionFactory;
105 public StringValue connectionFactoryName;
106 public StringValue connectionProperties;
107 public StringValue connectionFactoryProperties;
108 public BooleanValue connectionFactoryMode;
109 public StringValue connection2UserName;
110 public StringValue connection2Password;
111 public StringValue connection2URL;
112 public StringValue connection2DriverName;
113 public StringValue connection2Properties;
114 public ObjectValue connectionFactory2;
115 public StringValue connectionFactory2Name;
116 public StringValue connectionFactory2Properties;
117 public BooleanValue optimistic;
118 public IntValue autoClear;
119 public BooleanValue retainState;
120 public IntValue restoreState;
121 public ObjectValue detachStatePlugin;
122 public BooleanValue ignoreChanges;
123 public BooleanValue nontransactionalRead;
124 public BooleanValue nontransactionalWrite;
125 public BooleanValue multithreaded;
126 public StringValue mapping;
127 public PluginValue metaFactoryPlugin;
128 public ObjectValue metaRepositoryPlugin;
129 public ObjectValue lockManagerPlugin;
130 public ObjectValue inverseManagerPlugin;
131 public ObjectValue savepointManagerPlugin;
132 public ObjectValue orphanedKeyPlugin;
133 public ObjectValue compatibilityPlugin;
134 public QueryCompilationCacheValue queryCompilationCachePlugin;
135 public IntValue runtimeUnenhancedClasses;
136 public CacheMarshallersValue cacheMarshallerPlugins;
137
138 // custom values
139 public BrokerFactoryValue brokerFactoryPlugin;
140 public RemoteCommitProviderValue remoteProviderPlugin;
141 public AutoDetachValue autoDetach;
142
143 private Collection supportedOptions = new HashSet(33);
144 private String spec = null;
145 private final StoreFacadeTypeRegistry _storeFacadeRegistry =
146 new StoreFacadeTypeRegistry();
147 private BrokerFactoryEventManager _brokerFactoryEventManager =
148 new BrokerFactoryEventManager(this);
149
150 /**
151 * Default constructor. Attempts to load global properties.
152 */
153 public OpenJPAConfigurationImpl() {
154 this(true);
155 }
156
157 /**
158 * Constructor.
159 *
160 * @param loadGlobals whether to attempt to load the global properties
161 */
162 public OpenJPAConfigurationImpl(boolean loadGlobals) {
163 this(true, loadGlobals);
164 }
165
166 /**
167 * Constructor.
168 *
169 * @param derivations whether to apply product derivations
170 * @param loadGlobals whether to attempt to load the global properties
171 */
172 public OpenJPAConfigurationImpl(boolean derivations, boolean loadGlobals) {
173 super(false);
174 String[] aliases;
175
176 classResolverPlugin = addPlugin("ClassResolver", true);
177 aliases =
178 new String[] { "default",
179 "org.apache.openjpa.util.ClassResolverImpl",
180 // deprecated alias
181 "spec", "org.apache.openjpa.util.ClassResolverImpl", };
182 classResolverPlugin.setAliases(aliases);
183 classResolverPlugin.setDefault(aliases[0]);
184 classResolverPlugin.setString(aliases[0]);
185 classResolverPlugin.setInstantiatingGetter("getClassResolverInstance");
186
187 brokerFactoryPlugin = new BrokerFactoryValue();
188 addValue(brokerFactoryPlugin);
189
190 brokerPlugin = new BrokerValue();
191 addValue(brokerPlugin);
192
193 dataCacheManagerPlugin = addPlugin("DataCacheManager", true);
194 aliases =
195 new String[] { "default", DataCacheManagerImpl.class.getName(), };
196 dataCacheManagerPlugin.setAliases(aliases);
197 dataCacheManagerPlugin.setDefault(aliases[0]);
198 dataCacheManagerPlugin.setString(aliases[0]);
199 dataCacheManagerPlugin.setInstantiatingGetter("getDataCacheManager");
200
201 dataCachePlugin = addPlugin("DataCache", false);
202 aliases = new String[] {
203 "false", null,
204 "true", ConcurrentDataCache.class.getName(),
205 "concurrent", ConcurrentDataCache.class.getName(),
206 };
207 dataCachePlugin.setAliases(aliases);
208 dataCachePlugin.setDefault(aliases[0]);
209 dataCachePlugin.setString(aliases[0]);
210
211 dataCacheTimeout = addInt("DataCacheTimeout");
212 dataCacheTimeout.setDefault("-1");
213 dataCacheTimeout.set(-1);
214 dataCacheTimeout.setDynamic(true);
215
216 queryCachePlugin = addPlugin("QueryCache", true);
217 aliases = new String[] {
218 "true", ConcurrentQueryCache.class.getName(),
219 "concurrent", ConcurrentQueryCache.class.getName(),
220 "false", null,
221 };
222 queryCachePlugin.setAliases(aliases);
223 queryCachePlugin.setDefault(aliases[0]);
224 queryCachePlugin.setString(aliases[0]);
225
226 dynamicDataStructs = addBoolean("DynamicDataStructs");
227 dynamicDataStructs.setDefault("false");
228 dynamicDataStructs.set(false);
229
230 lockManagerPlugin = addPlugin("LockManager", false);
231 aliases =
232 new String[] { "none", "org.apache.openjpa.kernel.NoneLockManager",
233 "version", "org.apache.openjpa.kernel.VersionLockManager", };
234 lockManagerPlugin.setAliases(aliases);
235 lockManagerPlugin.setDefault(aliases[0]);
236 lockManagerPlugin.setString(aliases[0]);
237
238 inverseManagerPlugin = addPlugin("InverseManager", false);
239 aliases =
240 new String[] { "false", null, "true",
241 "org.apache.openjpa.kernel.InverseManager", };
242 inverseManagerPlugin.setAliases(aliases);
243 inverseManagerPlugin.setDefault(aliases[0]);
244 inverseManagerPlugin.setString(aliases[0]);
245
246 savepointManagerPlugin = addPlugin("SavepointManager", true);
247 aliases =
248 new String[] { "in-mem",
249 "org.apache.openjpa.kernel.InMemorySavepointManager", };
250 savepointManagerPlugin.setAliases(aliases);
251 savepointManagerPlugin.setDefault(aliases[0]);
252 savepointManagerPlugin.setString(aliases[0]);
253 savepointManagerPlugin
254 .setInstantiatingGetter("getSavepointManagerInstance");
255
256 orphanedKeyPlugin = addPlugin("OrphanedKeyAction", true);
257 aliases =
258 new String[] { "log",
259 "org.apache.openjpa.event.LogOrphanedKeyAction", "exception",
260 "org.apache.openjpa.event.ExceptionOrphanedKeyAction", "none",
261 "org.apache.openjpa.event.NoneOrphanedKeyAction", };
262 orphanedKeyPlugin.setAliases(aliases);
263 orphanedKeyPlugin.setDefault(aliases[0]);
264 orphanedKeyPlugin.setString(aliases[0]);
265 orphanedKeyPlugin
266 .setInstantiatingGetter("getOrphanedKeyActionInstance");
267
268 remoteProviderPlugin = new RemoteCommitProviderValue();
269 addValue(remoteProviderPlugin);
270
271 transactionMode = addBoolean("TransactionMode");
272 aliases = new String[] { "local", "false", "managed", "true", };
273 transactionMode.setAliases(aliases);
274 transactionMode.setDefault(aliases[0]);
275
276 managedRuntimePlugin = addPlugin("ManagedRuntime", true);
277 aliases =
278 new String[] { "auto",
279 "org.apache.openjpa.ee.AutomaticManagedRuntime", "jndi",
280 "org.apache.openjpa.ee.JNDIManagedRuntime", "invocation",
281 "org.apache.openjpa.ee.InvocationManagedRuntime", };
282 managedRuntimePlugin.setAliases(aliases);
283 managedRuntimePlugin.setDefault(aliases[0]);
284 managedRuntimePlugin.setString(aliases[0]);
285 managedRuntimePlugin
286 .setInstantiatingGetter("getManagedRuntimeInstance");
287
288 proxyManagerPlugin = addPlugin("ProxyManager", true);
289 aliases =
290 new String[] { "default",
291 "org.apache.openjpa.util.ProxyManagerImpl" };
292 proxyManagerPlugin.setAliases(aliases);
293 proxyManagerPlugin.setDefault(aliases[0]);
294 proxyManagerPlugin.setString(aliases[0]);
295 proxyManagerPlugin.setInstantiatingGetter("getProxyManagerInstance");
296
297 mapping = addString("Mapping");
298 metaFactoryPlugin = addPlugin("MetaDataFactory", false);
299
300 metaRepositoryPlugin = (ObjectValue)
301 addValue(new MetaDataRepositoryValue());
302
303 connectionFactory = addObject("ConnectionFactory");
304 connectionFactory.setInstantiatingGetter("getConnectionFactory");
305
306 connectionFactory2 = addObject("ConnectionFactory2");
307 connectionFactory2.setInstantiatingGetter("getConnectionFactory2");
308 // This is done because this plug-in may get initialized very lazily
309 // when the runtime needs it for flush or a sequence. To keep it
310 // dynamic allows it to be set even when the configuration is frozen
311 connectionFactory.setDynamic(true);
312 connectionFactory2.setDynamic(true);
313
314
315 connectionUserName = addString("ConnectionUserName");
316 connectionPassword = addString("ConnectionPassword");
317 connectionURL = addString("ConnectionURL");
318 connectionDriverName = addString("ConnectionDriverName");
319 connectionFactoryName = addString("ConnectionFactoryName");
320 connectionProperties = addString("ConnectionProperties");
321 connectionFactoryProperties = addString("ConnectionFactoryProperties");
322 connection2UserName = addString("Connection2UserName");
323 connection2Password = addString("Connection2Password");
324 connection2URL = addString("Connection2URL");
325 connection2DriverName = addString("Connection2DriverName");
326 connection2Properties = addString("Connection2Properties");
327 connectionFactory2Properties =
328 addString("ConnectionFactory2Properties");
329 connectionFactory2Name = addString("ConnectionFactory2Name");
330
331 connectionFactoryMode = addBoolean("ConnectionFactoryMode");
332 aliases = new String[] { "local", "false", "managed", "true", };
333 connectionFactoryMode.setAliases(aliases);
334 connectionFactoryMode.setDefault(aliases[0]);
335
336 optimistic = addBoolean("Optimistic");
337 optimistic.setDefault("true");
338 optimistic.set(true);
339
340 autoClear = addInt("AutoClear");
341 aliases =
342 new String[] { "datastore",
343 String.valueOf(AutoClear.CLEAR_DATASTORE), "all",
344 String.valueOf(AutoClear.CLEAR_ALL), };
345 autoClear.setAliases(aliases);
346 autoClear.setDefault(aliases[0]);
347 autoClear.set(AutoClear.CLEAR_DATASTORE);
348 autoClear.setAliasListComprehensive(true);
349
350 retainState = addBoolean("RetainState");
351 retainState.setDefault("true");
352 retainState.set(true);
353
354 restoreState = addInt("RestoreState");
355 aliases =
356 new String[] { "none", String.valueOf(RestoreState.RESTORE_NONE),
357 "false", String.valueOf(RestoreState.RESTORE_NONE),
358 "immutable", String.valueOf(RestoreState.RESTORE_IMMUTABLE),
359 // "true" for compat with jdo RestoreValues
360 "true", String.valueOf(RestoreState.RESTORE_IMMUTABLE), "all",
361 String.valueOf(RestoreState.RESTORE_ALL), };
362 restoreState.setAliases(aliases);
363 restoreState.setDefault(aliases[0]);
364 restoreState.set(RestoreState.RESTORE_IMMUTABLE);
365 restoreState.setAliasListComprehensive(true);
366
367 autoDetach = new AutoDetachValue();
368 addValue(autoDetach);
369
370 detachStatePlugin = addPlugin("DetachState", true);
371 aliases = new String[] {
372 "loaded", DetachOptions.Loaded.class.getName(),
373 "fgs", DetachOptions.FetchGroups.class.getName(),
374 "fetch-groups", DetachOptions.FetchGroups.class.getName(),
375 "all", DetachOptions.All.class.getName(),
376 };
377 detachStatePlugin.setAliases(aliases);
378 detachStatePlugin.setDefault(aliases[0]);
379 detachStatePlugin.setString(aliases[0]);
380 detachStatePlugin.setInstantiatingGetter("getDetachStateInstance");
381
382 ignoreChanges = addBoolean("IgnoreChanges");
383
384 nontransactionalRead = addBoolean("NontransactionalRead");
385 nontransactionalRead.setDefault("true");
386 nontransactionalRead.set(true);
387
388 nontransactionalWrite = addBoolean("NontransactionalWrite");
389 multithreaded = addBoolean("Multithreaded");
390
391 fetchBatchSize = addInt("FetchBatchSize");
392 fetchBatchSize.setDefault("-1");
393 fetchBatchSize.set(-1);
394 fetchBatchSize.setDynamic(true);
395
396 maxFetchDepth = addInt("MaxFetchDepth");
397 maxFetchDepth.setDefault("-1");
398 maxFetchDepth.set(-1);
399
400 fetchGroups = addStringList("FetchGroups");
401 fetchGroups.setDefault("default");
402 fetchGroups.set(new String[] { "default" });
403
404 flushBeforeQueries = addInt("FlushBeforeQueries");
405 aliases =
406 new String[] { "true", String.valueOf(QueryFlushModes.FLUSH_TRUE),
407 "false", String.valueOf(QueryFlushModes.FLUSH_FALSE),
408 "with-connection",
409 String.valueOf(QueryFlushModes.FLUSH_WITH_CONNECTION), };
410 flushBeforeQueries.setAliases(aliases);
411 flushBeforeQueries.setDefault(aliases[0]);
412 flushBeforeQueries.set(QueryFlushModes.FLUSH_TRUE);
413 flushBeforeQueries.setAliasListComprehensive(true);
414
415 lockTimeout = addInt("LockTimeout");
416 lockTimeout.setDefault("-1");
417 lockTimeout.set(-1);
418 lockTimeout.setDynamic(true);
419
420 readLockLevel = addInt("ReadLockLevel");
421 aliases =
422 new String[] {
423 "read", String.valueOf(LockLevels.LOCK_READ),
424 "write", String.valueOf(LockLevels.LOCK_WRITE),
425 "none", String.valueOf(LockLevels.LOCK_NONE),
426 };
427 readLockLevel.setAliases(aliases);
428 readLockLevel.setDefault(aliases[0]);
429 readLockLevel.set(LockLevels.LOCK_READ);
430 readLockLevel.setAliasListComprehensive(true);
431
432 writeLockLevel = addInt("WriteLockLevel");
433 aliases =
434 new String[] {
435 "read", String.valueOf(LockLevels.LOCK_READ),
436 "write", String.valueOf(LockLevels.LOCK_WRITE),
437 "none", String.valueOf(LockLevels.LOCK_NONE),
438 };
439 writeLockLevel.setAliases(aliases);
440 writeLockLevel.setDefault(aliases[1]);
441 writeLockLevel.set(LockLevels.LOCK_WRITE);
442 writeLockLevel.setAliasListComprehensive(true);
443
444 seqPlugin = new SeqValue("Sequence");
445 seqPlugin.setInstantiatingGetter("getSequenceInstance");
446 addValue(seqPlugin);
447
448 connectionRetainMode = addInt("ConnectionRetainMode");
449 aliases =
450 new String[] {
451 "on-demand",
452 String.valueOf(ConnectionRetainModes.CONN_RETAIN_DEMAND),
453 "transaction",
454 String.valueOf(ConnectionRetainModes.CONN_RETAIN_TRANS),
455 "always",
456 String.valueOf(ConnectionRetainModes.CONN_RETAIN_ALWAYS),
457 // deprecated
458 "persistence-manager",
459 String.valueOf(ConnectionRetainModes.CONN_RETAIN_ALWAYS),
460 };
461 connectionRetainMode.setAliases(aliases);
462 connectionRetainMode.setDefault(aliases[0]);
463 connectionRetainMode.setAliasListComprehensive(true);
464 connectionRetainMode.set(ConnectionRetainModes.CONN_RETAIN_DEMAND);
465
466 filterListenerPlugins = addPluginList("FilterListeners");
467 filterListenerPlugins
468 .setInstantiatingGetter("getFilterListenerInstances");
469
470 aggregateListenerPlugins = addPluginList("AggregateListeners");
471 aggregateListenerPlugins
472 .setInstantiatingGetter("getAggregateListenerInstances");
473
474 retryClassRegistration = addBoolean("RetryClassRegistration");
475
476 compatibilityPlugin = addPlugin("Compatibility", true);
477 aliases = new String[] { "default", Compatibility.class.getName() };
478 compatibilityPlugin.setAliases(aliases);
479 compatibilityPlugin.setDefault(aliases[0]);
480 compatibilityPlugin.setString(aliases[0]);
481 compatibilityPlugin.setInstantiatingGetter("getCompatibilityInstance");
482
483 queryCompilationCachePlugin = new QueryCompilationCacheValue(
484 "QueryCompilationCache");
485 queryCompilationCachePlugin.setInstantiatingGetter(
486 "getQueryCompilationCacheInstance");
487 addValue(queryCompilationCachePlugin);
488
489 runtimeUnenhancedClasses = addInt("RuntimeUnenhancedClasses");
490 runtimeUnenhancedClasses.setAliases(new String[] {
491 "supported", String.valueOf(
492 RuntimeUnenhancedClasssesModes.SUPPORTED),
493 "unsupported", String.valueOf(
494 RuntimeUnenhancedClasssesModes.UNSUPPORTED),
495 "warn", String.valueOf(
496 RuntimeUnenhancedClasssesModes.WARN),
497 });
498 runtimeUnenhancedClasses.setDefault("supported");
499 runtimeUnenhancedClasses.setString("supported");
500 runtimeUnenhancedClasses.setAliasListComprehensive(true);
501
502 cacheMarshallerPlugins = (CacheMarshallersValue)
503 addValue(new CacheMarshallersValue(this));
504
505 // initialize supported options that some runtimes may not support
506 supportedOptions.add(OPTION_NONTRANS_READ);
507 supportedOptions.add(OPTION_OPTIMISTIC);
508 supportedOptions.add(OPTION_ID_APPLICATION);
509 supportedOptions.add(OPTION_ID_DATASTORE);
510 supportedOptions.add(OPTION_TYPE_COLLECTION);
511 supportedOptions.add(OPTION_TYPE_MAP);
512 supportedOptions.add(OPTION_TYPE_ARRAY);
513 supportedOptions.add(OPTION_NULL_CONTAINER);
514 supportedOptions.add(OPTION_EMBEDDED_RELATION);
515 supportedOptions.add(OPTION_EMBEDDED_COLLECTION_RELATION);
516 supportedOptions.add(OPTION_EMBEDDED_MAP_RELATION);
517 supportedOptions.add(OPTION_INC_FLUSH);
518 supportedOptions.add(OPTION_VALUE_AUTOASSIGN);
519 supportedOptions.add(OPTION_VALUE_INCREMENT);
520 supportedOptions.add(OPTION_DATASTORE_CONNECTION);
521
522 if (derivations)
523 ProductDerivations.beforeConfigurationLoad(this);
524 if (loadGlobals)
525 loadGlobals();
526 }
527
528 public Collection supportedOptions() {
529 return supportedOptions;
530 }
531
532 public String getSpecification() {
533 return spec;
534 }
535
536 public boolean setSpecification(String spec) {
537 if (spec == null)
538 return false;
539
540 if (this.spec != null) {
541 if (!this.spec.equals(spec)
542 && getConfigurationLog().isWarnEnabled())
543 getConfigurationLog().warn(
544 _loc.get("diff-specs", this.spec, spec));
545 return false;
546 }
547 this.spec = spec;
548 ProductDerivations.afterSpecificationSet(this);
549 return true;
550 }
551
552 public void setClassResolver(String classResolver) {
553 classResolverPlugin.setString(classResolver);
554 }
555
556 public String getClassResolver() {
557 return classResolverPlugin.getString();
558 }
559
560 public void setClassResolver(ClassResolver classResolver) {
561 classResolverPlugin.set(classResolver);
562 }
563
564 public ClassResolver getClassResolverInstance() {
565 if (classResolverPlugin.get() == null)
566 classResolverPlugin.instantiate(ClassResolver.class, this);
567 return (ClassResolver) classResolverPlugin.get();
568 }
569
570 public void setBrokerFactory(String factory) {
571 brokerFactoryPlugin.setString(factory);
572 }
573
574 public String getBrokerFactory() {
575 return brokerFactoryPlugin.getString();
576 }
577
578 public void setBrokerImpl(String broker) {
579 brokerPlugin.setString(broker);
580 }
581
582 public String getBrokerImpl() {
583 return brokerPlugin.getString();
584 }
585
586 public BrokerImpl newBrokerInstance(String user, String pass) {
587 BrokerImpl broker =
588 (BrokerImpl) brokerPlugin.instantiate(BrokerImpl.class, this);
589 if (broker != null)
590 broker.setAuthentication(user, pass);
591 return broker;
592 }
593
594 public void setDataCacheManager(String mgr) {
595 dataCacheManagerPlugin.setString(mgr);
596 }
597
598 public String getDataCacheManager() {
599 return dataCacheManagerPlugin.getString();
600 }
601
602 public void setDataCacheManager(DataCacheManager dcm) {
603 if (dcm != null)
604 dcm.initialize(this, dataCachePlugin, queryCachePlugin);
605 dataCacheManagerPlugin.set(dcm);
606 }
607
608 public DataCacheManager getDataCacheManagerInstance() {
609 DataCacheManager dcm = (DataCacheManager) dataCacheManagerPlugin.get();
610 if (dcm == null) {
611 dcm =
612 (DataCacheManager) dataCacheManagerPlugin.instantiate(
613 DataCacheManager.class, this);
614 dcm.initialize(this, dataCachePlugin, queryCachePlugin);
615 }
616 return dcm;
617 }
618
619 public void setDataCache(String dataCache) {
620 dataCachePlugin.setString(dataCache);
621 }
622
623 public String getDataCache() {
624 return dataCachePlugin.getString();
625 }
626
627 public void setDataCacheTimeout(int dataCacheTimeout) {
628 this.dataCacheTimeout.set(dataCacheTimeout);
629 }
630
631 public void setDataCacheTimeout(Integer dataCacheTimeout) {
632 if (dataCacheTimeout != null)
633 setDataCacheTimeout(dataCacheTimeout.intValue());
634 }
635
636 public int getDataCacheTimeout() {
637 return dataCacheTimeout.get();
638 }
639
640 public void setQueryCache(String queryCache) {
641 queryCachePlugin.setString(queryCache);
642 }
643
644 public String getQueryCache() {
645 return queryCachePlugin.getString();
646 }
647
648 public boolean getDynamicDataStructs() {
649 return dynamicDataStructs.get();
650 }
651
652 public void setDynamicDataStructs(boolean dynamic) {
653 dynamicDataStructs.set(dynamic);
654 }
655
656 public void setDynamicDataStructs(Boolean dynamic) {
657 setDynamicDataStructs(dynamic.booleanValue());
658 }
659
660 public void setLockManager(String lockManager) {
661 lockManagerPlugin.setString(lockManager);
662 }
663
664 public String getLockManager() {
665 return lockManagerPlugin.getString();
666 }
667
668 public LockManager newLockManagerInstance() {
669 // don't validate plugin properties on instantiation because it
670 // is likely that back ends will override defaults with their
671 // own subclasses with new properties
672 return (LockManager) lockManagerPlugin.instantiate(LockManager.class,
673 this, false);
674 }
675
676 public void setInverseManager(String inverseManager) {
677 inverseManagerPlugin.setString(inverseManager);
678 }
679
680 public String getInverseManager() {
681 return inverseManagerPlugin.getString();
682 }
683
684 public InverseManager newInverseManagerInstance() {
685 return (InverseManager) inverseManagerPlugin.instantiate(
686 InverseManager.class, this);
687 }
688
689 public void setSavepointManager(String savepointManager) {
690 savepointManagerPlugin.setString(savepointManager);
691 }
692
693 public String getSavepointManager() {
694 return savepointManagerPlugin.getString();
695 }
696
697 public SavepointManager getSavepointManagerInstance() {
698 if (savepointManagerPlugin.get() == null)
699 savepointManagerPlugin.instantiate(SavepointManager.class, this);
700 return (SavepointManager) savepointManagerPlugin.get();
701 }
702
703 public void setOrphanedKeyAction(String action) {
704 orphanedKeyPlugin.setString(action);
705 }
706
707 public String getOrphanedKeyAction() {
708 return orphanedKeyPlugin.getString();
709 }
710
711 public OrphanedKeyAction getOrphanedKeyActionInstance() {
712 if (orphanedKeyPlugin.get() == null)
713 orphanedKeyPlugin.instantiate(OrphanedKeyAction.class, this);
714 return (OrphanedKeyAction) orphanedKeyPlugin.get();
715 }
716
717 public void setOrphanedKeyAction(OrphanedKeyAction action) {
718 orphanedKeyPlugin.set(action);
719 }
720
721 public void setRemoteCommitProvider(String remoteCommitProvider) {
722 remoteProviderPlugin.setString(remoteCommitProvider);
723 }
724
725 public String getRemoteCommitProvider() {
726 return remoteProviderPlugin.getString();
727 }
728
729 public RemoteCommitProvider newRemoteCommitProviderInstance() {
730 return remoteProviderPlugin.instantiateProvider(this);
731 }
732
733 public void setRemoteCommitEventManager(
734 RemoteCommitEventManager remoteEventManager) {
735 this.remoteEventManager = remoteEventManager;
736 remoteProviderPlugin.configureEventManager(remoteEventManager);
737 }
738
739 public RemoteCommitEventManager getRemoteCommitEventManager() {
740 if (remoteEventManager == null) {
741 remoteEventManager = new RemoteCommitEventManager(this);
742 remoteProviderPlugin.configureEventManager(remoteEventManager);
743 }
744 return remoteEventManager;
745 }
746
747 public void setTransactionMode(String transactionMode) {
748 this.transactionMode.setString(transactionMode);
749 }
750
751 public String getTransactionMode() {
752 return transactionMode.getString();
753 }
754
755 public void setTransactionModeManaged(boolean managed) {
756 transactionMode.set(managed);
757 }
758
759 public boolean isTransactionModeManaged() {
760 return transactionMode.get();
761 }
762
763 public void setManagedRuntime(String managedRuntime) {
764 managedRuntimePlugin.setString(managedRuntime);
765 }
766
767 public String getManagedRuntime() {
768 return managedRuntimePlugin.getString();
769 }
770
771 public void setManagedRuntime(ManagedRuntime managedRuntime) {
772 managedRuntimePlugin.set(managedRuntime);
773 }
774
775 public ManagedRuntime getManagedRuntimeInstance() {
776 if (managedRuntimePlugin.get() == null)
777 managedRuntimePlugin.instantiate(ManagedRuntime.class, this);
778 return (ManagedRuntime) managedRuntimePlugin.get();
779 }
780
781 public void setProxyManager(String proxyManager) {
782 proxyManagerPlugin.setString(proxyManager);
783 }
784
785 public String getProxyManager() {
786 return proxyManagerPlugin.getString();
787 }
788
789 public void setProxyManager(ProxyManager proxyManager) {
790 proxyManagerPlugin.set(proxyManager);
791 }
792
793 public ProxyManager getProxyManagerInstance() {
794 if (proxyManagerPlugin.get() == null)
795 proxyManagerPlugin.instantiate(ProxyManager.class, this);
796 return (ProxyManager) proxyManagerPlugin.get();
797 }
798
799 public void setMapping(String mapping) {
800 this.mapping.setString(mapping);
801 }
802
803 public String getMapping() {
804 return mapping.getString();
805 }
806
807 public void setMetaDataFactory(String meta) {
808 this.metaFactoryPlugin.setString(meta);
809 }
810
811 public String getMetaDataFactory() {
812 return metaFactoryPlugin.getString();
813 }
814
815 public MetaDataFactory newMetaDataFactoryInstance() {
816 return (MetaDataFactory) metaFactoryPlugin.instantiate(
817 MetaDataFactory.class, this);
818 }
819
820 public void setMetaDataRepository(String meta) {
821 this.metaRepositoryPlugin.setString(meta);
822 }
823
824 public String getMetaDataRepository() {
825 return metaRepositoryPlugin.getString();
826 }
827
828 public void setMetaDataRepository(MetaDataRepository meta) {
829 metaRepository = meta;
830 }
831
832 public MetaDataRepository getMetaDataRepositoryInstance() {
833 if (metaRepository == null)
834 metaRepository = newMetaDataRepositoryInstance();
835 return metaRepository;
836 }
837
838 public boolean metaDataRepositoryAvailable(){
839 return metaRepository != null;
840 }
841
842 public MetaDataRepository newMetaDataRepositoryInstance() {
843 return (MetaDataRepository) metaRepositoryPlugin.instantiate(
844 MetaDataRepository.class, this);
845 }
846
847 public void setConnectionUserName(String connectionUserName) {
848 this.connectionUserName.setString(connectionUserName);
849 }
850
851 public String getConnectionUserName() {
852 return connectionUserName.getString();
853 }
854
855 public void setConnectionPassword(String connectionPassword) {
856 this.connectionPassword.setString(connectionPassword);
857 }
858
859 public String getConnectionPassword() {
860 return connectionPassword.getString();
861 }
862
863 public void setConnectionURL(String connectionURL) {
864 this.connectionURL.setString(connectionURL);
865 }
866
867 public String getConnectionURL() {
868 return connectionURL.getString();
869 }
870
871 public void setConnectionDriverName(String driverName) {
872 this.connectionDriverName.setString(driverName);
873 }
874
875 public String getConnectionDriverName() {
876 return connectionDriverName.getString();
877 }
878
879 public void setConnectionProperties(String connectionProperties) {
880 this.connectionProperties.setString(connectionProperties);
881 }
882
883 public String getConnectionProperties() {
884 return connectionProperties.getString();
885 }
886
887 public void setConnectionFactoryProperties(
888 String connectionFactoryProperties) {
889 this.connectionFactoryProperties.setString(connectionFactoryProperties);
890 }
891
892 public String getConnectionFactoryProperties() {
893 return connectionFactoryProperties.getString();
894 }
895
896 public String getConnectionFactoryMode() {
897 return connectionFactoryMode.getString();
898 }
899
900 public void setConnectionFactoryMode(String mode) {
901 connectionFactoryMode.setString(mode);
902 }
903
904 public boolean isConnectionFactoryModeManaged() {
905 return connectionFactoryMode.get();
906 }
907
908 public void setConnectionFactoryModeManaged(boolean managed) {
909 connectionFactoryMode.set(managed);
910 }
911
912 public void setConnectionFactoryName(String connectionFactoryName) {
913 this.connectionFactoryName.setString(connectionFactoryName);
914 }
915
916 public String getConnectionFactoryName() {
917 return connectionFactoryName.getString();
918 }
919
920 public void setConnectionFactory(Object factory) {
921 connectionFactory.set(factory);
922 }
923
924 public Object getConnectionFactory() {
925 if (connectionFactory.get() == null)
926 connectionFactory.set(
927 lookupConnectionFactory(getConnectionFactoryName()), true);
928 return connectionFactory.get();
929 }
930
931 /**
932 * Lookup the connection factory at the given name.
933 */
934 private Object lookupConnectionFactory(String name) {
935 name = StringUtils.trimToNull(name);
936 if (name == null)
937 return null;
938 try {
939 return Configurations.lookup(name);
940 } catch (Exception ex) {
941 return null;
942 }
943 }
944
945 public void setConnection2UserName(String connection2UserName) {
946 this.connection2UserName.setString(connection2UserName);
947 }
948
949 public String getConnection2UserName() {
950 return connection2UserName.getString();
951 }
952
953 public void setConnection2Password(String connection2Password) {
954 this.connection2Password.setString(connection2Password);
955 }
956
957 public String getConnection2Password() {
958 return connection2Password.getString();
959 }
960
961 public void setConnection2URL(String connection2URL) {
962 this.connection2URL.setString(connection2URL);
963 }
964
965 public String getConnection2URL() {
966 return connection2URL.getString();
967 }
968
969 public void setConnection2DriverName(String driverName) {
970 this.connection2DriverName.setString(driverName);
971 }
972
973 public String getConnection2DriverName() {
974 return connection2DriverName.getString();
975 }
976
977 public void setConnection2Properties(String connection2Properties) {
978 this.connection2Properties.setString(connection2Properties);
979 }
980
981 public String getConnection2Properties() {
982 return connection2Properties.getString();
983 }
984
985 public void setConnectionFactory2Properties(
986 String connectionFactory2Properties) {
987 this.connectionFactory2Properties
988 .setString(connectionFactory2Properties);
989 }
990
991 public String getConnectionFactory2Properties() {
992 return connectionFactory2Properties.getString();
993 }
994
995 public void setConnectionFactory2Name(String connectionFactory2Name) {
996 this.connectionFactory2Name.setString(connectionFactory2Name);
997 }
998
999 public String getConnectionFactory2Name() {
1000 return connectionFactory2Name.getString();
1001 }
1002
1003 public void setConnectionFactory2(Object factory) {
1004 connectionFactory2.set(factory);
1005 }
1006
1007 public Object getConnectionFactory2() {
1008 if (connectionFactory2.get() == null)
1009 connectionFactory2.set(
1010 lookupConnectionFactory(getConnectionFactory2Name()), false);
1011 return connectionFactory2.get();
1012 }
1013
1014 public void setOptimistic(boolean optimistic) {
1015 this.optimistic.set(optimistic);
1016 }
1017
1018 public void setOptimistic(Boolean optimistic) {
1019 if (optimistic != null)
1020 setOptimistic(optimistic.booleanValue());
1021 }
1022
1023 public boolean getOptimistic() {
1024 return optimistic.get();
1025 }
1026
1027 public void setAutoClear(String clear) {
1028 autoClear.setString(clear);
1029 }
1030
1031 public String getAutoClear() {
1032 return autoClear.getString();
1033 }
1034
1035 public void setAutoClear(int clear) {
1036 autoClear.set(clear);
1037 }
1038
1039 public int getAutoClearConstant() {
1040 return autoClear.get();
1041 }
1042
1043 public void setRetainState(boolean retainState) {
1044 this.retainState.set(retainState);
1045 }
1046
1047 public void setRetainState(Boolean retainState) {
1048 if (retainState != null)
1049 setRetainState(retainState.booleanValue());
1050 }
1051
1052 public boolean getRetainState() {
1053 return retainState.get();
1054 }
1055
1056 public void setRestoreState(String restoreState) {
1057 this.restoreState.setString(restoreState);
1058 }
1059
1060 public String getRestoreState() {
1061 return restoreState.getString();
1062 }
1063
1064 public void setRestoreState(int restoreState) {
1065 this.restoreState.set(restoreState);
1066 }
1067
1068 public int getRestoreStateConstant() {
1069 return restoreState.get();
1070 }
1071
1072 public void setAutoDetach(String autoDetach) {
1073 this.autoDetach.setString(autoDetach);
1074 }
1075
1076 public String getAutoDetach() {
1077 return autoDetach.getString();
1078 }
1079
1080 public void setAutoDetach(int autoDetachFlags) {
1081 autoDetach.setConstant(autoDetachFlags);
1082 }
1083
1084 public int getAutoDetachConstant() {
1085 return autoDetach.getConstant();
1086 }
1087
1088 public void setDetachState(String detachState) {
1089 detachStatePlugin.setString(detachState);
1090 }
1091
1092 public String getDetachState() {
1093 return detachStatePlugin.getString();
1094 }
1095
1096 public void setDetachState(DetachOptions detachState) {
1097 detachStatePlugin.set(detachState);
1098 }
1099
1100 public DetachOptions getDetachStateInstance() {
1101 if (detachStatePlugin.get() == null)
1102 detachStatePlugin.instantiate(DetachOptions.class, this);
1103 return (DetachOptions) detachStatePlugin.get();
1104 }
1105
1106 public void setIgnoreChanges(boolean ignoreChanges) {
1107 this.ignoreChanges.set(ignoreChanges);
1108 }
1109
1110 public void setIgnoreChanges(Boolean ignoreChanges) {
1111 if (ignoreChanges != null)
1112 setIgnoreChanges(ignoreChanges.booleanValue());
1113 }
1114
1115 public boolean getIgnoreChanges() {
1116 return ignoreChanges.get();
1117 }
1118
1119 public void setNontransactionalRead(boolean nontransactionalRead) {
1120 this.nontransactionalRead.set(nontransactionalRead);
1121 }
1122
1123 public void setNontransactionalRead(Boolean nontransactionalRead) {
1124 if (nontransactionalRead != null)
1125 setNontransactionalRead(nontransactionalRead.booleanValue());
1126 }
1127
1128 public boolean getNontransactionalRead() {
1129 return nontransactionalRead.get();
1130 }
1131
1132 public void setNontransactionalWrite(boolean nontransactionalWrite) {
1133 this.nontransactionalWrite.set(nontransactionalWrite);
1134 }
1135
1136 public void setNontransactionalWrite(Boolean nontransactionalWrite) {
1137 if (nontransactionalWrite != null)
1138 setNontransactionalWrite(nontransactionalWrite.booleanValue());
1139 }
1140
1141 public boolean getNontransactionalWrite() {
1142 return nontransactionalWrite.get();
1143 }
1144
1145 public void setMultithreaded(boolean multithreaded) {
1146 this.multithreaded.set(multithreaded);
1147 }
1148
1149 public void setMultithreaded(Boolean multithreaded) {
1150 if (multithreaded != null)
1151 setMultithreaded(multithreaded.booleanValue());
1152 }
1153
1154 public boolean getMultithreaded() {
1155 return multithreaded.get();
1156 }
1157
1158 public void setFetchBatchSize(int fetchBatchSize) {
1159 this.fetchBatchSize.set(fetchBatchSize);
1160 }
1161
1162 public void setFetchBatchSize(Integer fetchBatchSize) {
1163 if (fetchBatchSize != null)
1164 setFetchBatchSize(fetchBatchSize.intValue());
1165 }
1166
1167 public int getFetchBatchSize() {
1168 return fetchBatchSize.get();
1169 }
1170
1171 public void setMaxFetchDepth(int maxFetchDepth) {
1172 this.maxFetchDepth.set(maxFetchDepth);
1173 }
1174
1175 public void setMaxFetchDepth(Integer maxFetchDepth) {
1176 if (maxFetchDepth != null)
1177 setMaxFetchDepth(maxFetchDepth.intValue());
1178 }
1179
1180 public int getMaxFetchDepth() {
1181 return maxFetchDepth.get();
1182 }
1183
1184 public void setFetchGroups(String fetchGroups) {
1185 this.fetchGroups.setString(fetchGroups);
1186 }
1187
1188 public String getFetchGroups() {
1189 return fetchGroups.getString();
1190 }
1191
1192 public String[] getFetchGroupsList() {
1193 return fetchGroups.get();
1194 }
1195
1196 public void setFetchGroups(String[] fetchGroups) {
1197 this.fetchGroups.set(fetchGroups);
1198 }
1199
1200 public void setFlushBeforeQueries(String flush) {
1201 flushBeforeQueries.setString(flush);
1202 }
1203
1204 public String getFlushBeforeQueries() {
1205 return flushBeforeQueries.getString();
1206 }
1207
1208 public void setFlushBeforeQueries(int flush) {
1209 flushBeforeQueries.set(flush);
1210 }
1211
1212 public int getFlushBeforeQueriesConstant() {
1213 return flushBeforeQueries.get();
1214 }
1215
1216 public void setLockTimeout(int timeout) {
1217 lockTimeout.set(timeout);
1218 }
1219
1220 public void setLockTimeout(Integer timeout) {
1221 if (timeout != null)
1222 setLockTimeout(timeout.intValue());
1223 }
1224
1225 public int getLockTimeout() {
1226 return lockTimeout.get();
1227 }
1228
1229 public void setReadLockLevel(String level) {
1230 readLockLevel.setString(level);
1231 }
1232
1233 public String getReadLockLevel() {
1234 return readLockLevel.getString();
1235 }
1236
1237 public void setReadLockLevel(int level) {
1238 readLockLevel.set(level);
1239 }
1240
1241 public int getReadLockLevelConstant() {
1242 return readLockLevel.get();
1243 }
1244
1245 public void setWriteLockLevel(String level) {
1246 writeLockLevel.setString(level);
1247 }
1248
1249 public String getWriteLockLevel() {
1250 return writeLockLevel.getString();
1251 }
1252
1253 public void setWriteLockLevel(int level) {
1254 writeLockLevel.set(level);
1255 }
1256
1257 public int getWriteLockLevelConstant() {
1258 return writeLockLevel.get();
1259 }
1260
1261 public void setSequence(String sequence) {
1262 seqPlugin.setString(sequence);
1263 }
1264
1265 public String getSequence() {
1266 return seqPlugin.getString();
1267 }
1268
1269 public void setSequence(Seq seq) {
1270 seqPlugin.set(seq);
1271 }
1272
1273 public Seq getSequenceInstance() {
1274 if (seqPlugin.get() == null)
1275 seqPlugin.instantiate(Seq.class, this);
1276 return (Seq) seqPlugin.get();
1277 }
1278
1279 public void setConnectionRetainMode(String connectionRetainMode) {
1280 this.connectionRetainMode.setString(connectionRetainMode);
1281 }
1282
1283 public String getConnectionRetainMode() {
1284 return connectionRetainMode.getString();
1285 }
1286
1287 public void setConnectionRetainMode(int connectionRetainMode) {
1288 this.connectionRetainMode.set(connectionRetainMode);
1289 }
1290
1291 public int getConnectionRetainModeConstant() {
1292 return connectionRetainMode.get();
1293 }
1294
1295 public void setFilterListeners(String filterListeners) {
1296 filterListenerPlugins.setString(filterListeners);
1297 }
1298
1299 public String getFilterListeners() {
1300 return filterListenerPlugins.getString();
1301 }
1302
1303 public void setFilterListeners(FilterListener[] listeners) {
1304 filterListenerPlugins.set(listeners);
1305 }
1306
1307 public FilterListener[] getFilterListenerInstances() {
1308 if (filterListenerPlugins.get() == null)
1309 filterListenerPlugins.instantiate(FilterListener.class, this);
1310 return (FilterListener[]) filterListenerPlugins.get();
1311 }
1312
1313 public void setAggregateListeners(String aggregateListeners) {
1314 aggregateListenerPlugins.setString(aggregateListeners);
1315 }
1316
1317 public String getAggregateListeners() {
1318 return aggregateListenerPlugins.getString();
1319 }
1320
1321 public void setAggregateListeners(AggregateListener[] listeners) {
1322 aggregateListenerPlugins.set(listeners);
1323 }
1324
1325 public AggregateListener[] getAggregateListenerInstances() {
1326 if (aggregateListenerPlugins.get() == null)
1327 aggregateListenerPlugins.instantiate(AggregateListener.class, this);
1328 return (AggregateListener[]) aggregateListenerPlugins.get();
1329 }
1330
1331 public void setRetryClassRegistration(boolean retry) {
1332 retryClassRegistration.set(retry);
1333 }
1334
1335 public void setRetryClassRegistration(Boolean retry) {
1336 if (retry != null)
1337 setRetryClassRegistration(retry.booleanValue());
1338 }
1339
1340 public boolean getRetryClassRegistration() {
1341 return retryClassRegistration.get();
1342 }
1343
1344 public String getCompatibility() {
1345 return compatibilityPlugin.getString();
1346 }
1347
1348 public void setCompatibility(String compatibility) {
1349 compatibilityPlugin.setString(compatibility);
1350 }
1351
1352 public Compatibility getCompatibilityInstance() {
1353 if (compatibilityPlugin.get() == null)
1354 compatibilityPlugin.instantiate(Compatibility.class, this);
1355 return (Compatibility) compatibilityPlugin.get();
1356 }
1357
1358 public String getQueryCompilationCache() {
1359 return queryCompilationCachePlugin.getString();
1360 }
1361
1362 public void setQueryCompilationCache(String queryCompilationCache) {
1363 queryCompilationCachePlugin.setString(queryCompilationCache);
1364 }
1365
1366 public Map getQueryCompilationCacheInstance() {
1367 if (queryCompilationCachePlugin.get() == null)
1368 queryCompilationCachePlugin.instantiate(Map.class, this);
1369 return (Map) queryCompilationCachePlugin.get();
1370 }
1371
1372 public StoreFacadeTypeRegistry getStoreFacadeTypeRegistry() {
1373 return _storeFacadeRegistry;
1374 }
1375
1376 public BrokerFactoryEventManager getBrokerFactoryEventManager() {
1377 return _brokerFactoryEventManager;
1378 }
1379
1380 public String getRuntimeUnenhancedClasses() {
1381 return runtimeUnenhancedClasses.getString();
1382 }
1383
1384 public int getRuntimeUnenhancedClassesConstant() {
1385 return runtimeUnenhancedClasses.get();
1386 }
1387
1388 public void setRuntimeUnenhancedClasses(int mode) {
1389 runtimeUnenhancedClasses.set(mode);
1390 }
1391
1392 public void setRuntimeUnenhancedClasses(String mode) {
1393 runtimeUnenhancedClasses.setString(mode);
1394 }
1395
1396 public String getCacheMarshallers() {
1397 return cacheMarshallerPlugins.getString();
1398 }
1399
1400 public void setCacheMarshallers(String marshallers) {
1401 cacheMarshallerPlugins.setString(marshallers);
1402 }
1403
1404 public Map getCacheMarshallerInstances() {
1405 return cacheMarshallerPlugins.getInstancesAsMap();
1406 }
1407
1408 public void instantiateAll() {
1409 super.instantiateAll();
1410 getMetaDataRepositoryInstance();
1411 getRemoteCommitEventManager();
1412 cacheMarshallerPlugins.initialize();
1413 }
1414
1415 protected void preClose() {
1416 ImplHelper.close(metaRepository);
1417 ImplHelper.close(remoteEventManager);
1418 super.preClose();
1419 }
1420
1421 public Log getConfigurationLog() {
1422 return getLog(LOG_RUNTIME);
1423 }
1424 }
Save This Page