public LCCClass(Architecture architecture) {
   this.architecture = architecture;
   for (Class cls : architecture.getAllClasses()) {
     // Thaina - 01/14 - se classe for um aspecto ela não é contada nas métricas
     if (!cls.isAspect()) {
       getResults().add(new LCCClassComponentResult(cls));
     }
   }
 }
  public RealizationRelationship(Element client, Element supplier, String name, String id) {
    setClient(client);
    setSupplier(supplier);
    setId(id);
    super.setName(name);
    super.setType(ElementsTypes.REALIZATION);

    if ((client instanceof Package) && (supplier instanceof Interface)) {
      ((Package) client).addImplementedInterface((Interface) supplier);
    }
    if ((client instanceof Class) && (supplier instanceof Interface)) {
      ((Class) client).addImplementedInterface((Interface) supplier);
    }
  }
  private static List<arquitetura.touml.Attribute> createAttributes(Operations op, Class klass) {
    List<arquitetura.touml.Attribute> attributes = new ArrayList<arquitetura.touml.Attribute>();

    for (Attribute attribute : klass.getAllAttributes()) {
      arquitetura.touml.Attribute attr =
          arquitetura.touml.Attribute.create()
              .withName(attribute.getName())
              .grafics(attribute.isGeneratVisualAttribute())
              .withConcerns(attribute.getOwnConcerns())
              .withVisibility(VisibilityKind.getByName(attribute.getVisibility()))
              .withType(Types.getByName(attribute.getType()));

      attributes.add(attr);
    }

    return attributes;
  }
  public DependencyRelationship create(Dependency element) {

    EList<NamedElement> suppliers = element.getSuppliers();
    EList<NamedElement> clieents = element.getClients();

    Element client = architecture.findElementById(getModelHelper().getXmiId(clieents.get(0)));
    Element supplier = architecture.findElementById(getModelHelper().getXmiId(suppliers.get(0)));

    if ((client instanceof Class) && (supplier instanceof Interface))
      ((Class) client).addRequiredInterface((Interface) supplier);

    if ((client instanceof Package) && (supplier instanceof Interface))
      ((Package) client).addRequiredInterface((Interface) supplier);

    DependencyRelationship dependency =
        new DependencyRelationship(
            supplier, client, element.getName(), getModelHelper().getXmiId(element));
    dependency.setStereotypes(StereotypeHelper.getAllRelationshipStereotypes(element));

    return dependency;
  }
Ejemplo n.º 5
0
  public arquitetura.representation.Class applyAdapter(Element target, Element adaptee) {
    arquitetura.representation.Class adapterClass = null;
    if (target != null
        && adaptee != null
        && (target instanceof arquitetura.representation.Class || target instanceof Interface)
        && (adaptee instanceof arquitetura.representation.Class || adaptee instanceof Interface)) {
      try {

        adapterClass = AdapterUtil.getAdapterClass(target, adaptee);
        if (adapterClass == null) {
          adapterClass = AdapterUtil.createAdapterClass(adaptee);
        }
        // Implements/Extends and add all methods.
        if (target instanceof arquitetura.representation.Class) {
          ElementUtil.extendClass(adapterClass, (arquitetura.representation.Class) target);
        } else {
          ElementUtil.implementInterface(adapterClass, (Interface) target);
        }

        RelationshipUtil.createNewUsageRelationship("adaptee", adapterClass, adaptee);

        Relationship relationshipToBeExcluded = null;
        if (adaptee.getClass().equals(target.getClass())) {
          for (Relationship relationship : ElementUtil.getRelationships(adaptee)) {
            if (target.equals(RelationshipUtil.getSuperElement(relationship))) {
              relationshipToBeExcluded = relationship;
              break;
            }
          }
        } else {
          for (Relationship relationship : ElementUtil.getRelationships(adaptee)) {
            if (target.equals(RelationshipUtil.getImplementedInterface(relationship))) {
              relationshipToBeExcluded = relationship;
              break;
            }
          }
        }

        if (relationshipToBeExcluded != null) {
          ArchitectureRepository.getCurrentArchitecture()
              .removeRelationship(relationshipToBeExcluded);
        }

        // Copy concerns
        for (Concern concern :
            CollectionUtils.union(target.getOwnConcerns(), adaptee.getOwnConcerns())) {
          try {
            adapterClass.addConcern(concern.getName());
          } catch (ConcernNotFoundException ex) {
            Logger.getLogger(Adapter.class.getName()).log(Level.SEVERE, null, ex);
          }
        }

        // Move variants
        Variant variant = adaptee.getVariant();
        if (variant != null) {
          adaptee.setVariant(null);
          adapterClass.setVariant(variant);
          variant.setVariantElement(adapterClass);
        }

        addStereotype(target);
        addStereotype(adaptee);
        addStereotype(adapterClass);
      } catch (Exception ex) {
        Logger.getLogger(Adapter.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    return adapterClass;
  }
  public void generate(Architecture a, String output) {

    getLogLog(); // para poder capturar logs na GUI.

    UtilResources.clearConsole();

    DocumentManager doc = null;
    try {
      doc = givenADocument(output);
    } catch (ModelNotFoundException e1) {
      LOGGER.warn("Cannot find model: " + e1.getMessage());
    } catch (ModelIncompleteException e1) {
      LOGGER.warn("Model Incomplete" + e1.getMessage());
    } catch (SMartyProfileNotAppliedToModelExcepetion e1) {
      LOGGER.warn("Smarty Profile note Applied: " + e1.getMessage());
    }

    Operations op = null;

    try {
      op = new Operations(doc, a);

      Set<Package> packages = a.getAllPackages();

      for (Class klass : a.getAllClasses()) {

        List<arquitetura.touml.Attribute> attributesForClass = createAttributes(op, klass);

        Set<Method> methodsForClass = createMethods(klass);

        // Variation Point
        VariationPoint variationPoint = klass.getVariationPoint();
        String variants = "";
        String variabilities = "";

        if (variationPoint != null) {
          variants = Strings.spliterVariants(variationPoint.getVariants());
          variabilities = Strings.spliterVariabilities(variationPoint.getVariabilities());
        }
        // Variation Point
        if (attributesForClass.isEmpty()) {
          op.forClass()
              .createClass(klass)
              .withMethods(methodsForClass)
              .isVariationPoint(variants, variabilities, BindingTime.DESIGN_TIME)
              .build();
        } else {
          op.forClass()
              .createClass(klass)
              .withMethods(methodsForClass)
              .withAttribute(attributesForClass)
              .isVariationPoint(variants, variabilities, BindingTime.DESIGN_TIME)
              .build();
        }

        // Adiciona Interesses nas classes
        op.forConcerns().withStereotypes(klass.getOwnConcerns(), klass.getId());

        op.forConcerns().withPatternsStereotype(klass);

        // Inicio - Thaina 12/14 - Aspecto
        op.forConcerns().withStereotypesAspect(klass.getAspects(), klass.getId());
        // Fim - Thaina 12/14 - Aspecto

        // Adiciona Interesses nos atributos
        for (arquitetura.touml.Attribute attr : attributesForClass) {
          op.forConcerns().withStereotypes(attr.getConcerns(), attr.getId());
        }
        // Adiciona Interesses nos métodos
        for (Method m : methodsForClass) {
          op.forConcerns().withStereotypes(m.getConcerns(), m.getId());
          // Inicio - Thaina 12/14 - Aspecto
          op.forConcerns().withStereotypesAspect(m.getAspects(), m.getId());
          // Fim - Thaina 12/14 - Aspecto
        }

        attributesForClass.clear();
        methodsForClass.clear();
        // Adiciona Interesses nas classes

        // Variant Type
        Variant v = null;

        Variant variant = klass.getVariant();
        if (variant != null) {
          try {
            Element elementRootVp = null;
            elementRootVp = a.findElementByName(variant.getRootVP(), "class");
            if (elementRootVp == null) {
              elementRootVp = a.findElementByName(variant.getRootVP(), "interface");
            }
            String rootVp = null;

            if (elementRootVp != null) {
              rootVp = elementRootVp.getName();
            } else {
              rootVp = "";
            }
            v =
                Variant.createVariant()
                    .withName(variant.getVariantName())
                    .andRootVp(rootVp)
                    .wihtVariabilities(variant.getVariabilities())
                    .withVariantType(variant.getVariantType())
                    .build();

            // Se tem variant adicionar na classe
            if (v != null) {
              op.forClass().addStereotype(klass.getId(), v);
            }

          } catch (Exception e) {
            System.out.println("Error when try create Variant." + e.getMessage());
            System.exit(0);
          }
        }
        // Variant Type
      }

      for (Interface _interface : a.getAllInterfaces()) {
        // Variation Point
        VariationPoint variationPoint = _interface.getVariationPoint();
        String variants = "";
        String variabilities = "";

        if (variationPoint != null) {
          variants = Strings.spliterVariants(variationPoint.getVariants());
          variabilities = Strings.spliterVariabilities(variationPoint.getVariabilities());
        }

        Set<Method> methodsForClass = createMethods(_interface);
        op.forClass()
            .createClass(_interface)
            .withMethods(methodsForClass)
            .isVariationPoint(variants, variabilities, BindingTime.DESIGN_TIME)
            .asInterface()
            .build();

        // Variant Type
        Variant v = null;

        Variant variant = _interface.getVariant();
        if (variant != null) {
          try {
            Element elementRootVp = null;
            elementRootVp = a.findElementByName(variant.getRootVP(), "class");
            if (elementRootVp == null) {
              elementRootVp = a.findElementByName(variant.getRootVP(), "interface");
            }
            String rootVp = null;

            if (elementRootVp != null) {
              rootVp = elementRootVp.getName();
            } else {
              rootVp = "";
            }
            v =
                Variant.createVariant()
                    .withName(variant.getVariantName())
                    .andRootVp(rootVp)
                    .wihtVariabilities(variant.getVariabilities())
                    .withVariantType(variant.getVariantType())
                    .build();

            // Se tem variant adicionar na classe
            if (v != null) {
              op.forClass().addStereotype(_interface.getId(), v);
            }

          } catch (Exception e) {
            if (this.logger != null) {
              this.logger.putLog("Error when try create Variant." + e.getMessage(), Level.FATAL);
            }
            System.exit(0);
          }
        }
        // Variant Type

      }

      for (Interface inter : a.getAllInterfaces()) {
        // Adiciona Interesses nos métodos da interface
        for (arquitetura.representation.Method operation : inter.getOperations()) {
          op.forConcerns().withStereotypes(operation.getOwnConcerns(), operation.getId());
        }
        op.forConcerns().withStereotypes(inter.getOwnConcerns(), inter.getId());
        op.forConcerns().withPatternsStereotype(inter);
      }

      if (!packages.isEmpty()) {
        buildPackages(op, packages);
      }

      for (AssociationRelationship r :
          a.getRelationshipHolder().getAllAssociationsRelationships()) {
        generateSimpleAssociation(op, r);
      }

      for (AssociationRelationship r : a.getRelationshipHolder().getAllCompositions()) {
        generateComposition(op, r);
      }

      for (AssociationRelationship r : a.getRelationshipHolder().getAllAgragations()) {
        generateAggregation(op, r);
      }

      for (GeneralizationRelationship g : a.getRelationshipHolder().getAllGeneralizations()) {
        try {
          op.forGeneralization()
              .createRelation()
              .between(g.getChild().getId())
              .and(g.getParent().getId())
              .build();
        } catch (Exception e) {
          LOGGER.info("Generalizacao nao criada");
        }
      }

      for (DependencyRelationship d : a.getRelationshipHolder().getAllDependencies()) {
        try {
          op.forDependency()
              .createRelation()
              .withName(d.getName())
              .withStereotypes(d.getStereotypes())
              .between(d.getClient().getId())
              .and(d.getSupplier().getId())
              .build();
        } catch (Exception e) {
          LOGGER.info("Dependencia nao criada");
        }
      }
      for (RealizationRelationship r : a.getRelationshipHolder().getAllRealizations()) {
        try {
          op.forRealization()
              .createRelation()
              .withName(r.getName())
              .between(r.getClient().getId())
              .and(r.getSupplier().getId())
              .build();
        } catch (Exception e) {
          LOGGER.info("Realizacao nao criada");
        }
      }

      for (AbstractionRelationship r : a.getRelationshipHolder().getAllAbstractions()) {
        try {
          op.forAbstraction()
              .createRelation()
              .withName(r.getName())
              .between(r.getClient().getId())
              .and(r.getSupplier().getId())
              .build();
        } catch (Exception e) {
          LOGGER.info("Abstracao nao criada");
        }
      }

      for (UsageRelationship u : a.getRelationshipHolder().getAllUsage()) {
        try {
          op.forUsage()
              .createRelation("")
              .between(u.getClient().getId())
              .and(u.getSupplier().getId())
              .build();
        } catch (Exception e) {
          LOGGER.info("Usage nao criada");
        }
      }

      for (AssociationClassRelationship asr : a.getRelationshipHolder().getAllAssociationsClass()) {
        try {
          op.forAssociationClass().createAssociationClass(asr).build();
          op.forPackage().withId(asr.getPackageOwner()).add(asr.getId());
        } catch (Exception e) {
          LOGGER.info("AssociationClass nao criada");
        }
      }

      // Variabilidades - Notes
      List<Variability> variabilities = a.getAllVariabilities();
      String idOwner = "";
      for (Variability variability : variabilities) {
        try {
          VariationPoint variationPointForVariability = variability.getVariationPoint();
          /*
           * Um Variabilidade pode estar ligada a uma classe que não
           * seja um ponto de variação, neste caso a chama do método
           * acima vai retornar null. Quando isso acontecer é usado o
           * método getOwnerClass() que retorna a classe que é dona da
           * variabilidade.
           */
          if (variationPointForVariability == null) {
            idOwner = a.findClassByName(variability.getOwnerClass()).get(0).getId();
          } else {
            idOwner = variationPointForVariability.getVariationPointElement().getId();
          }

          String idNote = op.forNote().createNote().build();
          VariabilityStereotype var = new VariabilityStereotype(variability);
          op.forNote().addVariability(idNote, var).build();
          op.forClass().withId(idOwner).linkToNote(idNote);
        } catch (Exception e) {
          LOGGER.info("Nao conseguiu criar variationPoint");
        }
      }
      variabilities.clear();

    } catch (Exception e) {
      e.printStackTrace();
      System.exit(0);
    }

    LOGGER.info(
        "\n\n\nDone. Architecture save into: "
            + ReaderConfig.getDirExportTarget()
            + doc.getNewModelName()
            + "\n\n\n\n");
    if (this.logger != null) {
      this.logger.putLog(
          "Done. Architecture save into: "
              + ReaderConfig.getDirExportTarget()
              + doc.getNewModelName(),
          Level.INFO);
    }
  }