protected void synchronizeMissingAttributes(
      FormContainer o,
      List<FormElement> children,
      AbstractClass real_class,
      Set<FormGroup> groups,
      String filterNS) {

    List<Attribute> allAttributes = real_class.getAllAttributes();

    // get FormElement that miss
    ArrayList<Attribute> missAtt = new ArrayList<Attribute>();

    if (allAttributes != null) {
      missAtt.addAll(allAttributes);
    }

    for (FormElement formElement : children) {
      ModelElement ref = formElement.getRef();
      if (ref != null && ref instanceof Attribute) {
        // linked element is attribute so remove this attribute from the missing list
        missAtt.remove(ref);
      }
    }

    EList<FormGroup> allSubGroups = o.getAllSubGroups();
    groups.addAll(allSubGroups);

    // now we have the attribute missing list
    // initialize missing Field
    for (Attribute attribute : missAtt) {
      // Field or searchField
      FormElement fieldForAttribute = null;
      if (o instanceof FormSearch) {
        fieldForAttribute = SearchInitialization.getSearchFieldForAttribute(attribute);
      } else if (o instanceof FormClass || o instanceof FormWorkflow) {
        fieldForAttribute = ClassDiagramUtils.getFieldForAttribute(attribute);
      } else {
        System.out.println("SynchronizeWithClass.synchronizeMissingAttributes() o :" + o);
      }
      if (WorkflowInitialization.filterFormElement(filterNS, fieldForAttribute)) {

        // get where to add the field
        FormGroup parent = null;
        // mybe a group exist with ref to the attribute container
        AbstractClass eContainer = (AbstractClass) attribute.eContainer();
        // search for matching group

        for (FormGroup formGroup : groups) {
          ModelElement ref = formGroup.getRef();
          if (ref != null && ref.equals(eContainer)) {
            // matching group founded
            parent = formGroup;
            break;
          }
        }
        if (createMissingGroup && parent == null) {
          parent = ClassInitialization.createGroup(eContainer);
          groups.add(parent);
          addChild(o, parent);
        }
        if (parent == null) {
          parent = o;
        }

        // add new Field to the parent
        addChild(parent, fieldForAttribute);
      }
    }
  }
  protected void synchronizeMissingAssociations(
      FormContainer o,
      List<FormElement> children,
      AbstractClass real_class,
      Set<FormGroup> groups,
      String filterNS) {

    List<Association> allAssociations = real_class.getAllSourceAssociations();

    // get FormElement that miss
    ArrayList<Association> missAtt = new ArrayList<Association>();

    if (allAssociations != null) {
      missAtt.addAll(allAssociations);
    }

    for (FormElement formElement : children) {
      ModelElement ref = formElement.getRef();
      if (ref != null && ref instanceof Association) {
        // linked element is attribute so remove this attribute from the missing list
        missAtt.remove(ref);
      }
    }

    EList<FormGroup> allSubGroups = o.getAllSubGroups();
    groups.addAll(allSubGroups);

    // now we have the attribute missing list
    // initialize missing Field
    for (Association ass : missAtt) {

      FormElement fieldForAssociation = null;
      if (o instanceof FormClass || o instanceof FormWorkflow) {
        fieldForAssociation = ClassDiagramUtils.getModelChoiceFieldForAssociation(ass, real_class);
      } else if (o instanceof FormSearch) {
        fieldForAssociation =
            ClassDiagramUtils.transformAssociationIntoModelChoiceSearchField(ass, real_class);
      }

      if (WorkflowInitialization.filterFormElement(filterNS, fieldForAssociation)) {

        // get where to add the field
        FormGroup parent = null;
        // mybe a group exist with ref to the attribute container

        // search for matching group

        for (FormGroup formGroup : groups) {
          ModelElement ref = formGroup.getRef();
          if (ref instanceof AbstractClass
              && ((AbstractClass) ref).getSourceAssociations().contains(ass)) {
            // matching group founded
            parent = formGroup;
            break;
          }
        }

        if (createMissingGroup && parent == null) {
          AbstractClass source = null;
          EList<AbstractClass> sources = ass.getSource();
          if (sources.size() == 1) {
            source = sources.get(0);
          } else {
            EList<AbstractClass> allLinkedAbstractClass = real_class.getAllLinkedAbstractClass();
            boolean contains = allLinkedAbstractClass.contains(sources.get(0));
            if (contains) {
              source = sources.get(0);
            } else {
              source = sources.get(1);
            }
          }
          parent = ClassInitialization.createGroup(source);
          addChild(o, parent);
        }

        // add new Field to the parent
        if (parent == null) {
          parent = o;
        }
        addChild(parent, fieldForAssociation);
      }
    }
  }