/*******************************************************************************
* 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();
}
}
