name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
Activiti_WSOperation_m0_rdh | /**
* {@inheritDoc }
*/
public MessageInstance
m0(MessageInstance message, Operation operation, ConcurrentMap<QName, URL> overridenEndpointAddresses) throws Exception {
Object[] arguments = this.getArguments(message);
Object[] results = this.safeSend(arguments, overridenEndpointAddresses);
return this.c... | 3.26 |
Activiti_WSOperation_getName_rdh | /**
* {@inheritDoc }
*/
public String getName() {
return this.name;
} | 3.26 |
Activiti_WSOperation_getId_rdh | /**
* {@inheritDoc }
*/
public String getId() {return this.id;
} | 3.26 |
Activiti_NativeHistoricProcessInstanceQueryImpl_executeList_rdh | // results ////////////////////////////////////////////////////////////////
public List<HistoricProcessInstance> executeList(CommandContext commandContext, Map<String, Object> parameterMap, int firstResult, int maxResults) {
return commandContext.getHistoricProcessInstanceEntityManager().findHistoricProcessInstance... | 3.26 |
Activiti_LongToString_primTransform_rdh | /**
* {@inheritDoc }
*/
@Override
protected Object primTransform(Object anObject) throws Exception {
return ((Long) (anObject)).toString();
} | 3.26 |
Activiti_TreeMethodExpression_isLiteralText_rdh | /**
*
* @return <code>true</code> if this is a literal text expression
*/
@Override
public boolean isLiteralText() {
return node.isLiteralText();
} | 3.26 |
Activiti_TreeMethodExpression_isDeferred_rdh | /**
* Answer <code>true</code> if this is a deferred expression (starting with <code>#{</code>)
*/public boolean isDeferred() {
return deferred;
} | 3.26 |
Activiti_TreeMethodExpression_m0_rdh | /**
* Evaluates the expression and answers information about the method
*
* @param context
* used to resolve properties (<code>base.property</code> and <code>base[property]</code>)
* @return method information or <code>null</code> for literal expressions
* @throws ELException
* if evaluation fails (e.g. suit... | 3.26 |
Activiti_TreeMethodExpression_invoke_rdh | /**
* Evaluates the expression and invokes the method.
*
* @param context
* used to resolve properties (<code>base.property</code> and <code>base[property]</code>)
* @param paramValues
* @return method result or <code>null</code> if this is a literal text expression
* @throws ELException
* if evaluation fai... | 3.26 |
Activiti_TreeMethodExpression_equals_rdh | /**
* Expressions are compared using the concept of a <em>structural id</em>:
* variable and function names are anonymized such that two expressions with
* same tree structure will also have the same structural id and vice versa.
* Two method expressions are equal if
* <ol>
* <li>their builders are equal</li>
* ... | 3.26 |
Activiti_TreeMethodExpression_isParametersProvided_rdh | /**
*
* @return <code>true</code> if this is a method invocation expression
*/
@Override
public boolean isParametersProvided() {
return node.isMethodInvocation();
} | 3.26 |
Activiti_TreeMethodExpression_dump_rdh | /**
* Print the parse tree.
*
* @param writer
*/
public void
dump(PrintWriter writer) {
NodePrinter.dump(writer, node);
} | 3.26 |
Activiti_UserTaskParseHandler_getHandledType_rdh | /**
*/
| 3.26 |
Activiti_ExclusiveGatewayActivityBehavior_leave_rdh | /**
* The default behaviour of BPMN, taking every outgoing sequence flow (where the condition evaluates to true), is not valid for an exclusive gateway.
*
* Hence, this behaviour is overridden and replaced by the correct behavior: selecting the first sequence flow which condition evaluates to true (or which hasn't g... | 3.26 |
Activiti_LongToInteger_primTransform_rdh | /**
* {@inheritDoc }
*/
@Override
protected Object primTransform(Object anObject) throws Exception {
return Integer.valueOf(((Long) (anObject)).toString());
} | 3.26 |
Activiti_BusinessRuleParseHandler_getHandledType_rdh | /**
*/public class BusinessRuleParseHandler extends AbstractActivityBpmnParseHandler<BusinessRuleTask> {
public Class<? extends BaseElement> getHandledType() {
return BusinessRuleTask.class;
} | 3.26 |
Activiti_Activiti_signallingMessageHandler_rdh | /**
* Any message that enters this {@link org.springframework.messaging.MessageHandler}
* containing a {@code executionId} parameter will trigger a
* {@link org.activiti.engine.RuntimeService#signalEventReceived(String)}.
*/
public static MessageHandler signallingMessageHandler(final ProcessEngine processEngine) {... | 3.26 |
Activiti_TablePage_getTotal_rdh | /**
*
* @return the total rowcount of the table from which this page is only a subset.
*/
public long getTotal() {
return total;
} | 3.26 |
Activiti_TablePage_getRows_rdh | /**
*
* @return the actual table content.
*/
public List<Map<String, Object>> getRows() {
return rowData;
} | 3.26 |
Activiti_TablePage_getFirstResult_rdh | /**
*
* @return the start index of this page (ie the index of the first element in the page)
*/
public long getFirstResult() {
return firstResult;
} | 3.26 |
Activiti_TablePage_getSize_rdh | /**
*
* @return the actual number of rows in this page.
*/
public long getSize() {
return rowData.size();
} | 3.26 |
Activiti_Builder_main_rdh | /**
* Dump out abstract syntax tree for a given expression
*
* @param args
* array with one element, containing the expression string
*/
public static void main(String[] args) {
if (args.length != 1) {
System.err.println(("usage: java " + Builder.class.getName()) + " <expression string>");
... | 3.26 |
Activiti_Builder_isEnabled_rdh | /**
*
* @return <code>true</code> iff the specified feature is supported.
*/
public boolean isEnabled(Feature feature) {
return features.contains(feature);
} | 3.26 |
Activiti_Builder_build_rdh | /**
* Parse expression.
*/
public Tree build(String expression) throws TreeBuilderException {
try {
return createParser(expression).tree();
} catch (Scanner.ScanException e) {
throw new TreeBuilderException(expression, e.position, e.encountered, e.expected, e.getMessage());
} catch (Pars... | 3.26 |
Activiti_DelegateExpressionTransactionDependentExecutionListener_m0_rdh | /**
* returns the expression text for this execution listener. Comes in handy if you want to check which listeners you already have.
*/
public String m0() {
return expression.getExpressionText();} | 3.26 |
Activiti_AbstractProcessEngineConfiguration_springProcessEngineBean_rdh | /**
* Provides sane definitions for the various beans required to be productive with Activiti in Spring.
*/ public
| 3.26 |
Activiti_DelegateHelper_getFieldExpression_rdh | /**
* Similar to {@link #getFieldExpression(DelegateExecution, String)}, but for use within a {@link TaskListener}.
*/
public static Expression getFieldExpression(DelegateTask task, String fieldName) {
if (task.getCurrentActivitiListener() != null) {
List<FieldExtension> fieldExtensions = task.getCurrentA... | 3.26 |
Activiti_DelegateHelper_getField_rdh | /**
* Returns the {@link FieldExtension} matching the provided 'fieldName' which
* is defined for the current activity of the provided
* {@link DelegateExecution}.
* <p>
* Returns null if no such {@link FieldExtension} can be found.
* <p>
* If the execution is currently being used for executing an
* {@link Exec... | 3.26 |
Activiti_DelegateHelper_getExtensionElements_rdh | /**
* Returns for the activityId of the passed {@link DelegateExecution} the
* {@link Map} of {@link ExtensionElement} instances. These represent the
* extension elements defined in the BPMN 2.0 XML as part of that particular
* activity.
* <p>
* If the execution is currently being used for executing an
* {@link ... | 3.26 |
Activiti_DelegateHelper_getBpmnModel_rdh | /**
* Returns the {@link BpmnModel} matching the process definition bpmn model
* for the process definition of the passed {@link DelegateExecution}.
*/
public static BpmnModel getBpmnModel(DelegateExecution execution) {
if (execution == null) {
throw new ActivitiException("Null execution passed");
... | 3.26 |
Activiti_DelegateHelper_isExecutingExecutionListener_rdh | /**
* Returns whether or not the provided execution is being use for executing an {@link ExecutionListener}.
*/
public static boolean isExecutingExecutionListener(DelegateExecution execution) {return execution.getCurrentActivitiListener() != null;
} | 3.26 |
Activiti_DelegateHelper_leaveDelegate_rdh | /**
* To be used in an {@link ActivityBehavior} or {@link JavaDelegate}: leaves
* the current activity via one specific sequenceflow.
*/
public static void leaveDelegate(DelegateExecution delegateExecution, String sequenceFlowId) {
String v0 = delegateExecution.getProcessDefinitionId();
Process process = Pr... | 3.26 |
Activiti_DelegateHelper_getFlowElement_rdh | /**
* Returns the current {@link FlowElement} where the {@link DelegateExecution} is currently at.
*/
public static FlowElement getFlowElement(DelegateExecution execution) {
BpmnModel bpmnModel = getBpmnModel(execution);
FlowElement flowElement =
bpmnModel.getFlowElement(execution.getCurrentActivityId())... | 3.26 |
Activiti_DelegateHelper_createExpressionForField_rdh | /**
* Creates an {@link Expression} for the {@link FieldExtension}.
*/
public static Expression createExpressionForField(FieldExtension fieldExtension) {
if (StringUtils.isNotEmpty(fieldExtension.getExpression())) {
ExpressionManager v10 = Context.getProcessEngineConfiguration().getExpressionManager();
... | 3.26 |
Activiti_DelegateHelper_getFields_rdh | /**
* Returns the list of field extensions, represented as instances of
* {@link FieldExtension}, for the current activity of the passed
* {@link DelegateExecution}.
* <p>
* If the execution is currently being used for executing an
* {@link ExecutionListener}, the fields of the listener will be returned. Use
* {... | 3.26 |
Activiti_TreeStore_get_rdh | /**
* Get a {@link Tree}.
* If a tree for the given expression is present in the cache, it is
* taken from there; otherwise, the expression string is parsed and
* the resulting tree is added to the cache.
*
* @param expression
* expression string
* @return expression tree
*/
public Tree get(String expression... | 3.26 |
Activiti_TreeValueExpression_getValue_rdh | /**
* Evaluates the expression as an rvalue and answers the result.
*
* @param context
* used to resolve properties (<code>base.property</code> and <code>base[property]</code>)
* and to determine the result from the last base/property pair
* @return rvalue evaluation result
* @throws ELException
* if eval... | 3.26 |
Activiti_TreeValueExpression_isLiteralText_rdh | /**
*
* @return <code>true</code> if this is a literal text expression
*/
@Override
public boolean isLiteralText() {
return node.isLiteralText();
} | 3.26 |
Activiti_TreeValueExpression_isDeferred_rdh | /**
* Answer <code>true</code> if this is a deferred expression (containing
* sub-expressions starting with <code>#{</code>)
*/
public boolean isDeferred() {
return deferred;
} | 3.26 |
Activiti_TreeValueExpression_equals_rdh | /**
* Expressions are compared using the concept of a <em>structural id</em>:
* variable and function names are anonymized such that two expressions with
* same tree structure will also have the same structural id and vice versa.
* Two value expressions are equal if
* <ol>
* <li>their structural id's are equal</l... | 3.26 |
Activiti_TreeValueExpression_getType_rdh | /**
* Evaluates the expression as an lvalue and answers the result type.
*
* @param context
* used to resolve properties (<code>base.property</code> and <code>base[property]</code>)
* and to determine the result from the last base/property pair
* @return lvalue evaluation type or <code>null</code> for rvalue ... | 3.26 |
Activiti_TreeValueExpression_setValue_rdh | /**
* Evaluates the expression as an lvalue and assigns the given value.
*
* @param context
* used to resolve properties (<code>base.property</code> and <code>base[property]</code>)
* and to perform the assignment to the last base/property pair
* @throws ELException
* if evaluation fails (e.g. property not... | 3.26 |
Activiti_TreeValueExpression_isReadOnly_rdh | /**
* Evaluates the expression as an lvalue and determines if {@link #setValue(ELContext, Object)}
* will always fail.
*
* @param context
* used to resolve properties (<code>base.property</code> and <code>base[property]</code>)
* and to determine the result from the last base/property pair
* @return <code>tr... | 3.26 |
Activiti_BigDecimalToString_primTransform_rdh | /**
* {@inheritDoc }
*/
@Override
protected Object primTransform(Object anObject) throws Exception {
return format.format(((BigDecimal) (anObject)));
} | 3.26 |
Activiti_ObjectValueExpression_equals_rdh | /**
* Two object value expressions are equal if and only if their wrapped objects are equal.
*/
@Override
public boolean equals(Object obj)
{
if ((obj != null) && (obj.getClass() == getClass())) {
ObjectValueExpression other = ((ObjectValueExpression) (obj));if (type != other.type) {
return f... | 3.26 |
Activiti_ObjectValueExpression_setValue_rdh | /**
* Throw an exception.
*/
@Override
public void setValue(ELContext context, Object value) {
throw new ELException(LocalMessages.get("error.value.set.rvalue", "<object value expression>"));
} | 3.26 |
Activiti_ObjectValueExpression_getType_rdh | /**
* Answer <code>null</code>.
*/@Override
public Class<?> getType(ELContext context) {
return null;
} | 3.26 |
Activiti_NativeHistoricTaskInstanceQueryImpl_executeList_rdh | // results ////////////////////////////////////////////////////////////////
public List<HistoricTaskInstance> executeList(CommandContext commandContext, Map<String, Object>
parameterMap, int firstResult, int maxResults) {
return commandContext.getHistoricTaskInstanceEntityManager().findHistoricTaskInstancesByNati... | 3.26 |
Activiti_AstNode_findPublicAccessibleMethod_rdh | /**
* Find accessible method. Searches the inheritance tree of the class declaring
* the method until it finds a method that can be invoked.
*
* @param method
* method
* @return accessible method or <code>null</code>
*/
private static Method findPublicAccessibleMethod(Method method) {
if ((method == null) ... | 3.26 |
Activiti_AstNode_getValue_rdh | /**
* evaluate and return the (optionally coerced) result.
*/
public final Object getValue(Bindings bindings, ELContext context, Class<?> type) {
Object value = eval(bindings, context);
if
(type != null) {
value
= bindings.convert(value, type);
}
return value;
... | 3.26 |
Activiti_DefaultServiceTaskBehavior_execute_rdh | /**
* We have two different implementation strategy that can be executed
* in according if we have a connector action definition match or not.
*/
@Override
public void execute(DelegateExecution execution) {
Connector connector = getConnector(getImplementation(execution));
IntegrationC... | 3.26 |
Activiti_StringToBoolean_primTransform_rdh | /**
* Transforms a {@link String} to a {@link Boolean}
*/public class StringToBoolean extends AbstractTransformer {
@Override
protected Object primTransform(Object anObject) throws Exception {return Boolean.valueOf(((String) (anObject)));
} | 3.26 |
Activiti_TimerManager_removeObsoleteTimers_rdh | /**
* Manages timers for newly-deployed process definitions and their previous versions.
*/public class TimerManager {
protected void removeObsoleteTimers(ProcessDefinitionEntity processDefinition) {
List<TimerJobEntity> jobsToDelete = null;
if ((processDefinition.getTenantId() != null) && (!ProcessEngineConfigur... | 3.26 |
Activiti_AbstractTransformer_transform_rdh | /**
* {@inheritDoc }
*/
public Object transform(Object anObject) {
try {
return this.primTransform(anObject);} catch (Exception e) {
throw new ActivitiException((("Error while executing transformation from object: " + anObject) + " using transformer ") + this);
}
} | 3.26 |
Activiti_NativeHistoricActivityInstanceQueryImpl_m0_rdh | // results ////////////////////////////////////////////////////////////////
public List<HistoricActivityInstance> m0(CommandContext commandContext, Map<String, Object> parameterMap, int
firstResult,
int maxResults) {
return commandContext.getHistoricActivityInstanceEntityManager().findHistoricActivityInstancesByNat... | 3.26 |
Activiti_IoUtil_closeSilently_rdh | /**
* Closes the given stream. The same as calling {@link OutputStream#close()} , but errors while closing are silently ignored.
*/
public static void closeSilently(OutputStream outputStream) {
try {if (outputStream != null) {
outputStream.close();
}
} catch (IOException ignore) {
... | 3.26 |
Activiti_ScriptingEngines_createBindings_rdh | /**
* override to build a spring aware ScriptingEngines
*/
protected Bindings createBindings(VariableScope variableScope,
boolean storeScriptVariables)
{
return scriptBindingsFactory.createBindings(variableScope, storeScriptVariables);
} | 3.26 |
Activiti_ActivitiEventDispatcherImpl_extractBpmnModelFromEvent_rdh | /**
* In case no process-context is active, this method attempts to extract a process-definition based on the event. In case it's an event related to an entity, this can be deducted by inspecting the
* entity, without additional queries to the database.
*
* If not an entity-related event, the process-definition wil... | 3.26 |
Activiti_BaseEntityEventListener_onCreate_rdh | /**
* Called when an entity create event is received.
*/
protected void onCreate(ActivitiEvent event) { // Default implementation is a NO-OP
} | 3.26 |
Activiti_BaseEntityEventListener_onEntityEvent_rdh | /**
* Called when an event is received, which is not a create, an update or delete.
*/
protected void onEntityEvent(ActivitiEvent event) {// Default implementation is a NO-OP
} | 3.26 |
Activiti_BaseEntityEventListener_onDelete_rdh | /**
* Called when an entity delete event is received.
*/
protected void onDelete(ActivitiEvent event) {
// Default implementation is a NO-OP
} | 3.26 |
Activiti_BaseEntityEventListener_onInitialized_rdh | /**
* Called when an entity initialized event is received.
*/
protected void onInitialized(ActivitiEvent event) {// Default implementation is a NO-OP
} | 3.26 |
Activiti_BaseEntityEventListener_m0_rdh | /**
*
* @return true, if the event is an {@link ActivitiEntityEvent} and (if needed) the entityClass set in this instance, is assignable from the entity class in the event.
*/
protected boolean m0(ActivitiEvent event) {
boolean valid = false;
if (event instanceof ActivitiEntityEvent) {if (entityClass == null) {
... | 3.26 |
Activiti_BpmnDeploymentHelper_setResourceNamesOnProcessDefinitions_rdh | /**
* Updates all the process definition entities to have the correct resource names.
*/
public void setResourceNamesOnProcessDefinitions(ParsedDeployment parsedDeployment) {
for (ProcessDefinitionEntity processDefinition : parsedDeployment.getAllProcessDefinitions()) {
String resourceName = parsedDeploy... | 3.26 |
Activiti_BpmnDeploymentHelper_copyDeploymentValuesToProcessDefinitions_rdh | /**
* Updates all the process definition entities to match the deployment's values for tenant,
* engine version, and deployment id.
*/
public void copyDeploymentValuesToProcessDefinitions(DeploymentEntity deployment, List<ProcessDefinitionEntity> processDefinitions) {
String engineVersion = deployment.getEngine... | 3.26 |
Activiti_BpmnDeploymentHelper_getMostRecentVersionOfProcessDefinition_rdh | /**
* Gets the most recent persisted process definition that matches this one for tenant and key.
* If none is found, returns null. This method assumes that the tenant and key are properly
* set on the process definition entity.
*/
public ProcessDefinitionEntity getMostRecentVersionOfProcessDefinition(ProcessDefin... | 3.26 |
Activiti_BpmnDeploymentHelper_verifyProcessDefinitionsDoNotShareKeys_rdh | /**
* Verifies that no two process definitions share the same key, to prevent database unique
* index violation.
*
* @throws ActivitiException
* if any two processes have the same key
*/
public void verifyProcessDefinitionsDoNotShareKeys(Collection<ProcessDefinitionEntity> processDefinitions) {
Set<String> ... | 3.26 |
Activiti_BpmnDeploymentHelper_updateTimersAndEvents_rdh | /**
* Updates all timers and events for the process definition. This removes obsolete message and signal
* subscriptions and timers, and adds new ones.
*/
public void updateTimersAndEvents(ProcessDefinitionEntity processDefinition, ProcessDefinitionEntity previousProcessDefinition, ParsedDeployment parsedDeployment... | 3.26 |
Activiti_BpmnDeploymentHelper_getPersistedInstanceOfProcessDefinition_rdh | /**
* Gets the persisted version of the already-deployed process definition. Note that this is
* different from {@link #getMostRecentVersionOfProcessDefinition} as it looks specifically for
* a process definition that is already persisted and attached to a particular deployment,
* rather than the latest version ac... | 3.26 |
Activiti_ExecutionGraphUtil_isReachable_rdh | /**
* Verifies if the element with the given source identifier can reach the element with the target identifier through following sequence flow.
*/
public static boolean isReachable(String processDefinitionId, String sourceElementId, String targetElementId) {
// Fetch source and target elements
Process proces... | 3.26 |
Activiti_ExecutionGraphUtil_orderFromRootToLeaf_rdh | /**
* Takes in a collection of executions belonging to the same process instance. Orders the executions in a list, first elements are the leaf, last element is the root elements.
*/
public static List<ExecutionEntity> orderFromRootToLeaf(Collection<ExecutionEntity> executions) {
List<ExecutionEntity> orderedLis... | 3.26 |
Activiti_DelegateExpressionExecutionListener_getExpressionText_rdh | /**
* returns the expression text for this execution listener. Comes in handy if you want to check which listeners you already have.
*/
public String getExpressionText() {
return expression.getExpressionText();
} | 3.26 |
Activiti_SimpleContext_getVariableMapper_rdh | /**
* Get our variable mapper.
*/
@Override
public VariableMapper getVariableMapper() {
if (variables == null) {
variables = new Variables();
}
return variables;} | 3.26 |
Activiti_SimpleContext_getELResolver_rdh | /**
* Get our resolver. Lazy initialize to a {@link SimpleResolver} if necessary.
*/
@Override
public ELResolver getELResolver() {
if (resolver == null) {
resolver = new SimpleResolver();
}
return resolver;
} | 3.26 |
Activiti_SimpleContext_setVariable_rdh | /**
* Define a variable.
*/
public ValueExpression setVariable(String name, ValueExpression expression) {
if (variables == null) {
variables = new Variables();
}
return variables.setVariable(name, expression);
} | 3.26 |
Activiti_JsonConverterUtil_gatherLongPropertyFromJsonNodes_rdh | // GENERIC
/**
* Loops through a list of {@link JsonNode} instances, and stores the given property with given type in the returned list.
*
* In Java 8, this probably could be done a lot cooler.
*/
public static Set<Long> gatherLongPropertyFromJsonNodes(Iterable<JsonNode> jsonNodes, String propertyName) {
Set<Lo... | 3.26 |
Activiti_JsonConverterUtil_getAppModelReferencedProcessModels_rdh | // APP MODEL
public static List<JsonNode> getAppModelReferencedProcessModels(JsonNode appModelJson) {
List<JsonNode> result = new ArrayList<JsonNode>();
if (appModelJson.has("models")) {
ArrayNode modelsArrayNode = ((ArrayNode) (appModelJson.get("models")));
Iterator<JsonNode> modelArrayIterator... | 3.26 |
Activiti_JsonConverterUtil_getBpmnProcessModelChildShapesPropertyValues_rdh | /**
* Usable for BPMN 2.0 editor json: traverses all child shapes (also nested), goes into
* the properties and sees if there is a matching property in the
* 'properties' of the childshape and returns those in a list.
*
* Returns a map with said json nodes, with the key the name of the childshape.
*/
protected st... | 3.26 |
Activiti_IntegerToString_primTransform_rdh | /**
* {@inheritDoc }
*/
@Override
protected Object primTransform(Object anObject) throws Exception {
return ((Integer) (anObject)).toString();
} | 3.26 |
Activiti_FlowNodeActivityBehavior_leave_rdh | /**
* Default way of leaving a BPMN 2.0 activity: evaluate the conditions on the outgoing sequence flow and take those that evaluate to true.
*/
public void leave(DelegateExecution execution) {
bpmnActivityBehavior.performDefaultOutgoingBehavior(((ExecutionEntity) (execution)));
} | 3.26 |
Activiti_FlowNodeActivityBehavior_execute_rdh | /**
* Default behaviour: just leave the activity with no extra functionality.
*/
public void execute(DelegateExecution execution) {
leave(execution);} | 3.26 |
Activiti_DelegateExpressionTaskListener_getExpressionText_rdh | /**
* returns the expression text for this task listener. Comes in handy if you want to check which listeners you already have.
*/
public String getExpressionText() {
return expression.getExpressionText();
} | 3.26 |
Activiti_ThrowMessage_builder_rdh | /**
* Creates builder to build {@link ThrowMessage}.
*
* @return created builder
*/
public static INameStage builder() {
return new ThrowMessagBuilder();
} | 3.26 |
Activiti_AstFunction_invoke_rdh | /**
* Invoke method.
*
* @param bindings
* @param context
* @param base
* @param method
* @return method result
* @throws InvocationTargetException
* @throws IllegalAccessException
*/
protected Object invoke(Bindings bindings, ELContext context, Object base, Method method) throws InvocationTargetException,... | 3.26 |
Activiti_StandaloneMybatisTransactionContextFactory_openTransactionContext_rdh | /**
*/
public class StandaloneMybatisTransactionContextFactory implements TransactionContextFactory {public TransactionContext openTransactionContext(CommandContext commandContext) {
return new StandaloneMybatisTransactionContext(commandContext);
}
} | 3.26 |
Activiti_ComposedTransformer_primTransform_rdh | /**
* {@inheritDoc }
*/
@Override
protected Object primTransform(Object anObject) throws Exception {
Object current = anObject;
for (Transformer transformer : this.transformers) {
current = transformer.transform(current);
}
return
current;
} | 3.26 |
Activiti_Identity_primTransform_rdh | /**
* {@inheritDoc }
*/
@Override
protected Object primTransform(Object anObject) throws Exception {
return anObject;
} | 3.26 |
Activiti_NeedsActiveExecutionCmd_getSuspendedExceptionMessage_rdh | /**
* Subclasses can override this to provide a more detailed exception message that will be thrown when the execution is suspended.
*/
protected String getSuspendedExceptionMessage() {
return ("Cannot execution operation because execution '" + executionId) + "' is suspended";
} | 3.26 |
Activiti_JobEntityImpl_setExecution_rdh | // getters and setters ////////////////////////////////////////////////////////
public void setExecution(ExecutionEntity execution) {
super.setExecution(execution);
execution.getJobs().add(this);
} | 3.26 |
Activiti_CachingAndArtifactsManager_updateCachingAndArtifacts_rdh | /**
* Ensures that the process definition is cached in the appropriate places, including the
* deployment's collection of deployed artifacts and the deployment manager's cache, as well
* as caching any ProcessDefinitionInfos.
*/
public void updateCachingAndArtifacts(ParsedDeployment parsedDe... | 3.26 |
Activiti_StartEventValidator_executeValidation_rdh | /**
*/public class StartEventValidator extends ProcessLevelValidator {
@Override
protected void executeValidation(BpmnModel bpmnModel, Process process, List<ValidationError> errors) {
List<StartEvent> startEvents = process.findFlowElementsOfType(StartEvent.class, false);
validateEventDefinitionTypes(startEve... | 3.26 |
Activiti_IntegerToLong_primTransform_rdh | /**
* {@inheritDoc }
*/
@Override
protected Object
primTransform(Object anObject) throws Exception {
return Long.valueOf(((Integer) (anObject)));
} | 3.26 |
Activiti_ProcessEngines_unregister_rdh | /**
* Unregisters the given process engine.
*/public static void unregister(ProcessEngine processEngine) {
processEngines.remove(processEngine.getName());
} | 3.26 |
Activiti_ProcessEngines_getProcessEngine_rdh | /**
* obtain a process engine by name.
*
* @param processEngineName
* is the name of the process engine or null for the default process engine.
*/
public static ProcessEngine getProcessEngine(String processEngineName) {
if (!isInitialized()) {
init();
}
return processEngines.get(processEngin... | 3.26 |
Activiti_ProcessEngines_init_rdh | /**
* Initializes all process engines that can be found on the classpath for resources <code>activiti.cfg.xml</code> (plain Activiti style configuration) and for resources
* <code>activiti-context.xml</code> (Spring style configuration).
*/
public static synchronized void init() {
if (!is... | 3.26 |
Activiti_ProcessEngines_getProcessEngineInfos_rdh | /**
* Get initialization results.
*/
public static List<ProcessEngineInfo> getProcessEngineInfos() {
return processEngineInfos;
} | 3.26 |
Activiti_ProcessEngines_retry_rdh | /**
* retries to initialize a process engine that previously failed.
*/
public static ProcessEngineInfo
retry(String resourceUrl) {
log.debug("retying initializing of resource {}", resourceUrl);
try {return initProcessEngineFromResource(new URL(resourceUrl));
} catch (MalformedURLException e) {throw new A... | 3.26 |
Activiti_ProcessEngines_getProcessEngines_rdh | /**
* provides access to process engine to application clients in a managed server environment.
*/
public static Map<String, ProcessEngine> getProcessEngines() {
return processEngines;
} | 3.26 |
Activiti_ProcessEngines_registerProcessEngine_rdh | /**
* Registers the given process engine. No {@link ProcessEngineInfo} will be available for this process engine. An engine that is registered will be closed when the {@link ProcessEngines#destroy()}
* is called.
*/
public static void registerProcessEngine(ProcessEngine processEngine) {
processEngines.put(proc... | 3.26 |
Activiti_ProcessEngines_destroy_rdh | /**
* closes all process engines. This method should be called when the server shuts down.
*/
public static synchronized void destroy() {
if (isInitialized()) {
Map<String, ProcessEngine> engines = new HashMap<String, ProcessEngine>(processEngines);
processEngines = new HashMap<String, ProcessEng... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.