addons/sna/org.eclipse.papyrus.iotml.sna.codegen/xtend-gen/org/eclipse/papyrus/iotml/sna/codegen/utils/IoTGenUtils.java

package org.eclipse.papyrus.iotml.sna.codegen.utils;

import java.util.ArrayList;
import java.util.List;
import org.eclipse.emf.common.util.EList;
import org.eclipse.papyrus.iotml.sensinact.Action;
import org.eclipse.papyrus.iotml.sensinact.SensorData;
import org.eclipse.papyrus.iotml.sensinact.StateVariable;
import org.eclipse.papyrus.uml.tools.utils.StereotypeUtil;
import org.eclipse.uml2.uml.Behavior;
import org.eclipse.uml2.uml.Constraint;
import org.eclipse.uml2.uml.OpaqueBehavior;
import org.eclipse.uml2.uml.OpaqueExpression;
import org.eclipse.uml2.uml.PackageableElement;
import org.eclipse.uml2.uml.Port;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.State;
import org.eclipse.uml2.uml.StateMachine;
import org.eclipse.uml2.uml.Transition;
import org.eclipse.uml2.uml.Type;
import org.eclipse.uml2.uml.ValueSpecification;
import org.eclipse.xtext.xbase.lib.Conversions;

@SuppressWarnings("all")
public class IoTGenUtils {
  public static String ORCHESTRATOR = "orchestrator";
  
  public static ArrayList<org.eclipse.uml2.uml.Class> getActions(final org.eclipse.uml2.uml.Package resourcePkg) {
    final ArrayList<org.eclipse.uml2.uml.Class> actionList = new ArrayList<org.eclipse.uml2.uml.Class>();
    EList<PackageableElement> _packagedElements = resourcePkg.getPackagedElements();
    for (final PackageableElement pe : _packagedElements) {
      if ((pe instanceof org.eclipse.uml2.uml.Class)) {
        boolean _isApplied = StereotypeUtil.isApplied(pe, Action.class);
        if (_isApplied) {
          actionList.add(((org.eclipse.uml2.uml.Class) pe));
        }
      }
    }
    return actionList;
  }
  
  public static ArrayList<org.eclipse.uml2.uml.Class> getSensorData(final org.eclipse.uml2.uml.Package resourcePkg) {
    final ArrayList<org.eclipse.uml2.uml.Class> sensorData = new ArrayList<org.eclipse.uml2.uml.Class>();
    EList<PackageableElement> _packagedElements = resourcePkg.getPackagedElements();
    for (final PackageableElement pe : _packagedElements) {
      if ((pe instanceof org.eclipse.uml2.uml.Class)) {
        boolean _isApplied = StereotypeUtil.isApplied(pe, SensorData.class);
        if (_isApplied) {
          sensorData.add(((org.eclipse.uml2.uml.Class) pe));
        }
      }
    }
    return sensorData;
  }
  
  public static ArrayList<org.eclipse.uml2.uml.Class> getStateVars(final org.eclipse.uml2.uml.Package resourcePkg) {
    final ArrayList<org.eclipse.uml2.uml.Class> stateVars = new ArrayList<org.eclipse.uml2.uml.Class>();
    EList<PackageableElement> _packagedElements = resourcePkg.getPackagedElements();
    for (final PackageableElement pe : _packagedElements) {
      if ((pe instanceof org.eclipse.uml2.uml.Class)) {
        boolean _isApplied = StereotypeUtil.isApplied(pe, StateVariable.class);
        if (_isApplied) {
          stateVars.add(((org.eclipse.uml2.uml.Class) pe));
        }
      }
    }
    return stateVars;
  }
  
  public static ArrayList<Property> getNonPortAttr(final org.eclipse.uml2.uml.Class clazz) {
    final ArrayList<Property> attributes = new ArrayList<Property>();
    EList<Property> _attributes = clazz.getAttributes();
    for (final Property attribute : _attributes) {
      if ((!(attribute instanceof Port))) {
        attributes.add(attribute);
      }
    }
    return attributes;
  }
  
  /**
   * return all subscribers accessible in the transitions from a state
   */
  public static ArrayList<String> getSubscribers(final State state) {
    final ArrayList<String> subscribers = new ArrayList<String>();
    EList<Transition> _outgoings = state.getOutgoings();
    for (final Transition transition : _outgoings) {
      IoTGenUtils.getSubscribers(transition, subscribers);
    }
    return subscribers;
  }
  
  /**
   * Analyze the constraint (of a transition). ADd all objects that are queried
   * via get as potential subscribers
   */
  public static void getSubscribers(final Transition transition, final List<String> subscribers) {
    final String guardStr = IoTGenUtils.guardStr(transition);
    boolean first = true;
    if ((guardStr != null)) {
      final String[] tokens = guardStr.split(".get\\(\\)");
      for (int i = 0; (i < (((List<String>)Conversions.doWrapArray(tokens)).size() - 1)); i++) {
        {
          final String token = tokens[i];
          final int lastSpace = token.lastIndexOf(" ");
          String subscriber = null;
          if (((lastSpace > 0) && (lastSpace < (token.length() - 1)))) {
            subscriber = token.substring((lastSpace + 1));
          } else {
            if (first) {
              subscriber = token;
              first = false;
            }
          }
          if (((subscriber != null) && (!subscribers.contains(subscriber)))) {
            subscribers.add(subscriber);
          }
        }
      }
    }
  }
  
  public static String guardStr(final Transition transition) {
    Constraint _guard = transition.getGuard();
    boolean _tripleNotEquals = (_guard != null);
    if (_tripleNotEquals) {
      final ValueSpecification spec = transition.getGuard().getSpecification();
      if ((spec instanceof OpaqueExpression)) {
        return ((OpaqueExpression)spec).getBodies().get(0);
      }
    }
    return null;
  }
  
  public static String effectStr(final Transition c) {
    Behavior _effect = c.getEffect();
    if ((_effect instanceof OpaqueBehavior)) {
      Behavior _effect_1 = c.getEffect();
      final OpaqueBehavior ob = ((OpaqueBehavior) _effect_1);
      return ob.getBodies().get(0);
    }
    return null;
  }
  
  public static StateMachine getOrchestratorSM(final org.eclipse.uml2.uml.Class gw) {
    final Property orchProp = gw.getOwnedAttribute(IoTGenUtils.ORCHESTRATOR, null);
    if (((orchProp != null) && (orchProp.getType() instanceof org.eclipse.uml2.uml.Class))) {
      Type _type = orchProp.getType();
      final org.eclipse.uml2.uml.Class orchestrator = ((org.eclipse.uml2.uml.Class) _type);
      Behavior _classifierBehavior = orchestrator.getClassifierBehavior();
      if ((_classifierBehavior instanceof StateMachine)) {
        Behavior _classifierBehavior_1 = orchestrator.getClassifierBehavior();
        return ((StateMachine) _classifierBehavior_1);
      } else {
        int _size = orchestrator.getOwnedBehaviors().size();
        boolean _greaterThan = (_size > 0);
        if (_greaterThan) {
          Behavior _get = orchestrator.getOwnedBehaviors().get(0);
          return ((StateMachine) _get);
        }
      }
    }
    return null;
  }
}