示例#1
0
  /**
   * Converts a primitive type value, this implementation only converts an EEnum to an Enum value.
   *
   * @param value the value to convert
   * @param eDataType its EDataType
   * @return the converted value
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  protected Object convertEAttributeValue(final Object value, final EDataType eDataType) {
    if (value instanceof Enum<?>) {
      final EDataType enumDataType = getDataTypeOrBaseType(eDataType);
      Check.isInstanceOf(enumDataType, EEnum.class);
      final ModelPackage modelPackage =
          ModelResolver.getInstance().getModelPackage(enumDataType.getEPackage().getNsURI());
      final Class<? extends Enum> enumClass =
          (Class<? extends Enum>) modelPackage.getEClassifierClass(enumDataType);
      return Enum.valueOf(enumClass, ((Enum<?>) value).name().toUpperCase(Locale.ENGLISH));
    } else if (value instanceof EEnumLiteral) {
      final EDataType enumDataType = getDataTypeOrBaseType(eDataType);
      Check.isInstanceOf(enumDataType, EEnum.class);
      final EEnumLiteral eeNumLiteral = (EEnumLiteral) value;
      final ModelPackage modelPackage =
          ModelResolver.getInstance().getModelPackage(enumDataType.getEPackage().getNsURI());
      if (modelPackage == null) {
        // dynamic model
        return eeNumLiteral;
      }
      final Class<? extends Enum> enumClass =
          (Class<? extends Enum>) modelPackage.getEClassifierClass(enumDataType);
      return Enum.valueOf(enumClass, eeNumLiteral.getName().toUpperCase(Locale.ENGLISH));
    }

    // convert these to a Date always
    if (value instanceof XMLGregorianCalendar) {
      final XMLGregorianCalendar xmlCalendar = (XMLGregorianCalendar) value;
      final Date date = xmlCalendar.toGregorianCalendar().getTime();
      return date;
    }

    return value;
  }
示例#2
0
  /**
   * Initializes this {@link ModelPackage}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @return an initialized instance of this class
   * @generated
   */
  public static IncludeModelPackage initialize() {

    if (isInitialized) {
      return (IncludeModelPackage) ModelResolver.getInstance().getModelPackage(NS_URI);
    }

    final IncludeModelPackage modelPackage = new IncludeModelPackage();

    ModelResolver.getInstance().registerModelPackage(modelPackage);

    // read the model from the ecore file, the EPackage is registered in the EPackage.Registry
    // see the ModelResolver getEPackageRegistry method
    ModelUtils.readEPackagesFromFile(modelPackage);

    isInitialized = true;

    IdentifiableModelPackage.initialize();

    // force the initialization of the EFactory proxy
    modelPackage.getEPackage();

    // register the relation between a Class and its EClassifier
    ModelResolver.getInstance()
        .registerClassModelMapping(Include1.class, modelPackage.getInclude1EClass(), modelPackage);
    ModelResolver.getInstance()
        .registerClassModelMapping(Include2.class, modelPackage.getInclude2EClass(), modelPackage);

    DaoRegistry.getInstance().registerDao(Include1.class, Include1Dao.class);
    DaoRegistry.getInstance().registerDao(Include2.class, Include2Dao.class);

    // and return ourselves
    return modelPackage;
  }
示例#3
0
  /**
   * Converts the values of an FeatureMap, the values of the collection are converted to and added
   * to the list in the correct feature in the modelObject.
   *
   * @param eObject the eObject from which the value is read
   * @param modelObject the {@link ModelObject} in which the value is to be set
   * @param eFeature the eFeature which is converted
   */
  protected void convertFeatureMap(
      final EObject eObject, final ModelObject<?> modelObject, final EStructuralFeature eFeature) {
    final Collection<?> eValues = (Collection<?>) eObject.eGet(eFeature);

    @SuppressWarnings("unchecked")
    final Collection<Object> values = (Collection<Object>) modelObject.eGet(eFeature);

    // clear as the object may have been read from the db
    values.clear();

    for (final Object eValue : eValues) {
      final FeatureMap.Entry eEntry = (FeatureMap.Entry) eValue;

      final Object featureMapEntry = ModelResolver.getInstance().createFeatureMapEntry(eFeature);
      final ModelFeatureMapEntry<?> mEntry =
          ModelResolver.getInstance().getModelFeatureMapEntry(eFeature, featureMapEntry);
      mEntry.setEStructuralFeature(eEntry.getEStructuralFeature());

      final Object convertedValue;
      if (mEntry.getEStructuralFeature() instanceof EAttribute) {
        convertedValue =
            convertEAttributeValue(
                eEntry.getValue(),
                ((EAttribute) eEntry.getEStructuralFeature()).getEAttributeType());
      } else {
        convertedValue = createTarget((EObject) eEntry.getValue());
      }

      mEntry.setValue(convertedValue);
      values.add(featureMapEntry);
    }
  }
示例#4
0
  /**
   * Converts the values of an FeatureMap, the values of the collection are converted to and added
   * to the list in the correct feature in the modelObject.
   *
   * @param eObject the eObject from which the value is read
   * @param modelObject the {@link ModelObject} in which the value is to be set
   * @param eFeature the eFeature which is converted
   */
  protected void convertFeatureMap(
      final ModelObject<?> modelObject, final EObject eObject, final EStructuralFeature eFeature) {
    final Collection<?> mValues = (Collection<?>) modelObject.eGet(eFeature);

    @SuppressWarnings("unchecked")
    final Collection<Object> values = (Collection<Object>) eObject.eGet(eFeature);
    for (final Object mValue : mValues) {
      final ModelFeatureMapEntry<?> mEntry =
          ModelResolver.getInstance().getModelFeatureMapEntry(eFeature, mValue);
      EStructuralFeature entryFeature = mEntry.getEStructuralFeature();
      Object entryValue = mEntry.getValue();

      // flatten the tree of feature map entries, feature maps maybe nested
      // EMF uses a flattened api, while Texo builds this actual tree of
      // featuremaps, the findFeature and findValue find the deepest featureMap entry
      if (FeatureMapUtil.isFeatureMap(entryFeature)) {
        final ModelFeatureMapEntry<?> modelFeatureMapEntry =
            ModelResolver.getInstance().getModelFeatureMapEntry(entryFeature, entryValue);
        entryFeature = ModelUtils.findFeature(modelFeatureMapEntry);
        entryValue = ModelUtils.findValue(modelFeatureMapEntry);
      }

      final Object convertedValue;
      if (entryFeature instanceof EAttribute) {
        convertedValue =
            convertEAttributeValue(entryValue, ((EAttribute) entryFeature).getEAttributeType());
      } else {
        convertedValue = createTarget(entryValue);
      }
      final FeatureMap.Entry eEntry = FeatureMapUtil.createEntry(entryFeature, convertedValue);
      values.add(eEntry);
    }
  }
示例#5
0
 public void repair() {
   final Object target = objectMapping.get(owner);
   final ModelObject<?> modelObject = ModelResolver.getInstance().getModelObject(target);
   final Object listObject = modelObject.eGet(eReference);
   if (!(listObject instanceof List<?>)) {
     // no order maintained anyway
     return;
   }
   final EList<?> eList = (EList<?>) owner.eGet(eReference);
   @SuppressWarnings("unchecked")
   final List<Object> list = (List<Object>) listObject;
   int correctIndex = 0;
   for (Object objectElement : eList) {
     final EObject eObjectElement = (EObject) objectElement;
     final Object element = objectMapping.get(eObjectElement);
     final int newIndex = list.indexOf(element);
     if (newIndex != correctIndex) {
       try {
         list.remove(element);
         list.add(correctIndex, element);
       } catch (UnsupportedOperationException ignore) {
         // unmodifiable collection, can't handle those, go away
         return;
       }
     }
     correctIndex++;
   }
 }
示例#6
0
 protected String getObjectUrlPart(Object object) {
   final Identifiable identifiable = (Identifiable) object;
   final ModelObject<?> valueModelObject = ModelResolver.getInstance().getModelObject(object);
   return ModelUtils.getQualifiedNameFromEClass(valueModelObject.eClass())
       + "/"
       + identifiable.getDb_Id(); // $NON-NLS-1$
 }
示例#7
0
 private ModelObject<?> getModelObject(Object target) {
   if (target == lastObject) {
     return lastModelObject;
   }
   lastObject = target;
   lastModelObject = ModelResolver.getInstance().getModelObject(target);
   return lastModelObject;
 }
  /**
   * Initializes this {@link ModelPackage}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @return an initialized instance of this class
   * @generated
   */
  public static ListunionModelPackage initialize() {

    if (isInitialized) {
      return (ListunionModelPackage) ModelResolver.getInstance().getModelPackage(NS_URI);
    }

    final ListunionModelPackage modelPackage = new ListunionModelPackage();

    ModelResolver.getInstance().registerModelPackage(modelPackage);

    // read the model from the ecore file, the EPackage is registered in the EPackage.Registry
    // see the ModelResolver getEPackageRegistry method
    ModelUtils.readEPackagesFromFile(modelPackage);

    isInitialized = true;

    IdentifiableModelPackage.initialize();

    // force the initialization of the EFactory proxy
    modelPackage.getEPackage();

    // register the relation between a Class and its EClassifier
    ModelResolver.getInstance()
        .registerClassModelMapping(
            StatesByCountry.class, modelPackage.getStatesByCountryEClass(), modelPackage);

    ModelResolver.getInstance()
        .registerClassModelMapping(
            SimpleUnionTypeMember1.class,
            modelPackage.getSimpleUnionTypeMember1EEnum(),
            modelPackage);

    DaoRegistry.getInstance().registerDao(StatesByCountry.class, StatesByCountryDao.class);

    // and return ourselves
    return modelPackage;
  }
示例#9
0
  protected void convertContent(EObject eObject) {
    final Object target = objectMapping.get(eObject);

    final ModelObject<?> modelObject = ModelResolver.getInstance().getModelObject(target);
    for (final EStructuralFeature eStructuralFeature :
        modelObject.eClass().getEAllStructuralFeatures()) {
      if (!eStructuralFeature.isChangeable() || eStructuralFeature.isVolatile()) {
        continue;
      }

      // not set, not convert
      if (!eStructuralFeature.isMany() && !eObject.eIsSet(eStructuralFeature)) {
        continue;
      }

      if (FeatureMapUtil.isFeatureMap(eStructuralFeature)) {
        convertFeatureMap(eObject, modelObject, eStructuralFeature);
      } else if (eStructuralFeature.isMany()) {
        if (eStructuralFeature instanceof EAttribute) {
          final EAttribute eAttribute = (EAttribute) eStructuralFeature;
          convertManyEAttribute(eObject, modelObject, eAttribute);
        } else {
          final EReference eReference = (EReference) eStructuralFeature;
          if (eReference.isContainer()) {
            continue;
          }
          convertManyEReference(eObject, modelObject, eReference);
        }
      } else {
        if (eStructuralFeature instanceof EAttribute) {
          final EAttribute eAttribute = (EAttribute) eStructuralFeature;
          convertSingleEAttribute(eObject, modelObject, eAttribute);
        } else {
          final EReference eReference = (EReference) eStructuralFeature;
          if (eReference.isContainer()) {
            continue;
          }
          convertSingleEReference(eObject, modelObject, eReference);
        }
      }
    }
  }
示例#10
0
 public void repair() {
   final EObject eObjectOwner = objectMapping.get(owner.getTarget());
   final ModelObject<?> modelObjectOwner = ModelResolver.getInstance().getModelObject(owner);
   final Object listObject = modelObjectOwner.eGet(eReference);
   if (!(listObject instanceof List<?>)) {
     // no order maintained anyway
     return;
   }
   final EList<?> eList = (EList<?>) eObjectOwner.eGet(eReference);
   final List<?> list = (List<?>) listObject;
   int currentIndex = 0;
   for (Object objectElement : list) {
     final EObject eObjectElement = objectMapping.get(objectElement);
     final int newIndex = eList.indexOf(eObjectElement);
     if (newIndex != currentIndex) {
       eList.move(currentIndex, newIndex);
     }
     currentIndex++;
   }
 }
示例#11
0
  protected void convertContent(Object target) {
    // if a proxy then do no feature conversions as this may load
    // the object
    InternalEObject eObject = objectMapping.get(target);
    final ModelObject<?> modelObject = ModelResolver.getInstance().getModelObject(target);
    if (getProxyObjects().contains(target)) {
      final URI proxyURI = getProxyId(modelObject);
      if (proxyURI != null) {
        eObject.eSetProxyURI(proxyURI);
      }
      return;
    }

    for (final EStructuralFeature eStructuralFeature :
        eObject.eClass().getEAllStructuralFeatures()) {
      if (!eStructuralFeature.isChangeable() || eStructuralFeature.isVolatile()) {
        continue;
      }

      if (FeatureMapUtil.isFeatureMap(eStructuralFeature)) {
        convertFeatureMap(modelObject, eObject, eStructuralFeature);
      } else if (eStructuralFeature.isMany()) {
        if (eStructuralFeature instanceof EAttribute) {
          final EAttribute eAttribute = (EAttribute) eStructuralFeature;
          convertManyEAttribute(modelObject, eObject, eAttribute);
        } else {
          final EReference eReference = (EReference) eStructuralFeature;
          convertManyEReference(modelObject, eObject, eReference);
        }
      } else {
        if (eStructuralFeature instanceof EAttribute) {
          final EAttribute eAttribute = (EAttribute) eStructuralFeature;
          convertSingleEAttribute(modelObject, eObject, eAttribute);
        } else {
          final EReference eReference = (EReference) eStructuralFeature;
          convertSingleEReference(modelObject, eObject, eReference);
        }
      }
    }
  }
示例#12
0
  /**
   * Initializes this {@link ModelPackage}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @return an initialized instance of this class
   * @generated
   */
  public static AnytypeModelPackage initialize() {

    if (isInitialized) {
      return (AnytypeModelPackage) ModelResolver.getInstance().getModelPackage(NS_URI);
    }

    final AnytypeModelPackage modelPackage = new AnytypeModelPackage();

    ModelResolver.getInstance().registerModelPackage(modelPackage);

    // read the model from the ecore file, the EPackage is registered in the EPackage.Registry
    // see the ModelResolver getEPackageRegistry method
    ModelUtils.readEPackagesFromFile(modelPackage);

    isInitialized = true;

    IdentifiableModelPackage.initialize();

    // force the initialization of the EFactory proxy
    modelPackage.getEPackage();

    // register the relation between a Class and its EClassifier
    ModelResolver.getInstance()
        .registerClassModelMapping(A.class, modelPackage.getAEClass(), modelPackage);
    ModelResolver.getInstance()
        .registerClassModelMapping(B.class, modelPackage.getBEClass(), modelPackage);
    ModelResolver.getInstance()
        .registerClassModelMapping(C.class, modelPackage.getCEClass(), modelPackage);
    ModelResolver.getInstance()
        .registerClassModelMapping(TestAny.class, modelPackage.getTestAnyEClass(), modelPackage);

    DaoRegistry.getInstance().registerDao(A.class, ADao.class);
    DaoRegistry.getInstance().registerDao(B.class, BDao.class);
    DaoRegistry.getInstance().registerDao(C.class, CDao.class);
    DaoRegistry.getInstance().registerDao(TestAny.class, TestAnyDao.class);

    // and return ourselves
    return modelPackage;
  }
示例#13
0
  /**
   * Converts the value of an EReference with isMany==true, the values of the collection are
   * converted to Objects and added to the list in the correct feature in the {@link ModelObject}.
   *
   * @param eObject the eObject from which the value is read
   * @param modelObject the Object in which the value is set
   * @param eReference the eReference which is converted
   */
  protected void convertManyEReference(
      final EObject eObject, final ModelObject<?> modelObject, final EReference eReference) {
    @SuppressWarnings("unchecked")
    final Collection<EObject> eValues = (Collection<EObject>) eObject.eGet(eReference);
    if (ModelUtils.isEMap(eReference)) {
      @SuppressWarnings("unchecked")
      final Map<Object, Object> mValues = (Map<Object, Object>) modelObject.eGet(eReference);

      // clear as there can be current values if the target is read from the db
      mValues.clear();

      for (final Object eValue : eValues) {
        @SuppressWarnings("unchecked")
        final Map.Entry<Object, Object> entry = (Map.Entry<Object, Object>) eValue;
        // key and value can also be an EObject
        final Object key;
        if (entry.getKey() instanceof EObject) {
          key = createTarget((EObject) entry.getKey());
        } else {
          key = entry.getKey();
        }
        final Object value;
        if (entry.getValue() instanceof EObject) {
          value = createTarget((EObject) entry.getValue());
        } else {
          value = entry.getValue();
        }

        mValues.put(key, value);
      }
    } else {

      // a many to many
      if (eReference.getEOpposite() != null && eReference.getEOpposite().isMany()) {
        final ManyToMany mtm = new ManyToMany();
        mtm.setOwner(eObject);
        mtm.setEReference(eReference);
        toRepairManyToMany.add(mtm);
      }

      final Collection<?> mValues = (Collection<?>) modelObject.eGet(eReference);

      // make a copy
      final List<Object> copiedMValues = new ArrayList<Object>(mValues);

      // clear as there can be current values if the target is read from the db
      // use forloop as the collection can be unmodifiable
      for (Object o : new ArrayList<Object>(mValues)) {
        modelObject.eRemoveFrom(eReference, o);
      }

      // check that the eopposite is indeed cleared, this is not the case if
      // there is no bi-directional code generated
      final EReference eOpposite = eReference.getEOpposite();
      if (eOpposite != null && !eOpposite.isMany()) {
        for (Object mValue : copiedMValues) {
          final ModelObject<?> modelMValue = ModelResolver.getInstance().getModelObject(mValue);
          modelMValue.eSet(eOpposite, null);
        }
      }

      for (final EObject eValue : eValues) {
        final Object target = createTarget(eValue);
        // first add to the many reference
        modelObject.eAddTo(eReference, target);

        // add to the other side, this is needed because the bi-directional
        // api is not always generated
        if (eOpposite != null && !eOpposite.isMany()) {
          final ModelObject<?> modelObjectTarget =
              ModelResolver.getInstance().getModelObject(target);
          modelObjectTarget.eSet(eReference.getEOpposite(), modelObject.getTarget());
        }
      }
    }
  }
示例#14
0
  @Test
  public void testRetrievalAndDelete() {
    final Library lib = createTestData();

    // children
    final Writer w = lib.getWriters().get(0);
    final Book bk = lib.getBooks().get(0);

    // get model information
    if (!isXmlTest()) {
      {
        final String content =
            doGetRequest("model/epackage?id=library", null, HttpServletResponse.SC_OK);
        final List<Object> objects = deserialize(content);
        Assert.assertEquals(1, objects.size());
        Assert.assertTrue(objects.get(0) instanceof DynamicModelObject);
        final DynamicModelObject dmo = (DynamicModelObject) objects.get(0);
        Assert.assertTrue(dmo.eClass() == EcorePackage.eINSTANCE.getEPackage());
        Assert.assertEquals("library", dmo.eGet(EcorePackage.eINSTANCE.getENamedElement_Name()));
        Assert.assertEquals(
            LibraryModelPackage.NS_URI, dmo.eGet(EcorePackage.eINSTANCE.getEPackage_NsURI()));
      }

      {
        final String content =
            doGetRequest(
                "model/epackage?id=" + LibraryModelPackage.NS_URI, null, HttpServletResponse.SC_OK);
        final List<Object> objects = deserialize(content);
        Assert.assertEquals(1, objects.size());
        Assert.assertTrue(objects.get(0) instanceof DynamicModelObject);
        final DynamicModelObject dmo = (DynamicModelObject) objects.get(0);
        Assert.assertTrue(dmo.eClass() == EcorePackage.eINSTANCE.getEPackage());
        Assert.assertEquals("library", dmo.eGet(EcorePackage.eINSTANCE.getENamedElement_Name()));
        Assert.assertEquals(
            LibraryModelPackage.NS_URI, dmo.eGet(EcorePackage.eINSTANCE.getEPackage_NsURI()));
      }

      {
        final String content =
            doGetRequest(
                "model/eclass?name=Book&epackage=" + LibraryModelPackage.NS_URI,
                null,
                HttpServletResponse.SC_OK);
        final List<Object> objects = deserialize(content);
        Assert.assertEquals(1, objects.size());
        Assert.assertTrue(objects.get(0) instanceof DynamicModelObject);
        final DynamicModelObject dmo = (DynamicModelObject) objects.get(0);
        Assert.assertTrue(dmo.eClass() == EcorePackage.eINSTANCE.getEClass());
        Assert.assertEquals("Book", dmo.eGet(EcorePackage.eINSTANCE.getENamedElement_Name()));
      }

      {
        final String content =
            doGetRequest(
                "model/eclassifier?name=BookCategory&epackage=" + LibraryModelPackage.NS_URI,
                null,
                HttpServletResponse.SC_OK);
        final List<Object> objects = deserialize(content);
        Assert.assertEquals(1, objects.size());
        Assert.assertTrue(objects.get(0) instanceof DynamicModelObject);
        final DynamicModelObject dmo = (DynamicModelObject) objects.get(0);
        Assert.assertTrue(dmo.eClass() == EcorePackage.eINSTANCE.getEEnum());
        Assert.assertEquals(
            "BookCategory", dmo.eGet(EcorePackage.eINSTANCE.getENamedElement_Name()));
      }
    }
    // get all libraries
    {
      final String content =
          doGetRequest(
              LibraryModelPackage.INSTANCE.getLibraryEClass().getName(),
              null,
              HttpServletResponse.SC_OK);
      final List<Object> objects = deserialize(content);
      Assert.assertEquals(1, objects.size());
      final ResponseType responseType = (ResponseType) objects.get(0);
      final Library libResult = (Library) responseType.getData().get(0);
      Assert.assertNotSame(lib, libResult);
      Assert.assertEquals(lib.getDb_Id(), libResult.getDb_Id());
    }

    // get one library, and call its content
    {
      String content = getOneObject(lib);
      getValidateOneObject(lib);

      System.err.println(content);
      // and all its content
      final ModelObject<?> modelObject = ModelResolver.getInstance().getModelObject(lib);
      for (EReference eReference : modelObject.eClass().getEAllReferences()) {
        final Object value = modelObject.eGet(eReference);
        if (value == null) {
          continue;
        }
        if (eReference.isMany()) {
          for (Object element : (List<?>) value) {
            if (element instanceof Identifiable) {
              getValidateOneObject(element);
            }
          }
        } else {
          if (value instanceof Identifiable) {
            getValidateOneObject(value);
          }
        }
      }
    }

    // now delete the library
    doDeleteRequest(
        LibraryModelPackage.INSTANCE.getLibraryEClass().getName() + "/" + lib.getDb_Id(),
        HttpServletResponse.SC_OK); // $NON-NLS-1$
    // this should fail
    {
      final String content =
          doGetRequest(
              LibraryModelPackage.INSTANCE.getLibraryEClass().getName() + "/" + lib.getDb_Id(),
              null,
              HttpServletResponse.SC_NOT_FOUND); // $NON-NLS-1$
      final List<Object> objects = deserialize(content);
      Assert.assertEquals(1, objects.size());
      final ErrorType errorType = (ErrorType) objects.get(0);
      Assert.assertTrue(errorType.getMessage().contains("Resource not found")); // $NON-NLS-1$
    }

    // children are removed
    checkExists(w, false);
    checkExists(bk, false);
  }
示例#15
0
 @Override
 protected boolean isModelEnabled(Object target) {
   return ModelResolver.getInstance().isModelEnabled(target);
 }