示例#1
0
  /** @generated */
  protected void set(SampleData src) {

    // children

    if (src.getBaseSampleData() != null) {
      EList<BaseSampleData> list = getBaseSampleData();
      for (BaseSampleData element : src.getBaseSampleData()) {
        list.add(element.copyInstance());
      }
    }

    if (src.getOrthogonalSampleData() != null) {
      EList<OrthogonalSampleData> list = getOrthogonalSampleData();
      for (OrthogonalSampleData element : src.getOrthogonalSampleData()) {
        list.add(element.copyInstance());
      }
    }

    if (src.getAncillarySampleData() != null) {
      EList<BaseSampleData> list = getAncillarySampleData();
      for (BaseSampleData element : src.getAncillarySampleData()) {
        list.add(element.copyInstance());
      }
    }
  }
  /** Collapse edit part */
  private void collapseEditPart() {
    final Set<ConnectionEditPart> childrenConnections = getChildrenConnections();
    final Set<ConnectionEditPart> outsideConnections =
        excludeInternConnections(childrenConnections);
    final Set<ConnectionEditPart> edges = filterForDependencyConstraints(outsideConnections);

    for (final ConnectionEditPart outConnection : edges) {
      final EdgeImpl edge = (EdgeImpl) outConnection.getModel();

      // it's for undo/redo operations
      if (outConnection.getSource().getModel() != edge.getSource()
          || outConnection.getTarget().getModel() != edge.getTarget()) {
        return;
      }

      if (compartmentChildren.contains(outConnection.getSource())) {
        // readjust connection and update original source history
        // readjust at source
        edge.setSource((ShapeImpl) editPartOfCompartment.getModel());
        final Connection con = (Connection) edge.getElement();
        con.setTemp(true);
        final EList<Shape> oSources = con.getOriginalSource();
        oSources.add(con.getSource());
        con.setSource((Shape) ((ShapeImpl) editPartOfCompartment.getModel()).getElement());
      } else {
        // readjust at target
        edge.setTarget((ShapeImpl) editPartOfCompartment.getModel());
        final Connection con = (Connection) edge.getElement();
        con.setTemp(true);
        final EList<Shape> oTargets = con.getOriginalTarget();
        oTargets.add(con.getTarget());
        con.setTarget((Shape) ((ShapeImpl) editPartOfCompartment.getModel()).getElement());
      }
    }
  }
  @Override
  public void execute() {
    for (ScatterSet ds : scatterSets) {
      // ok, we may have to add it to the chartset first
      ChartSet charts = parent.getParent();
      EList<SelectiveAnnotation> annots = charts.getSharedAxis().getAnnotations();
      SelectiveAnnotation host = null;
      for (SelectiveAnnotation annot : annots) {
        if (annot.getAnnotation().getName() != null
            && annot.getAnnotation().getName().equals(ds.getName())) {
          host = annot;
          break;
        }
      }

      if (host == null) {
        StackedchartsFactory factory = new StackedchartsFactoryImpl();
        host = factory.createSelectiveAnnotation();
        host.setAnnotation(ds);
        annots.add(host);
      }

      // check we're not already in that chart
      EList<Chart> appearsIn = host.getAppearsIn();
      if (!appearsIn.contains(parent)) {
        appearsIn.add(parent);
      }
    }
  }
  private void addResultToList(
      org.emftext.sdk.concretesyntax.resource.cs.ICsReferenceMapping<ReferenceType> mapping,
      org.eclipse.emf.ecore.EObject proxy,
      org.eclipse.emf.common.util.EList<org.eclipse.emf.ecore.EObject> list) {
    org.eclipse.emf.ecore.EObject target = null;
    int proxyPosition = list.indexOf(proxy);

    if (mapping instanceof org.emftext.sdk.concretesyntax.resource.cs.ICsElementMapping<?>) {
      target =
          ((org.emftext.sdk.concretesyntax.resource.cs.ICsElementMapping<ReferenceType>) mapping)
              .getTargetElement();
    } else if (mapping instanceof org.emftext.sdk.concretesyntax.resource.cs.ICsURIMapping<?>) {
      target = org.eclipse.emf.ecore.util.EcoreUtil.copy(proxy);
      org.eclipse.emf.common.util.URI uri =
          ((org.emftext.sdk.concretesyntax.resource.cs.ICsURIMapping<ReferenceType>) mapping)
              .getTargetIdentifier();
      ((org.eclipse.emf.ecore.InternalEObject) target).eSetProxyURI(uri);
    } else {
      assert false;
    }
    try {
      // if target is an another proxy and list is "unique" add() will try to resolve
      // the new proxy to check for uniqueness. There seems to be no way to avoid that.
      // Until now this does not cause any problems.
      if (proxyPosition + 1 == list.size()) {
        list.add(target);
      } else {
        list.add(proxyPosition + 1, target);
      }
    } catch (Exception e1) {
      e1.printStackTrace();
    }
  }
示例#5
0
  private void createModel() {
    EFactory factory = metamodelPackage.getEFactoryInstance();
    netObject = factory.create(getNetClass());

    place1Object = factory.create(getPlaceClass());
    setName(place1Object, "place1");
    setTokens(place1Object, 1);

    place2Object = factory.create(getPlaceClass());
    setName(place2Object, "place2");

    transitionObject = factory.create(getTransitionClass());
    setIncoming(transitionObject, place1Object);
    setOutgoing(transitionObject, place2Object);

    EList<EObject> placesValue = new BasicEList<EObject>();
    placesValue.add(place1Object);
    placesValue.add(place2Object);
    EReference placesReference = getPlacesReference(netObject.eClass());
    netObject.eSet(placesReference, placesValue);

    EList<EObject> transitionsValue = new BasicEList<EObject>();
    transitionsValue.add(transitionObject);
    EReference transitionsReference = getTransitionsReference(netObject.eClass());
    netObject.eSet(transitionsReference, transitionsValue);
  }
示例#6
0
  private void createContainment(
      EObject eObject, EReference reference, JsonNode root, JsonNode node, Resource resource) {
    if (node.isArray()) {
      if (reference.isMany()) {
        @SuppressWarnings("unchecked")
        EList<EObject> values = (EList<EObject>) eObject.eGet(reference);

        for (Iterator<JsonNode> it = node.getElements(); it.hasNext(); ) {
          JsonNode current = it.next();
          EObject contained = createContainedObject(reference, root, current, resource);
          if (contained != null) values.add(contained);
        }
      } else if (node.getElements().hasNext()) {
        JsonNode current = node.getElements().next();
        EObject contained = createContainedObject(reference, root, current, resource);
        if (contained != null) eObject.eSet(reference, contained);
      }
    } else {
      EObject contained = createContainedObject(reference, root, node, resource);

      if (reference.isMany()) {
        @SuppressWarnings("unchecked")
        EList<EObject> values = (EList<EObject>) eObject.eGet(reference);
        if (contained != null) values.add(contained);
      } else {
        if (contained != null) eObject.eSet(reference, contained);
      }
    }
  }
  public void testRemoveEqualValues() {
    E e = refFactory.createE();

    String s0 = "0";
    String s1 = "1";
    String s2 = "2";
    String s3 = new String(s1);

    EList<String> labels = e.getLabels();
    labels.add(s0);
    labels.add(s1);
    labels.add(s3);
    labels.add(s2);
    labels.add(s1);

    Collection<String> collection = new ArrayList<String>();
    collection.add(s1);
    collection.add(s1);
    collection.add(s1);

    Command remove = RemoveCommand.create(editingDomain, e, refPackage.getE_Labels(), collection);

    assertEquals(5, labels.size());
    assertSame(s0, labels.get(0));
    assertSame(s1, labels.get(1));
    assertSame(s3, labels.get(2));
    assertSame(s2, labels.get(3));
    assertSame(s1, labels.get(4));
    assertNotSame(s1, labels.get(2));
    assertTrue(remove.canExecute());

    CommandStack stack = editingDomain.getCommandStack();
    stack.execute(remove);

    assertEquals(2, labels.size());
    assertSame(s0, labels.get(0));
    assertSame(s2, labels.get(1));
    assertTrue(stack.canUndo());

    stack.undo();

    assertEquals(5, labels.size());
    assertSame(s0, labels.get(0));
    assertSame(s1, labels.get(1));
    assertSame(s3, labels.get(2));
    assertSame(s2, labels.get(3));
    assertSame(s1, labels.get(4));
    assertNotSame(s1, labels.get(2));
    assertTrue(stack.canRedo());

    stack.redo();

    assertEquals(2, labels.size());
    assertSame(s0, labels.get(0));
    assertSame(s2, labels.get(1));
    assertTrue(stack.canUndo());
  }
示例#8
0
  public void rebuildInputTable(
      InputTable inputTable, IMetadataTable metadataTable, PigMapData mapData) {
    if (metadataTable != null && metadataTable.getListColumns() != null) {
      List<IMetadataColumn> listColumns = metadataTable.getListColumns();
      EList<TableNode> nodes = inputTable.getNodes();
      for (int i = 0; i < listColumns.size(); i++) {
        IMetadataColumn column = listColumns.get(i);
        TableNode found = null;
        int j = 0;
        for (; j < nodes.size(); j++) {
          TableNode node = nodes.get(j);
          if (node.getName() != null && node.getName().equals(column.getLabel())) {
            found = node;
            break;
          }
        }
        if (found != null) {
          // set in case talend type changed in metadata
          found.setType(column.getTalendType());
          if (i != j) {
            // do switch to keep the same sequence
            TableNode temp = nodes.get(j);
            nodes.remove(j);
            nodes.add(i, temp);
          }
        } else {
          found = PigmapFactory.eINSTANCE.createTableNode();
          found.setName(column.getLabel());
          found.setType(column.getTalendType());
          found.setNullable(column.isNullable());
          nodes.add(i, found);
        }
      }

      if (nodes.size() > listColumns.size()) {
        List unUsed = new ArrayList();
        for (int i = listColumns.size(); i < nodes.size(); i++) {
          PigMapUtil.detachNodeConnections(nodes.get(i), mapData);
          unUsed.add(nodes.get(i));
        }
        nodes.removeAll(unUsed);
      }
    }

    // re-build the connections in case any unnecessary connections are created because of previous
    // bugs and can't
    // be deleted
    if (inputTable.isLookup()) {
      rebuildInputNodesConnections(inputTable.getNodes(), mapData);
    }
  }
  public EList<PartialStateDescription> getSubFormulas() {
    EList<PartialStateDescription> result = new BasicEList<PartialStateDescription>();

    if (leftStateFormula != null) {
      result.add(leftStateFormula);
      result.addAll(leftStateFormula.getSubFormulas());
    }
    if (rightStateFormula != null) {
      result.add(rightStateFormula);
      result.addAll(rightStateFormula.getSubFormulas());
    }

    return result;
  }
示例#10
0
  /** Tests support for attributes of ELong type. */
  public void test_supportForELongAttributes_198451() {
    helper.setContext(thingType);

    long maxInt = Integer.MAX_VALUE;
    long maxIntMinusOne = (long) Integer.MAX_VALUE - 1;
    long maxIntSquared = ((long) Integer.MAX_VALUE) * ((long) Integer.MAX_VALUE);
    double quotient = (double) maxIntSquared / (double) maxIntMinusOne;

    Numero maxIntN = new Numero(maxInt);
    Numero maxIntMinusOneN = new Numero(maxIntMinusOne);
    Numero maxIntSquaredN = new Numero(maxIntSquared);

    @SuppressWarnings("unchecked")
    EList<Numero> list = (EList<Numero>) thing.eGet(enumeros);
    list.clear();
    list.add(maxIntN);
    list.add(maxIntMinusOneN);
    list.add(maxIntSquaredN);
    list.add(new Numero(1));

    try {
      // this should be OK because both values can be represented as integers
      assertEquals(1, evaluate(helper, thing, "numeros->at(1).asLong() - numeros->at(2).asLong()"));

      // same number represented in different precision
      assertTrue(check(helper, thing, "numeros->at(4).asLong() = 1"));

      // different numbers represented in different precision
      assertTrue(check(helper, thing, "numeros->at(4).asLong() <> 2"));

      // this is also OK, because we compute in high precision and coerce
      // the result to lower precision
      assertEquals(
          quotient, evaluate(helper, thing, "numeros->at(3).asLong() / numeros->at(2).asLong()"));

      // this is another case where the intermediate result is high-precision but
      // the result is low
      assertEquals(
          (int) maxIntMinusOne,
          evaluate(helper, thing, String.format("(%d + %d).div(2) - 1", maxInt, maxInt)));

      // finally, a case where the result is in high precision (new capability)
      assertEquals(
          maxIntSquared, evaluate(helper, thing, String.format("%d * %d", maxInt, maxInt)));
    } catch (Exception e) {
      fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
    }
  }
示例#11
0
  public void testTransientResource() throws Exception {
    final URI uri = URI.createURI("cdo:/test1");

    msg("Creating resourceSet");
    ResourceSet resourceSet = new ResourceSetImpl();
    SessionUtil.prepareResourceSet(resourceSet);

    msg("Creating resource");
    CDOResource resource = (CDOResource) resourceSet.createResource(uri);
    assertTransient(resource);

    msg("Creating supplier");
    Supplier supplier = getModel1Factory().createSupplier();
    assertTransient(supplier);
    assertEquals(null, supplier.eContainer());

    msg("Verifying contents");
    EList<EObject> contents = resource.getContents();
    assertNotNull(contents);
    assertEquals(true, contents.isEmpty());
    assertEquals(0, contents.size());
    assertTransient(resource);

    msg("Adding supplier");
    contents.add(supplier);
    assertTransient(resource);
    assertTransient(supplier);
    assertContent(resource, supplier);

    assertEquals(true, resourceSet.getResources().contains(resource));
    resource.delete(null);
    assertEquals(false, resourceSet.getResources().contains(resource));
    assertTransient(supplier);
  }
示例#12
0
  private void fillEAttribute(EObject container, JsonNode root) {
    final EClass eClass = container.eClass();

    // Iterates over all key values of the JSON Object,
    // if the value is not an object then
    // if the key corresponds to an EAttribute, fill it
    // if not and the EClass contains a MapEntry, fill it with the key, value.
    for (Iterator<Entry<String, JsonNode>> it = root.getFields(); it.hasNext(); ) {
      Entry<String, JsonNode> field = it.next();

      String key = field.getKey();
      JsonNode value = field.getValue();

      if (value.isObject()) // not an attribute
      continue;

      EAttribute attribute = getEAttribute(eClass, key);
      if (attribute != null && !attribute.isTransient() && !attribute.isDerived()) {
        if (value.isArray()) {
          for (Iterator<JsonNode> itValue = value.getElements(); itValue.hasNext(); ) {
            setEAttributeValue(container, attribute, itValue.next());
          }
        } else {
          setEAttributeValue(container, attribute, value);
        }
      } else {
        EStructuralFeature eFeature = getDynamicMapEntryFeature(eClass);
        if (eFeature != null) {
          @SuppressWarnings("unchecked")
          EList<EObject> values = (EList<EObject>) container.eGet(eFeature);
          values.add(createEntry(key, value));
        }
      }
    }
  }
示例#13
0
  /**
   * Converts a JSIDL pop to a CJSIDL pop transition
   *
   * @param pop - a JSIDL pop
   * @param parentTrans - the parent transition
   * @return - resulting CJSIDL object
   */
  public static popTransition convert(Pop pop, transition parentTrans) {
    CjsidlFactoryImpl factory = new CjsidlFactoryImpl();
    org.jts.eclipse.cjsidl.popTransition output = factory.createpopTransition();
    output.setComment(JSIDLInterpToCJSIDLComment(pop.getInterpretation()));

    EList<org.jts.eclipse.cjsidl.guardParam> paramlist = output.getParam();
    if (pop.getArgument() != null) {
      java.util.List<org.jts.jsidl.binding.Argument> args = pop.getArgument();
      for (org.jts.jsidl.binding.Argument arg : args) {
        guardParam gp = factory.createguardParam();
        if (arg.getValue().contains("'")) {
          gp.setGuardConst(arg.getValue());
        } else {
          if (parentTrans != null) {
            gp.setParameter(
                (transParam)
                    Conversion.referenceHelper.getEObjectFromTransition(
                        arg.getValue(), parentTrans));
          } else {
            Logger.getLogger("CJSIDL").log(Level.SEVERE, "Unexpected parameter found in guard.");
          }
        }

        paramlist.add(gp);
      }
    }

    // need to have the reference set, but the object may not exist yet, so post-process
    String transName = pop.getTransition();
    if (transName != null && !transName.isEmpty()) {
      DefaultState.secondaryTransitionMap.put(transName, output);
    }

    return output;
  }
 @Override
 protected void execute(IProgressMonitor monitor) throws CoreException {
   try {
     IncQueryGeneratorModel generatorModel =
         genmodelProvider.getGeneratorModel(project, resourceSetProvider.get(project));
     EList<GeneratorModelReference> genmodelRefs = generatorModel.getGenmodels();
     for (GenModel ecoreGenmodel : genmodels) {
       GeneratorModelReference ref =
           GeneratorModelFactory.eINSTANCE.createGeneratorModelReference();
       ref.setGenmodel(ecoreGenmodel);
       genmodelRefs.add(ref);
     }
     if (genmodelRefs.isEmpty()) {
       IFile file = project.getFile(ViatraQueryNature.IQGENMODEL);
       file.create(new StringInputStream(""), false, new SubProgressMonitor(monitor, 1));
     } else {
       genmodelProvider.saveGeneratorModel(project, generatorModel);
     }
   } catch (IOException e) {
     throw new CoreException(
         new Status(
             IStatus.ERROR,
             ViatraQueryGUIPlugin.PLUGIN_ID,
             "Cannot create generator model: " + e.getMessage(),
             e));
   }
 }
示例#15
0
  /**
   * initialize before simulation begins. Rewind/forward any population model values to the start
   * time of the sequencer
   *
   * @param time
   */
  public void initialize(STEMTime time) {
    EList<Decorator> redoList = new BasicEList<Decorator>();

    boolean redo = false;
    for (Decorator d : this.getDecorators()) {
      if (d instanceof IntegrationDecorator) {
        EList<DynamicLabel> labels = d.getLabelsToUpdate();
        for (DynamicLabel l : labels) {
          if (l instanceof IntegrationLabel) {
            IntegrationLabel il = (IntegrationLabel) l;
            il.reset(time);
            if (((SimpleDataExchangeLabelValue) il.getDeltaValue()).getArrivals().size() > 0
                || ((SimpleDataExchangeLabelValue) il.getDeltaValue()).getDepartures().size() > 0)
              redo = true;
          }
        }
      }
      if (!redo) redoList.add(d);
    }
    // Fix decorators with unapplied deltas
    if (redo) {
      for (Decorator d : redoList) {
        if (d instanceof IntegrationDecorator) {
          EList<DynamicLabel> labels = d.getLabelsToUpdate();
          for (DynamicLabel l : labels) {
            if (l instanceof IntegrationLabel) {
              IntegrationLabel il = (IntegrationLabel) l;
              il.reset(time);
            }
          }
        }
      }
    }
    this.setInitialized(true);
  }
  @Test
  public void should_migrateAfter_update_version_in_connector_configuration() throws Exception {
    // Given
    doCallRealMethod().when(updateConnectorVersionMigration).migrateAfter(model, metamodel);
    final EList<Instance> connectorConfigInstanceList =
        connectorConfiguratiobInstanceList("id1", "id2");
    final Instance oldConnectorConfInstance = aConnectorConfigurationInstance("id1", "0.9");
    connectorConfigInstanceList.add(oldConnectorConfInstance);
    when(model.getAllInstances("connectorconfiguration.ConnectorConfiguration"))
        .thenReturn(connectorConfigInstanceList);
    when(model.getAllInstances("process.Connector")).thenReturn(new BasicEList<Instance>());
    when(updateConnectorVersionMigration.shouldUpdateVersion("id1")).thenReturn(true);
    when(updateConnectorVersionMigration.getOldDefinitionVersion()).thenReturn("1.0");
    when(updateConnectorVersionMigration.getNewDefinitionVersion()).thenReturn("2.0");

    // When
    updateConnectorVersionMigration.migrateAfter(model, metamodel);

    // Then
    final Instance id1ConnectorConf = connectorConfigInstanceList.get(0);
    final Instance id2ConnectorConf = connectorConfigInstanceList.get(1);
    verify(id1ConnectorConf).set(UpdateConnectorVersionMigration.VERSION_FEATURE_NAME, "2.0");
    verify(id2ConnectorConf, never())
        .set(UpdateConnectorVersionMigration.VERSION_FEATURE_NAME, "2.0");
    verify(oldConnectorConfInstance, never())
        .set(UpdateConnectorVersionMigration.VERSION_FEATURE_NAME, "2.0");
  }
示例#17
0
  /** Returns true if text can be inserted at the current position. */
  public boolean canInsertText() {

    VEXDocument doc = this.getDocument();
    if (doc == null) {
      return false;
    }

    Validator validator = this.document.getValidator();
    if (validator == null) {
      return true;
    }

    int startOffset = this.getCaretOffset();
    int endOffset = this.getCaretOffset();
    if (this.hasSelection()) {
      startOffset = this.getSelectionStart();
      endOffset = this.getSelectionEnd();
    }

    VEXElement parent = this.getDocument().getElementAt(startOffset);
    EList<String> seq1 = doc.getNodeNames(parent.getStartOffset() + 1, startOffset);

    EList<String> seq2 = new BasicEList<String>();
    seq2.add(Validator.PCDATA);

    EList<String> seq3 = doc.getNodeNames(endOffset, parent.getEndOffset());

    return validator.isValidSequence(parent.getName(), seq1, seq2, seq3, true);
  }
示例#18
0
 public static boolean setStringDataFilter(Analysis analysis, String datafilterString) {
   EList<Domain> dataFilters = analysis.getParameters().getDataFilter();
   // update existing filters
   if (!dataFilters.isEmpty()) {
     Domain domain = dataFilters.get(0);
     EList<RangeRestriction> ranges = domain.getRanges();
     RangeRestriction rangeRestriction =
         (ranges.isEmpty()) ? DomainHelper.addRangeRestriction(domain) : ranges.get(0);
     BooleanExpressionNode expressions = rangeRestriction.getExpressions();
     if (expressions == null) {
       expressions = BooleanExpressionHelper.createBooleanExpressionNode(datafilterString);
       rangeRestriction.setExpressions(expressions);
     } else {
       Expression expression = expressions.getExpression();
       if (expression == null) {
         expression =
             BooleanExpressionHelper.createTdExpression(
                 BooleanExpressionHelper.DEFAULT_LANGUAGE, datafilterString);
         expressions.setExpression(expression);
       } else {
         expression.setBody(datafilterString);
       }
     }
     return false;
   }
   // else
   return dataFilters.add(createDomain(analysis, datafilterString));
 }
  @Override
  public IScriptDependency addDependency(IScriptDependency dependency) {
    /*
     * Find the list of dependencies for the object of the specified dependency
     */
    final EObject object = dependency.getObject();
    EList<IScriptDependency> dList = getDependencies().get(object);
    if (dList == null) {
      final BasicEMap.Entry<EObject, EList<IScriptDependency>> entry =
          (Entry<EObject, EList<IScriptDependency>>)
              IScriptEngineFactory.eINSTANCE.create(
                  IScriptEnginePackage.Literals.EOBJECT_TO_SCRIPT_DEPENDENCY_LIST_MAP_ENTRY);
      entry.setKey(object);
      getDependencies().add(entry);
      dList = entry.getValue();
      object.eAdapters().add(myDependencyAdapter);
    }

    /*
     * See if we have an identical entry of the list
     */
    for (final IScriptDependency d : dList) {
      if (d.equals(dependency)) return d;
    }
    dList.add(dependency);

    return dependency;
  }
示例#20
0
 private static void addSourceOrLibrary(EList<MindRootSrc> allsrc, MindRootSrc rs) {
   if (rs == null) return;
   if (allsrc.add(rs))
     for (MindRootSrc drs : rs.getDependencies()) {
       addSourceOrLibrary(allsrc, drs);
     }
 }
 @Test
 public void testAddElementAfterInlineComment() {
   try {
     StringConcatenation _builder = new StringConcatenation();
     _builder.append("entities");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("Foo \"Bar\"\t//inline comment before inserted element");
     _builder.newLine();
     _builder.append("end");
     _builder.newLine();
     final Model model = this._parseHelper.parse(_builder);
     Entity _createEntity = HiddentokensequencertestFactory.eINSTANCE.createEntity();
     final Procedure1<Entity> _function =
         (Entity it) -> {
           it.setName("Baz");
           it.setDescription("Fizzle");
         };
     final Entity event = ObjectExtensions.<Entity>operator_doubleArrow(_createEntity, _function);
     DomainModel _domainModel = model.getDomainModel();
     EList<Entity> _entities = _domainModel.getEntities();
     _entities.add(event);
     StringConcatenation _builder_1 = new StringConcatenation();
     _builder_1.append("entities");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.append("Foo \"Bar\"\t//inline comment before inserted element");
     _builder_1.newLine();
     _builder_1.append("Baz \"Fizzle\" end");
     this.assertSerializesTo(model, _builder_1);
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
 @Override
 public EList<EStructuralFeature> GetEStructuralFeature() {
   // TODO Auto-generated method stub
   EList<EStructuralFeature> list_feat = new BasicEList<EStructuralFeature>();
   list_feat.add(GetEClass().getEStructuralFeature("name"));
   return list_feat;
 }
示例#23
0
  /** @generated */
  protected void set(ChartWithoutAxes src) {

    super.set(src);

    // children

    if (src.getSeriesDefinitions() != null) {
      EList<SeriesDefinition> list = getSeriesDefinitions();
      for (SeriesDefinition element : src.getSeriesDefinitions()) {
        list.add(element.copyInstance());
      }
    }

    // attributes

    minSlice = src.getMinSlice();

    minSliceESet = src.isSetMinSlice();

    minSlicePercent = src.isMinSlicePercent();

    minSlicePercentESet = src.isSetMinSlicePercent();

    minSliceLabel = src.getMinSliceLabel();

    coverage = src.getCoverage();

    coverageESet = src.isSetCoverage();
  }
 public void addToOperations(Object newValue) {
   operationsList.add(newValue);
   if (newValue != null) {
     operations.setText(operationsList.toString());
   } else {
     operations.setText(""); // $NON-NLS-1$
   }
 }
示例#25
0
  protected void assertSetEList(List<?> prototypeList) {
    EList<Object> eList = new BasicEList<Object>();
    ECollections.setEList(eList, prototypeList);
    assertTrue("Empty list test", TestUtil.areEqual(prototypeList, eList));

    eList = new BasicEList<Object>();
    eList.add(0, "String");
    eList.add(Boolean.FALSE);
    ECollections.setEList(eList, prototypeList);
    assertTrue("Smaller list test", TestUtil.areEqual(prototypeList, eList));

    eList = (EList<Object>) populateList(new BasicEList<Object>());
    ECollections.setEList(eList, prototypeList);
    assertTrue("Same list test", TestUtil.areEqual(prototypeList, eList));

    eList.remove(2);
    eList.add(3, this);
    ECollections.setEList(eList, prototypeList);
    assertTrue("Equal size list test", TestUtil.areEqual(prototypeList, eList));

    eList.add(0, "String");
    eList.add(2, Boolean.FALSE);
    eList.add(Boolean.FALSE);
    eList.add(this);
    ECollections.setEList(eList, prototypeList);
    assertTrue("Bigger list test", TestUtil.areEqual(prototypeList, eList));
  }
示例#26
0
  /** @generated */
  protected void set(Dial src) {

    // children

    if (src.getLineAttributes() != null) {
      setLineAttributes(src.getLineAttributes().copyInstance());
    }

    if (src.getFill() != null) {
      setFill(src.getFill().copyInstance());
    }

    if (src.getDialRegions() != null) {
      EList<DialRegion> list = getDialRegions();
      for (DialRegion element : src.getDialRegions()) {
        list.add(element.copyInstance());
      }
    }

    if (src.getMajorGrid() != null) {
      setMajorGrid(src.getMajorGrid().copyInstance());
    }

    if (src.getMinorGrid() != null) {
      setMinorGrid(src.getMinorGrid().copyInstance());
    }

    if (src.getScale() != null) {
      setScale(src.getScale().copyInstance());
    }

    if (src.getLabel() != null) {
      setLabel(src.getLabel().copyInstance());
    }

    if (src.getFormatSpecifier() != null) {
      setFormatSpecifier(src.getFormatSpecifier().copyInstance());
    }

    // attributes

    startAngle = src.getStartAngle();

    startAngleESet = src.isSetStartAngle();

    stopAngle = src.getStopAngle();

    stopAngleESet = src.isSetStopAngle();

    radius = src.getRadius();

    radiusESet = src.isSetRadius();

    inverseScale = src.isInverseScale();

    inverseScaleESet = src.isSetInverseScale();
  }
 /**
  * Return the subLines and the cells of this line.
  *
  * @param line The line
  * @return List of representations elements
  */
 private EList<DRepresentationElement> getRepresentationElements(DLine line) {
   EList<DRepresentationElement> result = new BasicEList<DRepresentationElement>();
   result.add(line);
   result.addAll(line.getCells());
   for (DLine subLine : line.getLines()) {
     result.addAll(getRepresentationElements(subLine));
   }
   return result;
 }
示例#28
0
  /**
   * Tests that the MSLUtil::addObject() method does the correct thing when adding an object that is
   * already in the list. It formerly attempted to move the object, but moved the wrong one.
   */
  public void test_MSLUtil_addObject_113261() {
    EList list = new BasicEList();

    list.add("a"); // $NON-NLS-1$
    list.add("b"); // $NON-NLS-1$
    list.add("c"); // $NON-NLS-1$
    list.add("d"); // $NON-NLS-1$

    Object object = list.get(3);

    // on a copy of this list, do the correct change
    EList expected = new BasicEList(list);
    expected.move(0, 3);

    MSLUtil.addObject(list, object, 0);

    // check that MSLUtil made the correct change
    assertEquals(expected, list);
  }
 protected EList<ConnectionInstance> filterSameSourceConnections(
     EList<ConnectionInstance> connections) {
   EList<ConnectionInstance> result = new BasicEList<ConnectionInstance>();
   for (ConnectionInstance conni : connections) {
     if (!hasConnectionSource(result, conni)) {
       result.add(conni);
     }
   }
   return result;
 }
示例#30
0
  /*
   * Bugzilla: 133907
   */
  public void testMoveIntObject() throws Exception {
    EList<Object> originalList = new BasicEList<Object>();
    originalList.add("pos0");
    originalList.add("pos1");
    originalList.add(2);
    originalList.add("pos3");

    EList<Object> eList = new BasicEList<Object>(originalList);
    List<Object> list = new ArrayList<Object>(originalList);

    int target = 2;
    Object object = originalList.get(3);
    originalList.move(target, object);
    ECollections.move(eList, target, object);
    assertTrue(TestUtil.areEqual(originalList, eList));
    ECollections.move(list, target, object);
    assertTrue(TestUtil.areEqual(originalList, list));

    target = 2;
    object = originalList.get(0);
    originalList.move(target, object);
    ECollections.move(eList, target, object);
    assertTrue(TestUtil.areEqual(originalList, eList));
    ECollections.move(list, target, object);
    assertTrue(TestUtil.areEqual(originalList, list));

    target = 1;
    object = originalList.get(1);
    originalList.move(target, object);
    ECollections.move(eList, target, object);
    assertTrue(TestUtil.areEqual(originalList, eList));
    ECollections.move(list, target, object);
    assertTrue(TestUtil.areEqual(originalList, list));

    target = 0;
    object = originalList.get(3);
    originalList.move(target, object);
    ECollections.move(eList, target, object);
    assertTrue(TestUtil.areEqual(originalList, eList));
    ECollections.move(list, target, object);
    assertTrue(TestUtil.areEqual(originalList, list));
  }