Example #1
0
  private void completeExecuteArc(GraphProcess process, Node targetNode, List<ArcToken> tokens) {
    NodeToken nodeToken = getFactory().newNodeToken(process, targetNode, tokens);
    process.addNodeToken(nodeToken);

    // Add new node token to add the token sets which its generating arc tokens are members of
    Set<TokenSet> tokenSets = new HashSet<TokenSet>();

    for (ArcToken token : tokens) {
      for (ArcTokenSetMember setMember : token.getTokenSetMemberships()) {
        TokenSet tokenSet = setMember.getTokenSet();
        if (!tokenSet.isComplete() && !tokenSets.contains(tokenSet)) {
          tokenSets.add(tokenSet);
          NodeTokenSetMember newSetMember =
              getFactory().newNodeTokenSetMember(tokenSet, nodeToken, setMember.getMemberIndex());
          tokenSet.getActiveNodeTokens(this).add(nodeToken);
          nodeToken.getTokenSetMemberships().add(newSetMember);
        }
      }
    }

    fireEvent(NodeTokenEvent.newCreatedEvent(this, nodeToken));

    for (ArcToken token : tokens) {
      process.removeActiveArcToken(token);
      if (token.isPending()) {
        token.markProcessed(this);
      }
      token.markComplete(this, nodeToken);
      fireEvent(ArcTokenEvent.newCompletedEvent(this, token));
    }

    executeNode(process, nodeToken);
  }
 private void shareTokenSets(final NodeToken newToken, final NodeToken origToken) {
   for (NodeTokenSetMember setMember : origToken.getTokenSetMemberships()) {
     TokenSet tokenSet = setMember.getTokenSet();
     NodeTokenSetMember newSetMember =
         engine.getFactory().newNodeTokenSetMember(tokenSet, newToken, setMember.getMemberIndex());
     newToken.getTokenSetMemberships().add(newSetMember);
     tokenSet.getActiveNodeTokens(engine).add(newToken);
     tokenSets.add(tokenSet);
   }
 }
Example #3
0
  private void completeNodeToken(
      final GraphProcess process, final NodeToken token, final String arcName) {
    process.removeActiveNodeToken(token);
    token.markComplete(this);

    // If the node was skipped, we already sent a 'skipped' event and don't want to
    // send another 'completed' event.
    if (token.getGuardAction() != GuardAction.SkipNode) {
      fireEvent(NodeTokenEvent.newCompletedEvent(this, token, arcName));
    }
  }
Example #4
0
  protected void completeNodeExecution(
      final NodeToken token, final String arcName, final boolean asynchronous) {
    GraphProcess process = token.getProcess();

    if (!process.isExecuting() || token.isComplete()) {
      return;
    }

    completeNodeToken(process, token, arcName);

    for (Arc arc : process.getGraph().getOutputArcs(token.getNode(), arcName)) {
      ArcToken arcToken = generateArcToken(process, arc, token);
      finishNewArcTokenProcessing(process, arcToken, asynchronous);
    }
  }
  @Override
  public void visit(final NodeToken token) {
    if (!token.getNode().isBacktrackable(engine, token)) {
      throw new SarasvatiException(
          "Can not backtrack node name: "
              + token.getNode().getName()
              + "id: "
              + token.getNode().getId());
    }

    if (token.getChildTokens().isEmpty()) {
      queue.add(token);
    }
    visited.add(token);
  }
Example #6
0
  private ArcToken generateArcToken(
      final GraphProcess process, final Arc arc, final NodeToken token) {
    ArcToken arcToken = getFactory().newArcToken(process, arc, ExecutionType.Forward, token);
    token.getChildTokens().add(arcToken);

    for (NodeTokenSetMember setMember : token.getTokenSetMemberships()) {
      TokenSet tokenSet = setMember.getTokenSet();
      if (!tokenSet.isComplete()) {
        ArcTokenSetMember newSetMember =
            getFactory().newArcTokenSetMember(tokenSet, arcToken, setMember.getMemberIndex());
        tokenSet.getActiveArcTokens(this).add(arcToken);
        arcToken.getTokenSetMemberships().add(newSetMember);
      }
    }

    return arcToken;
  }
Example #7
0
  public void completeWithNewTokenSet(
      final NodeToken token,
      final String arcName,
      final String tokenSetName,
      final int numberOfTokens,
      final boolean asynchronous,
      final Env initialEnv,
      final Map<String, List<?>> initialMemberEnv) {
    GraphProcess process = token.getProcess();

    if (!process.isExecuting() || token.isComplete()) {
      return;
    }

    completeNodeToken(process, token, arcName);

    List<? extends Arc> outArcs = process.getGraph().getOutputArcs(token.getNode(), arcName);

    if (!outArcs.isEmpty()) {
      TokenSet tokenSet = getFactory().newTokenSet(process, tokenSetName, numberOfTokens);

      if (initialEnv != null) {
        tokenSet.getEnv().importEnv(initialEnv);
      }

      if (initialMemberEnv != null) {
        TokenSetMemberEnv memberEnv = tokenSet.getMemberEnv();
        for (Map.Entry<String, List<?>> entry : initialMemberEnv.entrySet()) {
          memberEnv.setAttribute(entry.getKey(), entry.getValue());
        }
      }

      for (int memberIndex = 0; memberIndex < numberOfTokens; memberIndex++) {
        for (Arc arc : outArcs) {
          ArcToken arcToken = generateArcToken(process, arc, token);

          ArcTokenSetMember setMember =
              getFactory().newArcTokenSetMember(tokenSet, arcToken, memberIndex);
          tokenSet.getActiveArcTokens(this).add(arcToken);
          arcToken.getTokenSetMemberships().add(setMember);

          finishNewArcTokenProcessing(process, arcToken, asynchronous);
        }
      }
    }
  }
  private NodeToken backtrackCompletedToken(
      final NodeToken token, final ExecutionType executionType) {
    token.markBacktracked();
    NodeTokenEvent.fireBacktrackedEvent(engine, token);

    List<ArcToken> parents = new ArrayList<ArcToken>(token.getChildTokens().size());
    for (ArcToken childToken : token.getChildTokens()) {
      ArcToken parent = arcTokenMap.get(childToken);
      if (parent == null) {
        throw new RuntimeException("No backtrack found for: " + childToken);
      }
      parents.add(parent);
    }

    NodeToken backtrackToken =
        engine
            .getFactory()
            .newNodeToken(token.getProcess(), token.getNode(), executionType, parents, token);
    NodeTokenEvent.fireCreatedEvent(engine, backtrackToken);
    token.getProcess().addNodeToken(backtrackToken);
    shareTokenSets(backtrackToken, token);

    for (ArcToken parent : parents) {
      token.getProcess().removeActiveArcToken(parent);

      parent.markBacktracked();
      ArcTokenEvent.fireBacktrackedEvent(engine, parent);

      parent.markComplete(backtrackToken);
      ArcTokenEvent.fireCompletedEvent(engine, parent);
    }

    return backtrackToken;
  }
  public NodeToken backtrack() {
    backtrackLeafArcTokens();

    NodeToken resultToken = null;

    while (!queue.isEmpty()) {
      NodeToken token = queue.first();
      queue.remove(token);
      if (token.getExecutionType().isBacktracked()) {
        continue;
      }

      token.getNode().backtrack(engine, token);

      boolean isDestination = token.equals(destinationToken);

      if (isDestination) {
        resultToken = backtrackCompletedToken(token, ExecutionType.Forward);
      } else {
        NodeToken backtrackToken = backtrackToken(token);

        if (backtrackToken != token) {
          backtrackToken.markBacktracked();
          NodeTokenEvent.fireBacktrackedEvent(engine, backtrackToken);

          backtrackToken.markComplete();
          NodeTokenEvent.fireCompletedEvent(engine, backtrackToken, null);
        }
      }
    }

    reactivateTokenSets();

    return resultToken;
  }
Example #10
0
  @Override
  public void complete(NodeToken token, String arcName) {
    GraphProcess process = token.getProcess();

    completeNodeExecution(token, arcName, false);

    if (process.isExecuting() && !arcExecutionStarted) {
      executeQueuedArcTokens(process);
    }
  }
  @Override
  public HibNodeToken newNodeToken(
      final GraphProcess process,
      final Node node,
      final ExecutionType executionType,
      final List<ArcToken> parents,
      final NodeToken envSource) {
    // Here we setup the token attributes for the new node
    // If the node has no predecessors, it will have no attributes
    // If it has only one processor (or only one processor with attributes)
    // it will inherit the attributes of that one node
    // Otherwise, the attributes of all predecessor nodes will get merged into
    // a single set.
    List<ArcToken> envParents = envSource == null ? parents : envSource.getParentTokens();

    HibNodeToken attrSetToken = null;
    Map<String, String> attrMap = new HashMap<String, String>();
    Map<String, Object> transientAttributes = new HashMap<String, Object>();
    boolean isMerge = false;

    for (ArcToken arcToken : envParents) {
      HibNodeToken parent = (HibNodeToken) arcToken.getParentToken();

      if (parent.getAttrSetToken() == null) {
        continue;
      }
      if (attrSetToken == null) {
        attrSetToken = parent.getAttrSetToken();
      } else if (!isMerge) {
        attrMap.putAll(attrSetToken.getAttrMap());
        isMerge = true;
      }

      if (isMerge) {
        attrMap.putAll(parent.getAttrSetToken().getAttrMap());
      }

      Env mergeEnv = parent.getEnv();
      for (String name : mergeEnv.getTransientAttributeNames()) {
        transientAttributes.put(name, mergeEnv.getTransientAttribute(name));
      }
    }

    HibNodeToken token =
        new HibNodeToken(
            (HibGraphProcess) process,
            (HibNodeRef) node,
            attrSetToken,
            executionType,
            attrMap,
            parents,
            transientAttributes);
    session.save(token);
    return token;
  }
 /**
  * @see
  *     com.googlecode.sarasvati.test.framework.TokenOnNodePredicate#matches(com.googlecode.sarasvati.NodeToken)
  */
 @Override
 public boolean matches(final NodeToken token) {
   if (super.matches(token)) {
     for (final ArcToken parent : token.getParentTokens()) {
       if (parent.getParentToken().getTokenSetMember(tokenSetName) != null) {
         return true;
       }
     }
   }
   return false;
 }
Example #13
0
  protected void executeNode(GraphProcess process, NodeToken token) {
    GuardResponse response = token.getNode().guard(this, token);
    token.recordGuardAction(this, response.getGuardAction());

    switch (response.getGuardAction()) {
      case AcceptToken:
        process.addActiveNodeToken(token);
        fireEvent(NodeTokenEvent.newAcceptedEvent(this, token));
        token.getNode().execute(this, token);
        break;

      case DiscardToken:
        token.markComplete(this);
        fireEvent(NodeTokenEvent.newDiscardedEvent(this, token));
        break;

      case SkipNode:
        process.addActiveNodeToken(token);
        fireEvent(NodeTokenEvent.newSkippedEvent(this, token, response.getExitArcForSkip()));
        complete(token, response.getExitArcForSkip());
        break;
    }
  }
  public NodeToken backtrackDeadEnd(final NodeToken token) {
    token.markBacktracked();
    NodeTokenEvent.fireBacktrackedEvent(engine, token);

    List<ArcToken> parents = new ArrayList<ArcToken>(token.getParentTokens().size());
    for (ArcToken parent : token.getParentTokens()) {
      parent.markBacktracked();
      ArcTokenEvent.fireBacktrackedEvent(engine, parent);

      ArcToken backtrackArcToken =
          engine
              .getFactory()
              .newArcToken(token.getProcess(), parent.getArc(), ExecutionType.UTurn, token);
      ArcTokenEvent.fireCreatedEvent(engine, backtrackArcToken);
      token.getChildTokens().add(backtrackArcToken);
      parents.add(backtrackArcToken);
      shareTokenSets(backtrackArcToken, parent);
    }

    NodeToken backtrackToken =
        engine
            .getFactory()
            .newNodeToken(
                token.getProcess(), token.getNode(), ExecutionType.Forward, parents, token);
    NodeTokenEvent.fireCreatedEvent(engine, backtrackToken);
    token.getProcess().addNodeToken(backtrackToken);
    shareTokenSets(backtrackToken, token);

    for (ArcToken parent : parents) {
      parent.markProcessed();
      ArcTokenEvent.fireProcessedEvent(engine, parent);

      parent.markComplete(backtrackToken);
      ArcTokenEvent.fireCompletedEvent(engine, parent);
    }

    reactivateTokenSets();

    return backtrackToken;
  }
Example #15
0
  @Override
  public void backtrack(final NodeToken token) {
    if (!token.isComplete()) {
      throw new SarasvatiException("Cannot backtrack to a node token which isn't completed.");
    }

    if (token.getExecutionType().isBacktracked()) {
      throw new SarasvatiException("Cannot backtrack to a node token which has been backtracked.");
    }

    NodeToken resultToken = null;
    BacktrackTokenVisitor visitor = new BacktrackTokenVisitor(this, token);

    if (token.getChildTokens().isEmpty()) {
      resultToken = visitor.backtrackDeadEnd(token);
    } else {
      TokenTraversals.createOrderTraversal(token, visitor);
      resultToken = visitor.backtrack();
    }

    executeNode(resultToken.getProcess(), resultToken);
    executeQueuedArcTokens(token.getProcess());
  }
 public boolean isCompletedNodeToken() {
   return token != null && token.isComplete();
 }
 public boolean isStartTokenNode() {
   return token != null && token.getParentTokens().isEmpty() && token.getNode().isStart();
 }
  private NodeToken backtrackToken(final NodeToken token) {
    NodeToken backtrackToken = token;

    if (!token.isComplete()) {
      token.markComplete();
      NodeTokenEvent.fireCompletedEvent(engine, backtrackToken, null);

      token.markBacktracked();
      NodeTokenEvent.fireBacktrackedEvent(engine, token);

      token.getProcess().removeActiveNodeToken(token);
    } else if (!token.getExecutionType().isBacktracked()) {
      if (token.getChildTokens().isEmpty()) {
        token.markBacktracked();
        NodeTokenEvent.fireBacktrackedEvent(engine, token);
      } else {
        backtrackToken = backtrackCompletedToken(token, ExecutionType.Backtracked);
        backtrackToken.setGuardAction(GuardAction.SkipNode);
        NodeTokenEvent.fireSkippedEvent(engine, backtrackToken, null);
      }
    }

    for (ArcToken parent : getParents(token)) {
      boolean backtrackParent = visited.contains(parent.getParentToken());

      token.getProcess().removeActiveArcToken(parent);
      parent.markBacktracked();
      ArcTokenEvent.fireBacktrackedEvent(engine, parent);

      ArcToken backtrackArcToken =
          engine
              .getFactory()
              .newArcToken(
                  token.getProcess(),
                  parent.getArc(),
                  backtrackParent ? ExecutionType.Backtracked : ExecutionType.UTurn,
                  backtrackToken);
      ArcTokenEvent.fireCreatedEvent(engine, backtrackArcToken);
      backtrackToken.getChildTokens().add(backtrackArcToken);
      shareTokenSets(backtrackArcToken, parent);

      if (backtrackParent && parent.getExecutionType() != ExecutionType.Forward) {
        ArcToken mirror = backtrackMirror.getMirror(parent);
        arcTokenMap.put(mirror, backtrackArcToken);
        finishArcTokenBacktrack(backtrackArcToken, mirror);
      } else {
        finishArcTokenBacktrack(backtrackArcToken, parent);
      }
    }

    return backtrackToken;
  }
 public Node getNode() {
   return token == null ? node : token.getNode();
 }