コード例 #1
0
  @Check(CheckType.FAST)
  public void checkTransitionPropertySpec(final Transition transition) {
    for (ReactionProperty property : transition.getProperties()) {
      if (property instanceof EntryPointSpec) {
        if (transition.getTarget() instanceof org.yakindu.sct.model.sgraph.State) {
          org.yakindu.sct.model.sgraph.State state =
              (org.yakindu.sct.model.sgraph.State) transition.getTarget();
          if (!state.isComposite()) {
            warning(TRANSITION_ENTRY_SPEC_NOT_COMPOSITE, transition, null, -1);
          }
        }
      } else if (property instanceof ExitPointSpec) {
        final ExitPointSpec exitPointSpec = (ExitPointSpec) property;
        if (transition.getSource() instanceof org.yakindu.sct.model.sgraph.State) {
          org.yakindu.sct.model.sgraph.State state =
              (org.yakindu.sct.model.sgraph.State) transition.getSource();
          if (!state.isComposite()) {
            warning(TRANSITION_EXIT_SPEC_NOT_COMPOSITE, transition, null, -1);
          } else {
            // Validate an exit point is continued on one transition
            // only.
            for (Transition t : state.getOutgoingTransitions()) {
              if (transition != t
                  && STextValidationModelUtils.isNamedExitTransition(
                      t, exitPointSpec.getExitpoint())) {
                warning(TRANSITION_EXIT_SPEC_ON_MULTIPLE_SIBLINGS, transition, null, -1);
              }
            }

            // Validate the state has minimally one named exit
            // region

            boolean hasExit = false;
            Iterator<Region> regionIter = state.getRegions().iterator();
            while (regionIter.hasNext() && !hasExit) {

              Iterator<Exit> exitIter =
                  STextValidationModelUtils.getExits(regionIter.next().eContents()).iterator();
              while (exitIter.hasNext() && !hasExit) {
                Exit exit = exitIter.next();
                hasExit = exitPointSpec.getExitpoint().equals(exit.getName());
              }
            }
            if (!hasExit) {
              error(TRANSITION_NOT_EXISTING_NAMED_EXIT_POINT, transition, null, -1);
            }
          }
        }
      }
    }
  }
コード例 #2
0
  protected void createExitPoint(Edge edge, Diagram subdiagram) {
    Transition transition = (Transition) edge.getElement();
    // create semantic exit point
    Region exitPointContainer = getExitPointContainer(transition);
    Exit exitPoint = createSemanticExitPoint(transition);

    // create node for exit point
    View exitPointContainerView = helper.getViewForSemanticElement(exitPointContainer, subdiagram);
    View exitPointRegionCompartment =
        ViewUtil.getChildBySemanticHint(exitPointContainerView, SemanticHints.REGION_COMPARTMENT);
    Node exitNode =
        ViewService.createNode(
            exitPointRegionCompartment, exitPoint, SemanticHints.EXIT, preferencesHint);

    // re-wire existing transition to new exit point
    Vertex oldTarget = transition.getTarget();
    transition.setTarget(exitPoint);
    ViewService.createEdge(
        edge.getSource(), exitNode, transition, SemanticHints.TRANSITION, preferencesHint);

    // create transition from selected state to former transition target
    Transition exitPointTransition = SGraphFactory.eINSTANCE.createTransition();
    exitPointTransition.setSource((State) subdiagram.getElement());
    exitPointTransition.setTarget(oldTarget);
    ViewService.createEdge(
        getContextObject(),
        edge.getTarget(),
        exitPointTransition,
        SemanticHints.TRANSITION,
        preferencesHint);

    addExitPointSpec(exitPointTransition, exitPoint);
  }
コード例 #3
0
 /**
  * Retrieves the target from an entry. TODO: validation of preconditions for entry targets e.g
  * every region needs an entry with appropriate target
  */
 public State target(final Entry entry) {
   State _xifexpression = null;
   EList<Transition> _outgoingTransitions =
       entry == null ? (EList<Transition>) null : entry.getOutgoingTransitions();
   boolean _notEquals = (!Objects.equal(_outgoingTransitions, null));
   if (_notEquals) {
     State _xifexpression_1 = null;
     EList<Transition> _outgoingTransitions_1 = entry.getOutgoingTransitions();
     int _size = _outgoingTransitions_1.size();
     boolean _greaterThan = (_size > 0);
     if (_greaterThan) {
       State _xblockexpression = null;
       {
         EList<Transition> _outgoingTransitions_2 = entry.getOutgoingTransitions();
         Transition _get = _outgoingTransitions_2.get(0);
         final Vertex target = _get.getTarget();
         State _xifexpression_2 = null;
         if ((target instanceof State)) {
           _xifexpression_2 = ((State) target);
         }
         _xblockexpression = (_xifexpression_2);
       }
       _xifexpression_1 = _xblockexpression;
     }
     _xifexpression = _xifexpression_1;
   }
   return _xifexpression;
 }
コード例 #4
0
 protected String getEntryPointName(Transition transition) {
   StringBuilder stringBuilder = new StringBuilder();
   stringBuilder.append("entry_");
   stringBuilder.append(transition.getTarget().getName());
   int index = transition.getSource().getOutgoingTransitions().indexOf(transition);
   stringBuilder.append(index);
   return stringBuilder.toString();
 }
コード例 #5
0
  @Check
  public void orthogonalTransition(Transition transition) {

    Vertex source = transition.getSource();
    Vertex target = transition.getTarget();

    if ((source instanceof Synchronization) || (target instanceof Synchronization))
      return; // ... the check does not apply.

    EObject commonAncestor = commonAncestor(source, target);

    if (commonAncestor instanceof CompositeElement) {

      error(ISSUE_TRANSITION_ORTHOGONAL, transition, null, -1);
    }
  }
コード例 #6
0
  @Check
  public void orthogonalSynchronizedTransition(Synchronization sync) {

    List<Transition> incoming = sync.getIncomingTransitions();
    List<List<EObject>> inAncestorsList = new ArrayList<List<EObject>>();
    for (Transition trans : incoming) {
      inAncestorsList.add(collectAncestors(trans.getSource(), new ArrayList<EObject>()));
    }

    List<Transition> outgoing = sync.getOutgoingTransitions();
    List<List<EObject>> outAncestorsList = new ArrayList<List<EObject>>();
    for (Transition trans : outgoing) {
      outAncestorsList.add(collectAncestors(trans.getTarget(), new ArrayList<EObject>()));
    }

    Set<Transition> inOrthogonal = new HashSet<Transition>(incoming);
    Set<Transition> outOrthogonal = new HashSet<Transition>(outgoing);

    for (int i = 0; i < incoming.size(); i++) {
      for (int j = 0; j < outgoing.size(); j++) {

        EObject commonAncestor =
            findCommonAncestor(inAncestorsList.get(i), outAncestorsList.get(j));

        if (commonAncestor instanceof Region) {
          inOrthogonal.remove(incoming.get(i));
          outOrthogonal.remove(outgoing.get(j));
        }
      }
    }

    for (Transition trans : inOrthogonal) {
      error(ISSUE_SYNCHRONIZATION_SOURCE_STATES_NOT_WITHIN_SAME_PARENTSTATE, trans, null, -1);
    }

    for (Transition trans : outOrthogonal) {
      error(ISSUE_SYNCHRONIZATION_TARGET_STATES_NOT_WITHIN_SAME_PARENTSTATE, trans, null, -1);
    }
  }
コード例 #7
0
  protected Entry createSemanticEntryPoint(Transition transition) {
    Region entryPointTarget = getEntryPointContainer(transition);
    String name = getEntryPointName(transition);
    Entry entryPoint = null;
    Iterator<Vertex> iterator = entryPointTarget.getVertices().iterator();
    while (iterator.hasNext()) {
      Vertex next = iterator.next();
      if (next instanceof Entry) {
        Entry current = (Entry) next;
        if (name.equals(current.getName())) {
          // Do nothing, there already exists an entry point
          return current;
        }
      }
    }
    entryPoint = SGraphFactory.eINSTANCE.createEntry();
    entryPoint.setName(name);
    entryPointTarget.getVertices().add(entryPoint);
    Transition entryPointTransition = SGraphFactory.eINSTANCE.createTransition();
    entryPointTransition.setSource(entryPoint);
    entryPointTransition.setTarget(transition.getTarget());

    return entryPoint;
  }
コード例 #8
0
 private Region getEntryPointContainer(Transition transition) {
   // entry point container is the subdiagram's state's region which
   // contains the transition target
   EObject firstParentRegion = transition.getTarget().getParentRegion();
   return getOutermostParentRegion(firstParentRegion);
 }
コード例 #9
0
 @Check(CheckType.FAST)
 public void initialEntryWithTransitionToContainer(Transition t) {
   if (t.getSource() instanceof Entry && !isChildOrSibling(t.getSource(), t.getTarget())) {
     error(ISSUE_INITIAL_ENTRY_WITH_TRANSITION_TO_CONTAINER, t, null, -1);
   }
 }