| Method from org.apache.openjpa.conf.OpenJPAConfigurationImpl Detail: |
|---|
 public AggregateListener[] getAggregateListenerInstances() {
if (aggregateListenerPlugins.get() == null)
aggregateListenerPlugins.instantiate(AggregateListener.class, this);
return (AggregateListener[]) aggregateListenerPlugins.get();
}
|
public String getAggregateListeners() {
return aggregateListenerPlugins.getString();
} |
public String getAutoClear() {
return autoClear.getString();
} |
public int getAutoClearConstant() {
return autoClear.get();
} |
public String getAutoDetach() {
return autoDetach.getString();
} |
public int getAutoDetachConstant() {
return autoDetach.getConstant();
} |
public String getBrokerFactory() {
return brokerFactoryPlugin.getString();
} |
public BrokerFactoryEventManager getBrokerFactoryEventManager() {
return _brokerFactoryEventManager;
} |
public String getBrokerImpl() {
return brokerPlugin.getString();
} |
public Map getCacheMarshallerInstances() {
return cacheMarshallerPlugins.getInstancesAsMap();
} |
public String getCacheMarshallers() {
return cacheMarshallerPlugins.getString();
} |
public String getClassResolver() {
return classResolverPlugin.getString();
} |
public ClassResolver getClassResolverInstance() {
if (classResolverPlugin.get() == null)
classResolverPlugin.instantiate(ClassResolver.class, this);
return (ClassResolver) classResolverPlugin.get();
} |
public String getCompatibility() {
return compatibilityPlugin.getString();
} |
public Compatibility getCompatibilityInstance() {
if (compatibilityPlugin.get() == null)
compatibilityPlugin.instantiate(Compatibility.class, this);
return (Compatibility) compatibilityPlugin.get();
} |
public Log getConfigurationLog() {
return getLog(LOG_RUNTIME);
} |
public String getConnection2DriverName() {
return connection2DriverName.getString();
} |
public String getConnection2Password() {
return connection2Password.getString();
} |
public String getConnection2Properties() {
return connection2Properties.getString();
} |
public String getConnection2URL() {
return connection2URL.getString();
} |
public String getConnection2UserName() {
return connection2UserName.getString();
} |
public String getConnectionDriverName() {
return connectionDriverName.getString();
} |
public Object getConnectionFactory() {
if (connectionFactory.get() == null)
connectionFactory.set(
lookupConnectionFactory(getConnectionFactoryName()), true);
return connectionFactory.get();
} |
public Object getConnectionFactory2() {
if (connectionFactory2.get() == null)
connectionFactory2.set(
lookupConnectionFactory(getConnectionFactory2Name()), false);
return connectionFactory2.get();
} |
public String getConnectionFactory2Name() {
return connectionFactory2Name.getString();
} |
public String getConnectionFactory2Properties() {
return connectionFactory2Properties.getString();
} |
public String getConnectionFactoryMode() {
return connectionFactoryMode.getString();
} |
public String getConnectionFactoryName() {
return connectionFactoryName.getString();
} |
public String getConnectionFactoryProperties() {
return connectionFactoryProperties.getString();
} |
public String getConnectionPassword() {
return connectionPassword.getString();
} |
public String getConnectionProperties() {
return connectionProperties.getString();
} |
public String getConnectionRetainMode() {
return connectionRetainMode.getString();
} |
public int getConnectionRetainModeConstant() {
return connectionRetainMode.get();
} |
public String getConnectionURL() {
return connectionURL.getString();
} |
public String getConnectionUserName() {
return connectionUserName.getString();
} |
public String getDataCache() {
return dataCachePlugin.getString();
} |
public String getDataCacheManager() {
return dataCacheManagerPlugin.getString();
} |
public DataCacheManager getDataCacheManagerInstance() {
DataCacheManager dcm = (DataCacheManager) dataCacheManagerPlugin.get();
if (dcm == null) {
dcm =
(DataCacheManager) dataCacheManagerPlugin.instantiate(
DataCacheManager.class, this);
dcm.initialize(this, dataCachePlugin, queryCachePlugin);
}
return dcm;
} |
public int getDataCacheTimeout() {
return dataCacheTimeout.get();
} |
public String getDetachState() {
return detachStatePlugin.getString();
} |
public DetachOptions getDetachStateInstance() {
if (detachStatePlugin.get() == null)
detachStatePlugin.instantiate(DetachOptions.class, this);
return (DetachOptions) detachStatePlugin.get();
} |
public boolean getDynamicDataStructs() {
return dynamicDataStructs.get();
} |
public int getFetchBatchSize() {
return fetchBatchSize.get();
} |
public String getFetchGroups() {
return fetchGroups.getString();
} |
public String[] getFetchGroupsList() {
return fetchGroups.get();
} |
public FilterListener[] getFilterListenerInstances() {
if (filterListenerPlugins.get() == null)
filterListenerPlugins.instantiate(FilterListener.class, this);
return (FilterListener[]) filterListenerPlugins.get();
} |
public String getFilterListeners() {
return filterListenerPlugins.getString();
} |
public String getFlushBeforeQueries() {
return flushBeforeQueries.getString();
} |
public int getFlushBeforeQueriesConstant() {
return flushBeforeQueries.get();
} |
public boolean getIgnoreChanges() {
return ignoreChanges.get();
} |
public String getInverseManager() {
return inverseManagerPlugin.getString();
} |
public String getLockManager() {
return lockManagerPlugin.getString();
} |
public int getLockTimeout() {
return lockTimeout.get();
} |
public String getManagedRuntime() {
return managedRuntimePlugin.getString();
} |
public ManagedRuntime getManagedRuntimeInstance() {
if (managedRuntimePlugin.get() == null)
managedRuntimePlugin.instantiate(ManagedRuntime.class, this);
return (ManagedRuntime) managedRuntimePlugin.get();
} |
public String getMapping() {
return mapping.getString();
} |
public int getMaxFetchDepth() {
return maxFetchDepth.get();
} |
public String getMetaDataFactory() {
return metaFactoryPlugin.getString();
} |
public String getMetaDataRepository() {
return metaRepositoryPlugin.getString();
} |
public MetaDataRepository getMetaDataRepositoryInstance() {
if (metaRepository == null)
metaRepository = newMetaDataRepositoryInstance();
return metaRepository;
} |
public boolean getMultithreaded() {
return multithreaded.get();
} |
public boolean getNontransactionalRead() {
return nontransactionalRead.get();
} |
public boolean getNontransactionalWrite() {
return nontransactionalWrite.get();
} |
public boolean getOptimistic() {
return optimistic.get();
} |
public String getOrphanedKeyAction() {
return orphanedKeyPlugin.getString();
} |
public OrphanedKeyAction getOrphanedKeyActionInstance() {
if (orphanedKeyPlugin.get() == null)
orphanedKeyPlugin.instantiate(OrphanedKeyAction.class, this);
return (OrphanedKeyAction) orphanedKeyPlugin.get();
} |
public String getProxyManager() {
return proxyManagerPlugin.getString();
} |
public ProxyManager getProxyManagerInstance() {
if (proxyManagerPlugin.get() == null)
proxyManagerPlugin.instantiate(ProxyManager.class, this);
return (ProxyManager) proxyManagerPlugin.get();
} |
public String getQueryCache() {
return queryCachePlugin.getString();
} |
public String getQueryCompilationCache() {
return queryCompilationCachePlugin.getString();
} |
public Map getQueryCompilationCacheInstance() {
if (queryCompilationCachePlugin.get() == null)
queryCompilationCachePlugin.instantiate(Map.class, this);
return (Map) queryCompilationCachePlugin.get();
} |
public String getReadLockLevel() {
return readLockLevel.getString();
} |
public int getReadLockLevelConstant() {
return readLockLevel.get();
} |
public RemoteCommitEventManager getRemoteCommitEventManager() {
if (remoteEventManager == null) {
remoteEventManager = new RemoteCommitEventManager(this);
remoteProviderPlugin.configureEventManager(remoteEventManager);
}
return remoteEventManager;
} |
public String getRemoteCommitProvider() {
return remoteProviderPlugin.getString();
} |
public String getRestoreState() {
return restoreState.getString();
} |
public int getRestoreStateConstant() {
return restoreState.get();
} |
public boolean getRetainState() {
return retainState.get();
} |
public boolean getRetryClassRegistration() {
return retryClassRegistration.get();
} |
public String getRuntimeUnenhancedClasses() {
return runtimeUnenhancedClasses.getString();
} |
public int getRuntimeUnenhancedClassesConstant() {
return runtimeUnenhancedClasses.get();
} |
public String getSavepointManager() {
return savepointManagerPlugin.getString();
} |
public SavepointManager getSavepointManagerInstance() {
if (savepointManagerPlugin.get() == null)
savepointManagerPlugin.instantiate(SavepointManager.class, this);
return (SavepointManager) savepointManagerPlugin.get();
} |
public String getSequence() {
return seqPlugin.getString();
} |
public Seq getSequenceInstance() {
if (seqPlugin.get() == null)
seqPlugin.instantiate(Seq.class, this);
return (Seq) seqPlugin.get();
} |
public String getSpecification() {
return spec;
} |
public StoreFacadeTypeRegistry getStoreFacadeTypeRegistry() {
return _storeFacadeRegistry;
} |
public String getTransactionMode() {
return transactionMode.getString();
} |
public String getWriteLockLevel() {
return writeLockLevel.getString();
} |
public int getWriteLockLevelConstant() {
return writeLockLevel.get();
} |
public void instantiateAll() {
super.instantiateAll();
getMetaDataRepositoryInstance();
getRemoteCommitEventManager();
cacheMarshallerPlugins.initialize();
} |
public boolean isConnectionFactoryModeManaged() {
return connectionFactoryMode.get();
} |
public boolean isTransactionModeManaged() {
return transactionMode.get();
} |
public boolean metaDataRepositoryAvailable() {
return metaRepository != null;
} |
public BrokerImpl newBrokerInstance(String user,
String pass) {
BrokerImpl broker =
(BrokerImpl) brokerPlugin.instantiate(BrokerImpl.class, this);
if (broker != null)
broker.setAuthentication(user, pass);
return broker;
} |
public InverseManager newInverseManagerInstance() {
return (InverseManager) inverseManagerPlugin.instantiate(
InverseManager.class, this);
} |
public LockManager newLockManagerInstance() {
// don't validate plugin properties on instantiation because it
// is likely that back ends will override defaults with their
// own subclasses with new properties
return (LockManager) lockManagerPlugin.instantiate(LockManager.class,
this, false);
} |
public MetaDataFactory newMetaDataFactoryInstance() {
return (MetaDataFactory) metaFactoryPlugin.instantiate(
MetaDataFactory.class, this);
} |
public MetaDataRepository newMetaDataRepositoryInstance() {
return (MetaDataRepository) metaRepositoryPlugin.instantiate(
MetaDataRepository.class, this);
} |
public RemoteCommitProvider newRemoteCommitProviderInstance() {
return remoteProviderPlugin.instantiateProvider(this);
} |
protected void preClose() {
ImplHelper.close(metaRepository);
ImplHelper.close(remoteEventManager);
super.preClose();
} |
public void setAggregateListeners(String aggregateListeners) {
aggregateListenerPlugins.setString(aggregateListeners);
} |
public void setAggregateListeners(AggregateListener[] listeners) {
aggregateListenerPlugins.set(listeners);
} |
public void setAutoClear(String clear) {
autoClear.setString(clear);
} |
public void setAutoClear(int clear) {
autoClear.set(clear);
} |
public void setAutoDetach(String autoDetach) {
this.autoDetach.setString(autoDetach);
} |
public void setAutoDetach(int autoDetachFlags) {
autoDetach.setConstant(autoDetachFlags);
} |
public void setBrokerFactory(String factory) {
brokerFactoryPlugin.setString(factory);
} |
public void setBrokerImpl(String broker) {
brokerPlugin.setString(broker);
} |
public void setCacheMarshallers(String marshallers) {
cacheMarshallerPlugins.setString(marshallers);
} |
public void setClassResolver(String classResolver) {
classResolverPlugin.setString(classResolver);
} |
public void setClassResolver(ClassResolver classResolver) {
classResolverPlugin.set(classResolver);
} |
public void setCompatibility(String compatibility) {
compatibilityPlugin.setString(compatibility);
} |
public void setConnection2DriverName(String driverName) {
this.connection2DriverName.setString(driverName);
} |
public void setConnection2Password(String connection2Password) {
this.connection2Password.setString(connection2Password);
} |
public void setConnection2Properties(String connection2Properties) {
this.connection2Properties.setString(connection2Properties);
} |
public void setConnection2URL(String connection2URL) {
this.connection2URL.setString(connection2URL);
} |
public void setConnection2UserName(String connection2UserName) {
this.connection2UserName.setString(connection2UserName);
} |
public void setConnectionDriverName(String driverName) {
this.connectionDriverName.setString(driverName);
} |
public void setConnectionFactory(Object factory) {
connectionFactory.set(factory);
} |
public void setConnectionFactory2(Object factory) {
connectionFactory2.set(factory);
} |
public void setConnectionFactory2Name(String connectionFactory2Name) {
this.connectionFactory2Name.setString(connectionFactory2Name);
} |
public void setConnectionFactory2Properties(String connectionFactory2Properties) {
this.connectionFactory2Properties
.setString(connectionFactory2Properties);
} |
public void setConnectionFactoryMode(String mode) {
connectionFactoryMode.setString(mode);
} |
public void setConnectionFactoryModeManaged(boolean managed) {
connectionFactoryMode.set(managed);
} |
public void setConnectionFactoryName(String connectionFactoryName) {
this.connectionFactoryName.setString(connectionFactoryName);
} |
public void setConnectionFactoryProperties(String connectionFactoryProperties) {
this.connectionFactoryProperties.setString(connectionFactoryProperties);
} |
public void setConnectionPassword(String connectionPassword) {
this.connectionPassword.setString(connectionPassword);
} |
public void setConnectionProperties(String connectionProperties) {
this.connectionProperties.setString(connectionProperties);
} |
public void setConnectionRetainMode(String connectionRetainMode) {
this.connectionRetainMode.setString(connectionRetainMode);
} |
public void setConnectionRetainMode(int connectionRetainMode) {
this.connectionRetainMode.set(connectionRetainMode);
} |
public void setConnectionURL(String connectionURL) {
this.connectionURL.setString(connectionURL);
} |
public void setConnectionUserName(String connectionUserName) {
this.connectionUserName.setString(connectionUserName);
} |
public void setDataCache(String dataCache) {
dataCachePlugin.setString(dataCache);
} |
public void setDataCacheManager(String mgr) {
dataCacheManagerPlugin.setString(mgr);
} |
public void setDataCacheManager(DataCacheManager dcm) {
if (dcm != null)
dcm.initialize(this, dataCachePlugin, queryCachePlugin);
dataCacheManagerPlugin.set(dcm);
} |
public void setDataCacheTimeout(int dataCacheTimeout) {
this.dataCacheTimeout.set(dataCacheTimeout);
} |
public void setDataCacheTimeout(Integer dataCacheTimeout) {
if (dataCacheTimeout != null)
setDataCacheTimeout(dataCacheTimeout.intValue());
} |
public void setDetachState(String detachState) {
detachStatePlugin.setString(detachState);
} |
public void setDetachState(DetachOptions detachState) {
detachStatePlugin.set(detachState);
} |
public void setDynamicDataStructs(boolean dynamic) {
dynamicDataStructs.set(dynamic);
} |
public void setDynamicDataStructs(Boolean dynamic) {
setDynamicDataStructs(dynamic.booleanValue());
} |
public void setFetchBatchSize(int fetchBatchSize) {
this.fetchBatchSize.set(fetchBatchSize);
} |
public void setFetchBatchSize(Integer fetchBatchSize) {
if (fetchBatchSize != null)
setFetchBatchSize(fetchBatchSize.intValue());
} |
public void setFetchGroups(String fetchGroups) {
this.fetchGroups.setString(fetchGroups);
} |
public void setFetchGroups(String[] fetchGroups) {
this.fetchGroups.set(fetchGroups);
} |
public void setFilterListeners(String filterListeners) {
filterListenerPlugins.setString(filterListeners);
} |
public void setFilterListeners(FilterListener[] listeners) {
filterListenerPlugins.set(listeners);
} |
public void setFlushBeforeQueries(String flush) {
flushBeforeQueries.setString(flush);
} |
public void setFlushBeforeQueries(int flush) {
flushBeforeQueries.set(flush);
} |
public void setIgnoreChanges(boolean ignoreChanges) {
this.ignoreChanges.set(ignoreChanges);
} |
public void setIgnoreChanges(Boolean ignoreChanges) {
if (ignoreChanges != null)
setIgnoreChanges(ignoreChanges.booleanValue());
} |
public void setInverseManager(String inverseManager) {
inverseManagerPlugin.setString(inverseManager);
} |
public void setLockManager(String lockManager) {
lockManagerPlugin.setString(lockManager);
} |
public void setLockTimeout(int timeout) {
lockTimeout.set(timeout);
} |
public void setLockTimeout(Integer timeout) {
if (timeout != null)
setLockTimeout(timeout.intValue());
} |
public void setManagedRuntime(String managedRuntime) {
managedRuntimePlugin.setString(managedRuntime);
} |
public void setManagedRuntime(ManagedRuntime managedRuntime) {
managedRuntimePlugin.set(managedRuntime);
} |
public void setMapping(String mapping) {
this.mapping.setString(mapping);
} |
public void setMaxFetchDepth(int maxFetchDepth) {
this.maxFetchDepth.set(maxFetchDepth);
} |
public void setMaxFetchDepth(Integer maxFetchDepth) {
if (maxFetchDepth != null)
setMaxFetchDepth(maxFetchDepth.intValue());
} |
public void setMetaDataFactory(String meta) {
this.metaFactoryPlugin.setString(meta);
} |
public void setMetaDataRepository(String meta) {
this.metaRepositoryPlugin.setString(meta);
} |
public void setMetaDataRepository(MetaDataRepository meta) {
metaRepository = meta;
} |
public void setMultithreaded(boolean multithreaded) {
this.multithreaded.set(multithreaded);
} |
public void setMultithreaded(Boolean multithreaded) {
if (multithreaded != null)
setMultithreaded(multithreaded.booleanValue());
} |
public void setNontransactionalRead(boolean nontransactionalRead) {
this.nontransactionalRead.set(nontransactionalRead);
} |
public void setNontransactionalRead(Boolean nontransactionalRead) {
if (nontransactionalRead != null)
setNontransactionalRead(nontransactionalRead.booleanValue());
} |
public void setNontransactionalWrite(boolean nontransactionalWrite) {
this.nontransactionalWrite.set(nontransactionalWrite);
} |
public void setNontransactionalWrite(Boolean nontransactionalWrite) {
if (nontransactionalWrite != null)
setNontransactionalWrite(nontransactionalWrite.booleanValue());
} |
public void setOptimistic(boolean optimistic) {
this.optimistic.set(optimistic);
} |
public void setOptimistic(Boolean optimistic) {
if (optimistic != null)
setOptimistic(optimistic.booleanValue());
} |
public void setOrphanedKeyAction(String action) {
orphanedKeyPlugin.setString(action);
} |
public void setOrphanedKeyAction(OrphanedKeyAction action) {
orphanedKeyPlugin.set(action);
} |
public void setProxyManager(String proxyManager) {
proxyManagerPlugin.setString(proxyManager);
} |
public void setProxyManager(ProxyManager proxyManager) {
proxyManagerPlugin.set(proxyManager);
} |
public void setQueryCache(String queryCache) {
queryCachePlugin.setString(queryCache);
} |
public void setQueryCompilationCache(String queryCompilationCache) {
queryCompilationCachePlugin.setString(queryCompilationCache);
} |
public void setReadLockLevel(String level) {
readLockLevel.setString(level);
} |
public void setReadLockLevel(int level) {
readLockLevel.set(level);
} |
public void setRemoteCommitEventManager(RemoteCommitEventManager remoteEventManager) {
this.remoteEventManager = remoteEventManager;
remoteProviderPlugin.configureEventManager(remoteEventManager);
} |
public void setRemoteCommitProvider(String remoteCommitProvider) {
remoteProviderPlugin.setString(remoteCommitProvider);
} |
public void setRestoreState(String restoreState) {
this.restoreState.setString(restoreState);
} |
public void setRestoreState(int restoreState) {
this.restoreState.set(restoreState);
} |
public void setRetainState(boolean retainState) {
this.retainState.set(retainState);
} |
public void setRetainState(Boolean retainState) {
if (retainState != null)
setRetainState(retainState.booleanValue());
} |
public void setRetryClassRegistration(boolean retry) {
retryClassRegistration.set(retry);
} |
public void setRetryClassRegistration(Boolean retry) {
if (retry != null)
setRetryClassRegistration(retry.booleanValue());
} |
public void setRuntimeUnenhancedClasses(int mode) {
runtimeUnenhancedClasses.set(mode);
} |
public void setRuntimeUnenhancedClasses(String mode) {
runtimeUnenhancedClasses.setString(mode);
} |
public void setSavepointManager(String savepointManager) {
savepointManagerPlugin.setString(savepointManager);
} |
public void setSequence(String sequence) {
seqPlugin.setString(sequence);
} |
public void setSequence(Seq seq) {
seqPlugin.set(seq);
} |
public boolean setSpecification(String spec) {
if (spec == null)
return false;
if (this.spec != null) {
if (!this.spec.equals(spec)
&& getConfigurationLog().isWarnEnabled())
getConfigurationLog().warn(
_loc.get("diff-specs", this.spec, spec));
return false;
}
this.spec = spec;
ProductDerivations.afterSpecificationSet(this);
return true;
} |
public void setTransactionMode(String transactionMode) {
this.transactionMode.setString(transactionMode);
} |
public void setTransactionModeManaged(boolean managed) {
transactionMode.set(managed);
} |
public void setWriteLockLevel(String level) {
writeLockLevel.setString(level);
} |
public void setWriteLockLevel(int level) {
writeLockLevel.set(level);
} |
public Collection supportedOptions() {
return supportedOptions;
} |
org.apache.openjpa.lib.conf.ConfigurationImpl
Save This Page