public <T> T execute(Context context, Command<T> command) {

    ExecutionResultImpl results = null;
    if (context != null) {
      results = (ExecutionResultImpl) ((KnowledgeCommandContext) context).getExecutionResults();
    }

    if (results == null) {
      results = new ExecutionResultImpl();
    }

    if (!(command instanceof BatchExecutionCommandImpl)) {
      return (T)
          ((GenericCommand) command)
              .execute(new KnowledgeCommandContext(context, null, this.kbase, this, results));
    }

    try {
      session.startBatchExecution(results);
      ((GenericCommand) command)
          .execute(new KnowledgeCommandContext(context, null, this.kbase, this, results));
      ExecutionResults result = session.getExecutionResult();
      return (T) result;
    } finally {
      session.endBatchExecution();
    }
  }
 public static void readActionQueue(MarshallerReaderContext context)
     throws IOException, ClassNotFoundException {
   ReteooWorkingMemory wm = (ReteooWorkingMemory) context.wm;
   Queue<WorkingMemoryAction> actionQueue = wm.getActionQueue();
   while (context.readShort() == PersisterEnums.WORKING_MEMORY_ACTION) {
     actionQueue.offer(PersisterHelper.readWorkingMemoryAction(context));
   }
 }
示例#3
0
  public static void writeActionQueue(MarshallerWriteContext context) throws IOException {
    ReteooWorkingMemory wm = (ReteooWorkingMemory) context.wm;

    WorkingMemoryAction[] queue =
        wm.getActionQueue().toArray(new WorkingMemoryAction[wm.getActionQueue().size()]);
    for (int i = queue.length - 1; i >= 0; i--) {
      context.writeShort(PersisterEnums.WORKING_MEMORY_ACTION);
      queue[i].write(context);
    }
    context.writeShort(PersisterEnums.END);
  }
  public static void writeActionQueue(
      MarshallerWriteContext context, ProtobufMessages.RuleData.Builder _session)
      throws IOException {

    ReteooWorkingMemory wm = (ReteooWorkingMemory) context.wm;
    if (!wm.getActionQueue().isEmpty()) {
      ProtobufMessages.ActionQueue.Builder _queue = ProtobufMessages.ActionQueue.newBuilder();

      WorkingMemoryAction[] queue =
          wm.getActionQueue().toArray(new WorkingMemoryAction[wm.getActionQueue().size()]);
      for (int i = queue.length - 1; i >= 0; i--) {
        _queue.addAction(queue[i].serialize(context));
      }
      _session.setActionQueue(_queue.build());
    }
  }
示例#5
0
  public static void writeSession(MarshallerWriteContext context) throws IOException {
    // context.out.println( "... write session");
    ReteooWorkingMemory wm = (ReteooWorkingMemory) context.wm;
    wm.getAgenda().unstageActivations();

    final boolean multithread = wm.isPartitionManagersActive();
    // is multi-thread active?
    if (multithread) {
      context.writeBoolean(true);
      wm.stopPartitionManagers();
    } else {
      context.writeBoolean(false);
    }

    long time = 0;
    if (context.wm.getTimerService() instanceof PseudoClockScheduler) {
      time = context.clockTime;
    }
    context.writeLong(time);

    context.writeInt(wm.getFactHandleFactory().getId());
    context.writeLong(wm.getFactHandleFactory().getRecency());
    //// context.out.println( "FactHandleFactory int:" + wm.getFactHandleFactory().getId() + "
    // long:" + wm.getFactHandleFactory().getRecency() );

    context.writeLong(wm.getPropagationIdCounter());
    // context.out.println( "PropagationCounter long:" + wm.getPropagationIdCounter() );

    InternalFactHandle handle = context.wm.getInitialFactHandle();
    context.writeInt(handle.getId());
    context.writeLong(handle.getRecency());
    // context.out.println( "InitialFact int:" + handle.getId() + " long:" + handle.getRecency() );

    writeAgenda(context);

    writeInitialFactHandleRightTuples(context);
    for (WorkingMemoryEntryPoint wmep : wm.getEntryPoints().values()) {
      context.stream.writeShort(PersisterEnums.ENTRY_POINT);
      context.stream.writeUTF(wmep.getEntryPointId());
      writeFactHandles(context, ((NamedEntryPoint) wmep).getObjectStore());
    }
    context.stream.writeShort(PersisterEnums.END);
    writeInitialFactHandleLeftTuples(context);

    writePropagationContexts(context);

    writeActivations(context);

    writeActionQueue(context);

    writeTruthMaintenanceSystem(context);

    if (context.marshalProcessInstances && processMarshaller != null) {
      processMarshaller.writeProcessInstances(context);
    } else {
      context.stream.writeShort(PersisterEnums.END);
    }

    if (context.marshalWorkItems && processMarshaller != null) {
      processMarshaller.writeWorkItems(context);
    } else {
      context.stream.writeShort(PersisterEnums.END);
    }

    if (processMarshaller != null) {
      // this now just assigns the writer, it will not write out any timer information
      processMarshaller.writeProcessTimers(context);
    } else {
      context.stream.writeShort(PersisterEnums.END);
    }

    // Only works for JpaJDKTimerService
    writeTimers(context.wm.getTimerService().getTimerJobInstances(), context);

    if (multithread) {
      wm.startPartitionManagers();
    }

    // context.out.println( "--- write session --- END");
  }
 public org.drools.FactHandle getFactHandleByIdentity(Object object) {
   return session.getFactHandleByIdentity(object);
 }
 public EntryPoint getEntryPoint() {
   return session.getEntryPoint();
 }
 public Collection<Object> getObjects(org.drools.runtime.ObjectFilter filter) {
   return new ObjectStoreWrapper(session.getObjectStore(), filter, ObjectStoreWrapper.OBJECT);
 }
 public Collection<Object> getObjects() {
   return new ObjectStoreWrapper(session.getObjectStore(), null, ObjectStoreWrapper.OBJECT);
 }
 public <T extends org.drools.runtime.rule.FactHandle> Collection<T> getFactHandles(
     org.drools.runtime.ObjectFilter filter) {
   return new ObjectStoreWrapper(session.getObjectStore(), filter, ObjectStoreWrapper.FACT_HANDLE);
 }
 public KnowledgeBase getKnowledgeBase() {
   if (this.kbase == null) {
     this.kbase = new KnowledgeBaseImpl(session.getRuleBase());
   }
   return this.kbase;
 }
 public Collection<? extends org.drools.runtime.rule.WorkingMemoryEntryPoint>
     getWorkingMemoryEntryPoints() {
   return session.getWorkingMemoryEntryPoints();
 }
 public WorkingMemoryEntryPoint getWorkingMemoryEntryPoint(String name) {
   return session.getWorkingMemoryEntryPoint(name);
 }
 public StatefulKnowledgeSessionImpl(ReteooWorkingMemory session) {
   this(session, new KnowledgeBaseImpl(session.getRuleBase()));
 }
  private static ProtobufMessages.KnowledgeSession serializeSession(MarshallerWriteContext context)
      throws IOException {
    ReteooWorkingMemory wm = (ReteooWorkingMemory) context.wm;
    wm.getAgenda().unstageActivations();

    ProtobufMessages.RuleData.Builder _ruleData = ProtobufMessages.RuleData.newBuilder();

    final boolean multithread = wm.isPartitionManagersActive();
    if (multithread) {
      wm.stopPartitionManagers();
    }

    long time = 0;
    if (context.wm.getTimerService() instanceof PseudoClockScheduler) {
      time = context.clockTime;
    }
    _ruleData.setLastId(wm.getFactHandleFactory().getId());
    _ruleData.setLastRecency(wm.getFactHandleFactory().getRecency());

    InternalFactHandle handle = context.wm.getInitialFactHandle();
    ProtobufMessages.FactHandle _ifh =
        ProtobufMessages.FactHandle.newBuilder()
            .setType(ProtobufMessages.FactHandle.HandleType.INITIAL_FACT)
            .setId(handle.getId())
            .setRecency(handle.getRecency())
            .build();
    _ruleData.setInitialFact(_ifh);

    writeAgenda(context, _ruleData);

    writeNodeMemories(context, _ruleData);

    for (WorkingMemoryEntryPoint wmep : wm.getEntryPoints().values()) {
      org.drools.marshalling.impl.ProtobufMessages.EntryPoint.Builder _epb =
          ProtobufMessages.EntryPoint.newBuilder();
      _epb.setEntryPointId(wmep.getEntryPointId());
      writeFactHandles(context, _epb, ((NamedEntryPoint) wmep).getObjectStore());
      _ruleData.addEntryPoint(_epb.build());
    }

    writeActionQueue(context, _ruleData);

    writeTruthMaintenanceSystem(context, _ruleData);

    ProtobufMessages.KnowledgeSession.Builder _session =
        ProtobufMessages.KnowledgeSession.newBuilder()
            .setMultithread(multithread)
            .setTime(time)
            .setRuleData(_ruleData.build());

    if (processMarshaller != null) {
      Builder _pdata = ProtobufMessages.ProcessData.newBuilder();
      if (context.marshalProcessInstances) {
        context.parameterObject = _pdata;
        processMarshaller.writeProcessInstances(context);
      }

      if (context.marshalWorkItems) {
        context.parameterObject = _pdata;
        processMarshaller.writeWorkItems(context);
      }

      // this now just assigns the writer, it will not write out any timer information
      context.parameterObject = _pdata;
      processMarshaller.writeProcessTimers(context);

      _session.setProcessData(_pdata.build());
    }

    Timers _timers = writeTimers(context.wm.getTimerService().getTimerJobInstances(), context);
    if (_timers != null) {
      _session.setTimers(_timers);
    }

    if (multithread) {
      wm.startPartitionManagers();
    }

    return _session.build();
  }