How to use org.jbpm.runtime.manager.impl

public RuntimeManager newPerProcessInstanceRuntimeManager(RuntimeEnvironment environment, String identifier) {
  SessionFactory factory = getSessionFactory(environment, identifier);
  TaskServiceFactory taskServiceFactory = getTaskServiceFactory(environment);
  RuntimeManager manager = new PerProcessInstanceRuntimeManager(environment, factory, taskServiceFactory, identifier);
  initTimerService(environment, manager);
  ((AbstractRuntimeManager) manager).init();
  return manager;
}

public RuntimeManager newPerRequestRuntimeManager(RuntimeEnvironment environment, String identifier) {
  SessionFactory factory = getSessionFactory(environment, identifier);
  TaskServiceFactory taskServiceFactory = getTaskServiceFactory(environment);
  RuntimeManager manager = new PerRequestRuntimeManager(environment, factory, taskServiceFactory, identifier);
  initTimerService(environment, manager);
  ((AbstractRuntimeManager) manager).init();
  return manager;
}

@Override
public RuntimeManager newSingletonRuntimeManager(RuntimeEnvironment environment, String identifier) {
  SessionFactory factory = getSessionFactory(environment, identifier);
  TaskServiceFactory taskServiceFactory = getTaskServiceFactory(environment);
  
  RuntimeManager manager = new SingletonRuntimeManager(environment, factory, taskServiceFactory, identifier);
  initTimerService(environment, manager);
  ((AbstractRuntimeManager) manager).init();
  return manager;
}

public AuditEventBuilder getAuditBuilder(RuntimeEngine engine) {
  if (this.auditBuilder != null && this.auditBuilder instanceof ManagedAuditEventBuilderImpl) {
    String identifier = ((RuntimeEngineImpl)engine).getManager().getIdentifier();
    ((ManagedAuditEventBuilderImpl) this.auditBuilder).setOwnerId(identifier);
  }
  
  return this.auditBuilder;
}

public RuntimeManager newPerCaseRuntimeManager(RuntimeEnvironment environment, String identifier) {
  SessionFactory factory = getSessionFactory(environment, identifier);
  TaskServiceFactory taskServiceFactory = getTaskServiceFactory(environment);
  RuntimeManager manager = new PerCaseRuntimeManager(environment, factory, taskServiceFactory, identifier);
  initTimerService(environment, manager);
  ((AbstractRuntimeManager) manager).init();
  return manager;
}

public RuntimeEnvironmentBuilder addAsset(Resource asset, ResourceType type) {
  if (asset == null || type == null) {
    return this;
  }
  this.runtimeEnvironment.addAsset(asset, type);
  return this;
}

public RuntimeEnvironmentBuilder userGroupCallback(UserGroupCallback callback) {
  if (callback == null) {
    return this;
  }
  this.runtimeEnvironment.setUserGroupCallback(callback);
  return this;
}

/**
 * Provides default configuration of <code>RuntimeEnvironmentBuilder</code> that is based on:
 * <ul>
 *     <li>DefaultRuntimeEnvironment</li>
 * </ul>
 * @return new instance of <code>RuntimeEnvironmentBuilder</code> that is already preconfigured with defaults
 *
 * @see DefaultRuntimeEnvironment
 */
public static RuntimeEnvironmentBuilder getDefault() {
  return new RuntimeEnvironmentBuilder(new DefaultRuntimeEnvironment());
}

@Override
public void softDispose(RuntimeEngine runtimeEngine) {        
  super.softDispose(runtimeEngine);
  removeLocalRuntime(runtimeEngine);
}

@Override
public void softDispose(RuntimeEngine runtimeEngine) {
  super.softDispose(runtimeEngine);
  removeLocalRuntime(runtimeEngine);
}

@Override        
public TaskService initTaskService(Context<?> context, InternalRuntimeManager manager, RuntimeEngine engine) {
  InternalTaskService internalTaskService = newTaskService(taskServiceFactory);
  configureRuntimeOnTaskService(internalTaskService, engine);
  
  return internalTaskService;
}

@Override
public RuntimeManager newSingletonRuntimeManager(RuntimeEnvironment environment) {
  
  return newSingletonRuntimeManager(environment, "default-singleton");
}
@Override

public RuntimeEnvironmentBuilder registerableItemsFactory(RegisterableItemsFactory factory) {
  if (factory == null) {
    return this;
  }
  this.runtimeEnvironment.setRegisterableItemsFactory(factory);
  return this;
}

public RuntimeEnvironmentBuilder mapper(Mapper mapper) {
  if (mapper == null) {
    return this;
  }
  this.runtimeEnvironment.setMapper(mapper);
  return this;
}

public RuntimeEnvironmentBuilder knowledgeBase(KieBase kbase) {
  if (kbase == null) {
    return this;
  }
  this.runtimeEnvironment.setKieBase(kbase);
  return this;
}

public RuntimeEnvironmentBuilder addEnvironmentEntry(String name, Object value) {
  if (name == null || value == null) {
    return this;
  }
  this.runtimeEnvironment.addToEnvironment(name, value);
  return this;
}

protected boolean isActive() {
  if (hasEnvironmentEntry("Active", false)) {
    return false;
  }
  
  return true;
}

/**
 * Provides completely empty <code>RuntimeEnvironmentBuilder</code> instance that allows to manually
 * set all required components instead of relying on any defaults.
 * @return new instance of <code>RuntimeEnvironmentBuilder</code>
 */
public static RuntimeEnvironmentBuilder getEmpty() {
  return new RuntimeEnvironmentBuilder();
}

public KModuleRegisterableItemsFactory(KieContainer kieContainer,
    String ksessionName, AuditEventBuilder auditBuilder) {
  super();
  this.kieContainer = kieContainer;
  this.ksessionName = ksessionName;
  setAuditBuilder(auditBuilder);
}

@Override
public List<RuleRuntimeEventListener> getRuleRuntimeEventListeners(
    RuntimeEngine runtime) {
  return super.getRuleRuntimeEventListeners(runtime);
}