0001: /*
0002: * Licensed to the Apache Software Foundation (ASF) under one
0003: * or more contributor license agreements. See the NOTICE file
0004: * distributed with this work for additional information
0005: * regarding copyright ownership. The ASF licenses this file
0006: * to you under the Apache License, Version 2.0 (the
0007: * "License"); you may not use this file except in compliance
0008: * with the License. You may obtain a copy of the License at
0009: *
0010: * http://www.apache.org/licenses/LICENSE-2.0
0011: *
0012: * Unless required by applicable law or agreed to in writing,
0013: * software distributed under the License is distributed on an
0014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
0015: * KIND, either express or implied. See the License for the
0016: * specific language governing permissions and limitations
0017: * under the License.
0018: */
0019: package org.apache.openjpa.conf;
0020:
0021: import java.util.Collection;
0022: import java.util.HashSet;
0023: import java.util.Map;
0024:
0025: import org.apache.commons.lang.StringUtils;
0026: import org.apache.openjpa.datacache.ConcurrentDataCache;
0027: import org.apache.openjpa.datacache.ConcurrentQueryCache;
0028: import org.apache.openjpa.datacache.DataCacheManager;
0029: import org.apache.openjpa.datacache.DataCacheManagerImpl;
0030: import org.apache.openjpa.ee.ManagedRuntime;
0031: import org.apache.openjpa.event.OrphanedKeyAction;
0032: import org.apache.openjpa.event.RemoteCommitEventManager;
0033: import org.apache.openjpa.event.RemoteCommitProvider;
0034: import org.apache.openjpa.event.BrokerFactoryEventManager;
0035: import org.apache.openjpa.kernel.AutoClear;
0036: import org.apache.openjpa.kernel.BrokerImpl;
0037: import org.apache.openjpa.kernel.ConnectionRetainModes;
0038: import org.apache.openjpa.kernel.InverseManager;
0039: import org.apache.openjpa.kernel.LockLevels;
0040: import org.apache.openjpa.kernel.LockManager;
0041: import org.apache.openjpa.kernel.QueryFlushModes;
0042: import org.apache.openjpa.kernel.RestoreState;
0043: import org.apache.openjpa.kernel.SavepointManager;
0044: import org.apache.openjpa.kernel.Seq;
0045: import org.apache.openjpa.kernel.exps.AggregateListener;
0046: import org.apache.openjpa.kernel.exps.FilterListener;
0047: import org.apache.openjpa.lib.conf.*;
0048: import org.apache.openjpa.lib.log.Log;
0049: import org.apache.openjpa.lib.util.Localizer;
0050: import org.apache.openjpa.meta.MetaDataFactory;
0051: import org.apache.openjpa.meta.MetaDataRepository;
0052: import org.apache.openjpa.util.ClassResolver;
0053: import org.apache.openjpa.util.ImplHelper;
0054: import org.apache.openjpa.util.ProxyManager;
0055: import org.apache.openjpa.util.StoreFacadeTypeRegistry;
0056: import org.apache.openjpa.enhance.RuntimeUnenhancedClasssesModes;
0057:
0058: /**
0059: * Implementation of the {@link OpenJPAConfiguration} interface.
0060: *
0061: * @see ConfigurationImpl
0062: * @author Marc Prud'hommeaux
0063: * @author Abe White
0064: */
0065: public class OpenJPAConfigurationImpl extends ConfigurationImpl
0066: implements OpenJPAConfiguration {
0067:
0068: private static final Localizer _loc = Localizer
0069: .forPackage(OpenJPAConfigurationImpl.class);
0070:
0071: // cached state; some of this is created in getter methods, so make
0072: // protected in case subclasses want to access without creating
0073: protected MetaDataRepository metaRepository = null;
0074: protected RemoteCommitEventManager remoteEventManager = null;
0075:
0076: // openjpa properties
0077: public ObjectValue classResolverPlugin;
0078: public ObjectValue brokerPlugin;
0079: public ObjectValue dataCachePlugin;
0080: public ObjectValue dataCacheManagerPlugin;
0081: public IntValue dataCacheTimeout;
0082: public ObjectValue queryCachePlugin;
0083: public BooleanValue dynamicDataStructs;
0084: public ObjectValue managedRuntimePlugin;
0085: public BooleanValue transactionMode;
0086: public IntValue connectionRetainMode;
0087: public IntValue fetchBatchSize;
0088: public IntValue maxFetchDepth;
0089: public StringListValue fetchGroups;
0090: public IntValue flushBeforeQueries;
0091: public IntValue lockTimeout;
0092: public IntValue readLockLevel;
0093: public IntValue writeLockLevel;
0094: public ObjectValue seqPlugin;
0095: public PluginListValue filterListenerPlugins;
0096: public PluginListValue aggregateListenerPlugins;
0097: public BooleanValue retryClassRegistration;
0098: public ObjectValue proxyManagerPlugin;
0099: public StringValue connectionUserName;
0100: public StringValue connectionPassword;
0101: public StringValue connectionURL;
0102: public StringValue connectionDriverName;
0103: public ObjectValue connectionFactory;
0104: public StringValue connectionFactoryName;
0105: public StringValue connectionProperties;
0106: public StringValue connectionFactoryProperties;
0107: public BooleanValue connectionFactoryMode;
0108: public StringValue connection2UserName;
0109: public StringValue connection2Password;
0110: public StringValue connection2URL;
0111: public StringValue connection2DriverName;
0112: public StringValue connection2Properties;
0113: public ObjectValue connectionFactory2;
0114: public StringValue connectionFactory2Name;
0115: public StringValue connectionFactory2Properties;
0116: public BooleanValue optimistic;
0117: public IntValue autoClear;
0118: public BooleanValue retainState;
0119: public IntValue restoreState;
0120: public ObjectValue detachStatePlugin;
0121: public BooleanValue ignoreChanges;
0122: public BooleanValue nontransactionalRead;
0123: public BooleanValue nontransactionalWrite;
0124: public BooleanValue multithreaded;
0125: public StringValue mapping;
0126: public PluginValue metaFactoryPlugin;
0127: public ObjectValue metaRepositoryPlugin;
0128: public ObjectValue lockManagerPlugin;
0129: public ObjectValue inverseManagerPlugin;
0130: public ObjectValue savepointManagerPlugin;
0131: public ObjectValue orphanedKeyPlugin;
0132: public ObjectValue compatibilityPlugin;
0133: public QueryCompilationCacheValue queryCompilationCachePlugin;
0134: public IntValue runtimeUnenhancedClasses;
0135: public CacheMarshallersValue cacheMarshallerPlugins;
0136:
0137: // custom values
0138: public BrokerFactoryValue brokerFactoryPlugin;
0139: public RemoteCommitProviderValue remoteProviderPlugin;
0140: public AutoDetachValue autoDetach;
0141:
0142: private Collection supportedOptions = new HashSet(33);
0143: private String spec = null;
0144: private final StoreFacadeTypeRegistry _storeFacadeRegistry = new StoreFacadeTypeRegistry();
0145: private BrokerFactoryEventManager _brokerFactoryEventManager = new BrokerFactoryEventManager(
0146: this );
0147:
0148: /**
0149: * Default constructor. Attempts to load global properties.
0150: */
0151: public OpenJPAConfigurationImpl() {
0152: this (true);
0153: }
0154:
0155: /**
0156: * Constructor.
0157: *
0158: * @param loadGlobals whether to attempt to load the global properties
0159: */
0160: public OpenJPAConfigurationImpl(boolean loadGlobals) {
0161: this (true, loadGlobals);
0162: }
0163:
0164: /**
0165: * Constructor.
0166: *
0167: * @param derivations whether to apply product derivations
0168: * @param loadGlobals whether to attempt to load the global properties
0169: */
0170: public OpenJPAConfigurationImpl(boolean derivations,
0171: boolean loadGlobals) {
0172: super (false);
0173: String[] aliases;
0174:
0175: classResolverPlugin = addPlugin("ClassResolver", true);
0176: aliases = new String[] { "default",
0177: "org.apache.openjpa.util.ClassResolverImpl",
0178: // deprecated alias
0179: "spec", "org.apache.openjpa.util.ClassResolverImpl", };
0180: classResolverPlugin.setAliases(aliases);
0181: classResolverPlugin.setDefault(aliases[0]);
0182: classResolverPlugin.setString(aliases[0]);
0183: classResolverPlugin
0184: .setInstantiatingGetter("getClassResolverInstance");
0185:
0186: brokerFactoryPlugin = new BrokerFactoryValue();
0187: addValue(brokerFactoryPlugin);
0188:
0189: brokerPlugin = new BrokerValue();
0190: addValue(brokerPlugin);
0191:
0192: dataCacheManagerPlugin = addPlugin("DataCacheManager", true);
0193: aliases = new String[] { "default",
0194: DataCacheManagerImpl.class.getName(), };
0195: dataCacheManagerPlugin.setAliases(aliases);
0196: dataCacheManagerPlugin.setDefault(aliases[0]);
0197: dataCacheManagerPlugin.setString(aliases[0]);
0198: dataCacheManagerPlugin
0199: .setInstantiatingGetter("getDataCacheManager");
0200:
0201: dataCachePlugin = addPlugin("DataCache", false);
0202: aliases = new String[] { "false", null, "true",
0203: ConcurrentDataCache.class.getName(), "concurrent",
0204: ConcurrentDataCache.class.getName(), };
0205: dataCachePlugin.setAliases(aliases);
0206: dataCachePlugin.setDefault(aliases[0]);
0207: dataCachePlugin.setString(aliases[0]);
0208:
0209: dataCacheTimeout = addInt("DataCacheTimeout");
0210: dataCacheTimeout.setDefault("-1");
0211: dataCacheTimeout.set(-1);
0212: dataCacheTimeout.setDynamic(true);
0213:
0214: queryCachePlugin = addPlugin("QueryCache", true);
0215: aliases = new String[] { "true",
0216: ConcurrentQueryCache.class.getName(), "concurrent",
0217: ConcurrentQueryCache.class.getName(), "false", null, };
0218: queryCachePlugin.setAliases(aliases);
0219: queryCachePlugin.setDefault(aliases[0]);
0220: queryCachePlugin.setString(aliases[0]);
0221:
0222: dynamicDataStructs = addBoolean("DynamicDataStructs");
0223: dynamicDataStructs.setDefault("false");
0224: dynamicDataStructs.set(false);
0225:
0226: lockManagerPlugin = addPlugin("LockManager", false);
0227: aliases = new String[] { "none",
0228: "org.apache.openjpa.kernel.NoneLockManager", "version",
0229: "org.apache.openjpa.kernel.VersionLockManager", };
0230: lockManagerPlugin.setAliases(aliases);
0231: lockManagerPlugin.setDefault(aliases[0]);
0232: lockManagerPlugin.setString(aliases[0]);
0233:
0234: inverseManagerPlugin = addPlugin("InverseManager", false);
0235: aliases = new String[] { "false", null, "true",
0236: "org.apache.openjpa.kernel.InverseManager", };
0237: inverseManagerPlugin.setAliases(aliases);
0238: inverseManagerPlugin.setDefault(aliases[0]);
0239: inverseManagerPlugin.setString(aliases[0]);
0240:
0241: savepointManagerPlugin = addPlugin("SavepointManager", true);
0242: aliases = new String[] { "in-mem",
0243: "org.apache.openjpa.kernel.InMemorySavepointManager", };
0244: savepointManagerPlugin.setAliases(aliases);
0245: savepointManagerPlugin.setDefault(aliases[0]);
0246: savepointManagerPlugin.setString(aliases[0]);
0247: savepointManagerPlugin
0248: .setInstantiatingGetter("getSavepointManagerInstance");
0249:
0250: orphanedKeyPlugin = addPlugin("OrphanedKeyAction", true);
0251: aliases = new String[] { "log",
0252: "org.apache.openjpa.event.LogOrphanedKeyAction",
0253: "exception",
0254: "org.apache.openjpa.event.ExceptionOrphanedKeyAction",
0255: "none",
0256: "org.apache.openjpa.event.NoneOrphanedKeyAction", };
0257: orphanedKeyPlugin.setAliases(aliases);
0258: orphanedKeyPlugin.setDefault(aliases[0]);
0259: orphanedKeyPlugin.setString(aliases[0]);
0260: orphanedKeyPlugin
0261: .setInstantiatingGetter("getOrphanedKeyActionInstance");
0262:
0263: remoteProviderPlugin = new RemoteCommitProviderValue();
0264: addValue(remoteProviderPlugin);
0265:
0266: transactionMode = addBoolean("TransactionMode");
0267: aliases = new String[] { "local", "false", "managed", "true", };
0268: transactionMode.setAliases(aliases);
0269: transactionMode.setDefault(aliases[0]);
0270:
0271: managedRuntimePlugin = addPlugin("ManagedRuntime", true);
0272: aliases = new String[] { "auto",
0273: "org.apache.openjpa.ee.AutomaticManagedRuntime",
0274: "jndi", "org.apache.openjpa.ee.JNDIManagedRuntime",
0275: "invocation",
0276: "org.apache.openjpa.ee.InvocationManagedRuntime", };
0277: managedRuntimePlugin.setAliases(aliases);
0278: managedRuntimePlugin.setDefault(aliases[0]);
0279: managedRuntimePlugin.setString(aliases[0]);
0280: managedRuntimePlugin
0281: .setInstantiatingGetter("getManagedRuntimeInstance");
0282:
0283: proxyManagerPlugin = addPlugin("ProxyManager", true);
0284: aliases = new String[] { "default",
0285: "org.apache.openjpa.util.ProxyManagerImpl" };
0286: proxyManagerPlugin.setAliases(aliases);
0287: proxyManagerPlugin.setDefault(aliases[0]);
0288: proxyManagerPlugin.setString(aliases[0]);
0289: proxyManagerPlugin
0290: .setInstantiatingGetter("getProxyManagerInstance");
0291:
0292: mapping = addString("Mapping");
0293: metaFactoryPlugin = addPlugin("MetaDataFactory", false);
0294:
0295: metaRepositoryPlugin = (ObjectValue) addValue(new MetaDataRepositoryValue());
0296:
0297: connectionFactory = addObject("ConnectionFactory");
0298: connectionFactory
0299: .setInstantiatingGetter("getConnectionFactory");
0300:
0301: connectionFactory2 = addObject("ConnectionFactory2");
0302: connectionFactory2
0303: .setInstantiatingGetter("getConnectionFactory2");
0304: // This is done because this plug-in may get initialized very lazily
0305: // when the runtime needs it for flush or a sequence. To keep it
0306: // dynamic allows it to be set even when the configuration is frozen
0307: connectionFactory.setDynamic(true);
0308: connectionFactory2.setDynamic(true);
0309:
0310: connectionUserName = addString("ConnectionUserName");
0311: connectionPassword = addString("ConnectionPassword");
0312: connectionURL = addString("ConnectionURL");
0313: connectionDriverName = addString("ConnectionDriverName");
0314: connectionFactoryName = addString("ConnectionFactoryName");
0315: connectionProperties = addString("ConnectionProperties");
0316: connectionFactoryProperties = addString("ConnectionFactoryProperties");
0317: connection2UserName = addString("Connection2UserName");
0318: connection2Password = addString("Connection2Password");
0319: connection2URL = addString("Connection2URL");
0320: connection2DriverName = addString("Connection2DriverName");
0321: connection2Properties = addString("Connection2Properties");
0322: connectionFactory2Properties = addString("ConnectionFactory2Properties");
0323: connectionFactory2Name = addString("ConnectionFactory2Name");
0324:
0325: connectionFactoryMode = addBoolean("ConnectionFactoryMode");
0326: aliases = new String[] { "local", "false", "managed", "true", };
0327: connectionFactoryMode.setAliases(aliases);
0328: connectionFactoryMode.setDefault(aliases[0]);
0329:
0330: optimistic = addBoolean("Optimistic");
0331: optimistic.setDefault("true");
0332: optimistic.set(true);
0333:
0334: autoClear = addInt("AutoClear");
0335: aliases = new String[] { "datastore",
0336: String.valueOf(AutoClear.CLEAR_DATASTORE), "all",
0337: String.valueOf(AutoClear.CLEAR_ALL), };
0338: autoClear.setAliases(aliases);
0339: autoClear.setDefault(aliases[0]);
0340: autoClear.set(AutoClear.CLEAR_DATASTORE);
0341: autoClear.setAliasListComprehensive(true);
0342:
0343: retainState = addBoolean("RetainState");
0344: retainState.setDefault("true");
0345: retainState.set(true);
0346:
0347: restoreState = addInt("RestoreState");
0348: aliases = new String[] { "none",
0349: String.valueOf(RestoreState.RESTORE_NONE), "false",
0350: String.valueOf(RestoreState.RESTORE_NONE), "immutable",
0351: String.valueOf(RestoreState.RESTORE_IMMUTABLE),
0352: // "true" for compat with jdo RestoreValues
0353: "true", String.valueOf(RestoreState.RESTORE_IMMUTABLE),
0354: "all", String.valueOf(RestoreState.RESTORE_ALL), };
0355: restoreState.setAliases(aliases);
0356: restoreState.setDefault(aliases[0]);
0357: restoreState.set(RestoreState.RESTORE_IMMUTABLE);
0358: restoreState.setAliasListComprehensive(true);
0359:
0360: autoDetach = new AutoDetachValue();
0361: addValue(autoDetach);
0362:
0363: detachStatePlugin = addPlugin("DetachState", true);
0364: aliases = new String[] { "loaded",
0365: DetachOptions.Loaded.class.getName(), "fgs",
0366: DetachOptions.FetchGroups.class.getName(),
0367: "fetch-groups",
0368: DetachOptions.FetchGroups.class.getName(), "all",
0369: DetachOptions.All.class.getName(), };
0370: detachStatePlugin.setAliases(aliases);
0371: detachStatePlugin.setDefault(aliases[0]);
0372: detachStatePlugin.setString(aliases[0]);
0373: detachStatePlugin
0374: .setInstantiatingGetter("getDetachStateInstance");
0375:
0376: ignoreChanges = addBoolean("IgnoreChanges");
0377:
0378: nontransactionalRead = addBoolean("NontransactionalRead");
0379: nontransactionalRead.setDefault("true");
0380: nontransactionalRead.set(true);
0381:
0382: nontransactionalWrite = addBoolean("NontransactionalWrite");
0383: multithreaded = addBoolean("Multithreaded");
0384:
0385: fetchBatchSize = addInt("FetchBatchSize");
0386: fetchBatchSize.setDefault("-1");
0387: fetchBatchSize.set(-1);
0388: fetchBatchSize.setDynamic(true);
0389:
0390: maxFetchDepth = addInt("MaxFetchDepth");
0391: maxFetchDepth.setDefault("-1");
0392: maxFetchDepth.set(-1);
0393:
0394: fetchGroups = addStringList("FetchGroups");
0395: fetchGroups.setDefault("default");
0396: fetchGroups.set(new String[] { "default" });
0397:
0398: flushBeforeQueries = addInt("FlushBeforeQueries");
0399: aliases = new String[] { "true",
0400: String.valueOf(QueryFlushModes.FLUSH_TRUE), "false",
0401: String.valueOf(QueryFlushModes.FLUSH_FALSE),
0402: "with-connection",
0403: String.valueOf(QueryFlushModes.FLUSH_WITH_CONNECTION), };
0404: flushBeforeQueries.setAliases(aliases);
0405: flushBeforeQueries.setDefault(aliases[0]);
0406: flushBeforeQueries.set(QueryFlushModes.FLUSH_TRUE);
0407: flushBeforeQueries.setAliasListComprehensive(true);
0408:
0409: lockTimeout = addInt("LockTimeout");
0410: lockTimeout.setDefault("-1");
0411: lockTimeout.set(-1);
0412: lockTimeout.setDynamic(true);
0413:
0414: readLockLevel = addInt("ReadLockLevel");
0415: aliases = new String[] { "read",
0416: String.valueOf(LockLevels.LOCK_READ), "write",
0417: String.valueOf(LockLevels.LOCK_WRITE), "none",
0418: String.valueOf(LockLevels.LOCK_NONE), };
0419: readLockLevel.setAliases(aliases);
0420: readLockLevel.setDefault(aliases[0]);
0421: readLockLevel.set(LockLevels.LOCK_READ);
0422: readLockLevel.setAliasListComprehensive(true);
0423:
0424: writeLockLevel = addInt("WriteLockLevel");
0425: aliases = new String[] { "read",
0426: String.valueOf(LockLevels.LOCK_READ), "write",
0427: String.valueOf(LockLevels.LOCK_WRITE), "none",
0428: String.valueOf(LockLevels.LOCK_NONE), };
0429: writeLockLevel.setAliases(aliases);
0430: writeLockLevel.setDefault(aliases[1]);
0431: writeLockLevel.set(LockLevels.LOCK_WRITE);
0432: writeLockLevel.setAliasListComprehensive(true);
0433:
0434: seqPlugin = new SeqValue("Sequence");
0435: seqPlugin.setInstantiatingGetter("getSequenceInstance");
0436: addValue(seqPlugin);
0437:
0438: connectionRetainMode = addInt("ConnectionRetainMode");
0439: aliases = new String[] {
0440: "on-demand",
0441: String
0442: .valueOf(ConnectionRetainModes.CONN_RETAIN_DEMAND),
0443: "transaction",
0444: String.valueOf(ConnectionRetainModes.CONN_RETAIN_TRANS),
0445: "always",
0446: String
0447: .valueOf(ConnectionRetainModes.CONN_RETAIN_ALWAYS),
0448: // deprecated
0449: "persistence-manager",
0450: String
0451: .valueOf(ConnectionRetainModes.CONN_RETAIN_ALWAYS), };
0452: connectionRetainMode.setAliases(aliases);
0453: connectionRetainMode.setDefault(aliases[0]);
0454: connectionRetainMode.setAliasListComprehensive(true);
0455: connectionRetainMode
0456: .set(ConnectionRetainModes.CONN_RETAIN_DEMAND);
0457:
0458: filterListenerPlugins = addPluginList("FilterListeners");
0459: filterListenerPlugins
0460: .setInstantiatingGetter("getFilterListenerInstances");
0461:
0462: aggregateListenerPlugins = addPluginList("AggregateListeners");
0463: aggregateListenerPlugins
0464: .setInstantiatingGetter("getAggregateListenerInstances");
0465:
0466: retryClassRegistration = addBoolean("RetryClassRegistration");
0467:
0468: compatibilityPlugin = addPlugin("Compatibility", true);
0469: aliases = new String[] { "default",
0470: Compatibility.class.getName() };
0471: compatibilityPlugin.setAliases(aliases);
0472: compatibilityPlugin.setDefault(aliases[0]);
0473: compatibilityPlugin.setString(aliases[0]);
0474: compatibilityPlugin
0475: .setInstantiatingGetter("getCompatibilityInstance");
0476:
0477: queryCompilationCachePlugin = new QueryCompilationCacheValue(
0478: "QueryCompilationCache");
0479: queryCompilationCachePlugin
0480: .setInstantiatingGetter("getQueryCompilationCacheInstance");
0481: addValue(queryCompilationCachePlugin);
0482:
0483: runtimeUnenhancedClasses = addInt("RuntimeUnenhancedClasses");
0484: runtimeUnenhancedClasses
0485: .setAliases(new String[] {
0486: "supported",
0487: String
0488: .valueOf(RuntimeUnenhancedClasssesModes.SUPPORTED),
0489: "unsupported",
0490: String
0491: .valueOf(RuntimeUnenhancedClasssesModes.UNSUPPORTED),
0492: "warn",
0493: String
0494: .valueOf(RuntimeUnenhancedClasssesModes.WARN), });
0495: runtimeUnenhancedClasses.setDefault("supported");
0496: runtimeUnenhancedClasses.setString("supported");
0497: runtimeUnenhancedClasses.setAliasListComprehensive(true);
0498:
0499: cacheMarshallerPlugins = (CacheMarshallersValue) addValue(new CacheMarshallersValue(
0500: this ));
0501:
0502: // initialize supported options that some runtimes may not support
0503: supportedOptions.add(OPTION_NONTRANS_READ);
0504: supportedOptions.add(OPTION_OPTIMISTIC);
0505: supportedOptions.add(OPTION_ID_APPLICATION);
0506: supportedOptions.add(OPTION_ID_DATASTORE);
0507: supportedOptions.add(OPTION_TYPE_COLLECTION);
0508: supportedOptions.add(OPTION_TYPE_MAP);
0509: supportedOptions.add(OPTION_TYPE_ARRAY);
0510: supportedOptions.add(OPTION_NULL_CONTAINER);
0511: supportedOptions.add(OPTION_EMBEDDED_RELATION);
0512: supportedOptions.add(OPTION_EMBEDDED_COLLECTION_RELATION);
0513: supportedOptions.add(OPTION_EMBEDDED_MAP_RELATION);
0514: supportedOptions.add(OPTION_INC_FLUSH);
0515: supportedOptions.add(OPTION_VALUE_AUTOASSIGN);
0516: supportedOptions.add(OPTION_VALUE_INCREMENT);
0517: supportedOptions.add(OPTION_DATASTORE_CONNECTION);
0518:
0519: if (derivations)
0520: ProductDerivations.beforeConfigurationLoad(this );
0521: if (loadGlobals)
0522: loadGlobals();
0523: }
0524:
0525: public Collection supportedOptions() {
0526: return supportedOptions;
0527: }
0528:
0529: public String getSpecification() {
0530: return spec;
0531: }
0532:
0533: public boolean setSpecification(String spec) {
0534: if (spec == null)
0535: return false;
0536:
0537: if (this .spec != null) {
0538: if (!this .spec.equals(spec)
0539: && getConfigurationLog().isWarnEnabled())
0540: getConfigurationLog().warn(
0541: _loc.get("diff-specs", this .spec, spec));
0542: return false;
0543: }
0544: this .spec = spec;
0545: ProductDerivations.afterSpecificationSet(this );
0546: return true;
0547: }
0548:
0549: public void setClassResolver(String classResolver) {
0550: classResolverPlugin.setString(classResolver);
0551: }
0552:
0553: public String getClassResolver() {
0554: return classResolverPlugin.getString();
0555: }
0556:
0557: public void setClassResolver(ClassResolver classResolver) {
0558: classResolverPlugin.set(classResolver);
0559: }
0560:
0561: public ClassResolver getClassResolverInstance() {
0562: if (classResolverPlugin.get() == null)
0563: classResolverPlugin.instantiate(ClassResolver.class, this );
0564: return (ClassResolver) classResolverPlugin.get();
0565: }
0566:
0567: public void setBrokerFactory(String factory) {
0568: brokerFactoryPlugin.setString(factory);
0569: }
0570:
0571: public String getBrokerFactory() {
0572: return brokerFactoryPlugin.getString();
0573: }
0574:
0575: public void setBrokerImpl(String broker) {
0576: brokerPlugin.setString(broker);
0577: }
0578:
0579: public String getBrokerImpl() {
0580: return brokerPlugin.getString();
0581: }
0582:
0583: public BrokerImpl newBrokerInstance(String user, String pass) {
0584: BrokerImpl broker = (BrokerImpl) brokerPlugin.instantiate(
0585: BrokerImpl.class, this );
0586: if (broker != null)
0587: broker.setAuthentication(user, pass);
0588: return broker;
0589: }
0590:
0591: public void setDataCacheManager(String mgr) {
0592: dataCacheManagerPlugin.setString(mgr);
0593: }
0594:
0595: public String getDataCacheManager() {
0596: return dataCacheManagerPlugin.getString();
0597: }
0598:
0599: public void setDataCacheManager(DataCacheManager dcm) {
0600: if (dcm != null)
0601: dcm.initialize(this , dataCachePlugin, queryCachePlugin);
0602: dataCacheManagerPlugin.set(dcm);
0603: }
0604:
0605: public DataCacheManager getDataCacheManagerInstance() {
0606: DataCacheManager dcm = (DataCacheManager) dataCacheManagerPlugin
0607: .get();
0608: if (dcm == null) {
0609: dcm = (DataCacheManager) dataCacheManagerPlugin
0610: .instantiate(DataCacheManager.class, this );
0611: dcm.initialize(this , dataCachePlugin, queryCachePlugin);
0612: }
0613: return dcm;
0614: }
0615:
0616: public void setDataCache(String dataCache) {
0617: dataCachePlugin.setString(dataCache);
0618: }
0619:
0620: public String getDataCache() {
0621: return dataCachePlugin.getString();
0622: }
0623:
0624: public void setDataCacheTimeout(int dataCacheTimeout) {
0625: this .dataCacheTimeout.set(dataCacheTimeout);
0626: }
0627:
0628: public void setDataCacheTimeout(Integer dataCacheTimeout) {
0629: if (dataCacheTimeout != null)
0630: setDataCacheTimeout(dataCacheTimeout.intValue());
0631: }
0632:
0633: public int getDataCacheTimeout() {
0634: return dataCacheTimeout.get();
0635: }
0636:
0637: public void setQueryCache(String queryCache) {
0638: queryCachePlugin.setString(queryCache);
0639: }
0640:
0641: public String getQueryCache() {
0642: return queryCachePlugin.getString();
0643: }
0644:
0645: public boolean getDynamicDataStructs() {
0646: return dynamicDataStructs.get();
0647: }
0648:
0649: public void setDynamicDataStructs(boolean dynamic) {
0650: dynamicDataStructs.set(dynamic);
0651: }
0652:
0653: public void setDynamicDataStructs(Boolean dynamic) {
0654: setDynamicDataStructs(dynamic.booleanValue());
0655: }
0656:
0657: public void setLockManager(String lockManager) {
0658: lockManagerPlugin.setString(lockManager);
0659: }
0660:
0661: public String getLockManager() {
0662: return lockManagerPlugin.getString();
0663: }
0664:
0665: public LockManager newLockManagerInstance() {
0666: // don't validate plugin properties on instantiation because it
0667: // is likely that back ends will override defaults with their
0668: // own subclasses with new properties
0669: return (LockManager) lockManagerPlugin.instantiate(
0670: LockManager.class, this , false);
0671: }
0672:
0673: public void setInverseManager(String inverseManager) {
0674: inverseManagerPlugin.setString(inverseManager);
0675: }
0676:
0677: public String getInverseManager() {
0678: return inverseManagerPlugin.getString();
0679: }
0680:
0681: public InverseManager newInverseManagerInstance() {
0682: return (InverseManager) inverseManagerPlugin.instantiate(
0683: InverseManager.class, this );
0684: }
0685:
0686: public void setSavepointManager(String savepointManager) {
0687: savepointManagerPlugin.setString(savepointManager);
0688: }
0689:
0690: public String getSavepointManager() {
0691: return savepointManagerPlugin.getString();
0692: }
0693:
0694: public SavepointManager getSavepointManagerInstance() {
0695: if (savepointManagerPlugin.get() == null)
0696: savepointManagerPlugin.instantiate(SavepointManager.class,
0697: this );
0698: return (SavepointManager) savepointManagerPlugin.get();
0699: }
0700:
0701: public void setOrphanedKeyAction(String action) {
0702: orphanedKeyPlugin.setString(action);
0703: }
0704:
0705: public String getOrphanedKeyAction() {
0706: return orphanedKeyPlugin.getString();
0707: }
0708:
0709: public OrphanedKeyAction getOrphanedKeyActionInstance() {
0710: if (orphanedKeyPlugin.get() == null)
0711: orphanedKeyPlugin
0712: .instantiate(OrphanedKeyAction.class, this );
0713: return (OrphanedKeyAction) orphanedKeyPlugin.get();
0714: }
0715:
0716: public void setOrphanedKeyAction(OrphanedKeyAction action) {
0717: orphanedKeyPlugin.set(action);
0718: }
0719:
0720: public void setRemoteCommitProvider(String remoteCommitProvider) {
0721: remoteProviderPlugin.setString(remoteCommitProvider);
0722: }
0723:
0724: public String getRemoteCommitProvider() {
0725: return remoteProviderPlugin.getString();
0726: }
0727:
0728: public RemoteCommitProvider newRemoteCommitProviderInstance() {
0729: return remoteProviderPlugin.instantiateProvider(this );
0730: }
0731:
0732: public void setRemoteCommitEventManager(
0733: RemoteCommitEventManager remoteEventManager) {
0734: this .remoteEventManager = remoteEventManager;
0735: remoteProviderPlugin.configureEventManager(remoteEventManager);
0736: }
0737:
0738: public RemoteCommitEventManager getRemoteCommitEventManager() {
0739: if (remoteEventManager == null) {
0740: remoteEventManager = new RemoteCommitEventManager(this );
0741: remoteProviderPlugin
0742: .configureEventManager(remoteEventManager);
0743: }
0744: return remoteEventManager;
0745: }
0746:
0747: public void setTransactionMode(String transactionMode) {
0748: this .transactionMode.setString(transactionMode);
0749: }
0750:
0751: public String getTransactionMode() {
0752: return transactionMode.getString();
0753: }
0754:
0755: public void setTransactionModeManaged(boolean managed) {
0756: transactionMode.set(managed);
0757: }
0758:
0759: public boolean isTransactionModeManaged() {
0760: return transactionMode.get();
0761: }
0762:
0763: public void setManagedRuntime(String managedRuntime) {
0764: managedRuntimePlugin.setString(managedRuntime);
0765: }
0766:
0767: public String getManagedRuntime() {
0768: return managedRuntimePlugin.getString();
0769: }
0770:
0771: public void setManagedRuntime(ManagedRuntime managedRuntime) {
0772: managedRuntimePlugin.set(managedRuntime);
0773: }
0774:
0775: public ManagedRuntime getManagedRuntimeInstance() {
0776: if (managedRuntimePlugin.get() == null)
0777: managedRuntimePlugin
0778: .instantiate(ManagedRuntime.class, this );
0779: return (ManagedRuntime) managedRuntimePlugin.get();
0780: }
0781:
0782: public void setProxyManager(String proxyManager) {
0783: proxyManagerPlugin.setString(proxyManager);
0784: }
0785:
0786: public String getProxyManager() {
0787: return proxyManagerPlugin.getString();
0788: }
0789:
0790: public void setProxyManager(ProxyManager proxyManager) {
0791: proxyManagerPlugin.set(proxyManager);
0792: }
0793:
0794: public ProxyManager getProxyManagerInstance() {
0795: if (proxyManagerPlugin.get() == null)
0796: proxyManagerPlugin.instantiate(ProxyManager.class, this );
0797: return (ProxyManager) proxyManagerPlugin.get();
0798: }
0799:
0800: public void setMapping(String mapping) {
0801: this .mapping.setString(mapping);
0802: }
0803:
0804: public String getMapping() {
0805: return mapping.getString();
0806: }
0807:
0808: public void setMetaDataFactory(String meta) {
0809: this .metaFactoryPlugin.setString(meta);
0810: }
0811:
0812: public String getMetaDataFactory() {
0813: return metaFactoryPlugin.getString();
0814: }
0815:
0816: public MetaDataFactory newMetaDataFactoryInstance() {
0817: return (MetaDataFactory) metaFactoryPlugin.instantiate(
0818: MetaDataFactory.class, this );
0819: }
0820:
0821: public void setMetaDataRepository(String meta) {
0822: this .metaRepositoryPlugin.setString(meta);
0823: }
0824:
0825: public String getMetaDataRepository() {
0826: return metaRepositoryPlugin.getString();
0827: }
0828:
0829: public void setMetaDataRepository(MetaDataRepository meta) {
0830: metaRepository = meta;
0831: }
0832:
0833: public MetaDataRepository getMetaDataRepositoryInstance() {
0834: if (metaRepository == null)
0835: metaRepository = newMetaDataRepositoryInstance();
0836: return metaRepository;
0837: }
0838:
0839: public boolean metaDataRepositoryAvailable() {
0840: return metaRepository != null;
0841: }
0842:
0843: public MetaDataRepository newMetaDataRepositoryInstance() {
0844: return (MetaDataRepository) metaRepositoryPlugin.instantiate(
0845: MetaDataRepository.class, this );
0846: }
0847:
0848: public void setConnectionUserName(String connectionUserName) {
0849: this .connectionUserName.setString(connectionUserName);
0850: }
0851:
0852: public String getConnectionUserName() {
0853: return connectionUserName.getString();
0854: }
0855:
0856: public void setConnectionPassword(String connectionPassword) {
0857: this .connectionPassword.setString(connectionPassword);
0858: }
0859:
0860: public String getConnectionPassword() {
0861: return connectionPassword.getString();
0862: }
0863:
0864: public void setConnectionURL(String connectionURL) {
0865: this .connectionURL.setString(connectionURL);
0866: }
0867:
0868: public String getConnectionURL() {
0869: return connectionURL.getString();
0870: }
0871:
0872: public void setConnectionDriverName(String driverName) {
0873: this .connectionDriverName.setString(driverName);
0874: }
0875:
0876: public String getConnectionDriverName() {
0877: return connectionDriverName.getString();
0878: }
0879:
0880: public void setConnectionProperties(String connectionProperties) {
0881: this .connectionProperties.setString(connectionProperties);
0882: }
0883:
0884: public String getConnectionProperties() {
0885: return connectionProperties.getString();
0886: }
0887:
0888: public void setConnectionFactoryProperties(
0889: String connectionFactoryProperties) {
0890: this .connectionFactoryProperties
0891: .setString(connectionFactoryProperties);
0892: }
0893:
0894: public String getConnectionFactoryProperties() {
0895: return connectionFactoryProperties.getString();
0896: }
0897:
0898: public String getConnectionFactoryMode() {
0899: return connectionFactoryMode.getString();
0900: }
0901:
0902: public void setConnectionFactoryMode(String mode) {
0903: connectionFactoryMode.setString(mode);
0904: }
0905:
0906: public boolean isConnectionFactoryModeManaged() {
0907: return connectionFactoryMode.get();
0908: }
0909:
0910: public void setConnectionFactoryModeManaged(boolean managed) {
0911: connectionFactoryMode.set(managed);
0912: }
0913:
0914: public void setConnectionFactoryName(String connectionFactoryName) {
0915: this .connectionFactoryName.setString(connectionFactoryName);
0916: }
0917:
0918: public String getConnectionFactoryName() {
0919: return connectionFactoryName.getString();
0920: }
0921:
0922: public void setConnectionFactory(Object factory) {
0923: connectionFactory.set(factory);
0924: }
0925:
0926: public Object getConnectionFactory() {
0927: if (connectionFactory.get() == null)
0928: connectionFactory
0929: .set(
0930: lookupConnectionFactory(getConnectionFactoryName()),
0931: true);
0932: return connectionFactory.get();
0933: }
0934:
0935: /**
0936: * Lookup the connection factory at the given name.
0937: */
0938: private Object lookupConnectionFactory(String name) {
0939: name = StringUtils.trimToNull(name);
0940: if (name == null)
0941: return null;
0942: try {
0943: return Configurations.lookup(name);
0944: } catch (Exception ex) {
0945: return null;
0946: }
0947: }
0948:
0949: public void setConnection2UserName(String connection2UserName) {
0950: this .connection2UserName.setString(connection2UserName);
0951: }
0952:
0953: public String getConnection2UserName() {
0954: return connection2UserName.getString();
0955: }
0956:
0957: public void setConnection2Password(String connection2Password) {
0958: this .connection2Password.setString(connection2Password);
0959: }
0960:
0961: public String getConnection2Password() {
0962: return connection2Password.getString();
0963: }
0964:
0965: public void setConnection2URL(String connection2URL) {
0966: this .connection2URL.setString(connection2URL);
0967: }
0968:
0969: public String getConnection2URL() {
0970: return connection2URL.getString();
0971: }
0972:
0973: public void setConnection2DriverName(String driverName) {
0974: this .connection2DriverName.setString(driverName);
0975: }
0976:
0977: public String getConnection2DriverName() {
0978: return connection2DriverName.getString();
0979: }
0980:
0981: public void setConnection2Properties(String connection2Properties) {
0982: this .connection2Properties.setString(connection2Properties);
0983: }
0984:
0985: public String getConnection2Properties() {
0986: return connection2Properties.getString();
0987: }
0988:
0989: public void setConnectionFactory2Properties(
0990: String connectionFactory2Properties) {
0991: this .connectionFactory2Properties
0992: .setString(connectionFactory2Properties);
0993: }
0994:
0995: public String getConnectionFactory2Properties() {
0996: return connectionFactory2Properties.getString();
0997: }
0998:
0999: public void setConnectionFactory2Name(String connectionFactory2Name) {
1000: this .connectionFactory2Name.setString(connectionFactory2Name);
1001: }
1002:
1003: public String getConnectionFactory2Name() {
1004: return connectionFactory2Name.getString();
1005: }
1006:
1007: public void setConnectionFactory2(Object factory) {
1008: connectionFactory2.set(factory);
1009: }
1010:
1011: public Object getConnectionFactory2() {
1012: if (connectionFactory2.get() == null)
1013: connectionFactory2
1014: .set(
1015: lookupConnectionFactory(getConnectionFactory2Name()),
1016: false);
1017: return connectionFactory2.get();
1018: }
1019:
1020: public void setOptimistic(boolean optimistic) {
1021: this .optimistic.set(optimistic);
1022: }
1023:
1024: public void setOptimistic(Boolean optimistic) {
1025: if (optimistic != null)
1026: setOptimistic(optimistic.booleanValue());
1027: }
1028:
1029: public boolean getOptimistic() {
1030: return optimistic.get();
1031: }
1032:
1033: public void setAutoClear(String clear) {
1034: autoClear.setString(clear);
1035: }
1036:
1037: public String getAutoClear() {
1038: return autoClear.getString();
1039: }
1040:
1041: public void setAutoClear(int clear) {
1042: autoClear.set(clear);
1043: }
1044:
1045: public int getAutoClearConstant() {
1046: return autoClear.get();
1047: }
1048:
1049: public void setRetainState(boolean retainState) {
1050: this .retainState.set(retainState);
1051: }
1052:
1053: public void setRetainState(Boolean retainState) {
1054: if (retainState != null)
1055: setRetainState(retainState.booleanValue());
1056: }
1057:
1058: public boolean getRetainState() {
1059: return retainState.get();
1060: }
1061:
1062: public void setRestoreState(String restoreState) {
1063: this .restoreState.setString(restoreState);
1064: }
1065:
1066: public String getRestoreState() {
1067: return restoreState.getString();
1068: }
1069:
1070: public void setRestoreState(int restoreState) {
1071: this .restoreState.set(restoreState);
1072: }
1073:
1074: public int getRestoreStateConstant() {
1075: return restoreState.get();
1076: }
1077:
1078: public void setAutoDetach(String autoDetach) {
1079: this .autoDetach.setString(autoDetach);
1080: }
1081:
1082: public String getAutoDetach() {
1083: return autoDetach.getString();
1084: }
1085:
1086: public void setAutoDetach(int autoDetachFlags) {
1087: autoDetach.setConstant(autoDetachFlags);
1088: }
1089:
1090: public int getAutoDetachConstant() {
1091: return autoDetach.getConstant();
1092: }
1093:
1094: public void setDetachState(String detachState) {
1095: detachStatePlugin.setString(detachState);
1096: }
1097:
1098: public String getDetachState() {
1099: return detachStatePlugin.getString();
1100: }
1101:
1102: public void setDetachState(DetachOptions detachState) {
1103: detachStatePlugin.set(detachState);
1104: }
1105:
1106: public DetachOptions getDetachStateInstance() {
1107: if (detachStatePlugin.get() == null)
1108: detachStatePlugin.instantiate(DetachOptions.class, this );
1109: return (DetachOptions) detachStatePlugin.get();
1110: }
1111:
1112: public void setIgnoreChanges(boolean ignoreChanges) {
1113: this .ignoreChanges.set(ignoreChanges);
1114: }
1115:
1116: public void setIgnoreChanges(Boolean ignoreChanges) {
1117: if (ignoreChanges != null)
1118: setIgnoreChanges(ignoreChanges.booleanValue());
1119: }
1120:
1121: public boolean getIgnoreChanges() {
1122: return ignoreChanges.get();
1123: }
1124:
1125: public void setNontransactionalRead(boolean nontransactionalRead) {
1126: this .nontransactionalRead.set(nontransactionalRead);
1127: }
1128:
1129: public void setNontransactionalRead(Boolean nontransactionalRead) {
1130: if (nontransactionalRead != null)
1131: setNontransactionalRead(nontransactionalRead.booleanValue());
1132: }
1133:
1134: public boolean getNontransactionalRead() {
1135: return nontransactionalRead.get();
1136: }
1137:
1138: public void setNontransactionalWrite(boolean nontransactionalWrite) {
1139: this .nontransactionalWrite.set(nontransactionalWrite);
1140: }
1141:
1142: public void setNontransactionalWrite(Boolean nontransactionalWrite) {
1143: if (nontransactionalWrite != null)
1144: setNontransactionalWrite(nontransactionalWrite
1145: .booleanValue());
1146: }
1147:
1148: public boolean getNontransactionalWrite() {
1149: return nontransactionalWrite.get();
1150: }
1151:
1152: public void setMultithreaded(boolean multithreaded) {
1153: this .multithreaded.set(multithreaded);
1154: }
1155:
1156: public void setMultithreaded(Boolean multithreaded) {
1157: if (multithreaded != null)
1158: setMultithreaded(multithreaded.booleanValue());
1159: }
1160:
1161: public boolean getMultithreaded() {
1162: return multithreaded.get();
1163: }
1164:
1165: public void setFetchBatchSize(int fetchBatchSize) {
1166: this .fetchBatchSize.set(fetchBatchSize);
1167: }
1168:
1169: public void setFetchBatchSize(Integer fetchBatchSize) {
1170: if (fetchBatchSize != null)
1171: setFetchBatchSize(fetchBatchSize.intValue());
1172: }
1173:
1174: public int getFetchBatchSize() {
1175: return fetchBatchSize.get();
1176: }
1177:
1178: public void setMaxFetchDepth(int maxFetchDepth) {
1179: this .maxFetchDepth.set(maxFetchDepth);
1180: }
1181:
1182: public void setMaxFetchDepth(Integer maxFetchDepth) {
1183: if (maxFetchDepth != null)
1184: setMaxFetchDepth(maxFetchDepth.intValue());
1185: }
1186:
1187: public int getMaxFetchDepth() {
1188: return maxFetchDepth.get();
1189: }
1190:
1191: public void setFetchGroups(String fetchGroups) {
1192: this .fetchGroups.setString(fetchGroups);
1193: }
1194:
1195: public String getFetchGroups() {
1196: return fetchGroups.getString();
1197: }
1198:
1199: public String[] getFetchGroupsList() {
1200: return fetchGroups.get();
1201: }
1202:
1203: public void setFetchGroups(String[] fetchGroups) {
1204: this .fetchGroups.set(fetchGroups);
1205: }
1206:
1207: public void setFlushBeforeQueries(String flush) {
1208: flushBeforeQueries.setString(flush);
1209: }
1210:
1211: public String getFlushBeforeQueries() {
1212: return flushBeforeQueries.getString();
1213: }
1214:
1215: public void setFlushBeforeQueries(int flush) {
1216: flushBeforeQueries.set(flush);
1217: }
1218:
1219: public int getFlushBeforeQueriesConstant() {
1220: return flushBeforeQueries.get();
1221: }
1222:
1223: public void setLockTimeout(int timeout) {
1224: lockTimeout.set(timeout);
1225: }
1226:
1227: public void setLockTimeout(Integer timeout) {
1228: if (timeout != null)
1229: setLockTimeout(timeout.intValue());
1230: }
1231:
1232: public int getLockTimeout() {
1233: return lockTimeout.get();
1234: }
1235:
1236: public void setReadLockLevel(String level) {
1237: readLockLevel.setString(level);
1238: }
1239:
1240: public String getReadLockLevel() {
1241: return readLockLevel.getString();
1242: }
1243:
1244: public void setReadLockLevel(int level) {
1245: readLockLevel.set(level);
1246: }
1247:
1248: public int getReadLockLevelConstant() {
1249: return readLockLevel.get();
1250: }
1251:
1252: public void setWriteLockLevel(String level) {
1253: writeLockLevel.setString(level);
1254: }
1255:
1256: public String getWriteLockLevel() {
1257: return writeLockLevel.getString();
1258: }
1259:
1260: public void setWriteLockLevel(int level) {
1261: writeLockLevel.set(level);
1262: }
1263:
1264: public int getWriteLockLevelConstant() {
1265: return writeLockLevel.get();
1266: }
1267:
1268: public void setSequence(String sequence) {
1269: seqPlugin.setString(sequence);
1270: }
1271:
1272: public String getSequence() {
1273: return seqPlugin.getString();
1274: }
1275:
1276: public void setSequence(Seq seq) {
1277: seqPlugin.set(seq);
1278: }
1279:
1280: public Seq getSequenceInstance() {
1281: if (seqPlugin.get() == null)
1282: seqPlugin.instantiate(Seq.class, this );
1283: return (Seq) seqPlugin.get();
1284: }
1285:
1286: public void setConnectionRetainMode(String connectionRetainMode) {
1287: this .connectionRetainMode.setString(connectionRetainMode);
1288: }
1289:
1290: public String getConnectionRetainMode() {
1291: return connectionRetainMode.getString();
1292: }
1293:
1294: public void setConnectionRetainMode(int connectionRetainMode) {
1295: this .connectionRetainMode.set(connectionRetainMode);
1296: }
1297:
1298: public int getConnectionRetainModeConstant() {
1299: return connectionRetainMode.get();
1300: }
1301:
1302: public void setFilterListeners(String filterListeners) {
1303: filterListenerPlugins.setString(filterListeners);
1304: }
1305:
1306: public String getFilterListeners() {
1307: return filterListenerPlugins.getString();
1308: }
1309:
1310: public void setFilterListeners(FilterListener[] listeners) {
1311: filterListenerPlugins.set(listeners);
1312: }
1313:
1314: public FilterListener[] getFilterListenerInstances() {
1315: if (filterListenerPlugins.get() == null)
1316: filterListenerPlugins.instantiate(FilterListener.class,
1317: this );
1318: return (FilterListener[]) filterListenerPlugins.get();
1319: }
1320:
1321: public void setAggregateListeners(String aggregateListeners) {
1322: aggregateListenerPlugins.setString(aggregateListeners);
1323: }
1324:
1325: public String getAggregateListeners() {
1326: return aggregateListenerPlugins.getString();
1327: }
1328:
1329: public void setAggregateListeners(AggregateListener[] listeners) {
1330: aggregateListenerPlugins.set(listeners);
1331: }
1332:
1333: public AggregateListener[] getAggregateListenerInstances() {
1334: if (aggregateListenerPlugins.get() == null)
1335: aggregateListenerPlugins.instantiate(
1336: AggregateListener.class, this );
1337: return (AggregateListener[]) aggregateListenerPlugins.get();
1338: }
1339:
1340: public void setRetryClassRegistration(boolean retry) {
1341: retryClassRegistration.set(retry);
1342: }
1343:
1344: public void setRetryClassRegistration(Boolean retry) {
1345: if (retry != null)
1346: setRetryClassRegistration(retry.booleanValue());
1347: }
1348:
1349: public boolean getRetryClassRegistration() {
1350: return retryClassRegistration.get();
1351: }
1352:
1353: public String getCompatibility() {
1354: return compatibilityPlugin.getString();
1355: }
1356:
1357: public void setCompatibility(String compatibility) {
1358: compatibilityPlugin.setString(compatibility);
1359: }
1360:
1361: public Compatibility getCompatibilityInstance() {
1362: if (compatibilityPlugin.get() == null)
1363: compatibilityPlugin.instantiate(Compatibility.class, this );
1364: return (Compatibility) compatibilityPlugin.get();
1365: }
1366:
1367: public String getQueryCompilationCache() {
1368: return queryCompilationCachePlugin.getString();
1369: }
1370:
1371: public void setQueryCompilationCache(String queryCompilationCache) {
1372: queryCompilationCachePlugin.setString(queryCompilationCache);
1373: }
1374:
1375: public Map getQueryCompilationCacheInstance() {
1376: if (queryCompilationCachePlugin.get() == null)
1377: queryCompilationCachePlugin.instantiate(Map.class, this );
1378: return (Map) queryCompilationCachePlugin.get();
1379: }
1380:
1381: public StoreFacadeTypeRegistry getStoreFacadeTypeRegistry() {
1382: return _storeFacadeRegistry;
1383: }
1384:
1385: public BrokerFactoryEventManager getBrokerFactoryEventManager() {
1386: return _brokerFactoryEventManager;
1387: }
1388:
1389: public String getRuntimeUnenhancedClasses() {
1390: return runtimeUnenhancedClasses.getString();
1391: }
1392:
1393: public int getRuntimeUnenhancedClassesConstant() {
1394: return runtimeUnenhancedClasses.get();
1395: }
1396:
1397: public void setRuntimeUnenhancedClasses(int mode) {
1398: runtimeUnenhancedClasses.set(mode);
1399: }
1400:
1401: public String getCacheMarshallers() {
1402: return cacheMarshallerPlugins.getString();
1403: }
1404:
1405: public void setCacheMarshallers(String marshallers) {
1406: cacheMarshallerPlugins.setString(marshallers);
1407: }
1408:
1409: public Map getCacheMarshallerInstances() {
1410: return cacheMarshallerPlugins.getInstancesAsMap();
1411: }
1412:
1413: public void setRuntimeUnenhancedClasses(String mode) {
1414: runtimeUnenhancedClasses.setString(mode);
1415: }
1416:
1417: public void instantiateAll() {
1418: super .instantiateAll();
1419: getMetaDataRepositoryInstance();
1420: getRemoteCommitEventManager();
1421: cacheMarshallerPlugins.initialize();
1422: }
1423:
1424: protected void preClose() {
1425: ImplHelper.close(metaRepository);
1426: ImplHelper.close(remoteEventManager);
1427: super .preClose();
1428: }
1429:
1430: public Log getConfigurationLog() {
1431: return getLog(LOG_RUNTIME);
1432: }
1433: }
|