| /******************************************************************************* |
| * Copyright (c) 2006, 2008 Eclipse.org |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| *******************************************************************************/ |
| package org.eclipse.gmf.internal.xpand; |
| |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.LinkedHashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TreeMap; |
| |
| import org.eclipse.emf.common.util.Enumerator; |
| import org.eclipse.emf.ecore.EAnnotation; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EClassifier; |
| import org.eclipse.emf.ecore.EDataType; |
| import org.eclipse.emf.ecore.EEnum; |
| import org.eclipse.emf.ecore.EEnumLiteral; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EOperation; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.EParameter; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.ETypedElement; |
| import org.eclipse.emf.ecore.EcoreFactory; |
| import org.eclipse.emf.ecore.EcorePackage; |
| import org.eclipse.gmf.internal.xpand.expression.PolymorphicResolver; |
| import org.eclipse.gmf.internal.xpand.migration.Activator; |
| import org.eclipse.gmf.internal.xpand.model.XpandDefinitionWrap; |
| import org.eclipse.gmf.internal.xpand.model.XpandIterator; |
| |
| /** |
| * XXX Guess, will need special support to recognize the fact |
| * EJavaObject.isSupertypeOf(EObject) |
| * |
| * @author artem |
| */ |
| @SuppressWarnings("unchecked") |
| public class BuiltinMetaModel { |
| public final static String SET = "Set"; |
| public final static String LIST = "List"; |
| |
| |
| protected static EPackage XECORE = EcoreFactory.eINSTANCE.createEPackage(); |
| |
| static { |
| XECORE.setName("xecore"); |
| XECORE.setNsPrefix("xecore"); |
| XECORE.setNsURI("uri:org.eclipse.modeling/m2t/xpand/xecore/1.0"); |
| } |
| |
| private static EClass PARAMETERIZED_TYPE = EcoreFactory.eINSTANCE.createEClass(); |
| private static EReference PT_INNER_TYPE_REF = EcoreFactory.eINSTANCE.createEReference(); |
| private static EAttribute PT_INNER_TYPE_ATTR = EcoreFactory.eINSTANCE.createEAttribute(); |
| |
| static { |
| PARAMETERIZED_TYPE.setName("ParameterizedType"); |
| PARAMETERIZED_TYPE.getESuperTypes().add(EcorePackage.eINSTANCE.getEClass()); |
| PARAMETERIZED_TYPE.setAbstract(true); |
| PT_INNER_TYPE_REF.setName("innerType"); |
| PT_INNER_TYPE_REF.setContainment(false); |
| PT_INNER_TYPE_REF.setEType(EcorePackage.eINSTANCE.getEClass()); |
| |
| PARAMETERIZED_TYPE.getEStructuralFeatures().add(PT_INNER_TYPE_REF); |
| |
| PT_INNER_TYPE_ATTR.setName("innerDataType"); |
| PT_INNER_TYPE_ATTR.setEType(EcorePackage.eINSTANCE.getEDataType()); |
| PARAMETERIZED_TYPE.getEStructuralFeatures().add(PT_INNER_TYPE_ATTR); |
| XECORE.getEClassifiers().add(PARAMETERIZED_TYPE); |
| } |
| |
| /** |
| * Checks whether classifier is one of user's model extension classes |
| * (conforming to ParameterizedType from our extended ECore meta-model). |
| * EClassifier instances available in analyze() methods are param |
| * candidates. |
| * |
| * @param parameterizedTypeM1 - |
| * e.g. EClass "Order", or XEClass "OrderList" |
| */ |
| public static boolean isParameterizedType(EClassifier parameterizedTypeM1) { |
| return PARAMETERIZED_TYPE.isSuperTypeOf(parameterizedTypeM1.eClass()); |
| } |
| |
| // XXX revisit invocations, this check is doubled with isParameterizedType, perhaps, can refactor it |
| public static boolean isCollectionType(EClassifier parameterizedTypeM1) { |
| // XXX this implementation is not really 'isCollectionType', it's just a copy of what was in the original code |
| return isAssignableFrom(CollectionTypesSupport.COLLECTION_OF_OBJECT, parameterizedTypeM1); |
| } |
| |
| public static EClassifier getInnerType(EClassifier parameterizedTypeM1) { |
| assert isParameterizedType(parameterizedTypeM1); |
| if (parameterizedTypeM1.eIsSet(PT_INNER_TYPE_REF)) { |
| return (EClass) parameterizedTypeM1.eGet(PT_INNER_TYPE_REF); |
| } else { |
| return (EDataType) parameterizedTypeM1.eGet(PT_INNER_TYPE_ATTR); |
| } |
| } |
| |
| /** |
| * NOTE, parameterizedTypeM1 is M1 instance, you can't pass {@link BuiltinMetaModel#COLLECTION_TYPE} (or {@link BuiltinMetaModel#LIST_TYPE}) here, |
| * because COLLECTION_TYPE just extends PARAMETERIZED_TYPE, but still instance of EClass. We could, however, have COLLECTION_TYPE to be an |
| * instance of PARAMETERIZED_TYPE, and then we could use this method. The reasons not to do so (at least, now) are |
| * (a) didn't think it over yet (b) looks like extending M2 (sic!) dynamically, though I don't like even M1 polluting with type |
| * that happens. |
| * @param parameterizedTypeM1 |
| * @param innerTypeM1 |
| * @return |
| */ |
| public static EClass cloneParametrizedType(EClassifier parameterizedTypeM1, EClassifier innerTypeM1) { |
| assert isParameterizedType(parameterizedTypeM1); |
| return collectionTypes.getCollectionType(parameterizedTypeM1.eClass(), innerTypeM1); |
| } |
| |
| /*package*/ static EClass internalNewParameterizedType(EClass parameterizedTypeM2, EClassifier inner) { |
| assert PARAMETERIZED_TYPE.isSuperTypeOf(parameterizedTypeM2); |
| EObject anInstance = XECORE.getEFactoryInstance().create(parameterizedTypeM2); |
| assert anInstance instanceof EClass : "EClass is first supertype with instanceClass set"; |
| // e.g. "OrderCollection" or "IntegerList" |
| ((EClass) anInstance).setName(inner.getName() + parameterizedTypeM2.getName()); |
| anInstance.eSet(inner instanceof EClass ? PT_INNER_TYPE_REF : PT_INNER_TYPE_ATTR, inner); |
| return (EClass) anInstance; |
| } |
| |
| public static final EClass VOID = EcoreFactory.eINSTANCE.createEClass(); |
| |
| static { |
| VOID.setName("void"); |
| XECORE.getEClassifiers().add(VOID); |
| } |
| |
| protected static CollectionTypesSupport collectionTypes = new CollectionTypesSupport(); |
| |
| static { |
| collectionTypes.init(XECORE, PARAMETERIZED_TYPE); |
| } |
| /** |
| * @param name |
| * @return true if name is one of M2 collection meta-types (either Collection, List, Set) |
| */ |
| public static boolean isCollectionMetaType(String name) { |
| return collectionTypes.isCollectionMetaType(name); |
| } |
| |
| public static EClass getCollectionType(String metaTypeName, EClassifier innerType) { |
| return collectionTypes.getCollectionType(metaTypeName, innerType); |
| } |
| |
| // XXX actually, it's odd to use abstract and vague 'collection' |
| public static EClass getCollectionType(EClassifier innerType) { |
| return collectionTypes.getCollectionType(innerType); |
| } |
| public static EClass getListType(EClassifier innerType) { |
| return collectionTypes.getListType(innerType); |
| } |
| public static EClass getSetType(EClassifier innerType) { |
| return collectionTypes.getSetType(innerType); |
| } |
| |
| public static final EClass DEFINITION_TYPE = EcoreFactory.eINSTANCE.createEClass(); |
| |
| static { |
| DEFINITION_TYPE.setName("xpand2::Definition"); |
| DEFINITION_TYPE.getESuperTypes().add(EcorePackage.eINSTANCE.getEClass()); |
| XECORE.getEClassifiers().add(DEFINITION_TYPE); |
| } |
| |
| public static final EClass ITERATOR_TYPE = EcoreFactory.eINSTANCE.createEClass(); |
| |
| static { |
| ITERATOR_TYPE.setName("xpand2::Iterator"); |
| ITERATOR_TYPE.getESuperTypes().add(EcorePackage.eINSTANCE.getEClass()); |
| XECORE.getEClassifiers().add(ITERATOR_TYPE); |
| } |
| |
| /** |
| * ECore doesn't support 'return types' for Enums, to my best knowledge, |
| * they are all integers. original EEnumType returns itself as static |
| * property's return type BTW, what if we'd like to get string value, name, |
| * instead |
| */ |
| public static EClassifier getReturnType(EEnumLiteral sp) { |
| return sp.getEEnum(); |
| } |
| |
| // TODO obj.getClass lookup tree? |
| public static EClassifier getType(Object obj) { |
| if (obj == null) { |
| return VOID; |
| } |
| if (obj instanceof Enumerator) { |
| // unlike original impl, we don't return Enum as type |
| // mostly because it's just too hard to look for actual enum |
| // XXX perhaps, EEnumLiteral.getEEnum could help? |
| return EcorePackage.eINSTANCE.getEEnumerator(); |
| } |
| if (obj instanceof EObject) { |
| return ((EObject) obj).eClass(); |
| } |
| if (obj instanceof Collection) { |
| EClassifier type = null; |
| if (!((Collection) obj).isEmpty()) { |
| // FIXME respect all! elements in the collection, not only the first one |
| type = getType(((Collection) obj).iterator().next()); |
| } |
| if (obj instanceof Set) { |
| return collectionTypes.getSetType(type); |
| } |
| if (obj instanceof List) { |
| return collectionTypes.getListType(type); |
| } |
| return collectionTypes.getCollectionType(type); |
| } |
| if (obj instanceof Boolean) { |
| return EcorePackage.eINSTANCE.getEBoolean(); |
| } |
| if ((obj instanceof Byte) || (obj instanceof Integer) || (obj instanceof Long) || obj instanceof Short) { |
| return EcorePackage.eINSTANCE.getEInt(); |
| } |
| if ((obj instanceof Float) || (obj instanceof Double)) { |
| return EcorePackage.eINSTANCE.getEDouble(); |
| } |
| if (obj instanceof String) { |
| return EcorePackage.eINSTANCE.getEString(); |
| } |
| if (obj instanceof XpandDefinitionWrap) { |
| return DEFINITION_TYPE; |
| } |
| if (obj instanceof XpandIterator) { |
| return ITERATOR_TYPE; |
| } |
| return EcorePackage.eINSTANCE.getEJavaObject(); |
| } |
| |
| /** |
| * FIXME HACK!!! |
| */ |
| public static Object newInstance(EClassifier t) { |
| if (isCollectionType(t)) { |
| return collectionTypes.newInstance(t); |
| } |
| if (t.getInstanceClass() != null) { |
| try { |
| return t.getInstanceClass().newInstance(); |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * FIXME what if args has null or getType() returns null - we can't find an |
| * op then, and it's caller who knows how to handle this. |
| * |
| * @param name |
| * @param args |
| * @param instance |
| * @return |
| */ |
| public static Operation executableOperation(String name, Object[] args, Object instance) { |
| EClassifier[] argTypes = new EClassifier[args.length]; |
| for (int i = 0; i < args.length; i++) { |
| argTypes[i] = getType(args[i]); |
| } |
| EOperation metaOp = findOperation(getType(instance), name, argTypes); |
| if (metaOp == null) { |
| return null; |
| } |
| if (InternalOperation.isInternalOp(metaOp)) { |
| for (List<InternalOperation> ops : internalOperationsMap.values()) { |
| for (InternalOperation internalOp : ops) { |
| if (internalOp.metaOp == metaOp) { |
| return new OperationEx(instance, args, internalOp); |
| } |
| } |
| } |
| throw new IllegalStateException("Can't find implementation of built-in operation" + metaOp); |
| } |
| return new Operation(instance, args, metaOp); |
| } |
| |
| public static EOperation findOperation(EClassifier targetType, String name, EClassifier[] args) { |
| List<EOperation> allOp; |
| if (hasBuiltinSupport(targetType)) { |
| // this one is to cover m2 types that are *propagated* to user's model, m1. Those like |
| // boolean, integer, string, etc. |
| allOp = findInternalOp(targetType); |
| } else if (hasBuiltinSupport(targetType.eClass())){ |
| // this one is to cover collection types, because we register their operations |
| // against meta-model (m2) instance, rather than against M1 |
| allOp = findInternalOp(targetType.eClass()); |
| } else { |
| if (false == (targetType instanceof EClass)) { |
| return null; |
| } else { |
| allOp = new LinkedList<EOperation>(((EClass) targetType).getEAllOperations()); |
| allOp.addAll(findInternalOp(EcorePackage.eINSTANCE.getEJavaObject())); |
| } |
| } |
| return PolymorphicResolver.filterOperation(allOp, name, targetType, Arrays.asList(args)); |
| } |
| |
| private static Map<String, String> attrNameSubsts = new TreeMap<String, String>(); |
| public static EOperation Collection_IsEmpty; |
| public static EOperation Collection_Add; |
| public static EOperation Collection_AddAll; |
| public static EOperation Collection_Clear; |
| public static EOperation Collection_Flatten; |
| public static EOperation Collection_Size; |
| public static EOperation Collection_Union; |
| public static EOperation Collection_Intersect; |
| public static EOperation Collection_Without; |
| public static EOperation Collection_ToSet; |
| public static EOperation Collection_ToList; |
| public static EOperation Collection_Contains; |
| public static EOperation Collection_ContainsAll; |
| public static EOperation List_Get; |
| public static EOperation List_First; |
| public static EOperation List_Last; |
| public static EOperation List_WithoutFirst; |
| public static EOperation List_WithoutLast; |
| public static EOperation List_PurgeDups; |
| public static EOperation List_IndexOf; |
| public static EOperation Boolean_NE; |
| public static EOperation Int_Plus_Int; |
| public static EOperation Int_Plus_Double; |
| public static EOperation Int_Minus_Int; |
| public static EOperation Int_Minus_Double; |
| public static EOperation Int_Mult_Int; |
| public static EOperation Int_Mult_Double; |
| public static EOperation Int_Div_Int; |
| public static EOperation Int_Div_Double; |
| public static EOperation Int_Unary_Minus; |
| public static EOperation Int_GreatOrEqual; |
| public static EOperation Int_LessOrEqual; |
| public static EOperation Int_Less; |
| public static EOperation Int_Greater; |
| public static EOperation Int_UpTo; |
| public static EOperation Double_Plus_Double; |
| public static EOperation Double_Plus_Int; |
| public static EOperation Double_Minus_Double; |
| public static EOperation Double_Minus_Int; |
| public static EOperation Double_Mult_Double; |
| public static EOperation Double_Mult_Int; |
| public static EOperation Double_Div_Double; |
| public static EOperation Double_Div_Int; |
| public static EOperation Double_Unary_Minus; |
| public static EOperation Object_EQ; |
| public static EOperation EString_ToFirstUpper; |
| public static EOperation EString_Plus_EJavaObject; |
| public static EOperation EString_ToFirstLower; |
| public static EOperation EString_ToCharList; |
| public static EOperation EString_StartsWith; |
| public static EOperation EString_EndsWith; |
| public static EOperation EString_SubString_StartEnd; |
| public static EOperation EString_SubString; |
| public static EOperation EString_ToUpperCase; |
| public static EOperation EString_ToLowerCase; |
| public static EOperation EString_ReplaceAll; |
| public static EOperation EString_ReplaceFirst; |
| public static EOperation EString_Split; |
| public static EOperation EString_Matches; |
| public static EOperation EString_Trim; |
| public static EOperation EString_Length; |
| public static EOperation Object_CompareTo; |
| public static EOperation Object_ToString; |
| public static EOperation Object_NotEQ; |
| static { |
| attrNameSubsts.put("default_", "default"); |
| } |
| public static EStructuralFeature getAttribute(EClassifier type, String name) { |
| if (hasBuiltinSupport(type)) { |
| return findInternalAttr(type, name); |
| } |
| if (type instanceof EClass) { |
| return ((EClass) type).getEStructuralFeature(attrNameSubsts.containsKey(name) ? attrNameSubsts.get(name): name); |
| } |
| if (type instanceof EEnum || type == EcorePackage.eINSTANCE.getEEnumLiteral() || type == EcorePackage.eINSTANCE.getEEnumerator()) { |
| return EcorePackage.eINSTANCE.getEEnumLiteral().getEStructuralFeature(name); |
| } |
| return null; |
| } |
| public static Object getValue(EStructuralFeature prop, Object instance) { |
| if (instance instanceof Enumerator) { |
| if (prop == EcorePackage.eINSTANCE.getEEnumLiteral_Literal()) { |
| return ((Enumerator) instance).getLiteral(); |
| } |
| if (prop == EcorePackage.eINSTANCE.getENamedElement_Name()) { |
| return ((Enumerator) instance).getName(); |
| } |
| if (prop == EcorePackage.eINSTANCE.getEEnumLiteral_Value()) { |
| return ((Enumerator) instance).getValue(); |
| } |
| } |
| if (instance instanceof EObject) { |
| return ((EObject) instance).eGet(prop); |
| } |
| // handle collection/set/list properties? |
| return "HeyHo!"; |
| } |
| |
| private static boolean hasBuiltinSupport(EClassifier type) { |
| return internalOperationsMap.containsKey(type); |
| } |
| |
| private static EStructuralFeature findInternalAttr(EClassifier type, String name) { |
| if (type instanceof EClass) { |
| return ((EClass) type).getEStructuralFeature(name); |
| } |
| if (type instanceof EDataType && type == EcorePackage.eINSTANCE.getEEnumerator()) { |
| // I do not know where EMF uses EEnumLiteralImpl and where Enumerator for EEnum value. |
| return EcorePackage.eINSTANCE.getEEnumLiteral().getEStructuralFeature(name); |
| } |
| // TODO Auto-generated method stub |
| return null; |
| } |
| |
| private static final Map<EClassifier,List<InternalOperation>> internalOperationsMap = new HashMap<EClassifier, List<InternalOperation>>(); |
| |
| static { |
| final EcorePackage ecorePkg = EcorePackage.eINSTANCE; |
| final OperationFactory opf = new OperationFactory(); |
| |
| final List<InternalOperation> objectOps = new LinkedList<InternalOperation>(); |
| objectOps.add(new InternalOperation<Object>(Object_CompareTo = opf.create("compareTo", ecorePkg.getEBoolean(), ecorePkg.getEJavaObject())) { |
| @Override |
| public Object evaluate(Object target, Object[] params) { |
| if (target == null) { |
| return params[0] == null ? 0 : -1; |
| } |
| if (params[0] == null) { |
| return 1; |
| } |
| if (target instanceof Comparable) { |
| return ((Comparable) target).compareTo(params[0]); |
| } |
| // note, unlike ObjectTypeImpl we don't invoke toString registered against metatype here |
| return String.valueOf(target).compareTo(String.valueOf(params[0])); |
| } |
| }); |
| objectOps.add(new InternalOperation<Object>(Object_ToString = opf.create("toString", ecorePkg.getEString())) { |
| @Override |
| public Object evaluate(Object target, Object[] params) { |
| return String.valueOf(target); |
| } |
| }); |
| objectOps.add(new InternalOperation<Object>(Object_EQ = opf.create("==", boolean.class, Object.class)) { |
| @Override |
| public Object evaluate(Object target, Object[] params) { |
| return target == null ? params[0] == null : target.equals(params[0]); |
| } |
| }); |
| objectOps.add(new InternalOperation<Object>(Object_NotEQ = opf.create("!=", boolean.class, Object.class)) { |
| @Override |
| public Object evaluate(Object target, Object[] params) { |
| return target == null ? params[0] != null : !target.equals(params[0]); |
| } |
| }); |
| List<InternalOperation> unmodifiableObjectOps = Collections.unmodifiableList(objectOps); |
| internalOperationsMap.put(ecorePkg.getEJavaObject(), unmodifiableObjectOps); |
| // EEnumerator are enum literal instances at runtime (#evaluate), |
| // while EEnum are their types during #analyze phase |
| internalOperationsMap.put(ecorePkg.getEEnumerator(), unmodifiableObjectOps); |
| internalOperationsMap.put(ecorePkg.getEEnum(), unmodifiableObjectOps); |
| |
| final List<InternalOperation> stringOps = new LinkedList<InternalOperation>(); |
| |
| stringOps.add(new InternalOperation<String>(EString_Plus_EJavaObject = opf.create("+",ecorePkg.getEString(),ecorePkg.getEJavaObject())) { |
| @Override |
| public Object evaluate(String target, Object[] params) { |
| return target + String.valueOf(params[0]); |
| } |
| }); |
| stringOps.add(new InternalOperation<String>(EString_ToFirstUpper = opf.create("toFirstUpper",ecorePkg.getEString())) { |
| @Override |
| public Object evaluate(String target, Object[] params) { |
| return StringHelper.firstUpper(target); |
| } |
| }); |
| stringOps.add(new InternalOperation<String>(EString_ToFirstLower = opf.create("toFirstLower",ecorePkg.getEString())) { |
| @Override |
| public Object evaluate(String target, Object[] params) { |
| return StringHelper.firstLower(target); |
| } |
| }); |
| stringOps.add(new InternalOperation<String>(EString_ToCharList = opf.create("toCharList",collectionTypes.getListType(ecorePkg.getEString()))) { |
| @Override |
| public Object evaluate(String target, Object[] params) { |
| ArrayList<String> rv = new ArrayList<String>(target.length()); |
| for (int i = 0; i < target.length(); i++) { |
| rv.add(target.substring(i, i+1)); |
| } |
| return rv; |
| } |
| }); |
| InternalOperation internalOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "startsWith", String.class)); |
| EString_StartsWith = internalOp.metaOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "endsWith", String.class)); |
| EString_EndsWith = internalOp.metaOp; |
| InternalOperation subStringOp = opf.createReflective(String.class, "substring", int.class, int.class); |
| subStringOp.metaOp.setName("subString"); |
| EString_SubString_StartEnd = subStringOp.metaOp; |
| stringOps.add(subStringOp); |
| subStringOp = opf.createReflective(String.class, "substring", int.class); |
| subStringOp.metaOp.setName("subString"); |
| EString_SubString = subStringOp.metaOp; |
| stringOps.add(subStringOp); |
| stringOps.add(internalOp = opf.createReflective(String.class, "toUpperCase")); |
| EString_ToUpperCase = internalOp.metaOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "toLowerCase")); |
| EString_ToLowerCase = internalOp.metaOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "replaceAll", String.class, String.class)); |
| EString_ReplaceAll = internalOp.metaOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "replaceFirst", String.class, String.class)); |
| EString_ReplaceFirst = internalOp.metaOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "split", String.class)); |
| EString_Split = internalOp.metaOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "matches", String.class)); |
| EString_Matches = internalOp.metaOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "trim")); |
| EString_Trim = internalOp.metaOp; |
| stringOps.add(internalOp = opf.createReflective(String.class, "length")); |
| EString_Length = internalOp.metaOp; |
| stringOps.addAll(unmodifiableObjectOps); |
| internalOperationsMap.put(ecorePkg.getEString(), Collections.unmodifiableList(stringOps)); |
| |
| final List<InternalOperation> booleanOps = new LinkedList<InternalOperation>(); |
| booleanOps.add(new InternalOperation<Boolean>(Boolean_NE = opf.create("!", boolean.class)) { |
| @Override |
| public Object evaluate(Boolean target, Object[] params) { |
| return Boolean.valueOf(!target.booleanValue()); |
| } |
| }); |
| booleanOps.addAll(unmodifiableObjectOps); |
| internalOperationsMap.put(ecorePkg.getEBoolean(), Collections.unmodifiableList(booleanOps)); |
| final List<InternalOperation> voidOps = new LinkedList<InternalOperation>(); |
| voidOps.addAll(unmodifiableObjectOps); |
| internalOperationsMap.put(VOID, Collections.unmodifiableList(voidOps)); |
| |
| //--------------------------------------------------------------------------------- |
| class InternalSumOp extends InternalOperation<Number> { |
| InternalSumOp(EOperation metaOp) { |
| super(metaOp); |
| } |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| if (target instanceof Double || params[0] instanceof Double) { |
| return new Double(target.doubleValue() + ((Number) params[0]).doubleValue()); |
| } else { |
| return new Integer(target.intValue() + ((Number) params[0]).intValue()); |
| } |
| } |
| |
| }; |
| class InternalSubOp extends InternalOperation<Number> { |
| InternalSubOp(EOperation metaOp) { |
| super(metaOp); |
| } |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| if (target instanceof Double || params[0] instanceof Double) { |
| return new Double(target.doubleValue() - ((Number) params[0]).doubleValue()); |
| } else { |
| return new Integer(target.intValue() - ((Number) params[0]).intValue()); |
| } |
| } |
| |
| }; |
| class InternalMulOp extends InternalOperation<Number> { |
| InternalMulOp(EOperation metaOp) { |
| super(metaOp); |
| } |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| if (target instanceof Double || params[0] instanceof Double) { |
| return new Double(target.doubleValue() * ((Number) params[0]).doubleValue()); |
| } else { |
| return new Integer(target.intValue() * ((Number) params[0]).intValue()); |
| } |
| } |
| |
| }; |
| class InternalDivOp extends InternalOperation<Number> { |
| InternalDivOp(EOperation metaOp) { |
| super(metaOp); |
| } |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| if (target instanceof Double || params[0] instanceof Double) { |
| return new Double(target.doubleValue() / ((Number) params[0]).doubleValue()); |
| } else { |
| return new Integer(target.intValue() / ((Number) params[0]).intValue()); |
| } |
| } |
| |
| }; |
| class InternalNegateOp extends InternalOperation<Number> { |
| InternalNegateOp(EOperation metaOp) { |
| super(metaOp); |
| } |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| if (target instanceof Double) { |
| return -target.doubleValue(); |
| } |
| return -target.intValue(); |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| |
| final List<InternalOperation> intOps = new LinkedList<InternalOperation>(); |
| intOps.add(new InternalSumOp(Int_Plus_Int = opf.create("+", int.class, int.class))); |
| intOps.add(new InternalSumOp(Int_Plus_Double = opf.create("+", int.class, double.class))); |
| intOps.add(new InternalSubOp(Int_Minus_Int = opf.create("-", int.class, int.class))); |
| intOps.add(new InternalSubOp(Int_Minus_Double = opf.create("-", double.class, double.class))); |
| intOps.add(new InternalMulOp(Int_Mult_Int = opf.create("*", int.class, int.class))); |
| intOps.add(new InternalMulOp(Int_Mult_Double = opf.create("*", int.class, double.class))); |
| intOps.add(new InternalDivOp(Int_Div_Int = opf.create("/", int.class, int.class))); |
| intOps.add(new InternalDivOp(Int_Div_Double = opf.create("/", int.class, double.class))); |
| intOps.add(new InternalNegateOp(Int_Unary_Minus = opf.create("-", int.class))); |
| // intOps.add(new InternalOperation<Number>(opf.create("==", boolean.class, int.class)) { |
| // @Override |
| // public Object evaluate(Number target, Object[] params) { |
| // //we may need this to handle cases like {Long(5), Long(4)}.exists(a | a == 5) |
| // return Boolean.valueOf(target.intValue() == ((Integer) params[0]).intValue()); |
| // } |
| // |
| // }); |
| intOps.add(new InternalOperation<Number>(Int_GreatOrEqual = opf.create(">=", boolean.class, int.class)) { |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| return Boolean.valueOf(target.intValue() >= ((Number) params[0]).intValue()); |
| } |
| }); |
| intOps.add(new InternalOperation<Number>(Int_LessOrEqual = opf.create("<=", boolean.class, int.class)) { |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| return Boolean.valueOf(target.intValue() <= ((Number) params[0]).intValue()); |
| } |
| }); |
| intOps.add(new InternalOperation<Number>(Int_Less = opf.create("<", boolean.class, int.class)) { |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| return Boolean.valueOf(target.intValue() < ((Number) params[0]).intValue()); |
| } |
| }); |
| intOps.add(new InternalOperation<Number>(Int_Greater = opf.create(">", boolean.class, int.class)) { |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| return Boolean.valueOf(target.intValue() > ((Number) params[0]).intValue()); |
| } |
| }); |
| intOps.add(new InternalOperation<Number>(Int_UpTo = opf.create("upTo", collectionTypes.getListType(ecorePkg.getEInt()), ecorePkg.getEInt())) { |
| @Override |
| public Object evaluate(Number target, Object[] params) { |
| final ArrayList<Integer> result = new ArrayList<Integer>(); |
| for (int l1 = target.intValue(), l2 = ((Number) params[0]).intValue(); l1 <= l2; l1++) { |
| result.add(new Integer(l1)); |
| } |
| return result; |
| } |
| |
| }); |
| intOps.addAll(unmodifiableObjectOps); |
| List<InternalOperation> unmodifiableListIntOps = Collections.unmodifiableList(intOps); |
| internalOperationsMap.put(ecorePkg.getEIntegerObject(), unmodifiableListIntOps); |
| internalOperationsMap.put(ecorePkg.getEInt(), unmodifiableListIntOps); |
| |
| final List<InternalOperation> doubleOps = new LinkedList<InternalOperation>(); |
| doubleOps.add(new InternalSumOp(Double_Plus_Double = opf.create("+", double.class, double.class))); |
| doubleOps.add(new InternalSumOp(Double_Plus_Int = opf.create("+", double.class, int.class))); |
| doubleOps.add(new InternalSubOp(Double_Minus_Double = opf.create("-", double.class, double.class))); |
| doubleOps.add(new InternalSubOp(Double_Minus_Int = opf.create("-", double.class, int.class))); |
| doubleOps.add(new InternalMulOp(Double_Mult_Double = opf.create("*", double.class, double.class))); |
| doubleOps.add(new InternalMulOp(Double_Mult_Int = opf.create("*", double.class, int.class))); |
| doubleOps.add(new InternalDivOp(Double_Div_Double = opf.create("/", double.class, double.class))); |
| doubleOps.add(new InternalDivOp(Double_Div_Int = opf.create("/", double.class, int.class))); |
| doubleOps.add(new InternalNegateOp(Double_Unary_Minus = opf.create("-", double.class))); |
| doubleOps.addAll(unmodifiableObjectOps); |
| internalOperationsMap.put(ecorePkg.getEDouble(), doubleOps); |
| |
| final List<InternalOperation> collectionOps = new LinkedList<InternalOperation>(); |
| collectionOps.add(new InternalOperation<Collection>(Collection_IsEmpty = opf.create("isEmpty", ecorePkg.getEBoolean())) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| // TODO isEmpty is rather attribute |
| return target.isEmpty(); |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_Add = opf.create("add", CollectionTypesSupport.COLLECTION_OF_OBJECT, ecorePkg.getEJavaObject())) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| target.add(params[0]); |
| return target; |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_AddAll = opf.create("addAll", CollectionTypesSupport.COLLECTION_OF_OBJECT, CollectionTypesSupport.COLLECTION_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| target.addAll((Collection) params[0]); |
| return target; |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_Clear = opf.create("clear", CollectionTypesSupport.COLLECTION_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| target.clear(); |
| return target; |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_Flatten = opf.create("flatten", CollectionTypesSupport.COLLECTION_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| LinkedList rv = new LinkedList(); |
| for (Object o : target) { |
| if (o instanceof Collection) { |
| // XXX unlike original xpand, we do not flatten recursively |
| rv.addAll((Collection) o); |
| } else { |
| rv.add(o); |
| } |
| } |
| return rv; |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_Size = opf.create("size", ecorePkg.getEInt())) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| return target.size(); |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_Union = opf.create("union", CollectionTypesSupport.COLLECTION_OF_OBJECT, CollectionTypesSupport.COLLECTION_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| LinkedHashSet<Object> rv = new LinkedHashSet<Object>(target); |
| rv.addAll((Collection) params[0]); |
| return rv; |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_Intersect = opf.create("intersect", CollectionTypesSupport.COLLECTION_OF_OBJECT, CollectionTypesSupport.COLLECTION_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| LinkedHashSet<Object> rv = new LinkedHashSet<Object>(target); |
| rv.retainAll((Collection) params[0]); |
| return rv; |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_Without = opf.create("without", CollectionTypesSupport.COLLECTION_OF_OBJECT, CollectionTypesSupport.COLLECTION_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| LinkedHashSet<Object> rv = new LinkedHashSet<Object>(target); |
| rv.removeAll((Collection) params[0]); |
| return rv; |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_ToSet = opf.create("toSet", CollectionTypesSupport.SET_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| return new LinkedHashSet<Object>(target); |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_ToList = opf.create("toList", CollectionTypesSupport.LIST_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| return new LinkedList<Object>(target); |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_Contains = opf.create("contains", ecorePkg.getEBoolean(), ecorePkg.getEJavaObject())) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| return target.contains(params[0]); |
| } |
| }); |
| collectionOps.add(new InternalOperation<Collection>(Collection_ContainsAll = opf.create("containsAll", ecorePkg.getEBoolean(), CollectionTypesSupport.COLLECTION_OF_OBJECT)) { |
| @Override |
| public Object evaluate(Collection target, Object[] params) { |
| return target.containsAll((Collection) params[0]); |
| } |
| }); |
| List<InternalOperation> unmodifiableListCollectionOps = Collections.unmodifiableList(collectionOps); |
| internalOperationsMap.put(CollectionTypesSupport.COLLECTION_TYPE, unmodifiableListCollectionOps); |
| internalOperationsMap.put(CollectionTypesSupport.SET_TYPE, unmodifiableListCollectionOps); |
| final List<InternalOperation> listOps = new LinkedList<InternalOperation>(unmodifiableListCollectionOps); |
| listOps.add(new InternalOperation<List>(List_Get = opf.create("get", ecorePkg.getEJavaObject(), ecorePkg.getEInt())) { |
| @Override |
| public Object evaluate(List target, Object[] params) { |
| int index = ((Number) params[0]).intValue(); |
| return index < target.size() ? target.get(index) : null; |
| } |
| }); |
| listOps.add(new InternalOperation<List>(List_First = opf.create("first", ecorePkg.getEJavaObject())) { |
| @Override |
| public Object evaluate(List target, Object[] params) { |
| return target.isEmpty() ? null : target.get(0); |
| } |
| }); |
| listOps.add(new InternalOperation<List>(List_Last = opf.create("last", ecorePkg.getEJavaObject())) { |
| @Override |
| public Object evaluate(List target, Object[] params) { |
| return target.isEmpty() ? null : target.get(target.size() - 1); |
| } |
| }); |
| listOps.add(new InternalOperation<List>(List_WithoutFirst = opf.create("withoutFirst", CollectionTypesSupport.LIST_OF_OBJECT)) { |
| @Override |
| public Object evaluate(List target, Object[] params) { |
| if (!target.isEmpty()) { |
| LinkedList rv = new LinkedList(target); |
| rv.removeFirst(); |
| return rv; |
| } |
| return target; |
| } |
| }); |
| listOps.add(new InternalOperation<List>(List_WithoutLast = opf.create("withoutLast", CollectionTypesSupport.LIST_OF_OBJECT)) { |
| @Override |
| public Object evaluate(List target, Object[] params) { |
| if (!target.isEmpty()) { |
| LinkedList rv = new LinkedList(target); |
| rv.removeLast(); |
| return rv; |
| } |
| return target; |
| } |
| }); |
| listOps.add(new InternalOperation<List>(List_PurgeDups = opf.create("purgeDups", CollectionTypesSupport.LIST_OF_OBJECT)) { |
| @Override |
| public Object evaluate(List target, Object[] params) { |
| if (target.isEmpty()) { |
| return target; |
| } |
| return new LinkedList<Object>(new LinkedHashSet<Object>(target)); |
| } |
| }); |
| listOps.add(new InternalOperation<List>(List_IndexOf = opf.create("indexOf", ecorePkg.getEInt(), ecorePkg.getEJavaObject())) { |
| @Override |
| public Object evaluate(List target, Object[] params) { |
| return target.indexOf(params[0]); |
| } |
| }); |
| internalOperationsMap.put(CollectionTypesSupport.LIST_TYPE, Collections.unmodifiableList(listOps)); |
| |
| final List<InternalOperation> definitionOps = new LinkedList<InternalOperation>(); |
| definitionOps.add(new InternalOperation<XpandDefinitionWrap>(opf.create("proceed", VOID)) { |
| @Override |
| public Object evaluate(XpandDefinitionWrap target, Object[] params) { |
| target.proceed(); |
| return null; |
| } |
| }); |
| internalOperationsMap.put(DEFINITION_TYPE, Collections.unmodifiableList(definitionOps)); |
| |
| final List<InternalOperation> iteratorOps = new LinkedList<InternalOperation>(); |
| iteratorOps.add(new InternalOperation<XpandIterator>(opf.create("isFirstIteration", ecorePkg.getEBoolean())) { |
| @Override |
| public Object evaluate(XpandIterator target, Object[] params) { |
| return target.isFirstIteration(); |
| } |
| }); |
| internalOperationsMap.put(ITERATOR_TYPE, Collections.unmodifiableList(iteratorOps)); |
| } |
| |
| private static List<EOperation> findInternalOp(EClassifier targetType) { |
| List<InternalOperation> ops = internalOperationsMap.get(targetType); |
| if (ops != null) { |
| List<EOperation> rv = new ArrayList<EOperation>(ops.size()); |
| for (InternalOperation iop : ops) { |
| rv.add(iop.metaOp); |
| } |
| return rv; |
| } |
| if (targetType.eClass() == EcorePackage.eINSTANCE.getEClass()) { |
| // not instanceof because parametric type and all other XECore |
| // classes have different operations, at least |
| // meanwhile, when they are dynamic |
| return((EClass) targetType).getEAllOperations(); |
| } |
| // TODO Auto-generated method stub |
| // String length, +, startsWith, endsWith, subString, toUpperCase, toFirstUpper, toFirstLower, toCharList, replaceAll, replaceFirst, split, matches, trim |
| // Int/Real +-*/ > >= < <= != == |
| // Collection toList, toSet, toString, add, addAll, contains, containsAll, remove, removeAll, without, intersect, flatten ; |
| // properties - size, isEmpty |
| // List get, indexOf, last, first, withoutFirst, withoutLast |
| // Set - none |
| return null; |
| } |
| |
| public static EClassifier getTypedElementType(ETypedElement p) { |
| if (p.isMany()) { |
| return p.isOrdered() ? getListType(p.getEType()) : p.isUnique() ? getSetType(p.getEType()) : getCollectionType(p.getEType()); |
| } |
| return p.getEType(); |
| } |
| |
| private static class OperationFactory { |
| EOperation create(String name, Class returnType, Class ... params) { |
| EClassifier[] paramsNew = new EClassifier[params.length]; |
| for (int i = 0; i < paramsNew.length; i++) { |
| paramsNew[i] = toEClassifier(params[i]); |
| assert params[i] != null; |
| } |
| EClassifier rt = toEClassifier(returnType); |
| assert rt != null : "Unrecognized return type:" + returnType; |
| return create(name, rt, paramsNew); |
| } |
| |
| /** |
| * NOTE, targetType is NOT operation's return type, but method owning class |
| */ |
| InternalOperation createReflective(Class targetType, String methodName, Class ... params) { |
| try { |
| final Method m = targetType.getMethod(methodName, params); |
| assert m != null; |
| return new InternalOperation<Object>(create(methodName, m.getReturnType(), params)) { |
| public Object evaluate(Object target, Object[] params) { |
| try { |
| Object rv = m.invoke(target, params); |
| if (rv != null && rv.getClass().isArray()) { |
| return new LinkedList(Arrays.asList((Object[]) rv)); |
| } |
| return rv; |
| } catch (Exception e) { |
| Activator.logError(e); |
| return null; |
| } |
| } |
| }; |
| } catch (NoSuchMethodException ex) { |
| assert false : ex.getMessage(); |
| } |
| return null; |
| } |
| |
| private EClassifier toEClassifier(Class targetType) { |
| if (targetType == void.class) { |
| return VOID; |
| } |
| for (EClassifier c : EcorePackage.eINSTANCE.getEClassifiers()) { |
| if (c.getInstanceClass() == targetType) { |
| return c; |
| } |
| } |
| if (targetType.isArray()) { |
| EClassifier t = toEClassifier(targetType.getComponentType()); |
| assert t != null : "Unrecognized array component type:" + targetType; |
| return getListType(t); |
| } |
| // TODO other packages |
| return null; |
| } |
| |
| EOperation create(String name, EClassifier returnType, EClassifier ... params) { |
| EOperation op = EcoreFactory.eINSTANCE.createEOperation(); |
| op.setName(name); |
| op.setEType(returnType); |
| for (EClassifier c : params) { |
| EParameter p1 = EcoreFactory.eINSTANCE.createEParameter(); |
| p1.setName("arg" + c.getName()); |
| p1.setEType(c); |
| op.getEParameters().add(p1); |
| } |
| return op; |
| } |
| } |
| |
| private static abstract class InternalOperation<T> { |
| private final EOperation metaOp; |
| private static String INTERNAL_OP_ANNOTATION = "::internalop::"; |
| |
| private InternalOperation(EOperation metaOp) { |
| assert metaOp != null; |
| this.metaOp = metaOp; |
| EAnnotation internalOpAnn = EcoreFactory.eINSTANCE.createEAnnotation(); |
| internalOpAnn.setSource(INTERNAL_OP_ANNOTATION); |
| metaOp.getEAnnotations().add(internalOpAnn); |
| } |
| |
| public abstract Object evaluate(T target, Object[] params); |
| |
| static boolean isInternalOp(EOperation op) { |
| return op.getEAnnotation(INTERNAL_OP_ANNOTATION) != null; |
| } |
| } |
| |
| public static class OperationEx extends Operation { |
| private final InternalOperation<Object> internalOp; |
| private OperationEx(Object targetObject, Object[] args, InternalOperation<Object> internalOp) { |
| super(targetObject, args, internalOp.metaOp); |
| this.internalOp = internalOp; |
| } |
| @Override |
| public Object evaluate() { |
| return internalOp.evaluate(targetObject, args); |
| } |
| } |
| |
| private static final Map<EOperation, Method> externalOpImplementations = new HashMap<EOperation, Method>(); |
| |
| public static void registerOperationImpl(EOperation metaOp, Method implementation) { |
| assert metaOp != null; |
| assert implementation != null; |
| assert Modifier.isStatic(implementation.getModifiers()); |
| externalOpImplementations.put(metaOp, implementation); |
| } |
| |
| public static class Operation { |
| protected final EOperation metaOp; |
| protected final Object[] args; |
| protected final Object targetObject; |
| |
| private Operation(Object targetObject, Object[] args, EOperation metaOp) { |
| this.targetObject = targetObject; |
| this.args = args; |
| this.metaOp = metaOp; |
| |
| } |
| public Object evaluate() { |
| try { |
| final Method m; |
| if (externalOpImplementations.containsKey(metaOp)) { |
| m = externalOpImplementations.get(metaOp); |
| } else { |
| m = targetObject.getClass().getMethod(metaOp.getName(), getParameterClasses()); |
| } |
| return m.invoke(targetObject, args); |
| } catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| private Class[] getParameterClasses() { |
| List<EParameter> emfParams = metaOp.getEParameters(); |
| final Class[] paramClasses = new Class[emfParams.size()]; |
| for (int i = 0, x = emfParams.size(); i < x; i++) { |
| final EParameter param = emfParams.get(i); |
| // XXX works only for generated classes, or those with instance |
| // class set, |
| // and doesn't work with dynamic models, right? |
| paramClasses[i] = param.getEType().getInstanceClass(); |
| } |
| return paramClasses; |
| } |
| } |
| |
| /** |
| * @return true if first argument is more general and second is more |
| * specific, think Object and String |
| * @see AbstractTypeImpl.isAssignableFrom(this, t) |
| */ |
| public static boolean isAssignableFrom(EClassifier c1, EClassifier t) { |
| if ((t == null) || (c1 == null)) { |
| return false; |
| } |
| if (BuiltinMetaModel.primEquals(c1, t)) { |
| return true; |
| } |
| if (t.equals(VOID)) { |
| return true; |
| } |
| if (false == (t instanceof EClass)) { |
| if (c1 instanceof EEnum && t == EcorePackage.eINSTANCE.getEEnumerator()) { |
| return true; // HACK - any enumerator instance can be assigned to any enum attribute. |
| } |
| if (c1 instanceof EDataType && t instanceof EDataType) { |
| return isCompatibleDataTypes((EDataType) c1, (EDataType) t); |
| } |
| return false; |
| } |
| if (c1 instanceof EDataType) { |
| Class c1Class = ((EDataType) c1).getInstanceClass(); |
| return c1Class.isAssignableFrom(t.getInstanceClass() == null ? Object.class : t.getInstanceClass()); |
| } |
| if (isParameterizedType(c1) && isParameterizedType(t)) { |
| return c1.eClass().isSuperTypeOf(t.eClass()) && isAssignableFrom(getInnerType(c1), getInnerType(t)); |
| } |
| // == c1.isSuperTypeOf(t); |
| for (EClass superType : ((EClass) t).getEAllSuperTypes()) { |
| if (BuiltinMetaModel.primEquals(superType, c1)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private static boolean primEquals(EClassifier c1, EClassifier obj) { |
| if (obj == null) { |
| return false; |
| } |
| if (c1 == obj) { |
| return true; |
| } |
| final boolean namesEqual = c1.getName().equals(obj.getName()); |
| if (!namesEqual) { |
| return false; |
| } |
| if (c1.getEPackage() == null) { |
| return obj.getEPackage() == null; |
| } |
| if (obj.getEPackage() == null) { |
| return false; |
| } |
| if (c1.getEPackage().getNsURI() == null) { |
| return obj.getEPackage().getNsURI() == null; |
| } |
| return c1.getEPackage().getNsURI().equals(obj.getEPackage().getNsURI()); |
| } |
| |
| private static boolean isCompatibleDataTypes(EDataType dt1, EDataType dt2) { |
| try { |
| final Class dt1Class = dt1.getInstanceClass(); |
| final Class dt2Class = dt2.getInstanceClass(); |
| if (dt1Class != null && dt2Class != null) { |
| if (dt1Class == Object.class) { |
| // anything (with or without wrapping) can be assigned to object |
| return true; |
| } |
| if (dt1Class.isPrimitive() && !dt2Class.isPrimitive()) { |
| Field f = dt2Class.getField("TYPE"); |
| return dt1Class.equals(f.get(null)); |
| } else if (!dt1Class.isPrimitive() && dt2Class.isPrimitive()) { |
| Field f = dt1Class.getField("TYPE"); |
| return dt2Class.equals(f.get(null)); |
| } |
| return dt1Class.isAssignableFrom(dt2Class); |
| } |
| if (dt1Class != null && dt2Class == null) { |
| // special case for dt2 datatype from dynamic model instance |
| // (e.g. model file in same workspace as template) |
| // hence no instance classes yet, but anything is assignable to Object |
| // Fixed while resolving #analyze of enum literals compare (==) |
| return dt1Class == Object.class; |
| } |
| } catch (NoSuchFieldException ex) { |
| // IGNORE |
| } catch (IllegalAccessException ex) { |
| // IGNORE |
| } |
| return false; |
| } |
| public static List<EStructuralFeature> getAllFeatures(EClassifier targetType) { |
| // FIXME @see getAllOperations |
| if (targetType instanceof EClass) { |
| return ((EClass) targetType).getEAllStructuralFeatures(); |
| } |
| return Collections.emptyList(); |
| } |
| |
| public static List<EOperation> getAllOperation(EClassifier targetType) { |
| // FIXME - either have datatypes like int/real as 'honest' EClasses, or |
| // provide their operations here |
| if (hasBuiltinSupport(targetType)) { |
| return findInternalOp(targetType); |
| } |
| if (targetType instanceof EClass) { |
| return ((EClass) targetType).getEAllOperations(); |
| } |
| /* |
| * XXX might be not bad idea to use java reflection to provide |
| * datatype's possible operations if (targetType instanceof EDataType && |
| * false == targetType instanceof EEnum) { EDataType dt = (EDataType) |
| * targetType; dt.getInstanceClass().getMethods() } |
| */ |
| return Collections.emptyList(); |
| } |
| } |
