Example #1
0
  @Before
  public void before() {
    ePackage = FACTORY.createEPackage();
    ePackage.setName("Package");

    eClass0 = FACTORY.createEClass();
    eClass0.setName("EClass0");
    ePackage.getEClassifiers().add(eClass0);

    eClass1 = FACTORY.createEClass();
    eClass1.setName("EClass1");
    ePackage.getEClassifiers().add(eClass1);

    singleRef = FACTORY.createEReference();
    singleRef.setName("singleRef");
    singleRef.setUpperBound(1);
    singleRef.setEType(eClass1);
    singleRef.setContainment(true);
    eClass0.getEStructuralFeatures().add(singleRef);

    multiRef = FACTORY.createEReference();
    multiRef.setName("multiRef");
    multiRef.setUpperBound(-1);
    multiRef.setEType(eClass0);
    multiRef.setContainment(true);
    eClass1.getEStructuralFeatures().add(multiRef);
  }
  private EPackage createDynamicEPackage() {
    final EcoreFactory efactory = EcoreFactory.eINSTANCE;
    final EcorePackage epackage = EcorePackage.eINSTANCE;

    // Create a new EPackage and add the new EClasses
    EPackage topPackage = efactory.createEPackage();
    topPackage.setName("toppackage");
    topPackage.setNsPrefix("toppackage");
    topPackage.setNsURI("http:///www.elver.org/toppackage");

    EPackage subPackage1 = efactory.createEPackage();
    subPackage1.setName("subPackage1");
    subPackage1.setNsPrefix("subPackage1");
    subPackage1.setNsURI("http:///www.elver.org/subPackage1");

    {
      EClass schoolBookEClass = efactory.createEClass();
      schoolBookEClass.setName("class1");
      // create a new attribute for this EClass
      EAttribute level = efactory.createEAttribute();
      level.setName("level");
      level.setEType(epackage.getEInt());
      schoolBookEClass.getEStructuralFeatures().add(level);
      subPackage1.getEClassifiers().add(schoolBookEClass);
    }

    {
      EEnum schoolBookEClass = efactory.createEEnum();
      schoolBookEClass.setName("enum");
      subPackage1.getEClassifiers().add(schoolBookEClass);
    }

    {
      EClass schoolBookEClass = efactory.createEClass();
      schoolBookEClass.setName("class2");
      // create a new attribute for this EClass
      subPackage1.getEClassifiers().add(schoolBookEClass);
    }

    {
      EClass schoolBookEClass = efactory.createEClass();
      schoolBookEClass.setName("class3");
      // create a new attribute for this EClass
      EAttribute level = efactory.createEAttribute();
      level.setName("level");
      level.setEType(epackage.getEInt());
      schoolBookEClass.getEStructuralFeatures().add(level);
      subPackage1.getEClassifiers().add(schoolBookEClass);
    }

    EPackage subPackage2 = efactory.createEPackage();
    subPackage2.setName("subPackage2");
    subPackage2.setNsPrefix("subPackage2");
    subPackage2.setNsURI("http:///www.elver.org/subPackage2");

    topPackage.getESubpackages().add(subPackage1);
    return topPackage;
  }
Example #3
0
 /**
  * Collecting all properties from a EMF object, if contansReferences is TRUE, all features should
  * be contained, otherwise, only EAttrubutes will be returned.
  */
 public static List<EStructuralFeature> collectProperties(
     EClass eClass,
     boolean containsSupers,
     boolean containsReferences,
     boolean containsUnsettables) {
   if (eClass == null) {
     return Collections.emptyList();
   }
   List<EStructuralFeature> properties = new ArrayList<EStructuralFeature>();
   List<EStructuralFeature> features = null;
   if (containsReferences) {
     features = eClass.getEStructuralFeatures();
   } else {
     features = new ArrayList<EStructuralFeature>(eClass.getEAttributes());
   }
   for (EStructuralFeature sf : features) {
     try {
       if (containsUnsettables || eClass.eIsSet(sf)) {
         properties.add(sf);
       }
     } catch (Exception e) {
     }
   }
   if (containsSupers) {
     EList<EClass> eSuperTypes = eClass.getESuperTypes();
     for (EClass eSuperClass : eSuperTypes) {
       properties.addAll(
           collectProperties(
               eSuperClass, containsSupers, containsReferences, containsUnsettables));
     }
   }
   return properties;
 }
Example #4
0
  /**
   * Dynamically create an {@link EObject} with a collection called <code>children</code> which
   * contains the given elements.
   *
   * @param collection The initial filling of the collection.
   * @return An {@link EObject} which just has a containment list (named <code>children</code>) of
   *     type {@link EObject}.
   */
  @SuppressWarnings("unchecked")
  public static EObject wrapInGenericContainer(Collection<? extends EObject> collection) {

    // create the wrapper containment reference
    final EReference children = EcoreFactory.eINSTANCE.createEReference();
    children.setName("children");
    children.setLowerBound(0);
    children.setUpperBound(ETypedElement.UNBOUNDED_MULTIPLICITY);
    children.setContainment(true);
    children.setEType(EcorePackage.Literals.EOBJECT);

    // create the wrapper class
    final EClass containerClass = EcoreFactory.eINSTANCE.createEClass();
    containerClass.setName("GenericEContainer");
    containerClass.getEStructuralFeatures().add(children);

    // create a package for our wrapper class
    final EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
    ePackage.setName("dynamic");
    ePackage.setNsPrefix("dynamic");
    ePackage.setNsURI("http://www.example.org/dynamic");
    ePackage.getEClassifiers().add(containerClass);

    // validate what we just created
    if (Diagnostician.INSTANCE.validate(ePackage).getCode() == Diagnostic.OK) {

      // instantiate our class, fill the children and return it
      final EObject container = ePackage.getEFactoryInstance().create(containerClass);
      ((EList<EObject>) container.eGet(children)).addAll(collection);
      return container;
    } else {
      throw new UnknownError(
          "Dynamic EMF wrapper model creation failed for whatever reason. Developer, please debug better!");
    }
  }
  @Override
  public EClass eClass() {
    if (eClass == null) {
      ePackage = EcoreFactory.eINSTANCE.createEPackage();
      eClass = EcoreFactory.eINSTANCE.createEClass();
      ePackage.getEClassifiers().add(eClass);

      eClass.setName("StringWrapper"); // $NON-NLS-1$
      eClass.getESuperTypes().add(XMLTypePackage.eINSTANCE.getAnyType());
      ExtendedMetaData.INSTANCE.setName(eClass, ""); // $NON-NLS-1$
      eClass.setInstanceClass(AnyType.class);

      EAttribute eAttribute = EcoreFactory.eINSTANCE.createEAttribute();
      eAttribute.setName("value"); // $NON-NLS-1$
      eAttribute.setChangeable(true);
      eAttribute.setUnsettable(true);
      eAttribute.setEType(EcorePackage.eINSTANCE.getEClassifier("EString")); // $NON-NLS-1$
      eClass.getEStructuralFeatures().add(eAttribute);

      //			ExtendedMetaData.INSTANCE.setNamespace(eAttribute, ePackage.getNsURI());
      ExtendedMetaData.INSTANCE.setFeatureKind(eAttribute, ExtendedMetaData.ATTRIBUTE_FEATURE);
      ExtendedMetaData.INSTANCE.setName(eAttribute, "value"); // $NON-NLS-1$
    }
    return eClass;
  }
 private void addReference(EClass eClass, String name, EClassifier eType, boolean containment) {
   EReference placesReference = EcoreFactory.eINSTANCE.createEReference();
   placesReference.setName(name);
   placesReference.setLowerBound(0);
   placesReference.setUpperBound(-1);
   placesReference.setEType(eType);
   placesReference.setContainment(containment);
   eClass.getEStructuralFeatures().add(placesReference);
 }
 private void addOutgoingReference(EClass eClass) {
   EReference outgoingReference = EcoreFactory.eINSTANCE.createEReference();
   outgoingReference.setName(OUTGOING);
   outgoingReference.setLowerBound(0);
   outgoingReference.setUpperBound(-1);
   outgoingReference.setEType(getPlaceClass());
   outgoingReference.setContainment(false);
   eClass.getEStructuralFeatures().add(outgoingReference);
 }
 protected void handleEClassifier(
     EClassifier classifier, Set<EPackage> visitedPackages, Set<Object> visited) {
   if (classifier != null && visited.add(classifier)) {
     handleEPackage(classifier.getEPackage(), visitedPackages);
     handleETypeParameters(classifier.getETypeParameters(), visitedPackages, visited);
     if (classifier instanceof EClass) {
       EClass eClass = (EClass) classifier;
       handleEStructuralFeatures(eClass.getEStructuralFeatures(), visitedPackages, visited);
       handleEOperations(eClass.getEOperations(), visitedPackages, visited);
       handleEGenericTypes(eClass.getEGenericSuperTypes(), visitedPackages, visited);
     }
   }
 }
 public void testErrorMessage_04() {
   EClass eClass = createEClass();
   eClass.setName("EClassName");
   EAttribute attribute = EcoreFactory.eINSTANCE.createEAttribute();
   attribute.setName("Attribute");
   eClass.getEStructuralFeatures().add(attribute);
   IEObjectDescription description =
       EObjectDescription.create(QualifiedName.create(attribute.getName()), attribute);
   String errorMessage =
       helper.getDuplicateNameErrorMessage(
           description,
           EcorePackage.Literals.EATTRIBUTE,
           EcorePackage.Literals.ENAMED_ELEMENT__NAME);
   assertEquals("Duplicate EAttribute 'Attribute' in EClass 'EClassName'", errorMessage);
 }
  @Override
  public Object caseEClass(EClass object) {
    Type type = getType(object);

    if (object.isInterface()) {
    } else { // class
      Class clazz = (Class) type;
      clazz.setAbstract(object.isAbstract());
    }

    Set<Type> assocAndGen = new HashSet<>();
    Set<Type> dependencies = new HashSet<>();

    for (EClass eSuperType : object.getESuperTypes()) {
      Type superType = getType(eSuperType);
      assocAndGen.add(superType);

      if (eSuperType.isInterface()) {
        type.addInterface((Interface) superType);
      } else {
        type.addSuperClass((Class) superType);
      }
    }

    for (EStructuralFeature eFeature : object.getEStructuralFeatures()) {
      Attribute attr = (Attribute) doSwitch(eFeature);
      type.addAttribute(attr);

      assocAndGen.add(attr.type);
    }
    for (EOperation eOperation : object.getEOperations()) {
      Operation op = (Operation) doSwitch(eOperation);
      type.addOperation(op);

      dependencies.add(op.type);
      for (TypedElement fpar : op.formalParameters()) {
        dependencies.add(fpar.type);
      }
    }
    dependencies.removeAll(assocAndGen);
    for (Type dep : dependencies) {
      type.addDependency(dep);
    }

    return type;
  }
Example #11
0
 @Test
 public void cast() {
   final EClassifier[] types =
       new EClassifier[] {
         EcorePackage.eINSTANCE.getEInt(),
         EcorePackage.eINSTANCE.getEFloat(),
         EcorePackage.eINSTANCE.getEDouble()
       };
   final Object[] values = new Object[] {1, 1F, 1D};
   for (int i = 0; i < types.length; i++) {
     EClassifier classifier = types[i];
     EAttribute attribute = FACTORY.createEAttribute();
     attribute.setEType(classifier);
     eClass0.getEStructuralFeatures().add(attribute);
     assertEquals(values[i], EMFUtils.cast(values[(i + 1) % values.length], attribute));
   }
 }
Example #12
0
  /** @return an new object which is instance of <code>factoryChildClass</code>. */
  public EObject createFactoryChildObject() {
    String superType = ModelUtil.getSuperType(factoryChildClass);
    IProject project = (IProject) this.getPage().getEditor().getAdapter(IProject.class);
    String result =
        DialogUtil.openClassDialog(
            getSection().getShell(),
            project,
            superType,
            IJavaElementSearchConstants.CONSIDER_ALL_TYPES);

    if (result != null) {
      EObject component = FacesConfigFactory.eINSTANCE.create(factoryChildClass);
      // set the text content value.
      EStructuralFeature feature = factoryChildClass.getEStructuralFeatures().get(0);
      component.eSet(feature, result);
      return component;
    }
    return null;
  }
  public EPackage createPackage() {
    EcoreFactory theCoreFactory = EcoreFactory.eINSTANCE;
    EcorePackage theCorePackage = EcorePackage.eINSTANCE;

    mapContainerEClass = theCoreFactory.createEClass();
    mapContainerEClass.setName("MapContainer");

    EPackage dynamicMapEPackage = createUniquePackage();
    dynamicMapEPackage.getEClassifiers().add(mapContainerEClass);

    EStructuralFeature name = theCoreFactory.createEAttribute();
    name.setName("name");
    name.setEType(theCorePackage.getEString());

    mapContainerEClass.getEStructuralFeatures().add(name);

    if (!isConfig(LEGACY)) {
      CDOUtil.prepareDynamicEPackage(dynamicMapEPackage);
    }

    return dynamicMapEPackage;
  }
Example #14
0
  public void testGetAllReferencedObjects() {
    EClass a = createEClass("a");
    EClass b = createEClass("b");

    EPackage pack = EcoreFactory.eINSTANCE.createEPackage();
    pack.setName("empty");
    pack.setNsPrefix("empty");
    pack.setNsURI("empty");
    pack.getEClassifiers().add(a);
    pack.getEClassifiers().add(b);

    EReference ref = EcoreFactory.eINSTANCE.createEReference();
    a.getEStructuralFeatures().add(ref);
    ref.setUpperBound(1);
    ref.setEType(b);
    EObject objA = pack.getEFactoryInstance().create(a);
    EObject objB = pack.getEFactoryInstance().create(b);
    List<EObject> res = EcoreUtil2.getAllReferencedObjects(objA, ref);
    assertNotNull(res);
    assertTrue(res.isEmpty());
    res = EcoreUtil2.getAllReferencedObjects(objA, ref);
    assertNotNull(res);
    objA.eSet(ref, objB);
  }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getState_Name() {
   return (EAttribute) stateEClass.getEStructuralFeatures().get(0);
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EReference getDevice_States() {
   return (EReference) deviceEClass.getEStructuralFeatures().get(1);
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getDevice_Name() {
   return (EAttribute) deviceEClass.getEStructuralFeatures().get(0);
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EReference getModel_Declarations() {
   return (EReference) modelEClass.getEStructuralFeatures().get(0);
 }
Example #19
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getField_Upper() {
   return (EAttribute) fieldEClass.getEStructuralFeatures().get(5);
 }
Example #20
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getField_UpperUnlimited() {
   return (EAttribute) fieldEClass.getEStructuralFeatures().get(4);
 }
Example #21
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getField_Description() {
   return (EAttribute) fieldEClass.getEStructuralFeatures().get(2);
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getRule_Description() {
   return (EAttribute) ruleEClass.getEStructuralFeatures().get(0);
 }
Example #23
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getXFunctionTypeRef_InstanceContext() {
   return (EAttribute) xFunctionTypeRefEClass.getEStructuralFeatures().get(3);
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EReference getRule_ThenPart() {
   return (EReference) ruleEClass.getEStructuralFeatures().get(2);
 }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EReference getRule_DeviceState() {
   return (EReference) ruleEClass.getEStructuralFeatures().get(1);
 }
Example #26
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EReference getField_Type() {
   return (EReference) fieldEClass.getEStructuralFeatures().get(1);
 }
Example #27
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EReference getXFunctionTypeRef_Type() {
   return (EReference) xFunctionTypeRefEClass.getEStructuralFeatures().get(2);
 }
Example #28
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EReference getEntity_Fields() {
   return (EReference) entityEClass.getEStructuralFeatures().get(0);
 }
Example #29
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getXComputedTypeReference_TypeProvider() {
   return (EAttribute) xComputedTypeReferenceEClass.getEStructuralFeatures().get(0);
 }
Example #30
0
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 public EAttribute getField_Name() {
   return (EAttribute) fieldEClass.getEStructuralFeatures().get(0);
 }