private EClassifier resolveFeatureType(
EStructuralFeature feature,
Collection<EClassifierMapping> eClassifierMappings,
Collection<EPackage> ePackages) {
EAnnotation eAnnotation = feature.getEAnnotation(TypesPackage.eNS_URI);
if (eAnnotation != null) {
JvmTypeReference type = getEObject(eAnnotation.getReferences(), JvmTypeReference.class, null);
if (type == null) {
return null;
}
EClassifier eClassifier = null;
for (EClassifierMapping eClassifierMapping : eClassifierMappings) {
if (eClassifierMapping.getDeclaredType() == type) {
eClassifier = eClassifierMapping.getEClassifier();
break;
}
}
String typeName = getTypeName(type);
if (eClassifier == null) {
for (EPackage ePackage : ePackages) {
eClassifier = findEClassifier(typeName, ePackage);
if (eClassifier != null) {
break;
}
}
}
if (eClassifier == null) {
eClassifier = findEClassifier(typeName, EcorePackage.eINSTANCE);
}
feature.setEType(eClassifier);
return eClassifier;
}
return null;
}
private void writeEDataType(PrintWriter out, EObject object, EStructuralFeature feature)
throws SerializerException {
if (feature.getEAnnotation("derived") != null) {
out.print(ASTERISK);
} else if (feature.isMany()) {
writeList(out, object, feature);
} else {
writeObject(out, object, feature);
}
}
@SuppressWarnings("unchecked")
private void writeTable(PrintWriter out, EObject eObject) {
out.println("<h1>" + eObject.eClass().getName() + "</h1>");
out.println("<table>");
for (EStructuralFeature eStructuralFeature : eObject.eClass().getEAllStructuralFeatures()) {
if (eStructuralFeature.getEAnnotation("hidden") == null) {
out.println("<tr>");
out.println("<td>" + eStructuralFeature.getName() + "</td>");
Object eGet = eObject.eGet(eStructuralFeature);
if (eStructuralFeature instanceof EAttribute) {
if (eStructuralFeature.getUpperBound() == 1) {
out.println("<td>" + eGet + "</td>");
} else {
List<Object> list = (List<Object>) eGet;
out.println("<td>");
for (Object object : list) {
out.println(object + " ");
}
out.println("</td>");
}
} else if (eStructuralFeature instanceof EReference) {
if (eStructuralFeature.getUpperBound() == 1) {
if (eStructuralFeature.getEType().getEAnnotation("wrapped") != null) {
EObject value = (EObject) eGet;
if (value != null) {
out.println(
"<td>"
+ value.eGet(value.eClass().getEStructuralFeature("wrappedValue"))
+ "</td>");
}
} else {
}
} else {
if (eStructuralFeature.getEType().getEAnnotation("wrapped") != null) {
List<EObject> list = (List<EObject>) eGet;
out.println("<td>");
for (EObject object : list) {
out.println(
"<td>"
+ object.eGet(object.eClass().getEStructuralFeature("wrappedValue"))
+ "</td>");
}
out.println("</td>");
} else {
}
}
}
}
out.println("</tr>");
}
out.println("</table>");
}
private void write(PrintWriter out, IdEObject object) throws SerializerException {
EClass eClass = object.eClass();
if (eClass.getEAnnotation("hidden") != null) {
return;
}
out.print(DASH);
int convertedKey = getExpressId(object);
if (convertedKey == -1) {
throw new SerializerException(
"Going to serialize an object with id -1 (" + object.eClass().getName() + ")");
}
out.print(String.valueOf(convertedKey));
out.print("= ");
String upperCase = upperCases.get(eClass);
if (upperCase == null) {
throw new SerializerException("Type not found: " + eClass.getName());
}
out.print(upperCase);
out.print(OPEN_PAREN);
boolean isFirst = true;
for (EStructuralFeature feature : eClass.getEAllStructuralFeatures()) {
if (!feature.isDerived() && feature.getEAnnotation("hidden") == null) {
EClassifier type = feature.getEType();
if (type instanceof EEnum) {
if (!isFirst) {
out.print(COMMA);
}
writeEnum(out, object, feature);
isFirst = false;
} else if (type instanceof EClass) {
if (!isInverse(feature)) {
if (!isFirst) {
out.print(COMMA);
}
writeEClass(out, object, feature);
isFirst = false;
}
} else if (type instanceof EDataType) {
if (!isFirst) {
out.print(COMMA);
}
writeEDataType(out, object, feature);
isFirst = false;
}
}
}
out.println(PAREN_CLOSE_SEMICOLON);
}
private void writeEClass(PrintWriter out, EObject object, EStructuralFeature feature)
throws SerializerException {
Object referencedObject = object.eGet(feature);
if (referencedObject instanceof IdEObject
&& ((IdEObject) referencedObject).eClass().getEAnnotation("wrapped") != null) {
writeWrappedValue(out, object, feature, ((EObject) referencedObject).eClass());
} else {
if (referencedObject instanceof EObject && model.contains((IdEObject) referencedObject)) {
out.print(DASH);
out.print(String.valueOf(getExpressId((IdEObject) referencedObject)));
} else {
if (feature.getEAnnotation("derived") != null) {
out.print(ASTERISK);
} else if (feature.isMany()) {
writeList(out, object, feature);
} else {
writeObject(out, object, feature);
}
}
}
}
// TODO ! need new presentation of set-text-selection command or hide args
protected void convertSimple(Command command, ICommandFormatter formatter, boolean hasInput) {
String commandName = CoreUtils.getScriptletNameByClass(command.eClass());
formatter.addCommandName(commandName);
Map<EStructuralFeature, Command> bindingMap = new HashMap<EStructuralFeature, Command>();
for (Binding b : command.getBindings()) {
bindingMap.put(b.getFeature(), b.getCommand());
}
List<EStructuralFeature> attributes = CoreUtils.getFeatures(command.eClass());
boolean forced = false;
boolean bigTextCommand =
commandName.equals("upload-file") || commandName.equals("match-binary");
for (EStructuralFeature feature : attributes) {
if (feature.getEAnnotation(CoreUtils.INTERNAL_ANN) != null) continue;
if (feature.getEAnnotation(CoreUtils.INPUT_ANN) != null && hasInput) continue;
String name = feature.getName();
if (isForced(commandName, name)) forced = true;
Object val = command.eGet(feature);
boolean skippped = true;
Object defaultValue = feature.getDefaultValue();
boolean isDefault = val == null || val.equals(defaultValue);
if (!isDefault) {
if (feature instanceof EAttribute) {
EAttribute attr = (EAttribute) feature;
String type = attr.getEAttributeType().getInstanceTypeName();
if (val instanceof List<?>) {
List<?> list = (List<?>) val;
for (Object o : list) {
String value = convertValue(o, type);
if (value != null) {
formatter.addAttrName(name, forced);
formatter.addAttrValue(value);
skippped = false;
}
}
} else {
if (val.equals(true)) {
forced = true;
formatter.addAttrName(name, forced);
} else {
String value = convertValue(val, type);
if (value != null) {
formatter.addAttrName(name, forced);
if (bigTextCommand) formatter.addAttrValueWithLineBreak(value);
else formatter.addAttrValue(value);
skippped = false;
}
}
}
} else {
EReference ref = (EReference) feature;
EClass eclass = ref.getEReferenceType();
if (eclass.getEPackage() == CorePackage.eINSTANCE
&& eclass.getClassifierID() == CorePackage.COMMAND) {
boolean singleLine = !(val instanceof Sequence);
formatter.addAttrName(name, forced);
formatter.openGroup(singleLine);
doConvert((Command) val, formatter, true);
formatter.closeGroup(singleLine);
skippped = false;
} else {
IParamConverter<?> converter =
ParamConverterManager.getInstance().getConverter(eclass.getInstanceClass());
if (converter != null) {
try {
String strVal = String.format("\"%s\"", converter.convertToCode(val));
formatter.addAttrValue(strVal);
} catch (CoreException e) {
CorePlugin.log(e.getStatus());
}
}
}
}
} else {
Command c = bindingMap.get(feature);
if (c != null) {
formatter.addAttrName(name, forced);
formatter.openExec();
doConvert(c, formatter, hasInput);
formatter.closeExec();
skippped = false;
}
}
if (skippped) forced = true;
}
}