Beispiel #1
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));
  }
 @Test
 public void testRemoveElementInSameLine() {
   try {
     StringConcatenation _builder = new StringConcatenation();
     _builder.append("entities");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("Foo \"Bar\" /* the foo */ Baz \"Fizzle\"");
     _builder.newLine();
     _builder.append("end");
     _builder.newLine();
     final Model model = this._parseHelper.parse(_builder);
     DomainModel _domainModel = model.getDomainModel();
     EList<Entity> _entities = _domainModel.getEntities();
     _entities.remove(1);
     StringConcatenation _builder_1 = new StringConcatenation();
     _builder_1.append("entities");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.append("Foo \"Bar\" /* the foo */");
     _builder_1.newLine();
     _builder_1.append("end");
     this.assertSerializesTo(model, _builder_1);
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
 public void removeToOperations(Object newValue) {
   operationsList.remove(newValue);
   if (newValue != null) {
     operations.setText(operationsList.toString());
   } else {
     operations.setText(""); // $NON-NLS-1$
   }
 }
  /** Opens the edit part and restores the connections. */
  private void openEditPart() {

    final Set<ConnectionEditPart> connections = getAllConnections();

    for (final ConnectionEditPart i : connections) {
      final EdgeImpl edgeToRestore = (EdgeImpl) i.getModel();
      final Connection con = (Connection) edgeToRestore.getElement();

      if (con.isTemp()) {
        if (edgeToRestore.getSource() == editPartOfCompartment.getModel()
            && (!con.getOriginalSource().isEmpty())) {
          // readjust source
          final EList<Shape> oSources = con.getOriginalSource();
          final Shape source = oSources.remove(oSources.size() - 1);

          final NodeImpl shapeImpl = getViewFromModel(compartmentToSupport, source);

          edgeToRestore.setSource(shapeImpl);

          con.setSource(source);
        } else if (edgeToRestore.getTarget() == editPartOfCompartment.getModel()
            && (!con.getOriginalTarget().isEmpty())) {
          // readjust target
          final EList<Shape> oTargets = con.getOriginalTarget();
          final Shape target = oTargets.remove(oTargets.size() - 1);

          final NodeImpl shapeImpl = getViewFromModel(compartmentToSupport, target);
          edgeToRestore.setTarget(shapeImpl);

          con.setTarget(target);
        }
        if (con.getOriginalSource().isEmpty() && con.getOriginalTarget().isEmpty()) {
          // connection is points direct from original source to original target, thus it's not
          // temporal
          // anymore.
          con.setTemp(false);
        }
      }
    }
  }
  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 void updateAttributeFields(
      FormContainer formContainer, FormElement formElement, Attribute att) {
    FormElement fieldForAttribute = null;
    if (formContainer instanceof FormSearch) {
      fieldForAttribute = SearchInitialization.getSearchFieldForAttribute(att);
    } else if (formContainer instanceof FormClass || formContainer instanceof FormWorkflow) {
      fieldForAttribute = ClassDiagramUtils.getFieldForAttribute(att);
    }

    if (!fieldForAttribute.getClass().isInstance(formElement)) {
      // mismatch so we replace the Field
      FormGroup eContainer = (FormGroup) formElement.eContainer();
      boolean contains = eContainer.getChildren().contains(formElement);

      if (headless) {
        EList<FormElement> children = null;
        if (contains) {
          children = eContainer.getChildren();
        } else {
          children = eContainer.getDisabled();
        }
        // add the new Field
        children.add(fieldForAttribute);
        // remove
        children.remove(formElement);
      } else {
        if (contains) {
          cc.append(
              AddCommand.create(
                  domain,
                  eContainer,
                  FormPackage.eINSTANCE.getFormGroup_Children(),
                  fieldForAttribute));
        } else {
          cc.append(
              AddCommand.create(
                  domain,
                  eContainer,
                  FormPackage.eINSTANCE.getFormGroup_Disabled(),
                  fieldForAttribute));
        }
        Command rmCmd = RemoveCommand.create(domain, formElement);
        cc.append(rmCmd);
      }
    }
  }
 @Test
 public void testCommentOnRemovedElement() {
   try {
     StringConcatenation _builder = new StringConcatenation();
     _builder.append("entities");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("Foo \"Bar\" //inline comment before deleted element");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("//comment on deleted element");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("/**");
     _builder.newLine();
     _builder.append("\t ");
     _builder.append("* another comment on the deleted element");
     _builder.newLine();
     _builder.append("\t ");
     _builder.append("*/");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("Baz \"Fizzle\"");
     _builder.newLine();
     _builder.append("end");
     _builder.newLine();
     final Model model = this._parseHelper.parse(_builder);
     DomainModel _domainModel = model.getDomainModel();
     EList<Entity> _entities = _domainModel.getEntities();
     _entities.remove(1);
     StringConcatenation _builder_1 = new StringConcatenation();
     _builder_1.append("entities");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.append("Foo \"Bar\" //inline comment before deleted element");
     _builder_1.newLine();
     _builder_1.newLine();
     _builder_1.append("end");
     this.assertSerializesTo(model, _builder_1);
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
  void removeInvalide(EObject o) {
    CompoundCommand removeCommands = new CompoundCommand();
    List<EObject> validationErrors = EcoreHelper.getValidationErrors(o);
    for (EObject eObject : validationErrors) {
      if (eObject instanceof FormElement) {

        System.out.println("SynchronizeWithClass.removeInvalide() remove :" + eObject);
        if (headless) {
          EList<?> children = null;
          EObject eContainer = eObject.eContainer();
          System.out.println("SynchronizeWithClass.removeInvalide() eContainer :" + eContainer);
          if (eContainer != null) {
            if (eContainer instanceof FormGroup) {
              FormGroup fg = (FormGroup) eContainer;

              if (fg.getChildren().contains(eObject)) {
                children = fg.getChildren();
              } else if (fg.getDisabled().contains(eObject)) {
                children = fg.getDisabled();
              }
            } else if (eContainer instanceof FormCollection) {
              children = ((FormCollection) eContainer).getForms();
            }

            boolean remove = children.remove(eObject);
            System.out.println("SynchronizeWithClass.removeInvalide() removed? " + remove);
          } else {
            System.out.println("SynchronizeWithClass.removeInvalide() allready removed !");
          }

        } else {
          Command delCmd = RemoveCommand.create(domain, eObject);
          removeCommands.append(delCmd);
        }
      }
    }
    if (!headless) {
      domain.getCommandStack().execute(removeCommands);
    }
  }
 public E remove(int index) {
   copy.remove(index);
   return original.remove(index);
 }
 public boolean remove(Object o) {
   copy.remove(o);
   return original.remove(o);
 }
 @Test
 public void smokeTest() {
   try {
     StringConcatenation _builder = new StringConcatenation();
     _builder.append("entities");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("//before existing element");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("Foo /* within existing element */ \"Bar\" /* after existing element*/");
     _builder.newLine();
     _builder.append("\t");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("//unrelated comment");
     _builder.newLine();
     _builder.append("\t");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("//before deleted element");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("Baz \"Fizzle\" /* after deleted element */");
     _builder.newLine();
     _builder.append("\t");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("//between deleted elements");
     _builder.newLine();
     _builder.append("\t");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("//another deleted element");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("Blurb /* a comment within a deleted element */ \"Bla\"");
     _builder.newLine();
     _builder.append("\t");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("//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("AAA");
           it.setDescription("BBB");
         };
     final Entity event = ObjectExtensions.<Entity>operator_doubleArrow(_createEntity, _function);
     DomainModel _domainModel = model.getDomainModel();
     EList<Entity> _entities = _domainModel.getEntities();
     _entities.remove(1);
     DomainModel _domainModel_1 = model.getDomainModel();
     EList<Entity> _entities_1 = _domainModel_1.getEntities();
     _entities_1.remove(1);
     DomainModel _domainModel_2 = model.getDomainModel();
     EList<Entity> _entities_2 = _domainModel_2.getEntities();
     _entities_2.add(event);
     StringConcatenation _builder_1 = new StringConcatenation();
     _builder_1.append("entities");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.append("//before existing element");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.append("Foo /* within existing element */ \"Bar\" /* after existing element*/");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.append("//unrelated comment");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.append("//between deleted elements");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.newLine();
     _builder_1.append("\t");
     _builder_1.append("//before inserted element");
     _builder_1.newLine();
     _builder_1.append("AAA \"BBB\" end");
     this.assertSerializesTo(model, _builder_1);
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
 @Override
 public ClassLoader getClassLoader(final EObject ctx) {
   Resource _eResource = ctx.eResource();
   ResourceSet _resourceSet = _eResource.getResourceSet();
   final XtextResourceSet rs = ((XtextResourceSet) _resourceSet);
   ResourceSetContext _get = ResourceSetContext.get(rs);
   final boolean isBuilder = _get.isBuilder();
   ResourceSetContext _get_1 = ResourceSetContext.get(rs);
   final boolean isEditor = _get_1.isEditor();
   if (isBuilder) {
     EList<Adapter> _eAdapters = rs.eAdapters();
     Iterable<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter> _filter =
         Iterables.<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter>filter(
             _eAdapters, ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter.class);
     final ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter adapter =
         IterableExtensions.<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter>head(
             _filter);
     boolean _notEquals = (!Objects.equal(adapter, null));
     if (_notEquals) {
       return adapter.getClassLoader();
     }
   }
   if (isEditor) {
     Resource _editorResource = this.getEditorResource(ctx);
     EList<Adapter> _eAdapters_1 = _editorResource.eAdapters();
     Iterable<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter> _filter_1 =
         Iterables.<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter>filter(
             _eAdapters_1, ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter.class);
     final ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter adapter_1 =
         IterableExtensions.<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter>head(
             _filter_1);
     boolean _notEquals_1 = (!Objects.equal(adapter_1, null));
     if (_notEquals_1) {
       ClassLoader _classLoader = adapter_1.getClassLoader();
       boolean _equals = Objects.equal(_classLoader, null);
       if (_equals) {
         Resource _editorResource_1 = this.getEditorResource(ctx);
         EList<Adapter> _eAdapters_2 = _editorResource_1.eAdapters();
         _eAdapters_2.remove(adapter_1);
       } else {
         return adapter_1.getClassLoader();
       }
     }
   }
   Object _classpathURIContext = rs.getClasspathURIContext();
   final IJavaProject project = ((IJavaProject) _classpathURIContext);
   final URLClassLoader classloader = this.createClassLoaderForJavaProject(project);
   if (isBuilder) {
     EList<Adapter> _eAdapters_3 = rs.eAdapters();
     ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter _processorClassloaderAdapter =
         new ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter(classloader);
     _eAdapters_3.add(_processorClassloaderAdapter);
   }
   if (isEditor) {
     Resource _editorResource_2 = this.getEditorResource(ctx);
     EList<Adapter> _eAdapters_4 = _editorResource_2.eAdapters();
     ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter
         _processorClassloaderAdapter_1 =
             new ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter(classloader);
     _eAdapters_4.add(_processorClassloaderAdapter_1);
   }
   return classloader;
 }
  public void rebuildModelOutputs(List<IMetadataTable> outputMetadataTables, PigMapData mapData) {
    for (IMetadataTable meatadataTable : outputMetadataTables) {
      String name = meatadataTable.getTableName();
      OutputTable outputTable = null;
      for (OutputTable out : mapData.getOutputTables()) {
        if (out.getName() != null && out.getName().equals(name)) {
          outputTable = out;
          break;
        }
      }
      if (outputTable == null) {
        outputTable = PigmapFactory.eINSTANCE.createOutputTable();
        outputTable.setName(name);
        mapData.getOutputTables().add(outputTable);
      }

      List<IMetadataColumn> listColumns = meatadataTable.getListColumns();
      if (listColumns != null) {
        EList<TableNode> nodes = outputTable.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++) {
            TableNode node = nodes.get(i);
            PigMapUtil.detachConnectionsSouce(node, mapData);
            unUsed.add(node);
          }
          nodes.removeAll(unUsed);
        }
      }
      mapData.getOutputTables().add(outputTable);

      // re-build the connections in case any unnecessary connections are created because of
      // previous bugs and
      // can't be deleted
      rebuildOutputNodesConnections(outputTable.getNodes(), mapData);
    }
  }