@Override
 public @Nullable Object evaluate(
     @NonNull Executor executor, @NonNull TypeId returnTypeId, @Nullable Object sourceValue) {
   IdResolver idResolver = executor.getIdResolver();
   Property oppositeProperty = idResolver.getProperty(oppositePropertyId);
   ModelManager.ModelManagerExtension modelManager =
       (ModelManager.ModelManagerExtension) executor.getModelManager();
   Type thatType = ClassUtil.nonNullModel(oppositeProperty.getType());
   if (thatType instanceof CollectionType) {
     thatType = ((CollectionType) thatType).getElementType();
   }
   List<Object> results = new ArrayList<Object>();
   if (thatType instanceof org.eclipse.ocl.pivot.Class) {
     for (@NonNull
     Object eObject :
         modelManager.get((org.eclipse.ocl.pivot.Class) thatType)) { // FIXME Use a cache
       EClass eClass = modelManager.eClass(eObject);
       EStructuralFeature eFeature = eClass.getEStructuralFeature(oppositeProperty.getName());
       assert eFeature != null;
       Object eGet = modelManager.eGet(eObject, eFeature);
       if (eGet == sourceValue) {
         results.add(eObject);
       }
     }
   }
   return results;
 }
Example #2
0
 public @NonNull Model importObjects(
     @NonNull Collection<EObject> ecoreContents, @NonNull URI pivotURI) {
   EPackage libraryEPackage = isLibrary(ecoreContents);
   if (libraryEPackage != null) {
     newCreateMap = new HashMap<@NonNull EObject, @NonNull Element>();
     org.eclipse.ocl.pivot.Package asLibrary = standardLibrary.getPackage();
     newCreateMap.put(libraryEPackage, asLibrary);
     List<org.eclipse.ocl.pivot.Class> ownedType = asLibrary.getOwnedClasses();
     //			int prefix = LibraryConstants.ECORE_STDLIB_PREFIX.length();
     for (@SuppressWarnings("null") @NonNull
     EClassifier eClassifier : libraryEPackage.getEClassifiers()) {
       String name =
           environmentFactory.getTechnology().getOriginalName(eClassifier); // .substring(prefix);
       Type asType = NameUtil.getNameable(ownedType, name);
       if (asType != null) {
         newCreateMap.put(eClassifier, asType);
       }
     }
     Model containingRoot = PivotUtil.getContainingModel(asLibrary);
     return ClassUtil.nonNullModel(containingRoot);
   }
   @NonNull
   ASResource asResource = metamodelManager.getResource(pivotURI, ASResource.ECORE_CONTENT_TYPE);
   //		try {
   if ((metamodelManager.getLibraryResource() == null) && isPivot(ecoreContents)) {
     String nsURI = ((EPackage) ecoreContents.iterator().next()).getNsURI();
     if (nsURI != null) {
       String stdlibASUri = LibraryConstants.STDLIB_URI + PivotConstants.DOT_OCL_AS_FILE_EXTENSION;
       OCLstdlib library = OCLstdlib.create(stdlibASUri);
       metamodelManager.installResource(library);
       //					metamodelManager.installAs(nsURI, OCLstdlibTables.PACKAGE);
     }
   }
   URI uri = ecoreURI != null ? ecoreURI : ecoreResource.getURI();
   Model pivotModel2 = null;
   if (asResource.getContents().size() > 0) {
     EObject eObject = asResource.getContents().get(0);
     if (eObject instanceof Model) {
       pivotModel2 = (Model) eObject;
     }
   }
   if (pivotModel2 == null) {
     pivotModel2 = pivotModel = PivotUtil.createModel(uri.toString());
   }
   pivotModel = pivotModel2;
   //			installImports();
   update(asResource, ecoreContents);
   //		}
   //		catch (Exception e) {
   //			if (errors == null) {
   //				errors = new ArrayList<Resource.Diagnostic>();
   //			}
   //			errors.add(new XMIException("Failed to load '" + pivotURI + "'", e));
   //		}
   List<Diagnostic> errors2 = errors;
   if (errors2 != null) {
     asResource.getErrors().addAll(ClassUtil.nullFree(errors2));
   }
   return pivotModel2;
 }
 /**
  * Executes the query for the specified <tt>target</tt> object. The result is the OCL evaluation
  * result which may be a Number, String, Collection or other object for normal returns or a
  * NullLiteralExp for null, or an InvalidLiteralExp for invalid.
  *
  * @param target the object on which to execute the query; this must be an instance of the context
  *     with which the delegate was created
  * @param arguments a map of variable names to values; these must correspond to the variables with
  *     which the delegate was created
  * @return the query's result
  * @throws InvocationTargetException in case of failure to prepare or execute the query, usually
  *     because of an exception
  */
 @Override
 public Object execute(@Nullable Object target, Map<String, ?> arguments)
     throws InvocationTargetException {
   @SuppressWarnings("null")
   @NonNull
   Map<String, ?> nonNullArguments =
       (arguments != null ? arguments : (Map<String, ?>) Collections.<String, Object>emptyMap());
   try {
     if (specification == null) {
       prepare();
     }
     @SuppressWarnings("null")
     @NonNull
     ExpressionInOCL nonNullSpecification = specification;
     OCL ocl = delegateDomain.getOCL();
     IdResolver idResolver = ocl.getIdResolver();
     Object targetValue = idResolver.boxedValueOf(target);
     org.eclipse.ocl.pivot.Class targetType = idResolver.getStaticTypeOf(targetValue);
     Type requiredType = nonNullSpecification.getOwnedContext().getType();
     if ((requiredType == null)
         || !targetType.conformsTo(ocl.getStandardLibrary(), requiredType)) {
       String message =
           StringUtil.bind(
               PivotMessagesInternal.WrongContextClassifier_ERROR_, targetType, requiredType);
       throw new OCLDelegateException(new SemanticException(message));
     }
     List<Variable> parameterVariables = nonNullSpecification.getOwnedParameters();
     int argCount = arguments != null ? arguments.size() : 0;
     if (parameterVariables.size() != argCount) {
       String message =
           StringUtil.bind(
               PivotMessagesInternal.MismatchedArgumentCount_ERROR_,
               argCount,
               parameterVariables.size());
       throw new OCLDelegateException(new SemanticException(message));
     }
     Query query = ocl.createQuery(nonNullSpecification);
     EvaluationEnvironment env = query.getEvaluationEnvironment(target);
     for (Variable parameterVariable : parameterVariables) {
       // bind arguments to parameter names
       String name = parameterVariable.getName();
       Object object = nonNullArguments.get(name);
       if ((object == null) && !nonNullArguments.containsKey(name)) {
         String message =
             StringUtil.bind(
                 PivotMessagesInternal.EvaluationResultIsInvalid_ERROR_,
                 nonNullSpecification.getBody());
         throw new OCLDelegateException(new SemanticException(message));
       }
       Object value = idResolver.boxedValueOf(object);
       targetType = idResolver.getStaticTypeOf(value);
       requiredType = ClassUtil.nonNullModel(parameterVariable.getType());
       if (!targetType.conformsTo(ocl.getStandardLibrary(), requiredType)) {
         String message =
             StringUtil.bind(
                 PivotMessagesInternal.MismatchedArgumentType_ERROR_,
                 name,
                 targetType,
                 requiredType);
         throw new OCLDelegateException(new SemanticException(message));
       }
       env.add(parameterVariable, value);
     }
     Object result = evaluate(query, target);
     //			if (result.isInvalid()) {
     //				String message = ClassUtil.bind(OCLMessages.EvaluationResultIsInvalid_ERROR_,
     // getOperationName());
     //				throw new OCLDelegateException(message);
     //			}
     //		if ((result == null) / * || ocl.isInvalid(result) * /) {
     //			String message = ClassUtil.bind(OCLMessages.EvaluationResultIsNull_ERROR_,
     // getOperationName());
     //			throw new OCLDelegateException(message);
     //		}
     //		return converter.convert(ocl, result);
     //			if (result == null) {
     //				String message = NLS.bind(OCLMessages.EvaluationResultIsInvalid_ERROR_,
     // PivotUtil.getBody(specification));
     //				throw new InvocationTargetException(new OCLDelegateException(message));
     //			}
     return idResolver.ecoreValueOf(null, result);
   } catch (InvocationTargetException e) {
     throw e;
   } catch (EvaluationException e) {
     String message =
         StringUtil.bind(
             PivotMessagesInternal.EvaluationResultIsInvalid_ERROR_, specification.getBody());
     throw new InvocationTargetException(new EvaluationException(message));
   } catch (WrappedException e) {
     throw new InvocationTargetException(e.getCause());
   } catch (Exception e) {
     throw new InvocationTargetException(e);
   }
 }