protected String getTargetOS(InstanceSpecification node) {
   Target target = UMLUtil.getStereotypeApplication(node, Target.class);
   if (target == null) {
     // get information from node referenced by the instance
     target = UMLUtil.getStereotypeApplication(DepUtils.getClassifier(node), Target.class);
   }
   if (target != null) {
     OperatingSystem os = target.getUsedOS();
     if (os != null) {
       return os.getBase_Class().getName();
     }
   }
   return null;
 }
 /**
  * Is this property a DataFlow Port
  *
  * @param port
  * @return is this a DataFlow port ?
  */
 public static Boolean isDataFlowPort(Port port) {
   DataFlowPort dfp = UMLUtil.getStereotypeApplication(port, DataFlowPort.class);
   if (dfp == null) {
     return false;
   }
   return true;
 }
  /**
   * Checks if is correct graphical view.
   *
   * @param connectorEnd a connector end
   * @param view a view
   * @return <code>true</code> if the view represents the role of the connector AND if the view is
   *     encapsulated as required by the nested path of the connector end
   */
  protected boolean isCorrectGraphicalView(final ConnectorEnd connectorEnd, final View view) {
    final NestedConnectorEnd nestedConnectorEnd =
        org.eclipse.uml2.uml.util.UMLUtil.getStereotypeApplication(
            connectorEnd, NestedConnectorEnd.class);
    final Property partWithPort = connectorEnd.getPartWithPort();
    // final ConnectableElement role = end.getRole();
    // 1. we get the top view of this view with the same semantic element
    View localView = getTopViewWithSameSemanticElement(view);

    // 2. we verify the part with port
    if (partWithPort != null) {
      View parent = getTopViewWithSameSemanticElement(ViewUtil.getViewContainer(localView));
      if (parent.getElement() != partWithPort) {
        return false;
      }
    }

    // 3. we verify the nested path
    if (nestedConnectorEnd != null && nestedConnectorEnd.getPropertyPath().size() > 0) {
      View parent = view;
      final List<Property> paths = nestedConnectorEnd.getPropertyPath();
      for (int i = paths.size() - 1; i >= 0; i--) {
        final Property currentProperty = paths.get(i);
        parent = getTopViewWithSameSemanticElement(ViewUtil.getViewContainer(parent));
        if (parent.getElement() != currentProperty) {
          return false;
        }
      }
    }
    return true;
  }
 /**
  * Tell if the ActivityPartition is a AllocateActivityPartition implementation
  *
  * @param ActivityPartition
  * @return
  * @generated
  */
 protected Boolean isAllocateActivityPartitionFromActivityPartition(
     ActivityPartition activityPartition_) {
   if (UMLUtil.getStereotypeApplication(activityPartition_, AllocateActivityPartition.class)
       != null) {
     return true;
   }
   return false;
 }
 public static Boolean hasNativeImplementation(org.eclipse.uml2.uml.Class c) {
   org.eclipse.papyrus.RobotML.System sys =
       org.eclipse.uml2.uml.util.UMLUtil.getStereotypeApplication(
           c, org.eclipse.papyrus.RobotML.System.class);
   if (sys == null) {
     return false;
   }
   return sys.isNative();
 }
 public static int getOutputPortBufferSize(Port p) {
   org.eclipse.papyrus.RobotML.DataFlowPort dfp =
       org.eclipse.uml2.uml.util.UMLUtil.getStereotypeApplication(
           p, org.eclipse.papyrus.RobotML.DataFlowPort.class);
   if (dfp == null) {
     return 0;
   }
   return dfp.getBufferSize();
 }
 public static String getNativeComponentNameForComponent(org.eclipse.uml2.uml.Class c) {
   org.eclipse.papyrus.RobotML.System sys =
       org.eclipse.uml2.uml.util.UMLUtil.getStereotypeApplication(
           c, org.eclipse.papyrus.RobotML.System.class);
   if (sys == null) {
     return null;
   }
   return sys.getLibraryComponentName();
 }
 /**
  * Bind C++ const initializer
  *
  * @param operation
  * @param actual
  * @throws TransformationException
  */
 public static void bindOperation(Operation operation, Classifier actual)
     throws TransformationException {
   // perform binding in case of C++ initializer
   ConstInit cppConstInit = UMLUtil.getStereotypeApplication(operation, ConstInit.class);
   if (cppConstInit != null) {
     // TODO: specific to C++
     String init = cppConstInit.getInitialisation();
     String newInit = AcceleoDriverWrapper.bind(init, actual);
     cppConstInit.setInitialisation(newInit);
   }
 }
  public boolean matches(EObject eObject) {

    boolean isMatch = false;
    if (eObject instanceof Comment) {

      Comment element = (Comment) eObject;
      if (UMLUtil.getStereotypeApplication(element, Rationale.class) != null) {
        isMatch = true;
      }
    }
    return isMatch;
  }
  public boolean matches(EObject eObject) {

    boolean isMatch = false;
    if (eObject instanceof Dependency) {

      Dependency element = (Dependency) eObject;
      if (UMLUtil.getStereotypeApplication(element, Conform.class) != null) {
        isMatch = true;
      }
    }
    return isMatch;
  }
 /**
  * For DataFlow ports: is it an Output Port ?
  *
  * @param port
  * @return false if the port is not a DataFlowPort or not an input/output port.
  */
 public static Boolean isAnInputOutputPort(Port port) {
   try {
     DataFlowPort dfp = UMLUtil.getStereotypeApplication(port, DataFlowPort.class);
     if (dfp == null) {
       return false;
     }
     if (dfp.getDirection() == DataFlowDirectionKind.INOUT) {
       return true;
     }
     return false;
   } catch (Exception e) {
     java.lang.System.out.println("EXCEPTION caught:" + e.toString());
   }
   return false;
 }
 /**
  * For RobotML ServicePorts: is the port a "Required" port?
  *
  * @param port
  * @return false if the port is not a ServicePort or not a "Required" ServicePort.
  */
 public static Boolean isARequiredPort(Port port) {
   try {
     ServicePort sp = UMLUtil.getStereotypeApplication(port, ServicePort.class);
     if (sp == null) {
       return false;
     }
     if (sp.getKind() == ServiceFlowKind.REQUIRED) {
       return true;
     }
     return false;
   } catch (Exception e) {
     java.lang.System.out.println("EXCEPTION caught:" + e.toString());
   }
   return false;
 }
Exemple #13
0
  public boolean matches(EObject eObject) {

    boolean isFlowPort_NA = false;

    if (eObject instanceof Port) {

      Port port = (Port) eObject;
      FlowPort flowPort = UMLUtil.getStereotypeApplication(port, FlowPort.class);

      if ((flowPort != null) && (!flowPort.isAtomic())) {
        isFlowPort_NA = true;
      }
    }

    return isFlowPort_NA;
  }
  /**
   *
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated NOT
   */
  @Override
  public EList<FeatureModel> getTechnicalFeatureModel() {
    EList<FeatureModel> results = new BasicEList<FeatureModel>();
    FeatureModel adlFeatureModel = null;
    if (getBase_NamedElement() != null) {
      Iterator<Element> it = getBase_NamedElement().getOwnedElements().iterator();

      while (it.hasNext()) {
        Element element = it.next();
        adlFeatureModel = UMLUtil.getStereotypeApplication(element, FeatureModel.class);
        if (adlFeatureModel != null) {
          results.add(adlFeatureModel);
        }
      }
    }

    return new BasicInternalEList<FeatureModel>(
        FeatureModel.class, results.size(), results.toArray());
  }
Exemple #15
0
  /** {@inheritDoc} */
  public boolean matches(EObject eObject) {

    boolean isMatch = false;
    if ((eObject instanceof Property) && !(eObject instanceof Port)) {

      Property element = (Property) eObject;

      // The property is necessary a composition and has a type
      if ((element.getType() != null)
          && (element.getAggregation() == AggregationKind.COMPOSITE_LITERAL)) {

        // Moreover its type has to be a Block
        if (UMLUtil.getStereotypeApplication(element.getType(), Block.class) != null) {
          isMatch = true;
        }
      }
    }
    return isMatch;
  }
  /** {@inheritDoc} */
  @Override
  protected Diagram doCreateDiagram(
      Resource diagramResource,
      EObject owner,
      EObject element,
      ViewPrototype prototype,
      String name) {
    // Start of user code Custom diagram creation
    Diagram diagram = null;

    org.eclipse.uml2.uml.Class cOwner = (org.eclipse.uml2.uml.Class) element;
    Block block = UMLUtil.getStereotypeApplication(cOwner, Block.class);

    if (block != null) {
      canvasDomainElement = (EObject) element;
      Package owningPackage = ((Element) element).getNearestPackage();
      diagram = super.doCreateDiagram(diagramResource, owner, owningPackage, prototype, name);
    }

    return diagram;
    // End of user code
  }
  /**
   * Bind a named element. Besides of binding the passed element, this operation will bind all
   * elements that are referenced (required) by the passed element.
   *
   * <p>In consequence, typically only a small part of a package template is actually created within
   * the bound package. We call this mechanism lazy instantiation/binding
   *
   * @param copier Source and target model
   * @param namedElement A member within the package template which should be bound, i.e. for which
   *     template instantiation should be performed.
   * @param binding The binding between the bound package and the package template
   * @param args Acceleo arguments
   */
  @SuppressWarnings("unchecked")
  public <T extends NamedElement> T bindNamedElement(T namedElement)
      throws TransformationException {
    if (namedElement == null) {
      // user should never see this exception
      throw new TransformationException(Messages.TemplateInstantiation_TemplateIsNull);
    }

    Package boundPackage = (Package) binding.getBoundElement();
    EList<Namespace> path = TemplateUtils.relativePathWithMerge(namedElement, packageTemplate);
    Template template = UMLUtil.getStereotypeApplication(namedElement, Template.class);
    BindingHelper helper = (template != null) ? template.getHelper() : null;

    /*
    if((templateKind == TemplateKind.ACCUMULATE) || (templateKind == TemplateKind.LATE_EVALUATION)) {
    	// TODO: not very clean yet
    	path = TemplateUtils.relativePathWithMerge(namedElement, copy.source);
    	if(path == null) {
    		// element is imported
    		path = namedElement.allNamespaces();
    	}
    	boundPackage = copy.target; // CreationUtils.getAndCreate
    								// (sat.target, "accumulate");
    }
    */

    if (path != null) {
      // register owning package template (template can be defined in
      // multiple packages)
      Element owner = TemplateUtils.getTemplateOwner(namedElement, signature);
      if (owner != null) {
        // note that we might overwrite an existing value
        copier.put(owner, boundPackage);
      }
    } else {
      // element is not part of the package template referenced by the
      // binding
      if (namedElement instanceof TemplateableElement) {
        // check whether the referenced element is part of another
        // package template,
        // (for which we allow for implicit binding with the first
        // template parameter)
        TemplateSignature signatureOfNE =
            TemplateUtils.getSignature((TemplateableElement) namedElement);
        if ((signatureOfNE != null) && (signature != signatureOfNE)) {
          TemplateBinding subBinding =
              TemplateUtils.getSubBinding(
                  copier.target, (TemplateableElement) namedElement, binding);
          TemplateInstantiation ti = new TemplateInstantiation(copier, subBinding, args);
          NamedElement ret = ti.bindNamedElement(namedElement);
          return (T) ret;
        }
      }

      // => nothing to do with respect to template instantiation, but
      // since the template is potentially instantiated in another model,
      // the referenced element might need to be copied.

      return copier.getCopy(namedElement);
    }
    // element is contained in the template package, examine whether it
    // already exists in the
    // bound package.

    NamedElement existingMember = (NamedElement) copier.get(namedElement);
    /*
    if((existingMember != null) && (templateKind != TemplateKind.ACCUMULATE)) {
    	// element is already existing (and thus bound), nothing to do
    	// additional check, whether the ACCUMULATE information is unset)
    	// however: if the element is a package, existence is not sufficient
    	// since it might have been created via getAndCreate above

    	//if(namedElement instanceof Package) {
    	//	bindPackage((Package)namedElement);
    	//}
    	return (T)existingMember;
    }
    */
    if (existingMember == null) {
      FilterTemplate.getInstance().setActive(false);
      T copiedElement = copier.getCopy(namedElement);
      FilterTemplate.getInstance().setActive(true);
      copier.setPackageTemplate(null, null);
      return copiedElement;
    }

    return (T) existingMember;
  }
 /**
  * Is this property a Service Port
  *
  * @param port
  * @return is this a service port ?
  */
 public static Boolean isServicePort(Port port) {
   ServicePort serviceport = UMLUtil.getStereotypeApplication(port, ServicePort.class);
   return serviceport != null;
 }
 /**
  * Tell if the Abstraction is a Allocate implementation
  *
  * @param Abstraction
  * @return
  * @generated
  */
 protected Boolean isAllocateFromAbstraction(Abstraction abstraction_) {
   if (UMLUtil.getStereotypeApplication(abstraction_, Allocate.class) != null) {
     return true;
   }
   return false;
 }
 /**
  * Tell if the NamedElement is a Allocated implementation
  *
  * @param NamedElement
  * @return
  * @generated
  */
 protected Boolean isAllocatedFromNamedElement(NamedElement namedElement_) {
   if (UMLUtil.getStereotypeApplication(namedElement_, Allocated.class) != null) {
     return true;
   }
   return false;
 }