@Override public EList<XExpression> getExplicitArguments() { BasicEList<XExpression> result = new BasicEList<XExpression>(); if (getMemberCallTarget() != null) result.add(getMemberCallTarget()); result.addAll(getMemberCallArguments()); return result; }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * This is specialized for the more specific element type known in this context. * * @generated */ @Override public Link[] getValues() { if (values == null || values.isEmpty()) return VALUES_EEMPTY_ARRAY; BasicEList<Link> list = (BasicEList<Link>) values; list.shrink(); return (Link[]) list.data(); }
private EList<Instance> connectorConfiguratiobInstanceList(final String... defIds) { final BasicEList<Instance> instances = new BasicEList<Instance>(); for (final String defId : defIds) { instances.add(aConnectorConfigurationInstance(defId, "1.0")); } return instances; }
/** Returns a default class path. This is the root of the project */ protected static EList<MindPathEntry> defaultMindpath(IProject p) { MindPathEntry ret = MindideFactory.eINSTANCE.createMindPathEntry(); ret.setName(p.getFolder("src").getFullPath().toPortableString()); ret.setEntryKind(MindPathKind.SOURCE); BasicEList<MindPathEntry> retL = new BasicEList<MindPathEntry>(); retL.add(ret); return retL; }
public GrEMFStructuralFeaturesList( InternalEObject owner, BasicEList<EStructuralFeature> eAllStructuralFeatures) { super( owner, EcorePackage.eINSTANCE.getEClass_EAllStructuralFeatures(), eAllStructuralFeatures.size(), eAllStructuralFeatures.data()); this.init(); }
private void init() { BasicEList<EStructuralFeature> contains = new UniqueEList<EStructuralFeature>(this.size); BasicEList<EStructuralFeature> crossRefs = new UniqueEList<EStructuralFeature>(this.size); for (int i = 0; i < this.size; ++i) { EStructuralFeature eFeature = (EStructuralFeature) this.data[i]; if (eFeature instanceof EReference) { EReference eReference = (EReference) eFeature; if (eReference.isContainment()) { contains.add(eReference); } else if (!eReference.isContainer()) { crossRefs.add(eReference); } } } contains.shrink(); crossRefs.shrink(); this.containments = new EStructuralFeature[contains.size()]; this.crossReferences = new EStructuralFeature[crossRefs.size()]; int i = 0; for (EStructuralFeature feature : contains) { this.containments[i++] = feature; } i = 0; for (EStructuralFeature feature : crossRefs) { this.crossReferences[i++] = feature; } }
private void initWorkLists( int originSize, BasicEList<Element> ancestorList, PerSide<BasicEList<Element>> listPerSide) { BasicEList<Element> sourceList = new BasicEList<Element>(originSize); BasicEList<Element> targetList = new BasicEList<Element>(originSize); for (int i = 0; i < originSize; i++) { Element element = new Element(i); ancestorList.add(element); sourceList.add(element); targetList.add(element); } listPerSide.set(Side.SOURCE, sourceList); listPerSide.set(Side.TARGET, targetList); }
protected static EList<Transition> _privk3_getActiveTransitions( final RegionAspectRegionAspectProperties _self_, final Region _self, final AbstractState vertex, final EList<String> events) { final BasicEList<Transition> res = new BasicEList<Transition>(); EList<Transition> _outgoing = vertex.getOutgoing(); for (final Transition transition : _outgoing) { boolean _or = false; Trigger _trigger = transition.getTrigger(); boolean _equals = Objects.equal(_trigger, null); if (_equals) { _or = true; } else { boolean _or_1 = false; boolean _and = false; Trigger _trigger_1 = transition.getTrigger(); boolean _notEquals = (!Objects.equal(_trigger_1, null)); if (!_notEquals) { _and = false; } else { Trigger _trigger_2 = transition.getTrigger(); boolean _evalTrigger = TriggerAspect.evalTrigger(_trigger_2, events); _and = _evalTrigger; } if (_and) { _or_1 = true; } else { boolean _and_1 = false; AbstractState _target = transition.getTarget(); if (!(_target instanceof Pseudostate)) { _and_1 = false; } else { AbstractState _target_1 = transition.getTarget(); _and_1 = (_target_1 instanceof Junction); } _or_1 = _and_1; } _or = _or_1; } if (_or) { res.add(transition); } } return res; }
@Override public EList<MindLibOrProject> getUses() { BasicEList<MindLibOrProject> ret = new BasicEList<MindLibOrProject>(); for (MindPathEntry mpe : mindpathentries) { MindObject resolvedObject = mpe.getResolvedBy(); if (resolvedObject == null) continue; MindLibOrProject mp = null; if (resolvedObject instanceof MindRootSrc) { MindRootSrc s = (MindRootSrc) resolvedObject; mp = s.getProject(); } else if (resolvedObject instanceof MindPackage) { MindPackage mdPacakage = (MindPackage) resolvedObject; MindRootSrc s = mdPacakage.getRootsrc(); if (s == null) continue; mp = s.getProject(); } else if (resolvedObject instanceof MindProject) { mp = (MindProject) resolvedObject; } if (mp == null || ret.contains(mp)) continue; ret.add(mp); } return ret; }
/* * Reads and decode an XML classpath string */ public static EList<MindPathEntry> decodeMindpath(String xmlMindpath) throws IOException { BasicEList<MindPathEntry> paths = new BasicEList<MindPathEntry>(); StringReader reader = new StringReader(xmlMindpath); Element cpElement; try { DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder(); cpElement = parser.parse(new InputSource(reader)).getDocumentElement(); } catch (SAXException e) { e.printStackTrace(); throw new IOException("Bad format"); } catch (ParserConfigurationException e) { throw new IOException("Bad format"); } finally { reader.close(); } if (!cpElement .getNodeName() .equalsIgnoreCase(MindPathEntryCustomImpl.TAG_MINDPATH)) { // $NON-NLS-1$ throw new IOException("Bad format"); } NodeList list = cpElement.getElementsByTagName(MindPathEntryCustomImpl.TAG_MINDPATHENTRY); // $NON-NLS-1$ int length = list.getLength(); for (int i = 0; i < length; ++i) { Node node = list.item(i); if (node.getNodeType() == Node.ELEMENT_NODE) { MindPathEntry entry = MindPathEntryCustomImpl.elementDecode((Element) node); if (entry != null) { paths.add(entry); } } } return paths; }
private void pickChangesIntoResult( Side side, EStructuralFeature feature, BasicEList<Element> ancestorList, PerSide<List<CDOFeatureDelta>> changesPerSide, Map<CDOFeatureDelta, Element> allElements, Map<Object, List<Element>> additions, List<CDOFeatureDelta> result) { List<CDOFeatureDelta> changes = changesPerSide.get(side); for (CDOFeatureDelta change : changes) { Type changeType = change.getType(); switch (changeType) { case ADD: { CDOAddFeatureDeltaImpl addChange = (CDOAddFeatureDeltaImpl) change; result.add(addChange); int sideIndex = addChange.getIndex(); int ancestorIndex = sideIndex; int ancestorEnd = ancestorList.size(); if (ancestorIndex > ancestorEnd) { // TODO Better way to adjust ancestor indexes? ancestorIndex = ancestorEnd; addChange.setIndex(ancestorIndex); } Element newElement = allElements.get(addChange); ancestorList.add(ancestorIndex, newElement); if (treatAsUnique(feature)) { // Detect and remove corresponding AddDeltas from the other side Object value = addChange.getValue(); List<Element> elementsToAdd = additions.get(value); if (elementsToAdd != null) { for (Element element : elementsToAdd) { CDOAddFeatureDelta otherAdd = (CDOAddFeatureDelta) element.get(other(side)); if (otherAdd != null) { element.set(other(side), null); // Not taking an AddDelta has the same effect on indexes as a removal of the // element List<CDOFeatureDelta> otherChanges = changesPerSide.get(other(side)); int otherIndex = otherAdd.getIndex(); adjustAfterRemoval(otherChanges, otherIndex, addChange); } } } } break; } case REMOVE: { CDORemoveFeatureDeltaImpl removeChange = (CDORemoveFeatureDeltaImpl) change; result.add(removeChange); Element removedElement = allElements.get(removeChange); int ancestorIndex = ancestorList.indexOf(removedElement); removeChange.setIndex(ancestorIndex); ancestorList.remove(ancestorIndex); // Detect and remove a potential duplicate RemoveDelta from the other side CDOFeatureDelta otherChange = removedElement.get(other(side)); if (otherChange != null) { Type otherChangeType = otherChange.getType(); switch (otherChangeType) { case REMOVE: { CDORemoveFeatureDelta otherRemove = (CDORemoveFeatureDelta) otherChange; removedElement.set(other(side), null); // Not taking a RemoveDelta has the same effect on indexes as an addition of // the element List<CDOFeatureDelta> otherChanges = changesPerSide.get(other(side)); int otherIndex = otherRemove.getIndex(); adjustAfterAddition(otherChanges, otherIndex, otherRemove); break; } case MOVE: { CDOMoveFeatureDelta otherMove = (CDOMoveFeatureDelta) otherChange; removedElement.set(other(side), null); // Not taking a MoveDelta has the same effect on indexes as a reverse move // of the element List<CDOFeatureDelta> otherChanges = changesPerSide.get(other(side)); int otherOldPosition = otherMove.getOldPosition(); int otherNewPosition = otherMove.getNewPosition(); adjustAfterMove( otherChanges, otherOldPosition, otherNewPosition, otherMove); break; } default: throw new IllegalStateException("Unexpected change type: " + otherChangeType); } } break; } case SET: { throw new IllegalStateException("Unhandled change type: " + changeType); // CDOSetFeatureDelta setChange = (CDOSetFeatureDelta)change; // break; } case MOVE: { CDOMoveFeatureDeltaImpl moveChange = (CDOMoveFeatureDeltaImpl) change; int sideOldPosition = moveChange.getOldPosition(); int sideNewPosition = moveChange.getNewPosition(); Element movedElement = allElements.get(moveChange); CDOFeatureDelta otherChange = movedElement.get(other(side)); if (otherChange != null) { Type otherChangeType = otherChange.getType(); switch (otherChangeType) { case REMOVE: { // Prioritize the RemoveDelta of the other side, delete the MoveDelta from // this side adjustAfterMove(changes, sideOldPosition, sideNewPosition, moveChange); movedElement.set(side, null); return; } case MOVE: { CDOMoveFeatureDelta otherMove = (CDOMoveFeatureDelta) otherChange; movedElement.set(other(side), null); // Not taking a MoveDelta has the same effect on indexes as a reverse move // of the element List<CDOFeatureDelta> otherChanges = changesPerSide.get(other(side)); int otherOldPosition = otherMove.getOldPosition(); int otherNewPosition = otherMove.getNewPosition(); adjustAfterMove( otherChanges, otherOldPosition, otherNewPosition, otherMove); movedElement.set(other(side), null); break; } default: throw new IllegalStateException("Unexpected change type: " + otherChangeType); } } int positionDelta = sideNewPosition - sideOldPosition; int ancestorOldPosition = ancestorList.indexOf(movedElement); int ancestorNewPosition = ancestorOldPosition + positionDelta; if (ancestorNewPosition < 0) { ancestorNewPosition = 0; } int ancestorEnd = ancestorList.size() - 1; if (ancestorNewPosition > ancestorEnd) { ancestorNewPosition = ancestorEnd; } moveChange.setOldPosition(ancestorOldPosition); moveChange.setNewPosition(ancestorNewPosition); result.add(moveChange); ancestorList.move(ancestorNewPosition, ancestorOldPosition); break; } case CLEAR: case UNSET: default: throw new IllegalStateException("Illegal change type: " + changeType); } } }
private void applyChangesToWorkList( Side side, PerSide<BasicEList<Element>> listPerSide, PerSide<List<CDOFeatureDelta>> changesPerSide, Map<CDOFeatureDelta, Element> allElements, Map<Object, List<Element>> additions) { BasicEList<Element> list = listPerSide.get(side); List<CDOFeatureDelta> changes = changesPerSide.get(side); for (CDOFeatureDelta change : changes) { Type changeType = change.getType(); switch (changeType) { case ADD: { CDOAddFeatureDelta addChange = (CDOAddFeatureDelta) change; Element element = new Element(-1); element.set(side, addChange); allElements.put(addChange, element); list.add(addChange.getIndex(), element); rememberAddition(addChange.getValue(), element, additions); break; } case REMOVE: { CDORemoveFeatureDelta removeChange = (CDORemoveFeatureDelta) change; Element element = list.remove(removeChange.getIndex()); element.set(side, removeChange); allElements.put(removeChange, element); break; } case SET: { CDOSetFeatureDelta setChange = (CDOSetFeatureDelta) change; Element newElement = new Element(-1); newElement.set(side, setChange); rememberAddition(setChange.getValue(), newElement, additions); Element oldElement = list.set(setChange.getIndex(), newElement); oldElement.set(side, setChange); allElements.put(setChange, oldElement); break; } case MOVE: { CDOMoveFeatureDelta moveChange = (CDOMoveFeatureDelta) change; Element element = list.move(moveChange.getNewPosition(), moveChange.getOldPosition()); element.set(side, moveChange); allElements.put(moveChange, element); break; } case CLEAR: case UNSET: // These deltas should have been replaced by multiple REMOVE deltas in // copyListChanges() throw new IllegalStateException("Unhandled change type: " + changeType); default: throw new IllegalStateException("Illegal change type: " + changeType); } } }
@Override public EList<XExpression> getExplicitArguments() { BasicEList<XExpression> result = new BasicEList<XExpression>(); if (getOperand() != null) result.add(getOperand()); return result; }
public EList<EObject> getContents() { BasicEList<EObject> contents = new BasicEList<EObject>(1); contents.add(contentRoot); return contents; }
@SuppressWarnings("unchecked") private IdEObject cleanupModel( EClass originalEClass, IdEObject original, IfcModelInterface newModel, IfcModelInterface ifcModel, Map<IdEObject, IdEObject> converted) throws UserException { if (converted.containsKey(original)) { return converted.get(original); } IdEObject newObject = (IdEObject) original.eClass().getEPackage().getEFactoryInstance().create(original.eClass()); ((IdEObjectImpl) newObject).setOid(original.getOid()); converted.put(original, newObject); if (!(newObject instanceof WrappedValue) && !(newObject instanceof IfcGloballyUniqueId)) { newModel.add(newObject.getOid(), newObject); } ObjectIDM objectIDM; try { objectIDM = bimServer.getPluginManager().requireObjectIDM(); } catch (ObjectIDMException e) { throw new UserException(e); } for (EStructuralFeature eStructuralFeature : original.eClass().getEAllStructuralFeatures()) { if (objectIDM.shouldFollowReference(originalEClass, original.eClass(), eStructuralFeature)) { Object get = original.eGet(eStructuralFeature); if (eStructuralFeature instanceof EAttribute) { if (get instanceof Double) { EStructuralFeature doubleStringFeature = original.eClass().getEStructuralFeature("wrappedValueAsString"); if (doubleStringFeature != null) { Object doubleString = original.eGet(doubleStringFeature); newObject.eSet(doubleStringFeature, doubleString); } else { newObject.eSet(eStructuralFeature, get); } } else { newObject.eSet(eStructuralFeature, get); } } else if (eStructuralFeature instanceof EReference) { if (get == null) { } else { if (eStructuralFeature.isMany()) { BasicEList<EObject> list = (BasicEList<EObject>) get; BasicEList<EObject> toList = (BasicEList<EObject>) newObject.eGet(eStructuralFeature); for (Object o : list) { if (converted.containsKey(o)) { toList.addUnique(converted.get(o)); } else { IdEObject result = cleanupModel(originalEClass, (IdEObject) o, newModel, ifcModel, converted); if (result != null) { toList.addUnique(result); } } } } else { if (converted.containsKey(get)) { newObject.eSet(eStructuralFeature, converted.get(get)); } else { newObject.eSet( eStructuralFeature, cleanupModel(originalEClass, (IdEObject) get, newModel, ifcModel, converted)); } } } } } } return newObject; }