//
|
// Source code recreated from a .class file by IntelliJ IDEA
|
// (powered by FernFlower decompiler)
|
//
|
|
package org.activiti.engine.impl.cfg;
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import org.activiti.dmn.api.DmnRepositoryService;
|
import org.activiti.dmn.api.DmnRuleService;
|
import org.activiti.engine.*;
|
import org.activiti.engine.cfg.ProcessEngineConfigurator;
|
import org.activiti.engine.compatibility.Activiti5CompatibilityHandler;
|
import org.activiti.engine.compatibility.Activiti5CompatibilityHandlerFactory;
|
import org.activiti.engine.compatibility.DefaultActiviti5CompatibilityHandlerFactory;
|
import org.activiti.engine.delegate.event.ActivitiEventDispatcher;
|
import org.activiti.engine.delegate.event.ActivitiEventListener;
|
import org.activiti.engine.delegate.event.ActivitiEventType;
|
import org.activiti.engine.delegate.event.impl.ActivitiEventDispatcherImpl;
|
import org.activiti.engine.form.AbstractFormType;
|
import org.activiti.engine.impl.*;
|
import org.activiti.engine.impl.agenda.DefaultActivitiEngineAgendaFactory;
|
import org.activiti.engine.impl.asyncexecutor.DefaultAsyncJobExecutor;
|
import org.activiti.engine.impl.asyncexecutor.DefaultJobManager;
|
import org.activiti.engine.impl.asyncexecutor.ExecuteAsyncRunnableFactory;
|
import org.activiti.engine.impl.asyncexecutor.JobManager;
|
import org.activiti.engine.impl.bpmn.data.ItemInstance;
|
import org.activiti.engine.impl.bpmn.deployer.*;
|
import org.activiti.engine.impl.bpmn.listener.ListenerNotificationHelper;
|
import org.activiti.engine.impl.bpmn.parser.BpmnParseHandlers;
|
import org.activiti.engine.impl.bpmn.parser.BpmnParser;
|
import org.activiti.engine.impl.bpmn.parser.factory.*;
|
import org.activiti.engine.impl.bpmn.parser.handler.*;
|
import org.activiti.engine.impl.bpmn.webservice.MessageInstance;
|
import org.activiti.engine.impl.calendar.*;
|
import org.activiti.engine.impl.cfg.standalone.StandaloneMybatisTransactionContextFactory;
|
import org.activiti.engine.impl.cmd.ValidateExecutionRelatedEntityCountCfgCmd;
|
import org.activiti.engine.impl.context.Context;
|
import org.activiti.engine.impl.db.DbIdGenerator;
|
import org.activiti.engine.impl.db.DbSqlSessionFactory;
|
import org.activiti.engine.impl.db.IbatisVariableTypeHandler;
|
import org.activiti.engine.impl.delegate.invocation.DefaultDelegateInterceptor;
|
import org.activiti.engine.impl.el.ExpressionManager;
|
import org.activiti.engine.impl.event.CompensationEventHandler;
|
import org.activiti.engine.impl.event.EventHandler;
|
import org.activiti.engine.impl.event.MessageEventHandler;
|
import org.activiti.engine.impl.event.SignalEventHandler;
|
import org.activiti.engine.impl.event.logger.EventLogger;
|
import org.activiti.engine.impl.form.*;
|
import org.activiti.engine.impl.history.DefaultHistoryManager;
|
import org.activiti.engine.impl.history.HistoryLevel;
|
import org.activiti.engine.impl.history.HistoryManager;
|
import org.activiti.engine.impl.interceptor.*;
|
import org.activiti.engine.impl.jobexecutor.*;
|
import org.activiti.engine.impl.persistence.GenericManagerFactory;
|
import org.activiti.engine.impl.persistence.cache.EntityCache;
|
import org.activiti.engine.impl.persistence.cache.EntityCacheImpl;
|
import org.activiti.engine.impl.persistence.deploy.*;
|
import org.activiti.engine.impl.persistence.entity.*;
|
import org.activiti.engine.impl.persistence.entity.data.*;
|
import org.activiti.engine.impl.persistence.entity.data.impl.*;
|
import org.activiti.engine.impl.scripting.*;
|
import org.activiti.engine.impl.util.DefaultClockImpl;
|
import org.activiti.engine.impl.util.IoUtil;
|
import org.activiti.engine.impl.util.ProcessInstanceHelper;
|
import org.activiti.engine.impl.util.ReflectUtil;
|
import org.activiti.engine.impl.variable.*;
|
import org.activiti.engine.parse.BpmnParseHandler;
|
import org.activiti.engine.runtime.Clock;
|
import org.activiti.form.api.FormRepositoryService;
|
import org.activiti.image.impl.DefaultProcessDiagramGenerator;
|
import org.activiti.validation.ProcessValidator;
|
import org.activiti.validation.ProcessValidatorFactory;
|
import org.apache.ibatis.builder.xml.XMLConfigBuilder;
|
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
|
import org.apache.ibatis.datasource.pooled.PooledDataSource;
|
import org.apache.ibatis.mapping.Environment;
|
import org.apache.ibatis.session.Configuration;
|
import org.apache.ibatis.session.SqlSessionFactory;
|
import org.apache.ibatis.session.defaults.DefaultSqlSessionFactory;
|
import org.apache.ibatis.transaction.TransactionFactory;
|
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
|
import org.apache.ibatis.transaction.managed.ManagedTransactionFactory;
|
import org.apache.ibatis.type.JdbcType;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import javax.naming.InitialContext;
|
import javax.sql.DataSource;
|
import javax.xml.namespace.QName;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.io.Reader;
|
import java.net.URL;
|
import java.sql.Connection;
|
import java.sql.DatabaseMetaData;
|
import java.sql.SQLException;
|
import java.util.*;
|
import java.util.concurrent.BlockingQueue;
|
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.concurrent.ConcurrentMap;
|
|
public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfiguration {
|
private static Logger log = LoggerFactory.getLogger(ProcessEngineConfigurationImpl.class);
|
public static final String DB_SCHEMA_UPDATE_CREATE = "create";
|
public static final String DB_SCHEMA_UPDATE_DROP_CREATE = "drop-create";
|
public static final String DEFAULT_WS_SYNC_FACTORY = "org.activiti.engine.impl.webservice.CxfWebServiceClientFactory";
|
public static final String DEFAULT_MYBATIS_MAPPING_FILE = "org/activiti/db/mapping/mappings.xml";
|
public static final int DEFAULT_GENERIC_MAX_LENGTH_STRING = 4000;
|
public static final int DEFAULT_ORACLE_MAX_LENGTH_STRING = 2000;
|
protected RepositoryService repositoryService = new RepositoryServiceImpl();
|
protected RuntimeService runtimeService = new RuntimeServiceImpl();
|
protected HistoryService historyService = new HistoryServiceImpl(this);
|
protected IdentityService identityService = new IdentityServiceImpl();
|
protected TaskService taskService = new TaskServiceImpl(this);
|
protected FormService formService = new FormServiceImpl();
|
protected ManagementService managementService = new ManagementServiceImpl();
|
protected DynamicBpmnService dynamicBpmnService = new DynamicBpmnServiceImpl(this);
|
protected boolean formEngineInitialized;
|
protected FormRepositoryService formEngineRepositoryService;
|
protected org.activiti.form.api.FormService formEngineFormService;
|
protected boolean dmnEngineInitialized;
|
protected DmnRepositoryService dmnEngineRepositoryService;
|
protected DmnRuleService dmnEngineRuleService;
|
protected CommandConfig defaultCommandConfig;
|
protected CommandConfig schemaCommandConfig;
|
protected CommandInterceptor commandInvoker;
|
protected List<CommandInterceptor> customPreCommandInterceptors;
|
protected List<CommandInterceptor> customPostCommandInterceptors;
|
protected List<CommandInterceptor> commandInterceptors;
|
protected CommandExecutor commandExecutor;
|
protected AttachmentDataManager attachmentDataManager;
|
protected ByteArrayDataManager byteArrayDataManager;
|
protected CommentDataManager commentDataManager;
|
protected DeploymentDataManager deploymentDataManager;
|
protected EventLogEntryDataManager eventLogEntryDataManager;
|
protected EventSubscriptionDataManager eventSubscriptionDataManager;
|
protected ExecutionDataManager executionDataManager;
|
protected GroupDataManager groupDataManager;
|
protected HistoricActivityInstanceDataManager historicActivityInstanceDataManager;
|
protected HistoricDetailDataManager historicDetailDataManager;
|
protected HistoricIdentityLinkDataManager historicIdentityLinkDataManager;
|
protected HistoricProcessInstanceDataManager historicProcessInstanceDataManager;
|
protected HistoricTaskInstanceDataManager historicTaskInstanceDataManager;
|
protected HistoricVariableInstanceDataManager historicVariableInstanceDataManager;
|
protected IdentityInfoDataManager identityInfoDataManager;
|
protected IdentityLinkDataManager identityLinkDataManager;
|
protected JobDataManager jobDataManager;
|
protected TimerJobDataManager timerJobDataManager;
|
protected SuspendedJobDataManager suspendedJobDataManager;
|
protected DeadLetterJobDataManager deadLetterJobDataManager;
|
protected MembershipDataManager membershipDataManager;
|
protected ModelDataManager modelDataManager;
|
protected ProcessDefinitionDataManager processDefinitionDataManager;
|
protected ProcessDefinitionInfoDataManager processDefinitionInfoDataManager;
|
protected PropertyDataManager propertyDataManager;
|
protected ResourceDataManager resourceDataManager;
|
protected TaskDataManager taskDataManager;
|
protected UserDataManager userDataManager;
|
protected VariableInstanceDataManager variableInstanceDataManager;
|
protected AttachmentEntityManager attachmentEntityManager;
|
protected ByteArrayEntityManager byteArrayEntityManager;
|
protected CommentEntityManager commentEntityManager;
|
protected DeploymentEntityManager deploymentEntityManager;
|
protected EventLogEntryEntityManager eventLogEntryEntityManager;
|
protected EventSubscriptionEntityManager eventSubscriptionEntityManager;
|
protected ExecutionEntityManager executionEntityManager;
|
protected GroupEntityManager groupEntityManager;
|
protected HistoricActivityInstanceEntityManager historicActivityInstanceEntityManager;
|
protected HistoricDetailEntityManager historicDetailEntityManager;
|
protected HistoricIdentityLinkEntityManager historicIdentityLinkEntityManager;
|
protected HistoricProcessInstanceEntityManager historicProcessInstanceEntityManager;
|
protected HistoricTaskInstanceEntityManager historicTaskInstanceEntityManager;
|
protected HistoricVariableInstanceEntityManager historicVariableInstanceEntityManager;
|
protected IdentityInfoEntityManager identityInfoEntityManager;
|
protected IdentityLinkEntityManager identityLinkEntityManager;
|
protected JobEntityManager jobEntityManager;
|
protected TimerJobEntityManager timerJobEntityManager;
|
protected SuspendedJobEntityManager suspendedJobEntityManager;
|
protected DeadLetterJobEntityManager deadLetterJobEntityManager;
|
protected MembershipEntityManager membershipEntityManager;
|
protected ModelEntityManager modelEntityManager;
|
protected ProcessDefinitionEntityManager processDefinitionEntityManager;
|
protected ProcessDefinitionInfoEntityManager processDefinitionInfoEntityManager;
|
protected PropertyEntityManager propertyEntityManager;
|
protected ResourceEntityManager resourceEntityManager;
|
protected TableDataManager tableDataManager;
|
protected TaskEntityManager taskEntityManager;
|
protected UserEntityManager userEntityManager;
|
protected VariableInstanceEntityManager variableInstanceEntityManager;
|
protected HistoryManager historyManager;
|
protected JobManager jobManager;
|
protected List<SessionFactory> customSessionFactories;
|
protected DbSqlSessionFactory dbSqlSessionFactory;
|
protected Map<Class<?>, SessionFactory> sessionFactories;
|
protected boolean enableConfiguratorServiceLoader = true;
|
protected List<ProcessEngineConfigurator> configurators;
|
protected List<ProcessEngineConfigurator> allConfigurators;
|
protected BpmnDeployer bpmnDeployer;
|
protected BpmnParser bpmnParser;
|
protected ParsedDeploymentBuilderFactory parsedDeploymentBuilderFactory;
|
protected TimerManager timerManager;
|
protected EventSubscriptionManager eventSubscriptionManager;
|
protected BpmnDeploymentHelper bpmnDeploymentHelper;
|
protected CachingAndArtifactsManager cachingAndArtifactsManager;
|
protected ProcessDefinitionDiagramHelper processDefinitionDiagramHelper;
|
protected List<Deployer> customPreDeployers;
|
protected List<Deployer> customPostDeployers;
|
protected List<Deployer> deployers;
|
protected DeploymentManager deploymentManager;
|
protected int processDefinitionCacheLimit = -1;
|
protected DeploymentCache<ProcessDefinitionCacheEntry> processDefinitionCache;
|
protected int processDefinitionInfoCacheLimit = -1;
|
protected ProcessDefinitionInfoCache processDefinitionInfoCache;
|
protected int knowledgeBaseCacheLimit = -1;
|
protected DeploymentCache<Object> knowledgeBaseCache;
|
protected List<JobHandler> customJobHandlers;
|
protected Map<String, JobHandler> jobHandlers;
|
protected ProcessInstanceHelper processInstanceHelper;
|
protected ListenerNotificationHelper listenerNotificationHelper;
|
protected int asyncExecutorNumberOfRetries = 3;
|
protected int asyncExecutorCorePoolSize = 2;
|
protected int asyncExecutorMaxPoolSize = 10;
|
protected long asyncExecutorThreadKeepAliveTime = 5000L;
|
protected int asyncExecutorThreadPoolQueueSize = 100;
|
protected BlockingQueue<Runnable> asyncExecutorThreadPoolQueue;
|
protected long asyncExecutorSecondsToWaitOnShutdown = 60L;
|
protected int asyncExecutorMaxTimerJobsPerAcquisition = 1;
|
protected int asyncExecutorMaxAsyncJobsDuePerAcquisition = 1;
|
protected int asyncExecutorDefaultTimerJobAcquireWaitTime = 10000;
|
protected int asyncExecutorDefaultAsyncJobAcquireWaitTime = 10000;
|
protected int asyncExecutorDefaultQueueSizeFullWaitTime = 0;
|
protected String asyncExecutorLockOwner;
|
protected int asyncExecutorTimerLockTimeInMillis = 300000;
|
protected int asyncExecutorAsyncJobLockTimeInMillis = 300000;
|
protected int asyncExecutorResetExpiredJobsInterval = 60000;
|
protected int asyncExecutorResetExpiredJobsPageSize = 3;
|
protected boolean asyncExecutorMessageQueueMode;
|
protected ExecuteAsyncRunnableFactory asyncExecutorExecuteAsyncRunnableFactory;
|
protected SqlSessionFactory sqlSessionFactory;
|
protected TransactionFactory transactionFactory;
|
protected Set<Class<?>> customMybatisMappers;
|
protected Set<String> customMybatisXMLMappers;
|
protected IdGenerator idGenerator;
|
protected DataSource idGeneratorDataSource;
|
protected String idGeneratorDataSourceJndiName;
|
protected List<BpmnParseHandler> preBpmnParseHandlers;
|
protected List<BpmnParseHandler> postBpmnParseHandlers;
|
protected List<BpmnParseHandler> customDefaultBpmnParseHandlers;
|
protected ActivityBehaviorFactory activityBehaviorFactory;
|
protected ListenerFactory listenerFactory;
|
protected BpmnParseFactory bpmnParseFactory;
|
protected ProcessValidator processValidator;
|
protected List<FormEngine> customFormEngines;
|
protected Map<String, FormEngine> formEngines;
|
protected List<AbstractFormType> customFormTypes;
|
protected FormTypes formTypes;
|
protected List<VariableType> customPreVariableTypes;
|
protected List<VariableType> customPostVariableTypes;
|
protected VariableTypes variableTypes;
|
protected boolean serializableVariableTypeTrackDeserializedObjects = true;
|
protected ExpressionManager expressionManager;
|
protected List<String> customScriptingEngineClasses;
|
protected ScriptingEngines scriptingEngines;
|
protected List<ResolverFactory> resolverFactories;
|
protected BusinessCalendarManager businessCalendarManager;
|
protected int executionQueryLimit = 20000;
|
protected int taskQueryLimit = 20000;
|
protected int historicTaskQueryLimit = 20000;
|
protected int historicProcessInstancesQueryLimit = 20000;
|
protected String wsSyncFactoryClassName = "org.activiti.engine.impl.webservice.CxfWebServiceClientFactory";
|
protected ConcurrentMap<QName, URL> wsOverridenEndpointAddresses = new ConcurrentHashMap();
|
protected CommandContextFactory commandContextFactory;
|
protected TransactionContextFactory transactionContextFactory;
|
protected Map<Object, Object> beans;
|
protected DelegateInterceptor delegateInterceptor;
|
protected Map<String, EventHandler> eventHandlers;
|
protected List<EventHandler> customEventHandlers;
|
protected FailedJobCommandFactory failedJobCommandFactory;
|
protected boolean enableSafeBpmnXml;
|
protected int batchSizeProcessInstances = 25;
|
protected int batchSizeTasks = 25;
|
protected boolean enableEventDispatcher = true;
|
protected ActivitiEventDispatcher eventDispatcher;
|
protected List<ActivitiEventListener> eventListeners;
|
protected Map<String, List<ActivitiEventListener>> typedEventListeners;
|
protected boolean enableDatabaseEventLogging;
|
protected DelegateExpressionFieldInjectionMode delegateExpressionFieldInjectionMode;
|
protected int maxLengthStringVariableType;
|
protected boolean isBulkInsertEnabled;
|
protected int maxNrOfStatementsInBulkInsert;
|
public int DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER;
|
protected ObjectMapper objectMapper;
|
protected boolean usingRelationalDatabase;
|
protected boolean enableVerboseExecutionTreeLogging;
|
protected PerformanceSettings performanceSettings;
|
protected boolean isActiviti5CompatibilityEnabled;
|
protected Activiti5CompatibilityHandlerFactory activiti5CompatibilityHandlerFactory;
|
protected Activiti5CompatibilityHandler activiti5CompatibilityHandler;
|
protected Object activiti5ActivityBehaviorFactory;
|
protected Object activiti5ListenerFactory;
|
protected List<Object> activiti5PreBpmnParseHandlers;
|
protected List<Object> activiti5PostBpmnParseHandlers;
|
protected List<Object> activiti5CustomDefaultBpmnParseHandlers;
|
protected Set<Class<?>> activiti5CustomMybatisMappers;
|
protected Set<String> activiti5CustomMybatisXMLMappers;
|
protected static Properties databaseTypeMappings = getDefaultDatabaseTypeMappings();
|
|
public static final String DATABASE_TYPE_DM = "dm";
|
public static final String DATABASE_TYPE_H2 = "h2";
|
public static final String DATABASE_TYPE_HSQL = "hsql";
|
public static final String DATABASE_TYPE_MYSQL = "mysql";
|
public static final String DATABASE_TYPE_ORACLE = "oracle";
|
public static final String DATABASE_TYPE_POSTGRES = "postgres";
|
public static final String DATABASE_TYPE_MSSQL = "mssql";
|
public static final String DATABASE_TYPE_DB2 = "db2";
|
|
public ProcessEngineConfigurationImpl() {
|
this.delegateExpressionFieldInjectionMode = DelegateExpressionFieldInjectionMode.MIXED;
|
this.maxLengthStringVariableType = -1;
|
this.isBulkInsertEnabled = true;
|
this.maxNrOfStatementsInBulkInsert = 100;
|
this.DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER = 70;
|
this.objectMapper = new ObjectMapper();
|
this.usingRelationalDatabase = true;
|
this.performanceSettings = new PerformanceSettings();
|
}
|
|
public ProcessEngine buildProcessEngine() {
|
this.init();
|
ProcessEngineImpl processEngine = new ProcessEngineImpl(this);
|
if (this.isActiviti5CompatibilityEnabled && this.activiti5CompatibilityHandler != null) {
|
Context.setProcessEngineConfiguration(processEngine.getProcessEngineConfiguration());
|
this.activiti5CompatibilityHandler.getRawProcessEngine();
|
}
|
|
this.postProcessEngineInitialisation();
|
return processEngine;
|
}
|
|
public void init() {
|
this.initConfigurators();
|
this.configuratorsBeforeInit();
|
this.initProcessDiagramGenerator();
|
this.initHistoryLevel();
|
this.initExpressionManager();
|
if (this.usingRelationalDatabase) {
|
this.initDataSource();
|
}
|
|
this.initAgendaFactory();
|
this.initHelpers();
|
this.initVariableTypes();
|
this.initBeans();
|
this.initFormEngines();
|
this.initFormTypes();
|
this.initScriptingEngines();
|
this.initClock();
|
this.initBusinessCalendarManager();
|
this.initCommandContextFactory();
|
this.initTransactionContextFactory();
|
this.initCommandExecutors();
|
this.initServices();
|
this.initIdGenerator();
|
this.initBehaviorFactory();
|
this.initListenerFactory();
|
this.initBpmnParser();
|
this.initProcessDefinitionCache();
|
this.initProcessDefinitionInfoCache();
|
this.initKnowledgeBaseCache();
|
this.initJobHandlers();
|
this.initJobManager();
|
this.initAsyncExecutor();
|
this.initTransactionFactory();
|
if (this.usingRelationalDatabase) {
|
this.initSqlSessionFactory();
|
}
|
|
this.initSessionFactories();
|
this.initDataManagers();
|
this.initEntityManagers();
|
this.initHistoryManager();
|
this.initJpa();
|
this.initDeployers();
|
this.initDelegateInterceptor();
|
this.initEventHandlers();
|
this.initFailedJobCommandFactory();
|
this.initEventDispatcher();
|
this.initProcessValidator();
|
this.initDatabaseEventLogging();
|
this.initActiviti5CompatibilityHandler();
|
this.configuratorsAfterInit();
|
}
|
|
public void initFailedJobCommandFactory() {
|
if (this.failedJobCommandFactory == null) {
|
this.failedJobCommandFactory = new DefaultFailedJobCommandFactory();
|
}
|
|
}
|
|
public void initCommandExecutors() {
|
this.initDefaultCommandConfig();
|
this.initSchemaCommandConfig();
|
this.initCommandInvoker();
|
this.initCommandInterceptors();
|
this.initCommandExecutor();
|
}
|
|
public void initDefaultCommandConfig() {
|
if (this.defaultCommandConfig == null) {
|
this.defaultCommandConfig = new CommandConfig();
|
}
|
|
}
|
|
public void initSchemaCommandConfig() {
|
if (this.schemaCommandConfig == null) {
|
this.schemaCommandConfig = (new CommandConfig()).transactionNotSupported();
|
}
|
|
}
|
|
public void initCommandInvoker() {
|
if (this.commandInvoker == null) {
|
if (this.enableVerboseExecutionTreeLogging) {
|
this.commandInvoker = new DebugCommandInvoker();
|
} else {
|
this.commandInvoker = new CommandInvoker();
|
}
|
}
|
|
}
|
|
public void initCommandInterceptors() {
|
if (this.commandInterceptors == null) {
|
this.commandInterceptors = new ArrayList();
|
if (this.customPreCommandInterceptors != null) {
|
this.commandInterceptors.addAll(this.customPreCommandInterceptors);
|
}
|
|
this.commandInterceptors.addAll(this.getDefaultCommandInterceptors());
|
if (this.customPostCommandInterceptors != null) {
|
this.commandInterceptors.addAll(this.customPostCommandInterceptors);
|
}
|
|
this.commandInterceptors.add(this.commandInvoker);
|
}
|
|
}
|
|
public Collection<? extends CommandInterceptor> getDefaultCommandInterceptors() {
|
List<CommandInterceptor> interceptors = new ArrayList();
|
interceptors.add(new LogInterceptor());
|
CommandInterceptor transactionInterceptor = this.createTransactionInterceptor();
|
if (transactionInterceptor != null) {
|
interceptors.add(transactionInterceptor);
|
}
|
|
if (this.commandContextFactory != null) {
|
interceptors.add(new CommandContextInterceptor(this.commandContextFactory, this));
|
}
|
|
if (this.transactionContextFactory != null) {
|
interceptors.add(new TransactionContextInterceptor(this.transactionContextFactory));
|
}
|
|
return interceptors;
|
}
|
|
public void initCommandExecutor() {
|
if (this.commandExecutor == null) {
|
CommandInterceptor first = this.initInterceptorChain(this.commandInterceptors);
|
this.commandExecutor = new CommandExecutorImpl(this.getDefaultCommandConfig(), first);
|
}
|
|
}
|
|
public CommandInterceptor initInterceptorChain(List<CommandInterceptor> chain) {
|
if (chain != null && !chain.isEmpty()) {
|
for(int i = 0; i < chain.size() - 1; ++i) {
|
((CommandInterceptor)chain.get(i)).setNext((CommandInterceptor)chain.get(i + 1));
|
}
|
|
return (CommandInterceptor)chain.get(0);
|
} else {
|
throw new ActivitiException("invalid command interceptor chain configuration: " + chain);
|
}
|
}
|
|
public abstract CommandInterceptor createTransactionInterceptor();
|
|
public void initServices() {
|
this.initService(this.repositoryService);
|
this.initService(this.runtimeService);
|
this.initService(this.historyService);
|
this.initService(this.identityService);
|
this.initService(this.taskService);
|
this.initService(this.formService);
|
this.initService(this.managementService);
|
this.initService(this.dynamicBpmnService);
|
}
|
|
public void initService(Object service) {
|
if (service instanceof ServiceImpl) {
|
((ServiceImpl)service).setCommandExecutor(this.commandExecutor);
|
}
|
|
}
|
|
public void initDataSource() {
|
if (this.dataSource == null) {
|
if (this.dataSourceJndiName != null) {
|
try {
|
this.dataSource = (DataSource)(new InitialContext()).lookup(this.dataSourceJndiName);
|
} catch (Exception var2) {
|
Exception e = var2;
|
throw new ActivitiException("couldn't lookup datasource from " + this.dataSourceJndiName + ": " + e.getMessage(), e);
|
}
|
} else if (this.jdbcUrl != null) {
|
if (this.jdbcDriver == null || this.jdbcUsername == null) {
|
throw new ActivitiException("DataSource or JDBC properties have to be specified in a process engine configuration");
|
}
|
|
log.debug("initializing datasource to db: {}", this.jdbcUrl);
|
PooledDataSource pooledDataSource = new PooledDataSource(ReflectUtil.getClassLoader(), this.jdbcDriver, this.jdbcUrl, this.jdbcUsername, this.jdbcPassword);
|
if (this.jdbcMaxActiveConnections > 0) {
|
pooledDataSource.setPoolMaximumActiveConnections(this.jdbcMaxActiveConnections);
|
}
|
|
if (this.jdbcMaxIdleConnections > 0) {
|
pooledDataSource.setPoolMaximumIdleConnections(this.jdbcMaxIdleConnections);
|
}
|
|
if (this.jdbcMaxCheckoutTime > 0) {
|
pooledDataSource.setPoolMaximumCheckoutTime(this.jdbcMaxCheckoutTime);
|
}
|
|
if (this.jdbcMaxWaitTime > 0) {
|
pooledDataSource.setPoolTimeToWait(this.jdbcMaxWaitTime);
|
}
|
|
if (this.jdbcPingEnabled) {
|
pooledDataSource.setPoolPingEnabled(true);
|
if (this.jdbcPingQuery != null) {
|
pooledDataSource.setPoolPingQuery(this.jdbcPingQuery);
|
}
|
|
pooledDataSource.setPoolPingConnectionsNotUsedFor(this.jdbcPingConnectionNotUsedFor);
|
}
|
|
if (this.jdbcDefaultTransactionIsolationLevel > 0) {
|
pooledDataSource.setDefaultTransactionIsolationLevel(this.jdbcDefaultTransactionIsolationLevel);
|
}
|
|
this.dataSource = pooledDataSource;
|
}
|
|
if (this.dataSource instanceof PooledDataSource) {
|
((PooledDataSource)this.dataSource).forceCloseAll();
|
}
|
}
|
|
if (this.databaseType == null) {
|
this.initDatabaseType();
|
}
|
|
}
|
|
public static Properties getDefaultDatabaseTypeMappings() {
|
Properties databaseTypeMappings = new Properties();
|
databaseTypeMappings.setProperty("dm", DATABASE_TYPE_DM);
|
databaseTypeMappings.setProperty("DM DBMS",DATABASE_TYPE_ORACLE);
|
databaseTypeMappings.setProperty("H2", "h2");
|
databaseTypeMappings.setProperty("HSQL Database Engine", "hsql");
|
databaseTypeMappings.setProperty("MySQL", "mysql");
|
databaseTypeMappings.setProperty("Oracle", "oracle");
|
databaseTypeMappings.setProperty("PostgreSQL", "postgres");
|
databaseTypeMappings.setProperty("Microsoft SQL Server", "mssql");
|
databaseTypeMappings.setProperty("db2", "db2");
|
databaseTypeMappings.setProperty("DB2", "db2");
|
databaseTypeMappings.setProperty("DB2/NT", "db2");
|
databaseTypeMappings.setProperty("DB2/NT64", "db2");
|
databaseTypeMappings.setProperty("DB2 UDP", "db2");
|
databaseTypeMappings.setProperty("DB2/LINUX", "db2");
|
databaseTypeMappings.setProperty("DB2/LINUX390", "db2");
|
databaseTypeMappings.setProperty("DB2/LINUXX8664", "db2");
|
databaseTypeMappings.setProperty("DB2/LINUXZ64", "db2");
|
databaseTypeMappings.setProperty("DB2/LINUXPPC64", "db2");
|
databaseTypeMappings.setProperty("DB2/LINUXPPC64LE", "db2");
|
databaseTypeMappings.setProperty("DB2/400 SQL", "db2");
|
databaseTypeMappings.setProperty("DB2/6000", "db2");
|
databaseTypeMappings.setProperty("DB2 UDB iSeries", "db2");
|
databaseTypeMappings.setProperty("DB2/AIX64", "db2");
|
databaseTypeMappings.setProperty("DB2/HPUX", "db2");
|
databaseTypeMappings.setProperty("DB2/HP64", "db2");
|
databaseTypeMappings.setProperty("DB2/SUN", "db2");
|
databaseTypeMappings.setProperty("DB2/SUN64", "db2");
|
databaseTypeMappings.setProperty("DB2/PTX", "db2");
|
databaseTypeMappings.setProperty("DB2/2", "db2");
|
databaseTypeMappings.setProperty("DB2 UDB AS400", "db2");
|
return databaseTypeMappings;
|
}
|
|
public void initDatabaseType() {
|
Connection connection = null;
|
|
try {
|
connection = this.dataSource.getConnection();
|
DatabaseMetaData databaseMetaData = connection.getMetaData();
|
String databaseProductName = databaseMetaData.getDatabaseProductName();
|
log.debug("database product name: '{}'", databaseProductName);
|
this.databaseType = databaseTypeMappings.getProperty(databaseProductName);
|
if (this.databaseType == null) {
|
throw new ActivitiException("couldn't deduct database type from database product name '" + databaseProductName + "'");
|
}
|
|
log.debug("using database type: {}", this.databaseType);
|
if ("mssql".equals(this.databaseType)) {
|
this.maxNrOfStatementsInBulkInsert = this.DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER;
|
}
|
} catch (SQLException var12) {
|
SQLException e = var12;
|
log.error("Exception while initializing Database connection", e);
|
} finally {
|
try {
|
if (connection != null) {
|
connection.close();
|
}
|
} catch (SQLException var11) {
|
SQLException e = var11;
|
log.error("Exception while closing the Database connection", e);
|
}
|
|
}
|
|
}
|
|
public void initTransactionFactory() {
|
if (this.transactionFactory == null) {
|
if (this.transactionsExternallyManaged) {
|
this.transactionFactory = new ManagedTransactionFactory();
|
} else {
|
this.transactionFactory = new JdbcTransactionFactory();
|
}
|
}
|
|
}
|
|
public void initSqlSessionFactory() {
|
if (this.sqlSessionFactory == null) {
|
InputStream inputStream = null;
|
|
try {
|
inputStream = this.getMyBatisXmlConfigurationStream();
|
Environment environment = new Environment("default", this.transactionFactory, this.dataSource);
|
Reader reader = new InputStreamReader(inputStream);
|
Properties properties = new Properties();
|
properties.put("prefix", this.databaseTablePrefix);
|
String wildcardEscapeClause = "";
|
if (this.databaseWildcardEscapeCharacter != null && this.databaseWildcardEscapeCharacter.length() != 0) {
|
wildcardEscapeClause = " escape '" + this.databaseWildcardEscapeCharacter + "'";
|
}
|
|
properties.put("wildcardEscapeClause", wildcardEscapeClause);
|
properties.put("limitBefore", "");
|
properties.put("limitAfter", "");
|
properties.put("limitBetween", "");
|
properties.put("limitOuterJoinBetween", "");
|
properties.put("limitBeforeNativeQuery", "");
|
properties.put("orderBy", "order by ${orderByColumns}");
|
properties.put("blobType", "BLOB");
|
properties.put("boolValue", "TRUE");
|
if (this.databaseType != null) {
|
properties.load(this.getResourceAsStream("org/activiti/db/properties/" + this.databaseType + ".properties"));
|
}
|
|
Configuration configuration = this.initMybatisConfiguration(environment, reader, properties);
|
this.sqlSessionFactory = new DefaultSqlSessionFactory(configuration);
|
} catch (Exception var10) {
|
Exception e = var10;
|
throw new ActivitiException("Error while building ibatis SqlSessionFactory: " + e.getMessage(), e);
|
} finally {
|
IoUtil.closeSilently(inputStream);
|
}
|
}
|
|
}
|
|
public Configuration initMybatisConfiguration(Environment environment, Reader reader, Properties properties) {
|
XMLConfigBuilder parser = new XMLConfigBuilder(reader, "", properties);
|
Configuration configuration = parser.getConfiguration();
|
if (this.databaseType != null) {
|
configuration.setDatabaseId(this.databaseType);
|
}
|
|
configuration.setEnvironment(environment);
|
this.initMybatisTypeHandlers(configuration);
|
this.initCustomMybatisMappers(configuration);
|
configuration = this.parseMybatisConfiguration(configuration, parser);
|
return configuration;
|
}
|
|
public void initMybatisTypeHandlers(Configuration configuration) {
|
configuration.getTypeHandlerRegistry().register(VariableType.class, JdbcType.VARCHAR, new IbatisVariableTypeHandler());
|
}
|
|
public void initCustomMybatisMappers(Configuration configuration) {
|
if (this.getCustomMybatisMappers() != null) {
|
Iterator var2 = this.getCustomMybatisMappers().iterator();
|
|
while(var2.hasNext()) {
|
Class<?> clazz = (Class)var2.next();
|
configuration.addMapper(clazz);
|
}
|
}
|
|
}
|
|
public Configuration parseMybatisConfiguration(Configuration configuration, XMLConfigBuilder parser) {
|
return this.parseCustomMybatisXMLMappers(parser.parse());
|
}
|
|
public Configuration parseCustomMybatisXMLMappers(Configuration configuration) {
|
if (this.getCustomMybatisXMLMappers() != null) {
|
Iterator var2 = this.getCustomMybatisXMLMappers().iterator();
|
|
while(var2.hasNext()) {
|
String resource = (String)var2.next();
|
XMLMapperBuilder mapperParser = new XMLMapperBuilder(this.getResourceAsStream(resource), configuration, resource, configuration.getSqlFragments());
|
mapperParser.parse();
|
}
|
}
|
|
return configuration;
|
}
|
|
protected InputStream getResourceAsStream(String resource) {
|
return ReflectUtil.getResourceAsStream(resource);
|
}
|
|
public InputStream getMyBatisXmlConfigurationStream() {
|
return this.getResourceAsStream("org/activiti/db/mapping/mappings.xml");
|
}
|
|
public Set<Class<?>> getCustomMybatisMappers() {
|
return this.customMybatisMappers;
|
}
|
|
public void setCustomMybatisMappers(Set<Class<?>> customMybatisMappers) {
|
this.customMybatisMappers = customMybatisMappers;
|
}
|
|
public Set<String> getCustomMybatisXMLMappers() {
|
return this.customMybatisXMLMappers;
|
}
|
|
public void setCustomMybatisXMLMappers(Set<String> customMybatisXMLMappers) {
|
this.customMybatisXMLMappers = customMybatisXMLMappers;
|
}
|
|
public void initDataManagers() {
|
if (this.attachmentDataManager == null) {
|
this.attachmentDataManager = new MybatisAttachmentDataManager(this);
|
}
|
|
if (this.byteArrayDataManager == null) {
|
this.byteArrayDataManager = new MybatisByteArrayDataManager(this);
|
}
|
|
if (this.commentDataManager == null) {
|
this.commentDataManager = new MybatisCommentDataManager(this);
|
}
|
|
if (this.deploymentDataManager == null) {
|
this.deploymentDataManager = new MybatisDeploymentDataManager(this);
|
}
|
|
if (this.eventLogEntryDataManager == null) {
|
this.eventLogEntryDataManager = new MybatisEventLogEntryDataManager(this);
|
}
|
|
if (this.eventSubscriptionDataManager == null) {
|
this.eventSubscriptionDataManager = new MybatisEventSubscriptionDataManager(this);
|
}
|
|
if (this.executionDataManager == null) {
|
this.executionDataManager = new MybatisExecutionDataManager(this);
|
}
|
|
if (this.groupDataManager == null) {
|
this.groupDataManager = new MybatisGroupDataManager(this);
|
}
|
|
if (this.historicActivityInstanceDataManager == null) {
|
this.historicActivityInstanceDataManager = new MybatisHistoricActivityInstanceDataManager(this);
|
}
|
|
if (this.historicDetailDataManager == null) {
|
this.historicDetailDataManager = new MybatisHistoricDetailDataManager(this);
|
}
|
|
if (this.historicIdentityLinkDataManager == null) {
|
this.historicIdentityLinkDataManager = new MybatisHistoricIdentityLinkDataManager(this);
|
}
|
|
if (this.historicProcessInstanceDataManager == null) {
|
this.historicProcessInstanceDataManager = new MybatisHistoricProcessInstanceDataManager(this);
|
}
|
|
if (this.historicTaskInstanceDataManager == null) {
|
this.historicTaskInstanceDataManager = new MybatisHistoricTaskInstanceDataManager(this);
|
}
|
|
if (this.historicVariableInstanceDataManager == null) {
|
this.historicVariableInstanceDataManager = new MybatisHistoricVariableInstanceDataManager(this);
|
}
|
|
if (this.identityInfoDataManager == null) {
|
this.identityInfoDataManager = new MybatisIdentityInfoDataManager(this);
|
}
|
|
if (this.identityLinkDataManager == null) {
|
this.identityLinkDataManager = new MybatisIdentityLinkDataManager(this);
|
}
|
|
if (this.jobDataManager == null) {
|
this.jobDataManager = new MybatisJobDataManager(this);
|
}
|
|
if (this.timerJobDataManager == null) {
|
this.timerJobDataManager = new MybatisTimerJobDataManager(this);
|
}
|
|
if (this.suspendedJobDataManager == null) {
|
this.suspendedJobDataManager = new MybatisSuspendedJobDataManager(this);
|
}
|
|
if (this.deadLetterJobDataManager == null) {
|
this.deadLetterJobDataManager = new MybatisDeadLetterJobDataManager(this);
|
}
|
|
if (this.membershipDataManager == null) {
|
this.membershipDataManager = new MybatisMembershipDataManager(this);
|
}
|
|
if (this.modelDataManager == null) {
|
this.modelDataManager = new MybatisModelDataManager(this);
|
}
|
|
if (this.processDefinitionDataManager == null) {
|
this.processDefinitionDataManager = new MybatisProcessDefinitionDataManager(this);
|
}
|
|
if (this.processDefinitionInfoDataManager == null) {
|
this.processDefinitionInfoDataManager = new MybatisProcessDefinitionInfoDataManager(this);
|
}
|
|
if (this.propertyDataManager == null) {
|
this.propertyDataManager = new MybatisPropertyDataManager(this);
|
}
|
|
if (this.resourceDataManager == null) {
|
this.resourceDataManager = new MybatisResourceDataManager(this);
|
}
|
|
if (this.taskDataManager == null) {
|
this.taskDataManager = new MybatisTaskDataManager(this);
|
}
|
|
if (this.userDataManager == null) {
|
this.userDataManager = new MybatisUserDataManager(this);
|
}
|
|
if (this.variableInstanceDataManager == null) {
|
this.variableInstanceDataManager = new MybatisVariableInstanceDataManager(this);
|
}
|
|
}
|
|
public void initEntityManagers() {
|
if (this.attachmentEntityManager == null) {
|
this.attachmentEntityManager = new AttachmentEntityManagerImpl(this, this.attachmentDataManager);
|
}
|
|
if (this.byteArrayEntityManager == null) {
|
this.byteArrayEntityManager = new ByteArrayEntityManagerImpl(this, this.byteArrayDataManager);
|
}
|
|
if (this.commentEntityManager == null) {
|
this.commentEntityManager = new CommentEntityManagerImpl(this, this.commentDataManager);
|
}
|
|
if (this.deploymentEntityManager == null) {
|
this.deploymentEntityManager = new DeploymentEntityManagerImpl(this, this.deploymentDataManager);
|
}
|
|
if (this.eventLogEntryEntityManager == null) {
|
this.eventLogEntryEntityManager = new EventLogEntryEntityManagerImpl(this, this.eventLogEntryDataManager);
|
}
|
|
if (this.eventSubscriptionEntityManager == null) {
|
this.eventSubscriptionEntityManager = new EventSubscriptionEntityManagerImpl(this, this.eventSubscriptionDataManager);
|
}
|
|
if (this.executionEntityManager == null) {
|
this.executionEntityManager = new ExecutionEntityManagerImpl(this, this.executionDataManager);
|
}
|
|
if (this.groupEntityManager == null) {
|
this.groupEntityManager = new GroupEntityManagerImpl(this, this.groupDataManager);
|
}
|
|
if (this.historicActivityInstanceEntityManager == null) {
|
this.historicActivityInstanceEntityManager = new HistoricActivityInstanceEntityManagerImpl(this, this.historicActivityInstanceDataManager);
|
}
|
|
if (this.historicDetailEntityManager == null) {
|
this.historicDetailEntityManager = new HistoricDetailEntityManagerImpl(this, this.historicDetailDataManager);
|
}
|
|
if (this.historicIdentityLinkEntityManager == null) {
|
this.historicIdentityLinkEntityManager = new HistoricIdentityLinkEntityManagerImpl(this, this.historicIdentityLinkDataManager);
|
}
|
|
if (this.historicProcessInstanceEntityManager == null) {
|
this.historicProcessInstanceEntityManager = new HistoricProcessInstanceEntityManagerImpl(this, this.historicProcessInstanceDataManager);
|
}
|
|
if (this.historicTaskInstanceEntityManager == null) {
|
this.historicTaskInstanceEntityManager = new HistoricTaskInstanceEntityManagerImpl(this, this.historicTaskInstanceDataManager);
|
}
|
|
if (this.historicVariableInstanceEntityManager == null) {
|
this.historicVariableInstanceEntityManager = new HistoricVariableInstanceEntityManagerImpl(this, this.historicVariableInstanceDataManager);
|
}
|
|
if (this.identityInfoEntityManager == null) {
|
this.identityInfoEntityManager = new IdentityInfoEntityManagerImpl(this, this.identityInfoDataManager);
|
}
|
|
if (this.identityLinkEntityManager == null) {
|
this.identityLinkEntityManager = new IdentityLinkEntityManagerImpl(this, this.identityLinkDataManager);
|
}
|
|
if (this.jobEntityManager == null) {
|
this.jobEntityManager = new JobEntityManagerImpl(this, this.jobDataManager);
|
}
|
|
if (this.timerJobEntityManager == null) {
|
this.timerJobEntityManager = new TimerJobEntityManagerImpl(this, this.timerJobDataManager);
|
}
|
|
if (this.suspendedJobEntityManager == null) {
|
this.suspendedJobEntityManager = new SuspendedJobEntityManagerImpl(this, this.suspendedJobDataManager);
|
}
|
|
if (this.deadLetterJobEntityManager == null) {
|
this.deadLetterJobEntityManager = new DeadLetterJobEntityManagerImpl(this, this.deadLetterJobDataManager);
|
}
|
|
if (this.membershipEntityManager == null) {
|
this.membershipEntityManager = new MembershipEntityManagerImpl(this, this.membershipDataManager);
|
}
|
|
if (this.modelEntityManager == null) {
|
this.modelEntityManager = new ModelEntityManagerImpl(this, this.modelDataManager);
|
}
|
|
if (this.processDefinitionEntityManager == null) {
|
this.processDefinitionEntityManager = new ProcessDefinitionEntityManagerImpl(this, this.processDefinitionDataManager);
|
}
|
|
if (this.processDefinitionInfoEntityManager == null) {
|
this.processDefinitionInfoEntityManager = new ProcessDefinitionInfoEntityManagerImpl(this, this.processDefinitionInfoDataManager);
|
}
|
|
if (this.propertyEntityManager == null) {
|
this.propertyEntityManager = new PropertyEntityManagerImpl(this, this.propertyDataManager);
|
}
|
|
if (this.resourceEntityManager == null) {
|
this.resourceEntityManager = new ResourceEntityManagerImpl(this, this.resourceDataManager);
|
}
|
|
if (this.tableDataManager == null) {
|
this.tableDataManager = new TableDataManagerImpl(this);
|
}
|
|
if (this.taskEntityManager == null) {
|
this.taskEntityManager = new TaskEntityManagerImpl(this, this.taskDataManager);
|
}
|
|
if (this.userEntityManager == null) {
|
this.userEntityManager = new UserEntityManagerImpl(this, this.userDataManager);
|
}
|
|
if (this.variableInstanceEntityManager == null) {
|
this.variableInstanceEntityManager = new VariableInstanceEntityManagerImpl(this, this.variableInstanceDataManager);
|
}
|
|
}
|
|
public void initHistoryManager() {
|
if (this.historyManager == null) {
|
this.historyManager = new DefaultHistoryManager(this, this.historyLevel);
|
}
|
|
}
|
|
public void initJobManager() {
|
if (this.jobManager == null) {
|
this.jobManager = new DefaultJobManager(this);
|
}
|
|
this.jobManager.setProcessEngineConfiguration(this);
|
}
|
|
public void initSessionFactories() {
|
if (this.sessionFactories == null) {
|
this.sessionFactories = new HashMap();
|
if (this.usingRelationalDatabase) {
|
this.initDbSqlSessionFactory();
|
}
|
|
this.addSessionFactory(new GenericManagerFactory(EntityCache.class, EntityCacheImpl.class));
|
}
|
|
if (this.customSessionFactories != null) {
|
Iterator var1 = this.customSessionFactories.iterator();
|
|
while(var1.hasNext()) {
|
SessionFactory sessionFactory = (SessionFactory)var1.next();
|
this.addSessionFactory(sessionFactory);
|
}
|
}
|
|
}
|
|
public void initDbSqlSessionFactory() {
|
if (this.dbSqlSessionFactory == null) {
|
this.dbSqlSessionFactory = this.createDbSqlSessionFactory();
|
}
|
|
this.dbSqlSessionFactory.setDatabaseType(this.databaseType);
|
this.dbSqlSessionFactory.setIdGenerator(this.idGenerator);
|
this.dbSqlSessionFactory.setSqlSessionFactory(this.sqlSessionFactory);
|
this.dbSqlSessionFactory.setDbIdentityUsed(this.isDbIdentityUsed);
|
this.dbSqlSessionFactory.setDbHistoryUsed(this.isDbHistoryUsed);
|
this.dbSqlSessionFactory.setDatabaseTablePrefix(this.databaseTablePrefix);
|
this.dbSqlSessionFactory.setTablePrefixIsSchema(this.tablePrefixIsSchema);
|
this.dbSqlSessionFactory.setDatabaseCatalog(this.databaseCatalog);
|
this.dbSqlSessionFactory.setDatabaseSchema(this.databaseSchema);
|
this.dbSqlSessionFactory.setBulkInsertEnabled(this.isBulkInsertEnabled, this.databaseType);
|
this.dbSqlSessionFactory.setMaxNrOfStatementsInBulkInsert(this.maxNrOfStatementsInBulkInsert);
|
this.addSessionFactory(this.dbSqlSessionFactory);
|
}
|
|
public DbSqlSessionFactory createDbSqlSessionFactory() {
|
return new DbSqlSessionFactory();
|
}
|
|
public void addSessionFactory(SessionFactory sessionFactory) {
|
this.sessionFactories.put(sessionFactory.getSessionType(), sessionFactory);
|
}
|
|
public void initConfigurators() {
|
this.allConfigurators = new ArrayList();
|
if (this.configurators != null) {
|
Iterator var1 = this.configurators.iterator();
|
|
while(var1.hasNext()) {
|
ProcessEngineConfigurator configurator = (ProcessEngineConfigurator)var1.next();
|
this.allConfigurators.add(configurator);
|
}
|
}
|
|
if (this.enableConfiguratorServiceLoader) {
|
ClassLoader classLoader = this.getClassLoader();
|
if (classLoader == null) {
|
classLoader = ReflectUtil.getClassLoader();
|
}
|
|
ServiceLoader<ProcessEngineConfigurator> configuratorServiceLoader = ServiceLoader.load(ProcessEngineConfigurator.class, classLoader);
|
int nrOfServiceLoadedConfigurators = 0;
|
|
Iterator var4;
|
ProcessEngineConfigurator configurator;
|
for(var4 = configuratorServiceLoader.iterator(); var4.hasNext(); ++nrOfServiceLoadedConfigurators) {
|
configurator = (ProcessEngineConfigurator)var4.next();
|
this.allConfigurators.add(configurator);
|
}
|
|
if (nrOfServiceLoadedConfigurators > 0) {
|
log.info("Found {} auto-discoverable Process Engine Configurator{}", nrOfServiceLoadedConfigurators++, nrOfServiceLoadedConfigurators > 1 ? "s" : "");
|
}
|
|
if (!this.allConfigurators.isEmpty()) {
|
Collections.sort(this.allConfigurators, new Comparator<ProcessEngineConfigurator>() {
|
public int compare(ProcessEngineConfigurator configurator1, ProcessEngineConfigurator configurator2) {
|
int priority1 = configurator1.getPriority();
|
int priority2 = configurator2.getPriority();
|
if (priority1 < priority2) {
|
return -1;
|
} else {
|
return priority1 > priority2 ? 1 : 0;
|
}
|
}
|
});
|
log.info("Found {} Process Engine Configurators in total:", this.allConfigurators.size());
|
var4 = this.allConfigurators.iterator();
|
|
while(var4.hasNext()) {
|
configurator = (ProcessEngineConfigurator)var4.next();
|
log.info("{} (priority:{})", configurator.getClass(), configurator.getPriority());
|
}
|
}
|
}
|
|
}
|
|
public void configuratorsBeforeInit() {
|
Iterator var1 = this.allConfigurators.iterator();
|
|
while(var1.hasNext()) {
|
ProcessEngineConfigurator configurator = (ProcessEngineConfigurator)var1.next();
|
log.info("Executing beforeInit() of {} (priority:{})", configurator.getClass(), configurator.getPriority());
|
configurator.beforeInit(this);
|
}
|
|
}
|
|
public void configuratorsAfterInit() {
|
Iterator var1 = this.allConfigurators.iterator();
|
|
while(var1.hasNext()) {
|
ProcessEngineConfigurator configurator = (ProcessEngineConfigurator)var1.next();
|
log.info("Executing configure() of {} (priority:{})", configurator.getClass(), configurator.getPriority());
|
configurator.configure(this);
|
}
|
|
}
|
|
public void initProcessDefinitionCache() {
|
if (this.processDefinitionCache == null) {
|
if (this.processDefinitionCacheLimit <= 0) {
|
this.processDefinitionCache = new DefaultDeploymentCache();
|
} else {
|
this.processDefinitionCache = new DefaultDeploymentCache(this.processDefinitionCacheLimit);
|
}
|
}
|
|
}
|
|
public void initProcessDefinitionInfoCache() {
|
if (this.processDefinitionInfoCache == null) {
|
if (this.processDefinitionInfoCacheLimit <= 0) {
|
this.processDefinitionInfoCache = new ProcessDefinitionInfoCache(this.commandExecutor);
|
} else {
|
this.processDefinitionInfoCache = new ProcessDefinitionInfoCache(this.commandExecutor, this.processDefinitionInfoCacheLimit);
|
}
|
}
|
|
}
|
|
public void initKnowledgeBaseCache() {
|
if (this.knowledgeBaseCache == null) {
|
if (this.knowledgeBaseCacheLimit <= 0) {
|
this.knowledgeBaseCache = new DefaultDeploymentCache();
|
} else {
|
this.knowledgeBaseCache = new DefaultDeploymentCache(this.knowledgeBaseCacheLimit);
|
}
|
}
|
|
}
|
|
public void initDeployers() {
|
if (this.deployers == null) {
|
this.deployers = new ArrayList();
|
if (this.customPreDeployers != null) {
|
this.deployers.addAll(this.customPreDeployers);
|
}
|
|
this.deployers.addAll(this.getDefaultDeployers());
|
if (this.customPostDeployers != null) {
|
this.deployers.addAll(this.customPostDeployers);
|
}
|
}
|
|
if (this.deploymentManager == null) {
|
this.deploymentManager = new DeploymentManager();
|
this.deploymentManager.setDeployers(this.deployers);
|
this.deploymentManager.setProcessDefinitionCache(this.processDefinitionCache);
|
this.deploymentManager.setProcessDefinitionInfoCache(this.processDefinitionInfoCache);
|
this.deploymentManager.setKnowledgeBaseCache(this.knowledgeBaseCache);
|
this.deploymentManager.setProcessEngineConfiguration(this);
|
this.deploymentManager.setProcessDefinitionEntityManager(this.processDefinitionEntityManager);
|
this.deploymentManager.setDeploymentEntityManager(this.deploymentEntityManager);
|
}
|
|
}
|
|
public void initBpmnDeployerDependencies() {
|
if (this.parsedDeploymentBuilderFactory == null) {
|
this.parsedDeploymentBuilderFactory = new ParsedDeploymentBuilderFactory();
|
}
|
|
if (this.parsedDeploymentBuilderFactory.getBpmnParser() == null) {
|
this.parsedDeploymentBuilderFactory.setBpmnParser(this.bpmnParser);
|
}
|
|
if (this.timerManager == null) {
|
this.timerManager = new TimerManager();
|
}
|
|
if (this.eventSubscriptionManager == null) {
|
this.eventSubscriptionManager = new EventSubscriptionManager();
|
}
|
|
if (this.bpmnDeploymentHelper == null) {
|
this.bpmnDeploymentHelper = new BpmnDeploymentHelper();
|
}
|
|
if (this.bpmnDeploymentHelper.getTimerManager() == null) {
|
this.bpmnDeploymentHelper.setTimerManager(this.timerManager);
|
}
|
|
if (this.bpmnDeploymentHelper.getEventSubscriptionManager() == null) {
|
this.bpmnDeploymentHelper.setEventSubscriptionManager(this.eventSubscriptionManager);
|
}
|
|
if (this.cachingAndArtifactsManager == null) {
|
this.cachingAndArtifactsManager = new CachingAndArtifactsManager();
|
}
|
|
if (this.processDefinitionDiagramHelper == null) {
|
this.processDefinitionDiagramHelper = new ProcessDefinitionDiagramHelper();
|
}
|
|
}
|
|
public Collection<? extends Deployer> getDefaultDeployers() {
|
List<Deployer> defaultDeployers = new ArrayList();
|
if (this.bpmnDeployer == null) {
|
this.bpmnDeployer = new BpmnDeployer();
|
}
|
|
this.initBpmnDeployerDependencies();
|
this.bpmnDeployer.setIdGenerator(this.idGenerator);
|
this.bpmnDeployer.setParsedDeploymentBuilderFactory(this.parsedDeploymentBuilderFactory);
|
this.bpmnDeployer.setBpmnDeploymentHelper(this.bpmnDeploymentHelper);
|
this.bpmnDeployer.setCachingAndArtifactsManager(this.cachingAndArtifactsManager);
|
this.bpmnDeployer.setProcessDefinitionDiagramHelper(this.processDefinitionDiagramHelper);
|
defaultDeployers.add(this.bpmnDeployer);
|
return defaultDeployers;
|
}
|
|
public void initListenerFactory() {
|
if (this.listenerFactory == null) {
|
DefaultListenerFactory defaultListenerFactory = new DefaultListenerFactory();
|
defaultListenerFactory.setExpressionManager(this.expressionManager);
|
this.listenerFactory = defaultListenerFactory;
|
} else if (this.listenerFactory instanceof AbstractBehaviorFactory && ((AbstractBehaviorFactory)this.listenerFactory).getExpressionManager() == null) {
|
((AbstractBehaviorFactory)this.listenerFactory).setExpressionManager(this.expressionManager);
|
}
|
|
}
|
|
public void initBehaviorFactory() {
|
if (this.activityBehaviorFactory == null) {
|
DefaultActivityBehaviorFactory defaultActivityBehaviorFactory = new DefaultActivityBehaviorFactory();
|
defaultActivityBehaviorFactory.setExpressionManager(this.expressionManager);
|
this.activityBehaviorFactory = defaultActivityBehaviorFactory;
|
} else if (this.activityBehaviorFactory instanceof AbstractBehaviorFactory && ((AbstractBehaviorFactory)this.activityBehaviorFactory).getExpressionManager() == null) {
|
((AbstractBehaviorFactory)this.activityBehaviorFactory).setExpressionManager(this.expressionManager);
|
}
|
|
}
|
|
public void initBpmnParser() {
|
if (this.bpmnParser == null) {
|
this.bpmnParser = new BpmnParser();
|
}
|
|
if (this.bpmnParseFactory == null) {
|
this.bpmnParseFactory = new DefaultBpmnParseFactory();
|
}
|
|
this.bpmnParser.setBpmnParseFactory(this.bpmnParseFactory);
|
this.bpmnParser.setActivityBehaviorFactory(this.activityBehaviorFactory);
|
this.bpmnParser.setListenerFactory(this.listenerFactory);
|
List<BpmnParseHandler> parseHandlers = new ArrayList();
|
if (this.getPreBpmnParseHandlers() != null) {
|
parseHandlers.addAll(this.getPreBpmnParseHandlers());
|
}
|
|
parseHandlers.addAll(this.getDefaultBpmnParseHandlers());
|
if (this.getPostBpmnParseHandlers() != null) {
|
parseHandlers.addAll(this.getPostBpmnParseHandlers());
|
}
|
|
BpmnParseHandlers bpmnParseHandlers = new BpmnParseHandlers();
|
bpmnParseHandlers.addHandlers(parseHandlers);
|
this.bpmnParser.setBpmnParserHandlers(bpmnParseHandlers);
|
}
|
|
public List<BpmnParseHandler> getDefaultBpmnParseHandlers() {
|
List<BpmnParseHandler> bpmnParserHandlers = new ArrayList();
|
bpmnParserHandlers.add(new BoundaryEventParseHandler());
|
bpmnParserHandlers.add(new BusinessRuleParseHandler());
|
bpmnParserHandlers.add(new CallActivityParseHandler());
|
bpmnParserHandlers.add(new CancelEventDefinitionParseHandler());
|
bpmnParserHandlers.add(new CompensateEventDefinitionParseHandler());
|
bpmnParserHandlers.add(new EndEventParseHandler());
|
bpmnParserHandlers.add(new ErrorEventDefinitionParseHandler());
|
bpmnParserHandlers.add(new EventBasedGatewayParseHandler());
|
bpmnParserHandlers.add(new ExclusiveGatewayParseHandler());
|
bpmnParserHandlers.add(new InclusiveGatewayParseHandler());
|
bpmnParserHandlers.add(new IntermediateCatchEventParseHandler());
|
bpmnParserHandlers.add(new IntermediateThrowEventParseHandler());
|
bpmnParserHandlers.add(new ManualTaskParseHandler());
|
bpmnParserHandlers.add(new MessageEventDefinitionParseHandler());
|
bpmnParserHandlers.add(new ParallelGatewayParseHandler());
|
bpmnParserHandlers.add(new ProcessParseHandler());
|
bpmnParserHandlers.add(new ReceiveTaskParseHandler());
|
bpmnParserHandlers.add(new ScriptTaskParseHandler());
|
bpmnParserHandlers.add(new SendTaskParseHandler());
|
bpmnParserHandlers.add(new SequenceFlowParseHandler());
|
bpmnParserHandlers.add(new ServiceTaskParseHandler());
|
bpmnParserHandlers.add(new SignalEventDefinitionParseHandler());
|
bpmnParserHandlers.add(new StartEventParseHandler());
|
bpmnParserHandlers.add(new SubProcessParseHandler());
|
bpmnParserHandlers.add(new EventSubProcessParseHandler());
|
bpmnParserHandlers.add(new AdhocSubProcessParseHandler());
|
bpmnParserHandlers.add(new TaskParseHandler());
|
bpmnParserHandlers.add(new TimerEventDefinitionParseHandler());
|
bpmnParserHandlers.add(new TransactionParseHandler());
|
bpmnParserHandlers.add(new UserTaskParseHandler());
|
if (this.customDefaultBpmnParseHandlers != null) {
|
Map<Class<?>, BpmnParseHandler> customParseHandlerMap = new HashMap();
|
Iterator var3 = this.customDefaultBpmnParseHandlers.iterator();
|
|
BpmnParseHandler defaultBpmnParseHandler;
|
while(var3.hasNext()) {
|
defaultBpmnParseHandler = (BpmnParseHandler)var3.next();
|
Iterator var5 = defaultBpmnParseHandler.getHandledTypes().iterator();
|
|
while(var5.hasNext()) {
|
Class<?> handledType = (Class)var5.next();
|
customParseHandlerMap.put(handledType, defaultBpmnParseHandler);
|
}
|
}
|
|
for(int i = 0; i < bpmnParserHandlers.size(); ++i) {
|
defaultBpmnParseHandler = (BpmnParseHandler)bpmnParserHandlers.get(i);
|
if (defaultBpmnParseHandler.getHandledTypes().size() != 1) {
|
StringBuilder supportedTypes = new StringBuilder();
|
Iterator var12 = defaultBpmnParseHandler.getHandledTypes().iterator();
|
|
while(var12.hasNext()) {
|
Class<?> type = (Class)var12.next();
|
supportedTypes.append(" ").append(type.getCanonicalName()).append(" ");
|
}
|
|
throw new ActivitiException("The default BPMN parse handlers should only support one type, but " + defaultBpmnParseHandler.getClass() + " supports " + supportedTypes.toString() + ". This is likely a programmatic error");
|
}
|
|
Class<?> handledType = (Class)defaultBpmnParseHandler.getHandledTypes().iterator().next();
|
if (customParseHandlerMap.containsKey(handledType)) {
|
BpmnParseHandler newBpmnParseHandler = (BpmnParseHandler)customParseHandlerMap.get(handledType);
|
log.info("Replacing default BpmnParseHandler " + defaultBpmnParseHandler.getClass().getName() + " with " + newBpmnParseHandler.getClass().getName());
|
bpmnParserHandlers.set(i, newBpmnParseHandler);
|
}
|
}
|
}
|
|
return bpmnParserHandlers;
|
}
|
|
public void initClock() {
|
if (this.clock == null) {
|
this.clock = new DefaultClockImpl();
|
}
|
|
}
|
|
public void initProcessDiagramGenerator() {
|
if (this.processDiagramGenerator == null) {
|
this.processDiagramGenerator = new DefaultProcessDiagramGenerator();
|
}
|
|
}
|
|
public void initAgendaFactory() {
|
if (this.engineAgendaFactory == null) {
|
this.engineAgendaFactory = new DefaultActivitiEngineAgendaFactory();
|
}
|
|
}
|
|
public void initJobHandlers() {
|
this.jobHandlers = new HashMap();
|
AsyncContinuationJobHandler asyncContinuationJobHandler = new AsyncContinuationJobHandler();
|
this.jobHandlers.put(asyncContinuationJobHandler.getType(), asyncContinuationJobHandler);
|
TriggerTimerEventJobHandler triggerTimerEventJobHandler = new TriggerTimerEventJobHandler();
|
this.jobHandlers.put(triggerTimerEventJobHandler.getType(), triggerTimerEventJobHandler);
|
TimerStartEventJobHandler timerStartEvent = new TimerStartEventJobHandler();
|
this.jobHandlers.put(timerStartEvent.getType(), timerStartEvent);
|
TimerSuspendProcessDefinitionHandler suspendProcessDefinitionHandler = new TimerSuspendProcessDefinitionHandler();
|
this.jobHandlers.put(suspendProcessDefinitionHandler.getType(), suspendProcessDefinitionHandler);
|
TimerActivateProcessDefinitionHandler activateProcessDefinitionHandler = new TimerActivateProcessDefinitionHandler();
|
this.jobHandlers.put(activateProcessDefinitionHandler.getType(), activateProcessDefinitionHandler);
|
ProcessEventJobHandler processEventJobHandler = new ProcessEventJobHandler();
|
this.jobHandlers.put(processEventJobHandler.getType(), processEventJobHandler);
|
if (this.getCustomJobHandlers() != null) {
|
Iterator var7 = this.getCustomJobHandlers().iterator();
|
|
while(var7.hasNext()) {
|
JobHandler customJobHandler = (JobHandler)var7.next();
|
this.jobHandlers.put(customJobHandler.getType(), customJobHandler);
|
}
|
}
|
|
}
|
|
public void initAsyncExecutor() {
|
if (this.asyncExecutor == null) {
|
DefaultAsyncJobExecutor defaultAsyncExecutor = new DefaultAsyncJobExecutor();
|
defaultAsyncExecutor.setMessageQueueMode(this.asyncExecutorMessageQueueMode);
|
defaultAsyncExecutor.setCorePoolSize(this.asyncExecutorCorePoolSize);
|
defaultAsyncExecutor.setMaxPoolSize(this.asyncExecutorMaxPoolSize);
|
defaultAsyncExecutor.setKeepAliveTime(this.asyncExecutorThreadKeepAliveTime);
|
if (this.asyncExecutorThreadPoolQueue != null) {
|
defaultAsyncExecutor.setThreadPoolQueue(this.asyncExecutorThreadPoolQueue);
|
}
|
|
defaultAsyncExecutor.setQueueSize(this.asyncExecutorThreadPoolQueueSize);
|
defaultAsyncExecutor.setDefaultTimerJobAcquireWaitTimeInMillis(this.asyncExecutorDefaultTimerJobAcquireWaitTime);
|
defaultAsyncExecutor.setDefaultAsyncJobAcquireWaitTimeInMillis(this.asyncExecutorDefaultAsyncJobAcquireWaitTime);
|
defaultAsyncExecutor.setDefaultQueueSizeFullWaitTimeInMillis(this.asyncExecutorDefaultQueueSizeFullWaitTime);
|
defaultAsyncExecutor.setTimerLockTimeInMillis(this.asyncExecutorTimerLockTimeInMillis);
|
defaultAsyncExecutor.setAsyncJobLockTimeInMillis(this.asyncExecutorAsyncJobLockTimeInMillis);
|
if (this.asyncExecutorLockOwner != null) {
|
defaultAsyncExecutor.setLockOwner(this.asyncExecutorLockOwner);
|
}
|
|
defaultAsyncExecutor.setResetExpiredJobsInterval(this.asyncExecutorResetExpiredJobsInterval);
|
defaultAsyncExecutor.setResetExpiredJobsPageSize(this.asyncExecutorResetExpiredJobsPageSize);
|
defaultAsyncExecutor.setSecondsToWaitOnShutdown(this.asyncExecutorSecondsToWaitOnShutdown);
|
this.asyncExecutor = defaultAsyncExecutor;
|
}
|
|
this.asyncExecutor.setProcessEngineConfiguration(this);
|
this.asyncExecutor.setAutoActivate(this.asyncExecutorActivate);
|
}
|
|
public void initHistoryLevel() {
|
if (this.historyLevel == null) {
|
this.historyLevel = HistoryLevel.getHistoryLevelForKey(this.getHistory());
|
}
|
|
}
|
|
public void initIdGenerator() {
|
if (this.idGenerator == null) {
|
CommandExecutor idGeneratorCommandExecutor = null;
|
StandaloneProcessEngineConfiguration processEngineConfiguration;
|
if (this.idGeneratorDataSource != null) {
|
processEngineConfiguration = new StandaloneProcessEngineConfiguration();
|
processEngineConfiguration.setDataSource(this.idGeneratorDataSource);
|
processEngineConfiguration.setDatabaseSchemaUpdate("false");
|
processEngineConfiguration.init();
|
idGeneratorCommandExecutor = processEngineConfiguration.getCommandExecutor();
|
} else if (this.idGeneratorDataSourceJndiName != null) {
|
processEngineConfiguration = new StandaloneProcessEngineConfiguration();
|
processEngineConfiguration.setDataSourceJndiName(this.idGeneratorDataSourceJndiName);
|
processEngineConfiguration.setDatabaseSchemaUpdate("false");
|
processEngineConfiguration.init();
|
idGeneratorCommandExecutor = processEngineConfiguration.getCommandExecutor();
|
} else {
|
idGeneratorCommandExecutor = this.getCommandExecutor();
|
}
|
|
DbIdGenerator dbIdGenerator = new DbIdGenerator();
|
dbIdGenerator.setIdBlockSize(this.idBlockSize);
|
dbIdGenerator.setCommandExecutor(idGeneratorCommandExecutor);
|
dbIdGenerator.setCommandConfig(this.getDefaultCommandConfig().transactionRequiresNew());
|
this.idGenerator = dbIdGenerator;
|
}
|
|
}
|
|
public void initCommandContextFactory() {
|
if (this.commandContextFactory == null) {
|
this.commandContextFactory = new CommandContextFactory();
|
}
|
|
this.commandContextFactory.setProcessEngineConfiguration(this);
|
}
|
|
public void initTransactionContextFactory() {
|
if (this.transactionContextFactory == null) {
|
this.transactionContextFactory = new StandaloneMybatisTransactionContextFactory();
|
}
|
|
}
|
|
public void initHelpers() {
|
if (this.processInstanceHelper == null) {
|
this.processInstanceHelper = new ProcessInstanceHelper();
|
}
|
|
if (this.listenerNotificationHelper == null) {
|
this.listenerNotificationHelper = new ListenerNotificationHelper();
|
}
|
|
}
|
|
public void initVariableTypes() {
|
if (this.variableTypes == null) {
|
this.variableTypes = new DefaultVariableTypes();
|
Iterator var1;
|
VariableType customVariableType;
|
if (this.customPreVariableTypes != null) {
|
var1 = this.customPreVariableTypes.iterator();
|
|
while(var1.hasNext()) {
|
customVariableType = (VariableType)var1.next();
|
this.variableTypes.addType(customVariableType);
|
}
|
}
|
|
this.variableTypes.addType(new NullType());
|
this.variableTypes.addType(new StringType(this.getMaxLengthString()));
|
this.variableTypes.addType(new LongStringType(this.getMaxLengthString() + 1));
|
this.variableTypes.addType(new BooleanType());
|
this.variableTypes.addType(new ShortType());
|
this.variableTypes.addType(new IntegerType());
|
this.variableTypes.addType(new LongType());
|
this.variableTypes.addType(new DateType());
|
this.variableTypes.addType(new JodaDateType());
|
this.variableTypes.addType(new JodaDateTimeType());
|
this.variableTypes.addType(new DoubleType());
|
this.variableTypes.addType(new UUIDType());
|
this.variableTypes.addType(new JsonType(this.getMaxLengthString(), this.objectMapper));
|
this.variableTypes.addType(new LongJsonType(this.getMaxLengthString() + 1, this.objectMapper));
|
this.variableTypes.addType(new ByteArrayType());
|
this.variableTypes.addType(new SerializableType(this.serializableVariableTypeTrackDeserializedObjects));
|
this.variableTypes.addType(new CustomObjectType("item", ItemInstance.class));
|
this.variableTypes.addType(new CustomObjectType("message", MessageInstance.class));
|
if (this.customPostVariableTypes != null) {
|
var1 = this.customPostVariableTypes.iterator();
|
|
while(var1.hasNext()) {
|
customVariableType = (VariableType)var1.next();
|
this.variableTypes.addType(customVariableType);
|
}
|
}
|
}
|
|
}
|
|
public int getMaxLengthString() {
|
if (this.maxLengthStringVariableType == -1) {
|
return "oracle".equalsIgnoreCase(this.databaseType) ? 2000 : 4000;
|
} else {
|
return this.maxLengthStringVariableType;
|
}
|
}
|
|
public void initFormEngines() {
|
if (this.formEngines == null) {
|
this.formEngines = new HashMap();
|
FormEngine defaultFormEngine = new JuelFormEngine();
|
this.formEngines.put("", defaultFormEngine);
|
this.formEngines.put(defaultFormEngine.getName(), defaultFormEngine);
|
}
|
|
if (this.customFormEngines != null) {
|
Iterator var3 = this.customFormEngines.iterator();
|
|
while(var3.hasNext()) {
|
FormEngine formEngine = (FormEngine)var3.next();
|
this.formEngines.put(formEngine.getName(), formEngine);
|
}
|
}
|
|
}
|
|
public void initFormTypes() {
|
if (this.formTypes == null) {
|
this.formTypes = new FormTypes();
|
this.formTypes.addFormType(new StringFormType());
|
this.formTypes.addFormType(new LongFormType());
|
this.formTypes.addFormType(new DateFormType("dd/MM/yyyy"));
|
this.formTypes.addFormType(new BooleanFormType());
|
this.formTypes.addFormType(new DoubleFormType());
|
}
|
|
if (this.customFormTypes != null) {
|
Iterator var1 = this.customFormTypes.iterator();
|
|
while(var1.hasNext()) {
|
AbstractFormType customFormType = (AbstractFormType)var1.next();
|
this.formTypes.addFormType(customFormType);
|
}
|
}
|
|
}
|
|
public void initScriptingEngines() {
|
if (this.resolverFactories == null) {
|
this.resolverFactories = new ArrayList();
|
this.resolverFactories.add(new VariableScopeResolverFactory());
|
this.resolverFactories.add(new BeansResolverFactory());
|
}
|
|
if (this.scriptingEngines == null) {
|
this.scriptingEngines = new ScriptingEngines(new ScriptBindingsFactory(this, this.resolverFactories));
|
}
|
|
}
|
|
public void initExpressionManager() {
|
if (this.expressionManager == null) {
|
this.expressionManager = new ExpressionManager(this.beans);
|
}
|
|
}
|
|
public void initBusinessCalendarManager() {
|
if (this.businessCalendarManager == null) {
|
MapBusinessCalendarManager mapBusinessCalendarManager = new MapBusinessCalendarManager();
|
mapBusinessCalendarManager.addBusinessCalendar(DurationBusinessCalendar.NAME, new DurationBusinessCalendar(this.clock));
|
mapBusinessCalendarManager.addBusinessCalendar("dueDate", new DueDateBusinessCalendar(this.clock));
|
mapBusinessCalendarManager.addBusinessCalendar(CycleBusinessCalendar.NAME, new CycleBusinessCalendar(this.clock));
|
this.businessCalendarManager = mapBusinessCalendarManager;
|
}
|
|
}
|
|
public void initDelegateInterceptor() {
|
if (this.delegateInterceptor == null) {
|
this.delegateInterceptor = new DefaultDelegateInterceptor();
|
}
|
|
}
|
|
public void initEventHandlers() {
|
if (this.eventHandlers == null) {
|
this.eventHandlers = new HashMap();
|
SignalEventHandler signalEventHandler = new SignalEventHandler();
|
this.eventHandlers.put(signalEventHandler.getEventHandlerType(), signalEventHandler);
|
CompensationEventHandler compensationEventHandler = new CompensationEventHandler();
|
this.eventHandlers.put(compensationEventHandler.getEventHandlerType(), compensationEventHandler);
|
MessageEventHandler messageEventHandler = new MessageEventHandler();
|
this.eventHandlers.put(messageEventHandler.getEventHandlerType(), messageEventHandler);
|
}
|
|
if (this.customEventHandlers != null) {
|
Iterator var4 = this.customEventHandlers.iterator();
|
|
while(var4.hasNext()) {
|
EventHandler eventHandler = (EventHandler)var4.next();
|
this.eventHandlers.put(eventHandler.getEventHandlerType(), eventHandler);
|
}
|
}
|
|
}
|
|
public void initJpa() {
|
if (this.jpaPersistenceUnitName != null) {
|
this.jpaEntityManagerFactory =JpaHelper.createEntityManagerFactory(this.jpaPersistenceUnitName);
|
}
|
|
if (this.jpaEntityManagerFactory != null) {
|
this.sessionFactories.put(EntityManagerSession.class, new EntityManagerSessionFactory(this.jpaEntityManagerFactory, this.jpaHandleTransaction, this.jpaCloseEntityManager));
|
VariableType jpaType = this.variableTypes.getVariableType("jpa-entity");
|
if (jpaType == null) {
|
int serializableIndex = this.variableTypes.getTypeIndex("serializable");
|
if (serializableIndex > -1) {
|
this.variableTypes.addType(new JPAEntityVariableType(), serializableIndex);
|
} else {
|
this.variableTypes.addType(new JPAEntityVariableType());
|
}
|
}
|
|
jpaType = this.variableTypes.getVariableType("jpa-entity-list");
|
if (jpaType == null) {
|
this.variableTypes.addType(new JPAEntityListVariableType(), this.variableTypes.getTypeIndex("jpa-entity"));
|
}
|
}
|
|
}
|
|
public void initBeans() {
|
if (this.beans == null) {
|
this.beans = new HashMap();
|
}
|
|
}
|
|
public void initEventDispatcher() {
|
if (this.eventDispatcher == null) {
|
this.eventDispatcher = new ActivitiEventDispatcherImpl();
|
}
|
|
this.eventDispatcher.setEnabled(this.enableEventDispatcher);
|
Iterator var1;
|
if (this.eventListeners != null) {
|
var1 = this.eventListeners.iterator();
|
|
while(var1.hasNext()) {
|
ActivitiEventListener listenerToAdd = (ActivitiEventListener)var1.next();
|
this.eventDispatcher.addEventListener(listenerToAdd);
|
}
|
}
|
|
if (this.typedEventListeners != null) {
|
var1 = this.typedEventListeners.entrySet().iterator();
|
|
while(var1.hasNext()) {
|
Map.Entry<String, List<ActivitiEventListener>> listenersToAdd = (Map.Entry)var1.next();
|
ActivitiEventType[] types = ActivitiEventType.getTypesFromString((String)listenersToAdd.getKey());
|
Iterator var4 = ((List)listenersToAdd.getValue()).iterator();
|
|
while(var4.hasNext()) {
|
ActivitiEventListener listenerToAdd = (ActivitiEventListener)var4.next();
|
this.eventDispatcher.addEventListener(listenerToAdd, types);
|
}
|
}
|
}
|
|
}
|
|
public void initProcessValidator() {
|
if (this.processValidator == null) {
|
this.processValidator = (new ProcessValidatorFactory()).createDefaultProcessValidator();
|
}
|
|
}
|
|
public void initDatabaseEventLogging() {
|
if (this.enableDatabaseEventLogging) {
|
this.getEventDispatcher().addEventListener(new EventLogger(this.clock, this.objectMapper));
|
}
|
|
}
|
|
public void initActiviti5CompatibilityHandler() {
|
if (!this.isActiviti5CompatibilityEnabled || this.activiti5CompatibilityHandler == null) {
|
if (this.activiti5CompatibilityHandlerFactory == null) {
|
this.activiti5CompatibilityHandlerFactory = new DefaultActiviti5CompatibilityHandlerFactory();
|
}
|
|
this.activiti5CompatibilityHandler = this.activiti5CompatibilityHandlerFactory.createActiviti5CompatibilityHandler();
|
if (this.activiti5CompatibilityHandler != null) {
|
log.info("Found compatibility handler instance : " + this.activiti5CompatibilityHandler.getClass());
|
}
|
}
|
|
}
|
|
protected void postProcessEngineInitialisation() {
|
if (this.performanceSettings.isValidateExecutionRelationshipCountConfigOnBoot()) {
|
this.commandExecutor.execute(new ValidateExecutionRelatedEntityCountCfgCmd());
|
}
|
|
}
|
|
public CommandConfig getDefaultCommandConfig() {
|
return this.defaultCommandConfig;
|
}
|
|
public void setDefaultCommandConfig(CommandConfig defaultCommandConfig) {
|
this.defaultCommandConfig = defaultCommandConfig;
|
}
|
|
public CommandConfig getSchemaCommandConfig() {
|
return this.schemaCommandConfig;
|
}
|
|
public void setSchemaCommandConfig(CommandConfig schemaCommandConfig) {
|
this.schemaCommandConfig = schemaCommandConfig;
|
}
|
|
public CommandInterceptor getCommandInvoker() {
|
return this.commandInvoker;
|
}
|
|
public void setCommandInvoker(CommandInterceptor commandInvoker) {
|
this.commandInvoker = commandInvoker;
|
}
|
|
public List<CommandInterceptor> getCustomPreCommandInterceptors() {
|
return this.customPreCommandInterceptors;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomPreCommandInterceptors(List<CommandInterceptor> customPreCommandInterceptors) {
|
this.customPreCommandInterceptors = customPreCommandInterceptors;
|
return this;
|
}
|
|
public List<CommandInterceptor> getCustomPostCommandInterceptors() {
|
return this.customPostCommandInterceptors;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomPostCommandInterceptors(List<CommandInterceptor> customPostCommandInterceptors) {
|
this.customPostCommandInterceptors = customPostCommandInterceptors;
|
return this;
|
}
|
|
public List<CommandInterceptor> getCommandInterceptors() {
|
return this.commandInterceptors;
|
}
|
|
public ProcessEngineConfigurationImpl setCommandInterceptors(List<CommandInterceptor> commandInterceptors) {
|
this.commandInterceptors = commandInterceptors;
|
return this;
|
}
|
|
public CommandExecutor getCommandExecutor() {
|
return this.commandExecutor;
|
}
|
|
public ProcessEngineConfigurationImpl setCommandExecutor(CommandExecutor commandExecutor) {
|
this.commandExecutor = commandExecutor;
|
return this;
|
}
|
|
public RepositoryService getRepositoryService() {
|
return this.repositoryService;
|
}
|
|
public ProcessEngineConfigurationImpl setRepositoryService(RepositoryService repositoryService) {
|
this.repositoryService = repositoryService;
|
return this;
|
}
|
|
public RuntimeService getRuntimeService() {
|
return this.runtimeService;
|
}
|
|
public ProcessEngineConfigurationImpl setRuntimeService(RuntimeService runtimeService) {
|
this.runtimeService = runtimeService;
|
return this;
|
}
|
|
public HistoryService getHistoryService() {
|
return this.historyService;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoryService(HistoryService historyService) {
|
this.historyService = historyService;
|
return this;
|
}
|
|
public IdentityService getIdentityService() {
|
return this.identityService;
|
}
|
|
public ProcessEngineConfigurationImpl setIdentityService(IdentityService identityService) {
|
this.identityService = identityService;
|
return this;
|
}
|
|
public TaskService getTaskService() {
|
return this.taskService;
|
}
|
|
public ProcessEngineConfigurationImpl setTaskService(TaskService taskService) {
|
this.taskService = taskService;
|
return this;
|
}
|
|
public FormService getFormService() {
|
return this.formService;
|
}
|
|
public ProcessEngineConfigurationImpl setFormService(FormService formService) {
|
this.formService = formService;
|
return this;
|
}
|
|
public ManagementService getManagementService() {
|
return this.managementService;
|
}
|
|
public ProcessEngineConfigurationImpl setManagementService(ManagementService managementService) {
|
this.managementService = managementService;
|
return this;
|
}
|
|
public DynamicBpmnService getDynamicBpmnService() {
|
return this.dynamicBpmnService;
|
}
|
|
public ProcessEngineConfigurationImpl setDynamicBpmnService(DynamicBpmnService dynamicBpmnService) {
|
this.dynamicBpmnService = dynamicBpmnService;
|
return this;
|
}
|
|
public ProcessEngineConfigurationImpl getProcessEngineConfiguration() {
|
return this;
|
}
|
|
public boolean isFormEngineInitialized() {
|
return this.formEngineInitialized;
|
}
|
|
public ProcessEngineConfigurationImpl setFormEngineInitialized(boolean formEngineInitialized) {
|
this.formEngineInitialized = formEngineInitialized;
|
return this;
|
}
|
|
public FormRepositoryService getFormEngineRepositoryService() {
|
return this.formEngineRepositoryService;
|
}
|
|
public ProcessEngineConfigurationImpl setFormEngineRepositoryService(FormRepositoryService formEngineRepositoryService) {
|
this.formEngineRepositoryService = formEngineRepositoryService;
|
return this;
|
}
|
|
public org.activiti.form.api.FormService getFormEngineFormService() {
|
return this.formEngineFormService;
|
}
|
|
public ProcessEngineConfigurationImpl setFormEngineFormService(org.activiti.form.api.FormService formEngineFormService) {
|
this.formEngineFormService = formEngineFormService;
|
return this;
|
}
|
|
public boolean isDmnEngineInitialized() {
|
return this.dmnEngineInitialized;
|
}
|
|
public ProcessEngineConfigurationImpl setDmnEngineInitialized(boolean dmnEngineInitialized) {
|
this.dmnEngineInitialized = dmnEngineInitialized;
|
return this;
|
}
|
|
public DmnRepositoryService getDmnEngineRepositoryService() {
|
return this.dmnEngineRepositoryService;
|
}
|
|
public ProcessEngineConfigurationImpl setDmnEngineRepositoryService(DmnRepositoryService dmnEngineRepositoryService) {
|
this.dmnEngineRepositoryService = dmnEngineRepositoryService;
|
return this;
|
}
|
|
public DmnRuleService getDmnEngineRuleService() {
|
return this.dmnEngineRuleService;
|
}
|
|
public ProcessEngineConfigurationImpl setDmnEngineRuleService(DmnRuleService dmnEngineRuleService) {
|
this.dmnEngineRuleService = dmnEngineRuleService;
|
return this;
|
}
|
|
public Map<Class<?>, SessionFactory> getSessionFactories() {
|
return this.sessionFactories;
|
}
|
|
public ProcessEngineConfigurationImpl setSessionFactories(Map<Class<?>, SessionFactory> sessionFactories) {
|
this.sessionFactories = sessionFactories;
|
return this;
|
}
|
|
public List<ProcessEngineConfigurator> getConfigurators() {
|
return this.configurators;
|
}
|
|
public ProcessEngineConfigurationImpl addConfigurator(ProcessEngineConfigurator configurator) {
|
if (this.configurators == null) {
|
this.configurators = new ArrayList();
|
}
|
|
this.configurators.add(configurator);
|
return this;
|
}
|
|
public ProcessEngineConfigurationImpl setConfigurators(List<ProcessEngineConfigurator> configurators) {
|
this.configurators = configurators;
|
return this;
|
}
|
|
public void setEnableConfiguratorServiceLoader(boolean enableConfiguratorServiceLoader) {
|
this.enableConfiguratorServiceLoader = enableConfiguratorServiceLoader;
|
}
|
|
public List<ProcessEngineConfigurator> getAllConfigurators() {
|
return this.allConfigurators;
|
}
|
|
public BpmnDeployer getBpmnDeployer() {
|
return this.bpmnDeployer;
|
}
|
|
public ProcessEngineConfigurationImpl setBpmnDeployer(BpmnDeployer bpmnDeployer) {
|
this.bpmnDeployer = bpmnDeployer;
|
return this;
|
}
|
|
public BpmnParser getBpmnParser() {
|
return this.bpmnParser;
|
}
|
|
public ProcessEngineConfigurationImpl setBpmnParser(BpmnParser bpmnParser) {
|
this.bpmnParser = bpmnParser;
|
return this;
|
}
|
|
public ParsedDeploymentBuilderFactory getParsedDeploymentBuilderFactory() {
|
return this.parsedDeploymentBuilderFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setParsedDeploymentBuilderFactory(ParsedDeploymentBuilderFactory parsedDeploymentBuilderFactory) {
|
this.parsedDeploymentBuilderFactory = parsedDeploymentBuilderFactory;
|
return this;
|
}
|
|
public TimerManager getTimerManager() {
|
return this.timerManager;
|
}
|
|
public void setTimerManager(TimerManager timerManager) {
|
this.timerManager = timerManager;
|
}
|
|
public EventSubscriptionManager getEventSubscriptionManager() {
|
return this.eventSubscriptionManager;
|
}
|
|
public void setEventSubscriptionManager(EventSubscriptionManager eventSubscriptionManager) {
|
this.eventSubscriptionManager = eventSubscriptionManager;
|
}
|
|
public BpmnDeploymentHelper getBpmnDeploymentHelper() {
|
return this.bpmnDeploymentHelper;
|
}
|
|
public ProcessEngineConfigurationImpl setBpmnDeploymentHelper(BpmnDeploymentHelper bpmnDeploymentHelper) {
|
this.bpmnDeploymentHelper = bpmnDeploymentHelper;
|
return this;
|
}
|
|
public CachingAndArtifactsManager getCachingAndArtifactsManager() {
|
return this.cachingAndArtifactsManager;
|
}
|
|
public void setCachingAndArtifactsManager(CachingAndArtifactsManager cachingAndArtifactsManager) {
|
this.cachingAndArtifactsManager = cachingAndArtifactsManager;
|
}
|
|
public ProcessDefinitionDiagramHelper getProcessDefinitionDiagramHelper() {
|
return this.processDefinitionDiagramHelper;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessDefinitionDiagramHelper(ProcessDefinitionDiagramHelper processDefinitionDiagramHelper) {
|
this.processDefinitionDiagramHelper = processDefinitionDiagramHelper;
|
return this;
|
}
|
|
public List<Deployer> getDeployers() {
|
return this.deployers;
|
}
|
|
public ProcessEngineConfigurationImpl setDeployers(List<Deployer> deployers) {
|
this.deployers = deployers;
|
return this;
|
}
|
|
public IdGenerator getIdGenerator() {
|
return this.idGenerator;
|
}
|
|
public ProcessEngineConfigurationImpl setIdGenerator(IdGenerator idGenerator) {
|
this.idGenerator = idGenerator;
|
return this;
|
}
|
|
public String getWsSyncFactoryClassName() {
|
return this.wsSyncFactoryClassName;
|
}
|
|
public ProcessEngineConfigurationImpl setWsSyncFactoryClassName(String wsSyncFactoryClassName) {
|
this.wsSyncFactoryClassName = wsSyncFactoryClassName;
|
return this;
|
}
|
|
public ProcessEngineConfiguration addWsEndpointAddress(QName endpointName, URL address) {
|
this.wsOverridenEndpointAddresses.put(endpointName, address);
|
return this;
|
}
|
|
public ProcessEngineConfiguration removeWsEndpointAddress(QName endpointName) {
|
this.wsOverridenEndpointAddresses.remove(endpointName);
|
return this;
|
}
|
|
public ConcurrentMap<QName, URL> getWsOverridenEndpointAddresses() {
|
return this.wsOverridenEndpointAddresses;
|
}
|
|
public ProcessEngineConfiguration setWsOverridenEndpointAddresses(ConcurrentMap<QName, URL> wsOverridenEndpointAddress) {
|
this.wsOverridenEndpointAddresses.putAll(wsOverridenEndpointAddress);
|
return this;
|
}
|
|
public Map<String, FormEngine> getFormEngines() {
|
return this.formEngines;
|
}
|
|
public ProcessEngineConfigurationImpl setFormEngines(Map<String, FormEngine> formEngines) {
|
this.formEngines = formEngines;
|
return this;
|
}
|
|
public FormTypes getFormTypes() {
|
return this.formTypes;
|
}
|
|
public ProcessEngineConfigurationImpl setFormTypes(FormTypes formTypes) {
|
this.formTypes = formTypes;
|
return this;
|
}
|
|
public ScriptingEngines getScriptingEngines() {
|
return this.scriptingEngines;
|
}
|
|
public ProcessEngineConfigurationImpl setScriptingEngines(ScriptingEngines scriptingEngines) {
|
this.scriptingEngines = scriptingEngines;
|
return this;
|
}
|
|
public VariableTypes getVariableTypes() {
|
return this.variableTypes;
|
}
|
|
public ProcessEngineConfigurationImpl setVariableTypes(VariableTypes variableTypes) {
|
this.variableTypes = variableTypes;
|
return this;
|
}
|
|
public boolean isSerializableVariableTypeTrackDeserializedObjects() {
|
return this.serializableVariableTypeTrackDeserializedObjects;
|
}
|
|
public void setSerializableVariableTypeTrackDeserializedObjects(boolean serializableVariableTypeTrackDeserializedObjects) {
|
this.serializableVariableTypeTrackDeserializedObjects = serializableVariableTypeTrackDeserializedObjects;
|
}
|
|
public ExpressionManager getExpressionManager() {
|
return this.expressionManager;
|
}
|
|
public ProcessEngineConfigurationImpl setExpressionManager(ExpressionManager expressionManager) {
|
this.expressionManager = expressionManager;
|
return this;
|
}
|
|
public BusinessCalendarManager getBusinessCalendarManager() {
|
return this.businessCalendarManager;
|
}
|
|
public ProcessEngineConfigurationImpl setBusinessCalendarManager(BusinessCalendarManager businessCalendarManager) {
|
this.businessCalendarManager = businessCalendarManager;
|
return this;
|
}
|
|
public int getExecutionQueryLimit() {
|
return this.executionQueryLimit;
|
}
|
|
public ProcessEngineConfigurationImpl setExecutionQueryLimit(int executionQueryLimit) {
|
this.executionQueryLimit = executionQueryLimit;
|
return this;
|
}
|
|
public int getTaskQueryLimit() {
|
return this.taskQueryLimit;
|
}
|
|
public ProcessEngineConfigurationImpl setTaskQueryLimit(int taskQueryLimit) {
|
this.taskQueryLimit = taskQueryLimit;
|
return this;
|
}
|
|
public int getHistoricTaskQueryLimit() {
|
return this.historicTaskQueryLimit;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricTaskQueryLimit(int historicTaskQueryLimit) {
|
this.historicTaskQueryLimit = historicTaskQueryLimit;
|
return this;
|
}
|
|
public int getHistoricProcessInstancesQueryLimit() {
|
return this.historicProcessInstancesQueryLimit;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricProcessInstancesQueryLimit(int historicProcessInstancesQueryLimit) {
|
this.historicProcessInstancesQueryLimit = historicProcessInstancesQueryLimit;
|
return this;
|
}
|
|
public CommandContextFactory getCommandContextFactory() {
|
return this.commandContextFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setCommandContextFactory(CommandContextFactory commandContextFactory) {
|
this.commandContextFactory = commandContextFactory;
|
return this;
|
}
|
|
public TransactionContextFactory getTransactionContextFactory() {
|
return this.transactionContextFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setTransactionContextFactory(TransactionContextFactory transactionContextFactory) {
|
this.transactionContextFactory = transactionContextFactory;
|
return this;
|
}
|
|
public List<Deployer> getCustomPreDeployers() {
|
return this.customPreDeployers;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomPreDeployers(List<Deployer> customPreDeployers) {
|
this.customPreDeployers = customPreDeployers;
|
return this;
|
}
|
|
public List<Deployer> getCustomPostDeployers() {
|
return this.customPostDeployers;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomPostDeployers(List<Deployer> customPostDeployers) {
|
this.customPostDeployers = customPostDeployers;
|
return this;
|
}
|
|
public Map<String, JobHandler> getJobHandlers() {
|
return this.jobHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setJobHandlers(Map<String, JobHandler> jobHandlers) {
|
this.jobHandlers = jobHandlers;
|
return this;
|
}
|
|
public ProcessInstanceHelper getProcessInstanceHelper() {
|
return this.processInstanceHelper;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessInstanceHelper(ProcessInstanceHelper processInstanceHelper) {
|
this.processInstanceHelper = processInstanceHelper;
|
return this;
|
}
|
|
public ListenerNotificationHelper getListenerNotificationHelper() {
|
return this.listenerNotificationHelper;
|
}
|
|
public ProcessEngineConfigurationImpl setListenerNotificationHelper(ListenerNotificationHelper listenerNotificationHelper) {
|
this.listenerNotificationHelper = listenerNotificationHelper;
|
return this;
|
}
|
|
public SqlSessionFactory getSqlSessionFactory() {
|
return this.sqlSessionFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
|
this.sqlSessionFactory = sqlSessionFactory;
|
return this;
|
}
|
|
public DbSqlSessionFactory getDbSqlSessionFactory() {
|
return this.dbSqlSessionFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setDbSqlSessionFactory(DbSqlSessionFactory dbSqlSessionFactory) {
|
this.dbSqlSessionFactory = dbSqlSessionFactory;
|
return this;
|
}
|
|
public TransactionFactory getTransactionFactory() {
|
return this.transactionFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setTransactionFactory(TransactionFactory transactionFactory) {
|
this.transactionFactory = transactionFactory;
|
return this;
|
}
|
|
public List<SessionFactory> getCustomSessionFactories() {
|
return this.customSessionFactories;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomSessionFactories(List<SessionFactory> customSessionFactories) {
|
this.customSessionFactories = customSessionFactories;
|
return this;
|
}
|
|
public List<JobHandler> getCustomJobHandlers() {
|
return this.customJobHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomJobHandlers(List<JobHandler> customJobHandlers) {
|
this.customJobHandlers = customJobHandlers;
|
return this;
|
}
|
|
public List<FormEngine> getCustomFormEngines() {
|
return this.customFormEngines;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomFormEngines(List<FormEngine> customFormEngines) {
|
this.customFormEngines = customFormEngines;
|
return this;
|
}
|
|
public List<AbstractFormType> getCustomFormTypes() {
|
return this.customFormTypes;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomFormTypes(List<AbstractFormType> customFormTypes) {
|
this.customFormTypes = customFormTypes;
|
return this;
|
}
|
|
public List<String> getCustomScriptingEngineClasses() {
|
return this.customScriptingEngineClasses;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomScriptingEngineClasses(List<String> customScriptingEngineClasses) {
|
this.customScriptingEngineClasses = customScriptingEngineClasses;
|
return this;
|
}
|
|
public List<VariableType> getCustomPreVariableTypes() {
|
return this.customPreVariableTypes;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomPreVariableTypes(List<VariableType> customPreVariableTypes) {
|
this.customPreVariableTypes = customPreVariableTypes;
|
return this;
|
}
|
|
public List<VariableType> getCustomPostVariableTypes() {
|
return this.customPostVariableTypes;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomPostVariableTypes(List<VariableType> customPostVariableTypes) {
|
this.customPostVariableTypes = customPostVariableTypes;
|
return this;
|
}
|
|
public List<BpmnParseHandler> getPreBpmnParseHandlers() {
|
return this.preBpmnParseHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setPreBpmnParseHandlers(List<BpmnParseHandler> preBpmnParseHandlers) {
|
this.preBpmnParseHandlers = preBpmnParseHandlers;
|
return this;
|
}
|
|
public List<BpmnParseHandler> getCustomDefaultBpmnParseHandlers() {
|
return this.customDefaultBpmnParseHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomDefaultBpmnParseHandlers(List<BpmnParseHandler> customDefaultBpmnParseHandlers) {
|
this.customDefaultBpmnParseHandlers = customDefaultBpmnParseHandlers;
|
return this;
|
}
|
|
public List<BpmnParseHandler> getPostBpmnParseHandlers() {
|
return this.postBpmnParseHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setPostBpmnParseHandlers(List<BpmnParseHandler> postBpmnParseHandlers) {
|
this.postBpmnParseHandlers = postBpmnParseHandlers;
|
return this;
|
}
|
|
public ActivityBehaviorFactory getActivityBehaviorFactory() {
|
return this.activityBehaviorFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setActivityBehaviorFactory(ActivityBehaviorFactory activityBehaviorFactory) {
|
this.activityBehaviorFactory = activityBehaviorFactory;
|
return this;
|
}
|
|
public ListenerFactory getListenerFactory() {
|
return this.listenerFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setListenerFactory(ListenerFactory listenerFactory) {
|
this.listenerFactory = listenerFactory;
|
return this;
|
}
|
|
public BpmnParseFactory getBpmnParseFactory() {
|
return this.bpmnParseFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setBpmnParseFactory(BpmnParseFactory bpmnParseFactory) {
|
this.bpmnParseFactory = bpmnParseFactory;
|
return this;
|
}
|
|
public Map<Object, Object> getBeans() {
|
return this.beans;
|
}
|
|
public ProcessEngineConfigurationImpl setBeans(Map<Object, Object> beans) {
|
this.beans = beans;
|
return this;
|
}
|
|
public List<ResolverFactory> getResolverFactories() {
|
return this.resolverFactories;
|
}
|
|
public ProcessEngineConfigurationImpl setResolverFactories(List<ResolverFactory> resolverFactories) {
|
this.resolverFactories = resolverFactories;
|
return this;
|
}
|
|
public DeploymentManager getDeploymentManager() {
|
return this.deploymentManager;
|
}
|
|
public ProcessEngineConfigurationImpl setDeploymentManager(DeploymentManager deploymentManager) {
|
this.deploymentManager = deploymentManager;
|
return this;
|
}
|
|
public ProcessEngineConfigurationImpl setDelegateInterceptor(DelegateInterceptor delegateInterceptor) {
|
this.delegateInterceptor = delegateInterceptor;
|
return this;
|
}
|
|
public DelegateInterceptor getDelegateInterceptor() {
|
return this.delegateInterceptor;
|
}
|
|
public EventHandler getEventHandler(String eventType) {
|
return (EventHandler)this.eventHandlers.get(eventType);
|
}
|
|
public ProcessEngineConfigurationImpl setEventHandlers(Map<String, EventHandler> eventHandlers) {
|
this.eventHandlers = eventHandlers;
|
return this;
|
}
|
|
public Map<String, EventHandler> getEventHandlers() {
|
return this.eventHandlers;
|
}
|
|
public List<EventHandler> getCustomEventHandlers() {
|
return this.customEventHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setCustomEventHandlers(List<EventHandler> customEventHandlers) {
|
this.customEventHandlers = customEventHandlers;
|
return this;
|
}
|
|
public FailedJobCommandFactory getFailedJobCommandFactory() {
|
return this.failedJobCommandFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setFailedJobCommandFactory(FailedJobCommandFactory failedJobCommandFactory) {
|
this.failedJobCommandFactory = failedJobCommandFactory;
|
return this;
|
}
|
|
public DataSource getIdGeneratorDataSource() {
|
return this.idGeneratorDataSource;
|
}
|
|
public ProcessEngineConfigurationImpl setIdGeneratorDataSource(DataSource idGeneratorDataSource) {
|
this.idGeneratorDataSource = idGeneratorDataSource;
|
return this;
|
}
|
|
public String getIdGeneratorDataSourceJndiName() {
|
return this.idGeneratorDataSourceJndiName;
|
}
|
|
public ProcessEngineConfigurationImpl setIdGeneratorDataSourceJndiName(String idGeneratorDataSourceJndiName) {
|
this.idGeneratorDataSourceJndiName = idGeneratorDataSourceJndiName;
|
return this;
|
}
|
|
public int getBatchSizeProcessInstances() {
|
return this.batchSizeProcessInstances;
|
}
|
|
public ProcessEngineConfigurationImpl setBatchSizeProcessInstances(int batchSizeProcessInstances) {
|
this.batchSizeProcessInstances = batchSizeProcessInstances;
|
return this;
|
}
|
|
public int getBatchSizeTasks() {
|
return this.batchSizeTasks;
|
}
|
|
public ProcessEngineConfigurationImpl setBatchSizeTasks(int batchSizeTasks) {
|
this.batchSizeTasks = batchSizeTasks;
|
return this;
|
}
|
|
public int getProcessDefinitionCacheLimit() {
|
return this.processDefinitionCacheLimit;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessDefinitionCacheLimit(int processDefinitionCacheLimit) {
|
this.processDefinitionCacheLimit = processDefinitionCacheLimit;
|
return this;
|
}
|
|
public DeploymentCache<ProcessDefinitionCacheEntry> getProcessDefinitionCache() {
|
return this.processDefinitionCache;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessDefinitionCache(DeploymentCache<ProcessDefinitionCacheEntry> processDefinitionCache) {
|
this.processDefinitionCache = processDefinitionCache;
|
return this;
|
}
|
|
public int getKnowledgeBaseCacheLimit() {
|
return this.knowledgeBaseCacheLimit;
|
}
|
|
public ProcessEngineConfigurationImpl setKnowledgeBaseCacheLimit(int knowledgeBaseCacheLimit) {
|
this.knowledgeBaseCacheLimit = knowledgeBaseCacheLimit;
|
return this;
|
}
|
|
public DeploymentCache<Object> getKnowledgeBaseCache() {
|
return this.knowledgeBaseCache;
|
}
|
|
public ProcessEngineConfigurationImpl setKnowledgeBaseCache(DeploymentCache<Object> knowledgeBaseCache) {
|
this.knowledgeBaseCache = knowledgeBaseCache;
|
return this;
|
}
|
|
public boolean isEnableSafeBpmnXml() {
|
return this.enableSafeBpmnXml;
|
}
|
|
public ProcessEngineConfigurationImpl setEnableSafeBpmnXml(boolean enableSafeBpmnXml) {
|
this.enableSafeBpmnXml = enableSafeBpmnXml;
|
return this;
|
}
|
|
public ActivitiEventDispatcher getEventDispatcher() {
|
return this.eventDispatcher;
|
}
|
|
public ProcessEngineConfigurationImpl setEventDispatcher(ActivitiEventDispatcher eventDispatcher) {
|
this.eventDispatcher = eventDispatcher;
|
return this;
|
}
|
|
public ProcessEngineConfigurationImpl setEnableEventDispatcher(boolean enableEventDispatcher) {
|
this.enableEventDispatcher = enableEventDispatcher;
|
return this;
|
}
|
|
public Map<String, List<ActivitiEventListener>> getTypedEventListeners() {
|
return this.typedEventListeners;
|
}
|
|
public ProcessEngineConfigurationImpl setTypedEventListeners(Map<String, List<ActivitiEventListener>> typedListeners) {
|
this.typedEventListeners = typedListeners;
|
return this;
|
}
|
|
public List<ActivitiEventListener> getEventListeners() {
|
return this.eventListeners;
|
}
|
|
public ProcessEngineConfigurationImpl setEventListeners(List<ActivitiEventListener> eventListeners) {
|
this.eventListeners = eventListeners;
|
return this;
|
}
|
|
public ProcessValidator getProcessValidator() {
|
return this.processValidator;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessValidator(ProcessValidator processValidator) {
|
this.processValidator = processValidator;
|
return this;
|
}
|
|
public boolean isEnableEventDispatcher() {
|
return this.enableEventDispatcher;
|
}
|
|
public boolean isEnableDatabaseEventLogging() {
|
return this.enableDatabaseEventLogging;
|
}
|
|
public ProcessEngineConfigurationImpl setEnableDatabaseEventLogging(boolean enableDatabaseEventLogging) {
|
this.enableDatabaseEventLogging = enableDatabaseEventLogging;
|
return this;
|
}
|
|
public int getMaxLengthStringVariableType() {
|
return this.maxLengthStringVariableType;
|
}
|
|
public ProcessEngineConfigurationImpl setMaxLengthStringVariableType(int maxLengthStringVariableType) {
|
this.maxLengthStringVariableType = maxLengthStringVariableType;
|
return this;
|
}
|
|
public boolean isBulkInsertEnabled() {
|
return this.isBulkInsertEnabled;
|
}
|
|
public ProcessEngineConfigurationImpl setBulkInsertEnabled(boolean isBulkInsertEnabled) {
|
this.isBulkInsertEnabled = isBulkInsertEnabled;
|
return this;
|
}
|
|
public int getMaxNrOfStatementsInBulkInsert() {
|
return this.maxNrOfStatementsInBulkInsert;
|
}
|
|
public ProcessEngineConfigurationImpl setMaxNrOfStatementsInBulkInsert(int maxNrOfStatementsInBulkInsert) {
|
this.maxNrOfStatementsInBulkInsert = maxNrOfStatementsInBulkInsert;
|
return this;
|
}
|
|
public boolean isUsingRelationalDatabase() {
|
return this.usingRelationalDatabase;
|
}
|
|
public ProcessEngineConfigurationImpl setUsingRelationalDatabase(boolean usingRelationalDatabase) {
|
this.usingRelationalDatabase = usingRelationalDatabase;
|
return this;
|
}
|
|
public boolean isEnableVerboseExecutionTreeLogging() {
|
return this.enableVerboseExecutionTreeLogging;
|
}
|
|
public ProcessEngineConfigurationImpl setEnableVerboseExecutionTreeLogging(boolean enableVerboseExecutionTreeLogging) {
|
this.enableVerboseExecutionTreeLogging = enableVerboseExecutionTreeLogging;
|
return this;
|
}
|
|
public ProcessEngineConfigurationImpl setEnableEagerExecutionTreeFetching(boolean enableEagerExecutionTreeFetching) {
|
this.performanceSettings.setEnableEagerExecutionTreeFetching(enableEagerExecutionTreeFetching);
|
return this;
|
}
|
|
public ProcessEngineConfigurationImpl setEnableExecutionRelationshipCounts(boolean enableExecutionRelationshipCounts) {
|
this.performanceSettings.setEnableExecutionRelationshipCounts(enableExecutionRelationshipCounts);
|
return this;
|
}
|
|
public PerformanceSettings getPerformanceSettings() {
|
return this.performanceSettings;
|
}
|
|
public void setPerformanceSettings(PerformanceSettings performanceSettings) {
|
this.performanceSettings = performanceSettings;
|
}
|
|
public ProcessEngineConfigurationImpl setEnableLocalization(boolean enableLocalization) {
|
this.performanceSettings.setEnableLocalization(enableLocalization);
|
return this;
|
}
|
|
public AttachmentDataManager getAttachmentDataManager() {
|
return this.attachmentDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setAttachmentDataManager(AttachmentDataManager attachmentDataManager) {
|
this.attachmentDataManager = attachmentDataManager;
|
return this;
|
}
|
|
public ByteArrayDataManager getByteArrayDataManager() {
|
return this.byteArrayDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setByteArrayDataManager(ByteArrayDataManager byteArrayDataManager) {
|
this.byteArrayDataManager = byteArrayDataManager;
|
return this;
|
}
|
|
public CommentDataManager getCommentDataManager() {
|
return this.commentDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setCommentDataManager(CommentDataManager commentDataManager) {
|
this.commentDataManager = commentDataManager;
|
return this;
|
}
|
|
public DeploymentDataManager getDeploymentDataManager() {
|
return this.deploymentDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setDeploymentDataManager(DeploymentDataManager deploymentDataManager) {
|
this.deploymentDataManager = deploymentDataManager;
|
return this;
|
}
|
|
public EventLogEntryDataManager getEventLogEntryDataManager() {
|
return this.eventLogEntryDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setEventLogEntryDataManager(EventLogEntryDataManager eventLogEntryDataManager) {
|
this.eventLogEntryDataManager = eventLogEntryDataManager;
|
return this;
|
}
|
|
public EventSubscriptionDataManager getEventSubscriptionDataManager() {
|
return this.eventSubscriptionDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setEventSubscriptionDataManager(EventSubscriptionDataManager eventSubscriptionDataManager) {
|
this.eventSubscriptionDataManager = eventSubscriptionDataManager;
|
return this;
|
}
|
|
public ExecutionDataManager getExecutionDataManager() {
|
return this.executionDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setExecutionDataManager(ExecutionDataManager executionDataManager) {
|
this.executionDataManager = executionDataManager;
|
return this;
|
}
|
|
public GroupDataManager getGroupDataManager() {
|
return this.groupDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setGroupDataManager(GroupDataManager groupDataManager) {
|
this.groupDataManager = groupDataManager;
|
return this;
|
}
|
|
public HistoricActivityInstanceDataManager getHistoricActivityInstanceDataManager() {
|
return this.historicActivityInstanceDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricActivityInstanceDataManager(HistoricActivityInstanceDataManager historicActivityInstanceDataManager) {
|
this.historicActivityInstanceDataManager = historicActivityInstanceDataManager;
|
return this;
|
}
|
|
public HistoricDetailDataManager getHistoricDetailDataManager() {
|
return this.historicDetailDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricDetailDataManager(HistoricDetailDataManager historicDetailDataManager) {
|
this.historicDetailDataManager = historicDetailDataManager;
|
return this;
|
}
|
|
public HistoricIdentityLinkDataManager getHistoricIdentityLinkDataManager() {
|
return this.historicIdentityLinkDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricIdentityLinkDataManager(HistoricIdentityLinkDataManager historicIdentityLinkDataManager) {
|
this.historicIdentityLinkDataManager = historicIdentityLinkDataManager;
|
return this;
|
}
|
|
public HistoricProcessInstanceDataManager getHistoricProcessInstanceDataManager() {
|
return this.historicProcessInstanceDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricProcessInstanceDataManager(HistoricProcessInstanceDataManager historicProcessInstanceDataManager) {
|
this.historicProcessInstanceDataManager = historicProcessInstanceDataManager;
|
return this;
|
}
|
|
public HistoricTaskInstanceDataManager getHistoricTaskInstanceDataManager() {
|
return this.historicTaskInstanceDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricTaskInstanceDataManager(HistoricTaskInstanceDataManager historicTaskInstanceDataManager) {
|
this.historicTaskInstanceDataManager = historicTaskInstanceDataManager;
|
return this;
|
}
|
|
public HistoricVariableInstanceDataManager getHistoricVariableInstanceDataManager() {
|
return this.historicVariableInstanceDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricVariableInstanceDataManager(HistoricVariableInstanceDataManager historicVariableInstanceDataManager) {
|
this.historicVariableInstanceDataManager = historicVariableInstanceDataManager;
|
return this;
|
}
|
|
public IdentityInfoDataManager getIdentityInfoDataManager() {
|
return this.identityInfoDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setIdentityInfoDataManager(IdentityInfoDataManager identityInfoDataManager) {
|
this.identityInfoDataManager = identityInfoDataManager;
|
return this;
|
}
|
|
public IdentityLinkDataManager getIdentityLinkDataManager() {
|
return this.identityLinkDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setIdentityLinkDataManager(IdentityLinkDataManager identityLinkDataManager) {
|
this.identityLinkDataManager = identityLinkDataManager;
|
return this;
|
}
|
|
public JobDataManager getJobDataManager() {
|
return this.jobDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setJobDataManager(JobDataManager jobDataManager) {
|
this.jobDataManager = jobDataManager;
|
return this;
|
}
|
|
public TimerJobDataManager getTimerJobDataManager() {
|
return this.timerJobDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setTimerJobDataManager(TimerJobDataManager timerJobDataManager) {
|
this.timerJobDataManager = timerJobDataManager;
|
return this;
|
}
|
|
public SuspendedJobDataManager getSuspendedJobDataManager() {
|
return this.suspendedJobDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setSuspendedJobDataManager(SuspendedJobDataManager suspendedJobDataManager) {
|
this.suspendedJobDataManager = suspendedJobDataManager;
|
return this;
|
}
|
|
public DeadLetterJobDataManager getDeadLetterJobDataManager() {
|
return this.deadLetterJobDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setDeadLetterJobDataManager(DeadLetterJobDataManager deadLetterJobDataManager) {
|
this.deadLetterJobDataManager = deadLetterJobDataManager;
|
return this;
|
}
|
|
public MembershipDataManager getMembershipDataManager() {
|
return this.membershipDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setMembershipDataManager(MembershipDataManager membershipDataManager) {
|
this.membershipDataManager = membershipDataManager;
|
return this;
|
}
|
|
public ModelDataManager getModelDataManager() {
|
return this.modelDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setModelDataManager(ModelDataManager modelDataManager) {
|
this.modelDataManager = modelDataManager;
|
return this;
|
}
|
|
public ProcessDefinitionDataManager getProcessDefinitionDataManager() {
|
return this.processDefinitionDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessDefinitionDataManager(ProcessDefinitionDataManager processDefinitionDataManager) {
|
this.processDefinitionDataManager = processDefinitionDataManager;
|
return this;
|
}
|
|
public ProcessDefinitionInfoDataManager getProcessDefinitionInfoDataManager() {
|
return this.processDefinitionInfoDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessDefinitionInfoDataManager(ProcessDefinitionInfoDataManager processDefinitionInfoDataManager) {
|
this.processDefinitionInfoDataManager = processDefinitionInfoDataManager;
|
return this;
|
}
|
|
public PropertyDataManager getPropertyDataManager() {
|
return this.propertyDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setPropertyDataManager(PropertyDataManager propertyDataManager) {
|
this.propertyDataManager = propertyDataManager;
|
return this;
|
}
|
|
public ResourceDataManager getResourceDataManager() {
|
return this.resourceDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setResourceDataManager(ResourceDataManager resourceDataManager) {
|
this.resourceDataManager = resourceDataManager;
|
return this;
|
}
|
|
public TaskDataManager getTaskDataManager() {
|
return this.taskDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setTaskDataManager(TaskDataManager taskDataManager) {
|
this.taskDataManager = taskDataManager;
|
return this;
|
}
|
|
public UserDataManager getUserDataManager() {
|
return this.userDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setUserDataManager(UserDataManager userDataManager) {
|
this.userDataManager = userDataManager;
|
return this;
|
}
|
|
public VariableInstanceDataManager getVariableInstanceDataManager() {
|
return this.variableInstanceDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setVariableInstanceDataManager(VariableInstanceDataManager variableInstanceDataManager) {
|
this.variableInstanceDataManager = variableInstanceDataManager;
|
return this;
|
}
|
|
public boolean isEnableConfiguratorServiceLoader() {
|
return this.enableConfiguratorServiceLoader;
|
}
|
|
public AttachmentEntityManager getAttachmentEntityManager() {
|
return this.attachmentEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setAttachmentEntityManager(AttachmentEntityManager attachmentEntityManager) {
|
this.attachmentEntityManager = attachmentEntityManager;
|
return this;
|
}
|
|
public ByteArrayEntityManager getByteArrayEntityManager() {
|
return this.byteArrayEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setByteArrayEntityManager(ByteArrayEntityManager byteArrayEntityManager) {
|
this.byteArrayEntityManager = byteArrayEntityManager;
|
return this;
|
}
|
|
public CommentEntityManager getCommentEntityManager() {
|
return this.commentEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setCommentEntityManager(CommentEntityManager commentEntityManager) {
|
this.commentEntityManager = commentEntityManager;
|
return this;
|
}
|
|
public DeploymentEntityManager getDeploymentEntityManager() {
|
return this.deploymentEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setDeploymentEntityManager(DeploymentEntityManager deploymentEntityManager) {
|
this.deploymentEntityManager = deploymentEntityManager;
|
return this;
|
}
|
|
public EventLogEntryEntityManager getEventLogEntryEntityManager() {
|
return this.eventLogEntryEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setEventLogEntryEntityManager(EventLogEntryEntityManager eventLogEntryEntityManager) {
|
this.eventLogEntryEntityManager = eventLogEntryEntityManager;
|
return this;
|
}
|
|
public EventSubscriptionEntityManager getEventSubscriptionEntityManager() {
|
return this.eventSubscriptionEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setEventSubscriptionEntityManager(EventSubscriptionEntityManager eventSubscriptionEntityManager) {
|
this.eventSubscriptionEntityManager = eventSubscriptionEntityManager;
|
return this;
|
}
|
|
public ExecutionEntityManager getExecutionEntityManager() {
|
return this.executionEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setExecutionEntityManager(ExecutionEntityManager executionEntityManager) {
|
this.executionEntityManager = executionEntityManager;
|
return this;
|
}
|
|
public GroupEntityManager getGroupEntityManager() {
|
return this.groupEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setGroupEntityManager(GroupEntityManager groupEntityManager) {
|
this.groupEntityManager = groupEntityManager;
|
return this;
|
}
|
|
public HistoricActivityInstanceEntityManager getHistoricActivityInstanceEntityManager() {
|
return this.historicActivityInstanceEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricActivityInstanceEntityManager(HistoricActivityInstanceEntityManager historicActivityInstanceEntityManager) {
|
this.historicActivityInstanceEntityManager = historicActivityInstanceEntityManager;
|
return this;
|
}
|
|
public HistoricDetailEntityManager getHistoricDetailEntityManager() {
|
return this.historicDetailEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricDetailEntityManager(HistoricDetailEntityManager historicDetailEntityManager) {
|
this.historicDetailEntityManager = historicDetailEntityManager;
|
return this;
|
}
|
|
public HistoricIdentityLinkEntityManager getHistoricIdentityLinkEntityManager() {
|
return this.historicIdentityLinkEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricIdentityLinkEntityManager(HistoricIdentityLinkEntityManager historicIdentityLinkEntityManager) {
|
this.historicIdentityLinkEntityManager = historicIdentityLinkEntityManager;
|
return this;
|
}
|
|
public HistoricProcessInstanceEntityManager getHistoricProcessInstanceEntityManager() {
|
return this.historicProcessInstanceEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricProcessInstanceEntityManager(HistoricProcessInstanceEntityManager historicProcessInstanceEntityManager) {
|
this.historicProcessInstanceEntityManager = historicProcessInstanceEntityManager;
|
return this;
|
}
|
|
public HistoricTaskInstanceEntityManager getHistoricTaskInstanceEntityManager() {
|
return this.historicTaskInstanceEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricTaskInstanceEntityManager(HistoricTaskInstanceEntityManager historicTaskInstanceEntityManager) {
|
this.historicTaskInstanceEntityManager = historicTaskInstanceEntityManager;
|
return this;
|
}
|
|
public HistoricVariableInstanceEntityManager getHistoricVariableInstanceEntityManager() {
|
return this.historicVariableInstanceEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoricVariableInstanceEntityManager(HistoricVariableInstanceEntityManager historicVariableInstanceEntityManager) {
|
this.historicVariableInstanceEntityManager = historicVariableInstanceEntityManager;
|
return this;
|
}
|
|
public IdentityInfoEntityManager getIdentityInfoEntityManager() {
|
return this.identityInfoEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setIdentityInfoEntityManager(IdentityInfoEntityManager identityInfoEntityManager) {
|
this.identityInfoEntityManager = identityInfoEntityManager;
|
return this;
|
}
|
|
public IdentityLinkEntityManager getIdentityLinkEntityManager() {
|
return this.identityLinkEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setIdentityLinkEntityManager(IdentityLinkEntityManager identityLinkEntityManager) {
|
this.identityLinkEntityManager = identityLinkEntityManager;
|
return this;
|
}
|
|
public JobEntityManager getJobEntityManager() {
|
return this.jobEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setJobEntityManager(JobEntityManager jobEntityManager) {
|
this.jobEntityManager = jobEntityManager;
|
return this;
|
}
|
|
public TimerJobEntityManager getTimerJobEntityManager() {
|
return this.timerJobEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setTimerJobEntityManager(TimerJobEntityManager timerJobEntityManager) {
|
this.timerJobEntityManager = timerJobEntityManager;
|
return this;
|
}
|
|
public SuspendedJobEntityManager getSuspendedJobEntityManager() {
|
return this.suspendedJobEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setSuspendedJobEntityManager(SuspendedJobEntityManager suspendedJobEntityManager) {
|
this.suspendedJobEntityManager = suspendedJobEntityManager;
|
return this;
|
}
|
|
public DeadLetterJobEntityManager getDeadLetterJobEntityManager() {
|
return this.deadLetterJobEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setDeadLetterJobEntityManager(DeadLetterJobEntityManager deadLetterJobEntityManager) {
|
this.deadLetterJobEntityManager = deadLetterJobEntityManager;
|
return this;
|
}
|
|
public MembershipEntityManager getMembershipEntityManager() {
|
return this.membershipEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setMembershipEntityManager(MembershipEntityManager membershipEntityManager) {
|
this.membershipEntityManager = membershipEntityManager;
|
return this;
|
}
|
|
public ModelEntityManager getModelEntityManager() {
|
return this.modelEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setModelEntityManager(ModelEntityManager modelEntityManager) {
|
this.modelEntityManager = modelEntityManager;
|
return this;
|
}
|
|
public ProcessDefinitionEntityManager getProcessDefinitionEntityManager() {
|
return this.processDefinitionEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessDefinitionEntityManager(ProcessDefinitionEntityManager processDefinitionEntityManager) {
|
this.processDefinitionEntityManager = processDefinitionEntityManager;
|
return this;
|
}
|
|
public ProcessDefinitionInfoEntityManager getProcessDefinitionInfoEntityManager() {
|
return this.processDefinitionInfoEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setProcessDefinitionInfoEntityManager(ProcessDefinitionInfoEntityManager processDefinitionInfoEntityManager) {
|
this.processDefinitionInfoEntityManager = processDefinitionInfoEntityManager;
|
return this;
|
}
|
|
public PropertyEntityManager getPropertyEntityManager() {
|
return this.propertyEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setPropertyEntityManager(PropertyEntityManager propertyEntityManager) {
|
this.propertyEntityManager = propertyEntityManager;
|
return this;
|
}
|
|
public ResourceEntityManager getResourceEntityManager() {
|
return this.resourceEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setResourceEntityManager(ResourceEntityManager resourceEntityManager) {
|
this.resourceEntityManager = resourceEntityManager;
|
return this;
|
}
|
|
public TaskEntityManager getTaskEntityManager() {
|
return this.taskEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setTaskEntityManager(TaskEntityManager taskEntityManager) {
|
this.taskEntityManager = taskEntityManager;
|
return this;
|
}
|
|
public UserEntityManager getUserEntityManager() {
|
return this.userEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setUserEntityManager(UserEntityManager userEntityManager) {
|
this.userEntityManager = userEntityManager;
|
return this;
|
}
|
|
public VariableInstanceEntityManager getVariableInstanceEntityManager() {
|
return this.variableInstanceEntityManager;
|
}
|
|
public ProcessEngineConfigurationImpl setVariableInstanceEntityManager(VariableInstanceEntityManager variableInstanceEntityManager) {
|
this.variableInstanceEntityManager = variableInstanceEntityManager;
|
return this;
|
}
|
|
public TableDataManager getTableDataManager() {
|
return this.tableDataManager;
|
}
|
|
public ProcessEngineConfigurationImpl setTableDataManager(TableDataManager tableDataManager) {
|
this.tableDataManager = tableDataManager;
|
return this;
|
}
|
|
public HistoryManager getHistoryManager() {
|
return this.historyManager;
|
}
|
|
public ProcessEngineConfigurationImpl setHistoryManager(HistoryManager historyManager) {
|
this.historyManager = historyManager;
|
return this;
|
}
|
|
public JobManager getJobManager() {
|
return this.jobManager;
|
}
|
|
public ProcessEngineConfigurationImpl setJobManager(JobManager jobManager) {
|
this.jobManager = jobManager;
|
return this;
|
}
|
|
public ProcessEngineConfigurationImpl setClock(Clock clock) {
|
if (this.clock == null) {
|
this.clock = clock;
|
} else {
|
this.clock.setCurrentCalendar(clock.getCurrentCalendar());
|
}
|
|
if (this.isActiviti5CompatibilityEnabled && this.activiti5CompatibilityHandler != null) {
|
this.getActiviti5CompatibilityHandler().setClock(clock);
|
}
|
|
return this;
|
}
|
|
public void resetClock() {
|
if (this.clock != null) {
|
this.clock.reset();
|
if (this.isActiviti5CompatibilityEnabled && this.activiti5CompatibilityHandler != null) {
|
this.getActiviti5CompatibilityHandler().resetClock();
|
}
|
}
|
|
}
|
|
public DelegateExpressionFieldInjectionMode getDelegateExpressionFieldInjectionMode() {
|
return this.delegateExpressionFieldInjectionMode;
|
}
|
|
public ProcessEngineConfigurationImpl setDelegateExpressionFieldInjectionMode(DelegateExpressionFieldInjectionMode delegateExpressionFieldInjectionMode) {
|
this.delegateExpressionFieldInjectionMode = delegateExpressionFieldInjectionMode;
|
return this;
|
}
|
|
public ObjectMapper getObjectMapper() {
|
return this.objectMapper;
|
}
|
|
public ProcessEngineConfigurationImpl setObjectMapper(ObjectMapper objectMapper) {
|
this.objectMapper = objectMapper;
|
return this;
|
}
|
|
public boolean isActiviti5CompatibilityEnabled() {
|
return this.isActiviti5CompatibilityEnabled;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5CompatibilityEnabled(boolean isActiviti5CompatibilityEnabled) {
|
this.isActiviti5CompatibilityEnabled = isActiviti5CompatibilityEnabled;
|
return this;
|
}
|
|
public Activiti5CompatibilityHandlerFactory getActiviti5CompatibilityHandlerFactory() {
|
return this.activiti5CompatibilityHandlerFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5CompatibilityHandlerFactory(Activiti5CompatibilityHandlerFactory activiti5CompatibilityHandlerFactory) {
|
this.activiti5CompatibilityHandlerFactory = activiti5CompatibilityHandlerFactory;
|
return this;
|
}
|
|
public Activiti5CompatibilityHandler getActiviti5CompatibilityHandler() {
|
return this.activiti5CompatibilityHandler;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5CompatibilityHandler(Activiti5CompatibilityHandler activiti5CompatibilityHandler) {
|
this.activiti5CompatibilityHandler = activiti5CompatibilityHandler;
|
return this;
|
}
|
|
public Object getActiviti5ActivityBehaviorFactory() {
|
return this.activiti5ActivityBehaviorFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5ActivityBehaviorFactory(Object activiti5ActivityBehaviorFactory) {
|
this.activiti5ActivityBehaviorFactory = activiti5ActivityBehaviorFactory;
|
return this;
|
}
|
|
public Object getActiviti5ListenerFactory() {
|
return this.activiti5ListenerFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5ListenerFactory(Object activiti5ListenerFactory) {
|
this.activiti5ListenerFactory = activiti5ListenerFactory;
|
return this;
|
}
|
|
public List<Object> getActiviti5PreBpmnParseHandlers() {
|
return this.activiti5PreBpmnParseHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5PreBpmnParseHandlers(List<Object> activiti5PreBpmnParseHandlers) {
|
this.activiti5PreBpmnParseHandlers = activiti5PreBpmnParseHandlers;
|
return this;
|
}
|
|
public List<Object> getActiviti5PostBpmnParseHandlers() {
|
return this.activiti5PostBpmnParseHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5PostBpmnParseHandlers(List<Object> activiti5PostBpmnParseHandlers) {
|
this.activiti5PostBpmnParseHandlers = activiti5PostBpmnParseHandlers;
|
return this;
|
}
|
|
public List<Object> getActiviti5CustomDefaultBpmnParseHandlers() {
|
return this.activiti5CustomDefaultBpmnParseHandlers;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5CustomDefaultBpmnParseHandlers(List<Object> activiti5CustomDefaultBpmnParseHandlers) {
|
this.activiti5CustomDefaultBpmnParseHandlers = activiti5CustomDefaultBpmnParseHandlers;
|
return this;
|
}
|
|
public Set<Class<?>> getActiviti5CustomMybatisMappers() {
|
return this.activiti5CustomMybatisMappers;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5CustomMybatisMappers(Set<Class<?>> activiti5CustomMybatisMappers) {
|
this.activiti5CustomMybatisMappers = activiti5CustomMybatisMappers;
|
return this;
|
}
|
|
public Set<String> getActiviti5CustomMybatisXMLMappers() {
|
return this.activiti5CustomMybatisXMLMappers;
|
}
|
|
public ProcessEngineConfigurationImpl setActiviti5CustomMybatisXMLMappers(Set<String> activiti5CustomMybatisXMLMappers) {
|
this.activiti5CustomMybatisXMLMappers = activiti5CustomMybatisXMLMappers;
|
return this;
|
}
|
|
public int getAsyncExecutorCorePoolSize() {
|
return this.asyncExecutorCorePoolSize;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorCorePoolSize(int asyncExecutorCorePoolSize) {
|
this.asyncExecutorCorePoolSize = asyncExecutorCorePoolSize;
|
return this;
|
}
|
|
public int getAsyncExecutorNumberOfRetries() {
|
return this.asyncExecutorNumberOfRetries;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorNumberOfRetries(int asyncExecutorNumberOfRetries) {
|
this.asyncExecutorNumberOfRetries = asyncExecutorNumberOfRetries;
|
return this;
|
}
|
|
public int getAsyncExecutorMaxPoolSize() {
|
return this.asyncExecutorMaxPoolSize;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorMaxPoolSize(int asyncExecutorMaxPoolSize) {
|
this.asyncExecutorMaxPoolSize = asyncExecutorMaxPoolSize;
|
return this;
|
}
|
|
public long getAsyncExecutorThreadKeepAliveTime() {
|
return this.asyncExecutorThreadKeepAliveTime;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorThreadKeepAliveTime(long asyncExecutorThreadKeepAliveTime) {
|
this.asyncExecutorThreadKeepAliveTime = asyncExecutorThreadKeepAliveTime;
|
return this;
|
}
|
|
public int getAsyncExecutorThreadPoolQueueSize() {
|
return this.asyncExecutorThreadPoolQueueSize;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorThreadPoolQueueSize(int asyncExecutorThreadPoolQueueSize) {
|
this.asyncExecutorThreadPoolQueueSize = asyncExecutorThreadPoolQueueSize;
|
return this;
|
}
|
|
public BlockingQueue<Runnable> getAsyncExecutorThreadPoolQueue() {
|
return this.asyncExecutorThreadPoolQueue;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorThreadPoolQueue(BlockingQueue<Runnable> asyncExecutorThreadPoolQueue) {
|
this.asyncExecutorThreadPoolQueue = asyncExecutorThreadPoolQueue;
|
return this;
|
}
|
|
public long getAsyncExecutorSecondsToWaitOnShutdown() {
|
return this.asyncExecutorSecondsToWaitOnShutdown;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorSecondsToWaitOnShutdown(long asyncExecutorSecondsToWaitOnShutdown) {
|
this.asyncExecutorSecondsToWaitOnShutdown = asyncExecutorSecondsToWaitOnShutdown;
|
return this;
|
}
|
|
public int getAsyncExecutorMaxTimerJobsPerAcquisition() {
|
return this.asyncExecutorMaxTimerJobsPerAcquisition;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorMaxTimerJobsPerAcquisition(int asyncExecutorMaxTimerJobsPerAcquisition) {
|
this.asyncExecutorMaxTimerJobsPerAcquisition = asyncExecutorMaxTimerJobsPerAcquisition;
|
return this;
|
}
|
|
public int getAsyncExecutorMaxAsyncJobsDuePerAcquisition() {
|
return this.asyncExecutorMaxAsyncJobsDuePerAcquisition;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorMaxAsyncJobsDuePerAcquisition(int asyncExecutorMaxAsyncJobsDuePerAcquisition) {
|
this.asyncExecutorMaxAsyncJobsDuePerAcquisition = asyncExecutorMaxAsyncJobsDuePerAcquisition;
|
return this;
|
}
|
|
public int getAsyncExecutorDefaultTimerJobAcquireWaitTime() {
|
return this.asyncExecutorDefaultTimerJobAcquireWaitTime;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorDefaultTimerJobAcquireWaitTime(int asyncExecutorDefaultTimerJobAcquireWaitTime) {
|
this.asyncExecutorDefaultTimerJobAcquireWaitTime = asyncExecutorDefaultTimerJobAcquireWaitTime;
|
return this;
|
}
|
|
public int getAsyncExecutorDefaultAsyncJobAcquireWaitTime() {
|
return this.asyncExecutorDefaultAsyncJobAcquireWaitTime;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorDefaultAsyncJobAcquireWaitTime(int asyncExecutorDefaultAsyncJobAcquireWaitTime) {
|
this.asyncExecutorDefaultAsyncJobAcquireWaitTime = asyncExecutorDefaultAsyncJobAcquireWaitTime;
|
return this;
|
}
|
|
public int getAsyncExecutorDefaultQueueSizeFullWaitTime() {
|
return this.asyncExecutorDefaultQueueSizeFullWaitTime;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorDefaultQueueSizeFullWaitTime(int asyncExecutorDefaultQueueSizeFullWaitTime) {
|
this.asyncExecutorDefaultQueueSizeFullWaitTime = asyncExecutorDefaultQueueSizeFullWaitTime;
|
return this;
|
}
|
|
public String getAsyncExecutorLockOwner() {
|
return this.asyncExecutorLockOwner;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorLockOwner(String asyncExecutorLockOwner) {
|
this.asyncExecutorLockOwner = asyncExecutorLockOwner;
|
return this;
|
}
|
|
public int getAsyncExecutorTimerLockTimeInMillis() {
|
return this.asyncExecutorTimerLockTimeInMillis;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorTimerLockTimeInMillis(int asyncExecutorTimerLockTimeInMillis) {
|
this.asyncExecutorTimerLockTimeInMillis = asyncExecutorTimerLockTimeInMillis;
|
return this;
|
}
|
|
public int getAsyncExecutorAsyncJobLockTimeInMillis() {
|
return this.asyncExecutorAsyncJobLockTimeInMillis;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorAsyncJobLockTimeInMillis(int asyncExecutorAsyncJobLockTimeInMillis) {
|
this.asyncExecutorAsyncJobLockTimeInMillis = asyncExecutorAsyncJobLockTimeInMillis;
|
return this;
|
}
|
|
public int getAsyncExecutorResetExpiredJobsInterval() {
|
return this.asyncExecutorResetExpiredJobsInterval;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorResetExpiredJobsInterval(int asyncExecutorResetExpiredJobsInterval) {
|
this.asyncExecutorResetExpiredJobsInterval = asyncExecutorResetExpiredJobsInterval;
|
return this;
|
}
|
|
public ExecuteAsyncRunnableFactory getAsyncExecutorExecuteAsyncRunnableFactory() {
|
return this.asyncExecutorExecuteAsyncRunnableFactory;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorExecuteAsyncRunnableFactory(ExecuteAsyncRunnableFactory asyncExecutorExecuteAsyncRunnableFactory) {
|
this.asyncExecutorExecuteAsyncRunnableFactory = asyncExecutorExecuteAsyncRunnableFactory;
|
return this;
|
}
|
|
public int getAsyncExecutorResetExpiredJobsPageSize() {
|
return this.asyncExecutorResetExpiredJobsPageSize;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorResetExpiredJobsPageSize(int asyncExecutorResetExpiredJobsPageSize) {
|
this.asyncExecutorResetExpiredJobsPageSize = asyncExecutorResetExpiredJobsPageSize;
|
return this;
|
}
|
|
public boolean isAsyncExecutorIsMessageQueueMode() {
|
return this.asyncExecutorMessageQueueMode;
|
}
|
|
public ProcessEngineConfigurationImpl setAsyncExecutorMessageQueueMode(boolean asyncExecutorMessageQueueMode) {
|
this.asyncExecutorMessageQueueMode = asyncExecutorMessageQueueMode;
|
return this;
|
}
|
}
|
