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; }
/** * CDO persists the isUnset state of an eObject in the database. The indicator for this is that * the feature is null in the revision (see CDOStore.isSet()). When committing a legacy object all * values in the instance for native attributes are set with the java default values. So, these * values will be stored in the revision and CDO cannot distinguish whether the feature is set or * not. This method must ensure that the value will be set to null if the feature is not set. */ public void cdoInternalPreCommit() { // We have to set this here because the CDOLegacyAdapter will not be notified when the instance // is the target of a // single-directional containment reference. // If the container is not an legacy Object the system will get no information instanceToRevisionContainment(); InternalCDORevision revision = cdoRevision(); for (EStructuralFeature feature : classInfo.getAllPersistentFeatures()) { if (feature.isUnsettable()) { if (!isSetInstanceValue(instance, feature)) { if (feature.isMany()) { @SuppressWarnings("unchecked") InternalEList<Object> list = (InternalEList<Object>) instance.eGet(feature); clearEList(list); } else { revision.set(feature, EStore.NO_INDEX, null); } } else if (instance.eGet(feature) == null) { // Must be single-valued! revision.set(feature, EStore.NO_INDEX, CDORevisionData.NIL); } } } }
public static boolean isMany(EClass eClass, String featureName) { if (eClass == null || featureName == null) { return false; } EStructuralFeature feature = eClass.getEStructuralFeature(featureName); return feature != null && feature.isMany(); }
UncontrolUpdate( EStructuralFeature.Setting setting, EObject originalObject, CDOID originalProxy, URI destinationURI, CDOID destinationProxy) { super(setting); this.originalObject = originalObject; this.originalProxy = originalProxy; this.destinationURI = destinationURI; this.destinationProxy = destinationProxy; EStructuralFeature feature = setting.getEStructuralFeature(); InternalEObject owner = (InternalEObject) setting.getEObject(); if (!feature.isMany()) { index = EStore.NO_INDEX; } else { // don't go directly to the store because it may have proxies. // Use the resolved view in the EObject, instead index = ((EList<?>) owner.eGet(feature)).indexOf(originalObject); if (index < 0) { Activator.log.error( "Setting does not include the object being replaced by a proxy.", null); //$NON-NLS-1$ } } }
/** * 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); }
/* * (non-Javadoc) * * @see com.puppetlabs.geppetto.pp.dsl.linking.IMessageAcceptor#accept(org.eclipse.xtext.diagnostics.Severity, java.lang.String, * org.eclipse.emf.ecore.EObject, org.eclipse.emf.ecore.EStructuralFeature, int, java.lang.String, java.lang.String) */ @Override public void accept( Severity severity, String message, EObject source, EStructuralFeature feature, int index, String issueCode, String... issueData) { if (severity == null) throw new IllegalArgumentException("severity can not be null"); if (feature == null) throw new IllegalArgumentException("feature can not be null"); if (source == null) throw new IllegalArgumentException("source can not be null"); if (source.eClass().getEStructuralFeature(feature.getName()) != feature) { throw new IllegalArgumentException( "EClass '" + source.eClass().getName() + "' does not expose a feature '" + feature.getName() + // "' (id: " + feature.getFeatureID() + ")"); } producer.setNode(getNode(source, feature, index)); DiagnosticMessage m = new DiagnosticMessage(message, severity, issueCode, issueData); producer.addDiagnostic(m); }
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; }
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; }
@SuppressWarnings({"unchecked", "rawtypes"}) private void setSourceRef( DataAssociation association, ItemAwareElement value, EObject container, EStructuralFeature containerFeature) { if (association.getSourceRef().size() == 0) { if (container != null) { if (containerFeature.isMany()) ((List) container.eGet(containerFeature)).add(value); else container.eSet(containerFeature, value); } if (value == null) association.getSourceRef().clear(); else association.getSourceRef().add(value); updateConnectionIfNeeded(association, value); } else { if (container != null) { if (containerFeature.isMany()) ((List) container.eGet(containerFeature)).add(value); else container.eSet(containerFeature, value); } updateConnectionIfNeeded(association, value); if (value == null) association.getSourceRef().clear(); else association.getSourceRef().set(0, value); updateConnectionIfNeeded(association, value); } if (association.getTargetRef() != null) { ItemAwareElement targetRef = association.getTargetRef(); if (value != null) targetRef.setItemSubjectRef(value.getItemSubjectRef()); else targetRef.setItemSubjectRef(null); updateConnectionIfNeeded(association, value); } }
protected Map<Declaration, Boolean> handleStyle(Style style) { if (style instanceof NamedStyle) { return Collections.emptyMap(); } Map<Declaration, Boolean> declarations = new LinkedHashMap<Declaration, Boolean>(); for (EStructuralFeature feature : style.eClass().getEAllStructuralFeatures()) { if (NotationPackage.eINSTANCE.getStyle().isSuperTypeOf(feature.getEContainingClass())) { Object currentValue = style.eGet(feature); Object defaultValue = feature.getDefaultValue(); boolean check = currentValue == null ? currentValue != defaultValue : !currentValue.equals(defaultValue); Declaration declaration = handleStyleFeature(style, feature); if (declaration.getExpression() != null) { // If expression is null, the type of this property is not supported declarations.put(declaration, check); } } } return declarations; }
protected String toString(IEObjectRegion region) { EObject obj = region.getSemanticElement(); StringBuilder builder = new StringBuilder(Strings.padEnd(toClassWithName(obj), textWidth, ' ') + " "); EObject element = region.getGrammarElement(); if (element instanceof AbstractElement) builder.append(grammarToString.apply((AbstractElement) element)); else if (element instanceof AbstractRule) builder.append(((AbstractRule) element).getName()); else builder.append(": ERROR: No grammar element."); List<String> segments = Lists.newArrayList(); EObject current = obj; while (current.eContainer() != null) { EObject container = current.eContainer(); EStructuralFeature containingFeature = current.eContainingFeature(); StringBuilder segment = new StringBuilder(); segment.append(toClassWithName(container)); segment.append("/"); segment.append(containingFeature.getName()); if (containingFeature.isMany()) { int index = ((List<?>) container.eGet(containingFeature)).indexOf(current); segment.append("[" + index + "]"); } current = container; segments.add(segment.toString()); } if (!segments.isEmpty()) { builder.append(" path:"); builder.append(Joiner.on("=").join(segments)); } return builder.toString(); }
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; }
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; }
/* (non-Javadoc) * @see org.eclipse.graphiti.features.IFeature#canExecute(org.eclipse.graphiti.features.context.IContext) */ @Override public boolean canExecute(IContext context) { // TODO: clean this mess up: use {@code getWorkItemEditor()) to check if the selected task // has a WID and if the WID defines a customEditor BPMN2Editor editor = (BPMN2Editor) getFeatureProvider() .getDiagramTypeProvider() .getDiagramBehavior() .getDiagramContainer(); IBpmn2RuntimeExtension rte = editor.getTargetRuntime().getRuntimeExtension(); if (rte instanceof JBPM5RuntimeExtension && context instanceof ICustomContext) { PictogramElement[] pes = ((ICustomContext) context).getPictogramElements(); if (pes.length == 1) { Object o = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(pes[0]); if (o instanceof Task) { Task task = (Task) o; List<EStructuralFeature> features = ModelDecorator.getAnyAttributes(task); for (EStructuralFeature f : features) { if ("taskName".equals(f.getName())) { // $NON-NLS-1$ // make sure the Work Item Definition exists String taskName = (String) task.eGet(f); return ((JBPM5RuntimeExtension) rte).getWorkItemDefinition(taskName) != null; } } } } } 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); }
protected boolean matchesFeature(Object featureObj) { if (featureObj instanceof EStructuralFeature) { EStructuralFeature f = (EStructuralFeature) featureObj; return feature.getName().equals(f.getName()); } return false; }
/** 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; }
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"); } }
/** * Tests the behavior of reference <code>conflict</code>'s accessors. * * @generated */ @Test public void testConflict() { EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Conflict(); ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange(); referenceChange.eAdapters().add(new MockEAdapter()); org.eclipse.emf.compare.Conflict conflictValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE.createConflict(); assertFalse(referenceChange.eIsSet(feature)); assertNull(referenceChange.getConflict()); referenceChange.setConflict(conflictValue); assertTrue(notified); notified = false; assertSame(conflictValue, referenceChange.getConflict()); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature)); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false)); assertTrue(referenceChange.eIsSet(feature)); assertTrue(conflictValue.getDifferences().contains(referenceChange)); referenceChange.eUnset(feature); assertTrue(notified); notified = false; assertNull(referenceChange.getConflict()); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature)); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false)); assertFalse(referenceChange.eIsSet(feature)); assertFalse(conflictValue.getDifferences().contains(referenceChange)); referenceChange.setConflict(conflictValue); assertTrue(notified); notified = false; assertSame(conflictValue, referenceChange.getConflict()); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature)); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false)); assertTrue(referenceChange.eIsSet(feature)); assertTrue(conflictValue.getDifferences().contains(referenceChange)); referenceChange.eSet(feature, conflictValue); assertTrue(notified); notified = false; assertSame(conflictValue, referenceChange.getConflict()); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature)); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false)); assertTrue(referenceChange.eIsSet(feature)); assertTrue(conflictValue.getDifferences().contains(referenceChange)); referenceChange.setConflict(null); assertTrue(notified); notified = false; assertNull(referenceChange.getConflict()); assertSame(feature.getDefaultValue(), referenceChange.getConflict()); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature)); assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false)); assertFalse(referenceChange.eIsSet(feature)); assertFalse(conflictValue.getDifferences().contains(referenceChange)); }
@Override public void revert() { EStructuralFeature feature = setting.getEStructuralFeature(); if (index >= 0 || !feature.isMany()) { InternalEObject owner = (InternalEObject) setting.getEObject(); store.set(owner, feature, index, CDOUtils.getCDOID(originalObject)); } }
/** * 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; }
protected Task createFlowElement(ICreateContext context) { Task task = ModelHandler.FACTORY.createTask(); task.setName("Email Task"); ArrayList<EStructuralFeature> attributes = Bpmn2Preferences.getAttributes(task.eClass()); for (EStructuralFeature eStructuralFeature : attributes) { if (eStructuralFeature.getName().equals("taskName")) task.eSet(eStructuralFeature, "email"); } return task; }
@Override public void apply() { EStructuralFeature feature = setting.getEStructuralFeature(); if ((index >= 0) || !feature.isMany()) { InternalEObject owner = (InternalEObject) setting.getEObject(); store.set(owner, feature, index, proxy); } }
/** * @return the result feature delta, or <code>null</code> to indicate an unresolved conflict. */ protected CDOFeatureDelta changedInSourceAndTarget( CDOFeatureDelta targetFeatureDelta, CDOFeatureDelta sourceFeatureDelta) { EStructuralFeature feature = targetFeatureDelta.getFeature(); if (feature.isMany()) { return changedInSourceAndTargetManyValued(feature, targetFeatureDelta, sourceFeatureDelta); } return changedInSourceAndTargetSingleValued(feature, targetFeatureDelta, sourceFeatureDelta); }
public static void markFeatureAsStatic(EStructuralFeature eFeature) { IntermediateStaticFieldAdapter adapter = (IntermediateStaticFieldAdapter) EcoreUtil.getAdapter(eFeature.eAdapters(), IntermediateStaticFieldAdapter.class); if (adapter == null) { adapter = new IntermediateStaticFieldAdapter(); eFeature.eAdapters().add(adapter); } }
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; }
public String syntheticName(final KeyAST b) { final EObject binding = b.eContainer(); EStructuralFeature _eContainingFeature = b.eContainingFeature(); String _name = _eContainingFeature.getName(); String _plus = ("_" + _name); EObject _eContainer = binding.eContainer(); EList<EObject> _eContents = _eContainer.eContents(); int _indexOf = _eContents.indexOf(binding); return (_plus + Integer.valueOf(_indexOf)); }
/** * 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(); }
/** * 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; }
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); } }