protected Object convertValue(EStructuralFeature feature, Object value) {
String constantName = String.valueOf(value).toUpperCase();
Class<?> constants = SWT.class;
String constantClass =
EcoreUtil.getAnnotation(feature, SwtBuilder.getAnnotationUri(), "constantClass");
if (constantClass != null) {
try {
constants = context.convert(constantClass, Class.class);
} catch (Exception e) {
throw new IllegalArgumentException(
"Conversion from " + value + " failed: " + e.getMessage(), e);
}
}
if (feature.getEType() == EcorePackage.eINSTANCE.getEString()) {
String type = EcoreUtil.getAnnotation(feature, SwtBuilder.getAnnotationUri(), "type");
if ("int".equals(type)) {
value = SwtBuilder.getStaticField(constants, constantName, Integer.class, SWT.DEFAULT);
} else if (type != null) {
try {
Class<?> typeClass = context.convert(type, Class.class);
value = SwtBuilder.getStaticField(constants, constantName, typeClass, null);
} catch (Exception e) {
throw new IllegalArgumentException(
"Conversion from " + value + " to " + type + " failed: " + e.getMessage(), e);
}
}
} else if (feature.getEType()
== org.eclipse.e4.tm.swt.styles.StylesPackage.eINSTANCE.getSwtConstant()) {
value = SwtBuilder.getStaticField(constants, constantName, Integer.class, SWT.DEFAULT);
}
return value;
}
protected Declaration handleStyleFeature(Style style, EStructuralFeature feature) {
Declaration declaration = CssFactory.eINSTANCE.createDeclaration();
declaration.setProperty(feature.getName());
GMFToCSSConverter converter = GMFToCSSConverter.instance;
if (isString(feature)) {
declaration.setExpression(converter.convert((String) style.eGet(feature)));
}
if (isInteger(feature)) {
if (feature.getName().endsWith("Color")) {
Color color = FigureUtilities.integerToColor((Integer) style.eGet(feature));
declaration.setExpression(converter.convert(color));
color.dispose();
} else {
declaration.setExpression(converter.convert((Integer) style.eGet(feature)));
}
}
if (feature.getEType() == NotationPackage.eINSTANCE.getGradientData()) {
declaration.setExpression(converter.convert((GradientData) style.eGet(feature)));
}
if (feature.getEType() instanceof EEnum) {
declaration.setExpression(converter.convert((Enumerator) style.eGet(feature)));
}
if (isBoolean(feature)) {
declaration.setExpression(converter.convert((Boolean) style.eGet(feature)));
}
return declaration;
}
public DateFilterUtil(Class<T> eObjClass, EStructuralFeature... dateFeature) {
final EStructuralFeature tail = dateFeature[dateFeature.length - 1];
this.dateFeature = FeaturePath.fromList(dateFeature);
if (!Date.class.isAssignableFrom(tail.getEType().getInstanceClass())) {
throw new IllegalArgumentException(
"feature type " + tail.getEType().getInstanceClass() + " not a Date subclass");
}
}
@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>");
}
/* (non-Javadoc)
* @see com.hundsun.ares.studio.jres.ui.viewers.BaseEObjectColumnLabelProvider#getCopyText(java.lang.Object)
*/
@Override
public String getCopyText(Object element) {
Parameter p = (Parameter) getOwner(element);
EStructuralFeature feature = getEStructuralFeature(element);
if (feature.getEType().equals(EcorePackage.Literals.EBOOLEAN)
|| feature.getEType().equals(EcorePackage.Literals.EBOOLEAN_OBJECT)) {
return BooleanUtils.toStringTrueFalse((Boolean) p.eGet(feature));
} else {
return super.getCopyText(element);
}
}
protected boolean isInteger(EStructuralFeature feature) {
if (feature.getEType() == EcorePackage.eINSTANCE.getEInt()
|| feature.getEType() == EcorePackage.eINSTANCE.getEIntegerObject()) {
return true;
}
if (feature.getEType() instanceof EDataType) {
EDataType datatype = (EDataType) feature.getEType();
return datatype.getName().equals("Integer");
}
return false;
}
private void writeEmbedded(PrintWriter out, EObject eObject) throws SerializerException {
EClass class1 = eObject.eClass();
out.print(upperCases.get(class1));
out.print(OPEN_PAREN);
EStructuralFeature structuralFeature = class1.getEStructuralFeature(WRAPPED_VALUE);
if (structuralFeature != null) {
Object realVal = eObject.eGet(structuralFeature);
if (structuralFeature.getEType() == ECORE_PACKAGE_INSTANCE.getEDouble()) {
Object stringVal =
eObject.eGet(class1.getEStructuralFeature(structuralFeature.getName() + "AsString"));
if (stringVal != null && model.isUseDoubleStrings()) {
out.print(stringVal);
} else {
if (((Double) realVal).isInfinite() || (((Double) realVal).isNaN())) {
LOGGER.info("Serializing infinite or NaN double as 0.0");
out.print("0.0");
} else {
out.print(realVal);
}
}
} else {
writePrimitive(out, realVal);
}
}
out.print(CLOSE_PAREN);
}
/**
* Get the value of the named AD parameter for the activity as a string. Works with several types,
* not just strings -- enums, for example.
*
* @param element
* @param parameterName
* @return null if the parameter is not found
*/
public static String getParameterString(EPlanElement element, String parameterName) {
EObject data = element.getData();
if (data == null) return null;
EStructuralFeature feature;
try {
feature = getParameterFeature(data, parameterName);
} catch (UndefinedParameterException e) {
return null;
}
Object object = data.eGet(feature);
if (object instanceof EEnumLiteral) {
EEnumLiteral literal = (EEnumLiteral) object;
return literal.getName();
}
EClassifier type = feature.getEType();
if (type instanceof EDataType) {
EDataType dataType = (EDataType) type;
EPackage typePackage = dataType.getEPackage();
EFactory factory = typePackage.getEFactoryInstance();
String string = factory.convertToString(dataType, object);
return string;
}
LogUtil.warnOnce("feature type '" + type + "'is not EDataType: " + parameterName);
return String.valueOf(object);
}
public void addNavigatedDependency(
EStructuralFeature navigationFeature, EStructuralFeature dependantFeature) {
if (navigationFeature == null || dependantFeature == null) {
return;
}
if (!source.eClass().getEAllStructuralFeatures().contains(navigationFeature)) {
return;
}
if (!(navigationFeature.getEType() instanceof EClass)
|| !dependantFeature
.getEContainingClass()
.isSuperTypeOf((EClass) navigationFeature.getEType())) {
return;
}
addNavigatedDependencyInternal(navigationFeature, dependantFeature);
}
protected EObject createInitialModel() {
EClass eClass = ExtendedMetaData.INSTANCE.getDocumentRoot(dsPackage);
EStructuralFeature eStructuralFeature = eClass.getEStructuralFeature("data");
EObject rootObject = dsFactory.create(eClass);
rootObject.eSet(eStructuralFeature, EcoreUtil.create((EClass) eStructuralFeature.getEType()));
return rootObject;
}
public CharSequence assignmentOperator(final EStructuralFeature it) {
StringConcatenation _builder = new StringConcatenation();
{
boolean _isMany = it.isMany();
if (_isMany) {
_builder.append("+=");
} else {
boolean _and = false;
EClassifier _eType = it.getEType();
boolean _isBoolean = Ecore2XtextExtensions.isBoolean(_eType);
if (!_isBoolean) {
_and = false;
} else {
boolean _isPrefixBooleanFeature = Ecore2XtextExtensions.isPrefixBooleanFeature(it);
_and = (_isBoolean && _isPrefixBooleanFeature);
}
if (_and) {
_builder.append("?=");
} else {
_builder.append("=");
}
}
}
return _builder;
}
public Dynamic(InternalEObject owner, EStructuralFeature eStructuralFeature) {
super(
kind(eStructuralFeature),
wrapperClassFor(eStructuralFeature.getEType().getInstanceClass()),
owner);
this.eStructuralFeature = eStructuralFeature;
}
/** Constructor. */
public EEnumComboBoxDataProvider(Object axisElement) {
Object object = AxisUtils.getRepresentedElement(axisElement);
Assert.isTrue(object instanceof EStructuralFeature);
EStructuralFeature feature = (EStructuralFeature) object;
EClassifier type = feature.getEType();
Assert.isTrue(type instanceof EEnum);
this.eenum = (EEnum) type;
}
/**
* Returns the default alignment for the specific value type.
*
* <p>If you want to change the alignment use the <code>uibindings/model</code> and <code>
* uibindings/model/feature elements</code>.
*
* @param valueType the value type to test
* @return the default alignment
*/
public static int defaultAlignment(Object valueType) {
if (valueType instanceof EStructuralFeature) {
final EStructuralFeature sf = (EStructuralFeature) valueType;
valueType = sf.getEType();
}
final Integer alignment = DEFAULT_ALIGNMENT.get(valueType);
if (alignment != null) return alignment;
return SWT.NONE;
}
private void writeObject(PrintWriter out, EObject object, EStructuralFeature feature)
throws SerializerException {
Object ref = object.eGet(feature);
if (ref == null || (feature.isUnsettable() && !object.eIsSet(feature))) {
EClassifier type = feature.getEType();
if (type instanceof EClass) {
EStructuralFeature structuralFeature = ((EClass) type).getEStructuralFeature(WRAPPED_VALUE);
if (structuralFeature != null) {
String name = structuralFeature.getEType().getName();
if (name.equals(IFC_BOOLEAN)
|| name.equals(IFC_LOGICAL)
|| structuralFeature.getEType() == EcorePackage.eINSTANCE.getEBoolean()) {
out.print(BOOLEAN_UNDEFINED);
} else {
out.print(DOLLAR);
}
} else {
out.print(DOLLAR);
}
} else {
if (type == EcorePackage.eINSTANCE.getEBoolean()) {
out.print(BOOLEAN_UNDEFINED);
} else if (feature.isMany()) {
out.print("()");
} else {
out.print(DOLLAR);
}
}
} else {
if (ref instanceof EObject) {
writeEmbedded(out, (EObject) ref);
} else if (feature.getEType() == ECORE_PACKAGE_INSTANCE.getEDouble()) {
Object stringValue =
object.eGet(object.eClass().getEStructuralFeature(feature.getName() + "AsString"));
if (stringValue != null && model.isUseDoubleStrings()) {
out.print(stringValue);
} else {
writePrimitive(out, ref);
}
} else {
writePrimitive(out, ref);
}
}
}
public static int kind(EStructuralFeature eStructuralFeature) {
int result = 0;
EClassifier eClassifier = eStructuralFeature.getEType();
if (eClassifier.getInstanceClass() != null) {
result |= HAS_INSTANCE_CLASS;
}
if (eStructuralFeature.isUnsettable()) {
result |= IS_UNSETTABLE;
}
if (eStructuralFeature instanceof EReference) {
EReference eReference = (EReference) eStructuralFeature;
EReference inverseEReference = eReference.getEOpposite();
if (eReference.isContainment()) {
result |= IS_CONTAINMENT;
}
if (inverseEReference != null) {
// This forces the feature ids to be assigned.
//
inverseEReference.getEContainingClass().getFeatureCount();
result |= HAS_NAVIGABLE_INVERSE;
if (inverseEReference.isMany()) {
result |= HAS_MANY_INVERSE;
}
if (inverseEReference.isContainment()) {
result |= IS_CONTAINER;
}
}
if (eReference.isResolveProxies()) {
result |= HAS_PROXIES;
}
result |= IS_EOBJECT;
} else // if (eStructuralFeature instanceof EAttribute
{
if (eClassifier instanceof EEnum) {
result |= IS_ENUM;
} else {
Class<?> instanceClass = eClassifier.getInstanceClass();
if (instanceClass != null && instanceClass.isPrimitive()) {
result |= IS_PRIMITIVE;
}
}
}
if (eStructuralFeature.isUnique()) {
result |= IS_UNIQUE;
}
return result;
}
@Override
protected void saveEObjectSingle(EObject o, EStructuralFeature f) {
StringBuffer buffer = new StringBuffer();
EObject value = (EObject) helper.getValue(o, f);
if (value != null) {
String id = helper.getHREF(value);
if (id != null) {
id = convertURI(id);
buffer.setLength(0);
// if (!id.startsWith("#"))
// {
if (!o.eClass().getEPackage().getNsURI().equals(f.getEType().getEPackage().getNsURI())) {
EClass eClass = value.eClass();
EClass expectedType = (EClass) f.getEType();
if (saveTypeInfo
? xmlTypeInfo.shouldSaveType(eClass, expectedType, f)
: eClass != expectedType
&& (expectedType.isAbstract()
|| f.getEGenericType().getETypeParameter() != null)) {
buffer.append(helper.getQName(eClass));
buffer.append(' ');
}
}
// }
buffer.append(id);
if (!toDOM) {
String name = helper.getQName(f);
doc.startAttribute(name);
doc.addAttributeContent(buffer.toString());
doc.endAttribute();
} else {
helper.populateNameInfo(nameInfo, f);
Attr attr =
document.createAttributeNS(nameInfo.getNamespaceURI(), nameInfo.getQualifiedName());
attr.setNodeValue(buffer.toString());
((Element) currentNode).setAttributeNodeNS(attr);
handler.recordValues(attr, o, f, value);
}
}
}
}
public EnvironmentView(
@NonNull EnvironmentFactoryInternal environmentFactory,
@NonNull EStructuralFeature reference,
@Nullable String name) {
this.environmentFactory = environmentFactory;
this.reference = reference;
this.requiredType = reference.getEType();
this.isQualifier = false;
this.name = name;
}
/**
* Returns whether activity contains AD parameter of given type
*
* @param element
* @param parameterType
* @return
*/
@SuppressWarnings("unchecked")
public static boolean isParameterForType(EPlanElement element, EClass parameterType) {
EObject data = element.getData();
EList<EStructuralFeature> structuralFeatures = data.eClass().getEStructuralFeatures();
for (int i = 0; i < structuralFeatures.size(); i++) {
final EStructuralFeature feature = structuralFeatures.get(i);
if (parameterType == feature.getEType()) return true;
}
return false;
}
/**
* Creates and returns a <em>proxy</em> object. The usage of a proxy object is strongly limited.
* The only guarantee that can be made is that the following methods are callable and will behave
* in the expected way:
*
* <ul>
* <li>{@link CDOObject#cdoID()} will return the {@link CDOID} of the target object
* <li>{@link CDOObject#cdoState()} will return {@link CDOState#PROXY PROXY}
* <li>{@link InternalEObject#eIsProxy()} will return <code>true</code>
* <li>{@link InternalEObject#eProxyURI()} will return the EMF proxy URI of the target object
* </ul>
*
* Calling any other method on the proxy object will result in an {@link
* UnsupportedOperationException} being thrown at runtime. Note also that the proxy object might
* even not be cast to the concrete type of the target object. The proxy can only guaranteed to be
* of <em>any</em> concrete subtype of the declared type of the given feature.
*
* <p>TODO {@link InternalEObject#eResolveProxy(InternalEObject)}
*/
protected InternalEObject createProxy(
InternalCDOView view, EStructuralFeature feature, CDOID id) {
EClassifier eType = feature.getEType();
Class<?> instanceClass = eType.getInstanceClass();
Class<?>[] interfaces = {instanceClass, InternalEObject.class, LegacyProxy.class};
ClassLoader classLoader = CDOLegacyWrapper.class.getClassLoader();
LegacyProxyInvocationHandler handler = new LegacyProxyInvocationHandler(this, id);
return (InternalEObject) Proxy.newProxyInstance(classLoader, interfaces, handler);
}
/**
* Get the value of the AD parameter by type for the activity
*
* @param element
* @param parameterType
* @return
*/
@SuppressWarnings("unchecked")
public static <T> Option<T> getParameterObjectByType(EPlanElement element, EClass parameterType) {
EObject data = element.getData();
EList<EStructuralFeature> structuralFeatures = data.eClass().getEStructuralFeatures();
for (int i = 0; i < structuralFeatures.size(); i++) {
final EStructuralFeature feature = structuralFeatures.get(i);
if (parameterType == feature.getEType()) return Option.fromNull((T) data.eGet(feature));
}
return Option.none();
}
/**
* Add ReferenceableObject.
*
* @param referenceableObject
* @param eContainingFeature
* @return
*/
private EObject add(
ReferenceableObject referenceableObject, final EStructuralFeature eContainingFeature) {
assertNotNull("The editeur is not opened.", editor);
final EObject container = getEObjectFromReferenceableEObject(referenceableObject);
assertNotNull("No container is found to launch add action.", container);
final SWTBotTreeItem selectNode = selectNode(editor, container);
assertNotNull("No element is selected in the editor", selectNode);
SWTBotHelper.clickContextMenu(selectNode, eContainingFeature.getEType().getName());
SWTBotHelper.waitAllUiEvents();
return (EObject) EEFModelHelper.eGet(container, eContainingFeature);
}
/**
* This method retrieves the value from the feature at the given index. It retrieves the value
* either from the views's store or the internal pre-registration Map.
*
* @param feature the feature to retrieve the value from
* @param index the given index of the object in the feature
* @return the value from the feature at the given index
*/
private Object getValueFromRevision(EStructuralFeature feature, int index) {
InternalCDORevision revision = cdoRevision();
Object object = revision.get(feature, index);
if (object == null) {
return null;
}
if (object instanceof CDOElementProxy) {
// Resolve proxy
CDOElementProxy proxy = (CDOElementProxy) object;
object =
viewAndState
.view
.getSession()
.resolveElementProxy(revision, feature, index, proxy.getIndex());
}
if (object instanceof CDOLegacyWrapper) {
return ((CDOLegacyWrapper) object).cdoInternalInstance();
}
CDOType type = CDOModelUtil.getType(feature.getEType());
object = viewAndState.view.getStore().convertToEMF(instance, revision, feature, index, object);
if (type == CDOType.OBJECT) {
if (object instanceof CDOID) {
CDOID id = (CDOID) object;
if (id.isNull()) {
return null;
}
object = getRegisteredWrapper(id);
if (object != null) {
return ((CDOLegacyWrapper) object).cdoInternalInstance();
}
if (id.isExternal()) {
object =
viewAndState
.view
.getResourceSet()
.getEObject(URI.createURI(id.toURIFragment()), true);
} else {
object = viewAndState.view.getObject(id);
}
if (object instanceof CDOObjectWrapper) {
return ((CDOObjectWrapper) object).cdoInternalInstance();
}
}
}
return object;
}
public static boolean isMultiChoice(EObject object, EStructuralFeature feature) {
if (feature.getEType() instanceof EClass) {
ExtendedPropertiesAdapter adapter =
(ExtendedPropertiesAdapter) AdapterUtil.adapt(object, ExtendedPropertiesAdapter.class);
if (adapter != null) {
Object result = adapter.getProperty(feature, ExtendedPropertiesAdapter.UI_IS_MULTI_CHOICE);
if (result instanceof Boolean) return ((Boolean) result);
}
}
return getChoiceOfValues(object, feature) != null;
}
public static boolean canEditInline(EObject object, EStructuralFeature feature) {
if (feature.getEType() instanceof EClass) {
ExtendedPropertiesAdapter adapter =
(ExtendedPropertiesAdapter) AdapterUtil.adapt(object, ExtendedPropertiesAdapter.class);
if (adapter != null) {
Object result = adapter.getProperty(feature, ExtendedPropertiesAdapter.UI_CAN_EDIT_INLINE);
if (result instanceof Boolean) return ((Boolean) result);
}
}
return false;
}
public static boolean canCreateNew(EObject object, EStructuralFeature feature) {
if (feature.getEType() instanceof EClass) {
ExtendedPropertiesAdapter adapter =
(ExtendedPropertiesAdapter) AdapterUtil.adapt(object, ExtendedPropertiesAdapter.class);
if (adapter != null) {
Object result = adapter.getProperty(feature, ExtendedPropertiesAdapter.UI_CAN_CREATE_NEW);
if (result instanceof Boolean) return ((Boolean) result);
}
return true;
}
return false;
}
@Override
public boolean isStereotype(
@NonNull EnvironmentFactoryInternal environmentFactory, @NonNull EClass eClass) {
for (EStructuralFeature eFeature : eClass.getEAllStructuralFeatures()) {
EClassifier eType = eFeature.getEType();
if (eType != null) {
assert !eType.eIsProxy() : "Unresolved proxy: '" + EcoreUtil.getURI(eType) + "'";
EPackage ePackage = eType.getEPackage();
assert !"http://www.eclipse.org/uml2/5.0.0/UML".equals(ePackage.getNsURI());
}
}
return false;
}
public static Collection<EClass> filterByFeatureSeqInitializer(
Collection<EClass> eClasses, FeatureSeqInitializer featureSeqInitializer) {
if (featureSeqInitializer.getCreatingInitializer() != null) {
EStructuralFeature feature = featureSeqInitializer.getCreatingInitializer().getFeature();
if (feature != null && feature.getEType() instanceof EClass) {
for (Iterator<EClass> it = eClasses.iterator(); it.hasNext(); ) {
EClass nextEClass = it.next();
EClass typeEClass = (EClass) feature.getEType();
if (nextEClass == null
|| nextEClass.isAbstract()
|| nextEClass.isInterface()
|| !typeEClass.isSuperTypeOf(nextEClass)) {
it.remove();
}
}
}
} else if (featureSeqInitializer.getElementClass() != null) {
return Collections.singleton(featureSeqInitializer.getElementClass());
}
return eClasses;
}
/**
* Method which looks up structural features of an eobject by type.
*
* @param eobject The eobject.
* @param propertyType The type of the properties.
* @return The list of structure features, or an empty list if none are found.
*/
public static List /*<EStructuralFeature>*/ features(EObject eobject, Class propertyType) {
List match = new ArrayList();
List features = eobject.eClass().getEAllStructuralFeatures();
for (Iterator itr = features.iterator(); itr.hasNext(); ) {
EStructuralFeature feature = (EStructuralFeature) itr.next();
if (feature.getEType().getInstanceClass().isAssignableFrom(propertyType)) {
match.add(feature);
}
}
return match;
}
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);
}
