コード例 #1
0
ファイル: UMLClass.java プロジェクト: mcgarrdg/UMLGenerator
  /**
   * This method is only useful if the graph has been built, and {@link #generateArrows(ArrayList)}
   * has been called on all classes. This method removes any arrows that point to classes that are
   * super classes of classes that this class has arrows to.
   */
  public void removeExtraArrows() {
    ArrayList<UMLClass> pointedTo = new ArrayList<UMLClass>();
    for (UMLArrow arrow : this.arrows) {
      pointedTo.add(arrow.getEndClass());
    }

    // If the used class is in a field, ignore it.
    for (UMLClass firstClass : new ArrayList<UMLClass>(pointedTo)) {
      for (UMLClass secondClass : new ArrayList<UMLClass>(pointedTo)) {
        if (firstClass.checkExtendsOrImplements(secondClass)) {
          pointedTo.remove(secondClass);
        } else if (secondClass.checkExtendsOrImplements(firstClass)) {
          pointedTo.remove(firstClass);
        }
      }
    }

    // Add back in extends/implements arrows
    for (UMLArrow arrow : this.arrows) {
      if (arrow.extendsOrImplements()) {
        pointedTo.add(arrow.getEndClass());
      }
    }

    for (UMLArrow arrow : new ArrayList<UMLArrow>(this.arrows)) {
      if ((!pointedTo.contains(arrow.getEndClass())) && arrow.isUsesArrow()) {
        this.arrows.remove(arrow);
      }
    }
  }
コード例 #2
0
ファイル: UMLClass.java プロジェクト: mcgarrdg/UMLGenerator
  public ArrayList<UMLClass> getAllExtendsOrImplements() {
    ArrayList<UMLClass> finalList = new ArrayList<UMLClass>();
    ArrayList<UMLClass> extendsOrImplements = new ArrayList<UMLClass>();

    for (UMLArrow arrow : this.arrows) {
      if (arrow.extendsOrImplements()) {
        extendsOrImplements.add(arrow.getEndClass());
      }
    }

    for (UMLClass uClass : extendsOrImplements) {
      finalList.addAll(uClass.getAllExtendsOrImplementsHelper());
    }

    return finalList;
  }
コード例 #3
0
ファイル: UMLClass.java プロジェクト: mcgarrdg/UMLGenerator
  /**
   * This method is only useful if the graph has been built, and {@link #generateArrows(ArrayList)}
   * has been called on all classes.
   *
   * @param c The class to check if this class (directly or indirectly) extends or implements.
   * @return Whether or not this class extends or implements c.
   */
  public boolean checkExtendsOrImplements(UMLClass c) {
    if ((this.extension == null || this.extension.isEmpty()) && this.implementations.isEmpty()) {
      return false;
    }

    ArrayList<UMLClass> extImpl = new ArrayList<UMLClass>();
    for (UMLArrow arrow : this.arrows) {
      if (arrow.extendsOrImplements()) {
        extImpl.add(arrow.getEndClass());
      }
    }

    for (UMLClass cls : extImpl) {
      if (cls.getName().equals(c.getName())) {
        return true;
      } else if (cls.checkExtendsOrImplements(c)) {
        return true;
      }
    }
    return false;
  }
コード例 #4
0
ファイル: UMLClass.java プロジェクト: mcgarrdg/UMLGenerator
  private ArrayList<UMLClass> getAllExtendsOrImplementsHelper() {
    ArrayList<UMLClass> finalList = new ArrayList<UMLClass>();
    ArrayList<UMLClass> extendsOrImplements = new ArrayList<UMLClass>();

    for (UMLArrow arrow : this.arrows) {
      if (arrow.extendsOrImplements()) {
        extendsOrImplements.add(arrow.getEndClass());
      }
    }

    for (UMLClass uClass : extendsOrImplements) {
      ArrayList<UMLClass> temp = uClass.getAllExtendsOrImplementsHelper();
      for (UMLClass uClass2 : temp) {
        if (!finalList.contains(uClass2)) {
          finalList.add(uClass2);
        }
      }
    }

    finalList.add(this);
    return finalList;
  }
コード例 #5
0
ファイル: UMLClass.java プロジェクト: mcgarrdg/UMLGenerator
  /**
   * Should be called after all classes have been parsed. This generates the different arrow types.
   * connecting the classes in the UML.
   *
   * @param classes A list of all classes in the UML.
   */
  public void generateArrows(ArrayList<UMLClass> classes) {
    for (UMLClass secondClass : classes) {
      // Check for implements arrows
      for (String implementation : this.implementations) {
        if (secondClass.getName().equals(implementation)) {
          this.addArrow(secondClass, "onormal", "dashed");
        }
      }

      // Check for extends arrows
      if (secondClass.getName().equals(this.extension)) {
        this.addArrow(secondClass, "onormal", "");
      }

      // Check for association arrows
      // Keep in mind, if we do the diamonds this is technically
      // backwards.
      for (UMLField field : this.fields) {
        String type = field.getType().getFullBaseDataType();
        if (secondClass.getName().equals(type)) {
          this.addArrow(secondClass, "vee", "solid");
          //					System.out.println("association from " + this.getName() + " " + type );
        }
      }
    }

    // Check for uses arrows
    for (UMLMethod meth : this.methods) {
      ArrayList<UMLClass> classUsedList = new ArrayList<UMLClass>();
      for (TypeData d : meth.getClassesUsed()) {
        for (UMLClass c : classes) {
          if (c.getName().equals(d.getFullBaseDataType())) {
            classUsedList.add(c);
          }
        }
      }
      for (UMLClass cls : classUsedList) {
        this.addArrow(cls, "vee", "dashed");
      }
    }
  }
コード例 #6
0
ファイル: UMLClass.java プロジェクト: mcgarrdg/UMLGenerator
  // TODO Move these methods into UMLGraph where it makes more sense?
  // TODO Have a seperate array stored for all of the arrows?
  public void removeRedundantUsesArrows() {
    ArrayList<UMLClass> extendsOrImplements = this.getAllExtendsOrImplements();
    ArrayList<UMLClass> thisUsed = this.getAllUsedClasses();

    // Go through everything this class extends or implements (directly or
    // indirectly)
    for (UMLClass extendedClass : extendsOrImplements) {
      ArrayList<UMLClass> otherUsed = extendedClass.getAllUsedClasses();
      // Go through all of the classes that this class uses
      for (UMLClass usedClass : thisUsed) {
        boolean removeArrow = true;
        // If the other class uses the same thing as this class, check
        // to see
        // if all instances where that is used is the same in both
        // classes
        // or not used in this class. If so, remove the arrow from this
        // class.
        if (otherUsed.contains(usedClass)) {
          // Check if the used class is within a field
          boolean foundField = false;
          for (UMLField field : this.getFields()) {
            if (field.getType().getFullBaseDataType().equals(usedClass.getName())) {
              foundField = true;
              removeArrow = false;
            }
          }
          // If the used class is in a field, don't remove the arrow,
          // so skip the arrow checks.
          if (!foundField) {
            // Check everything for type, and if they are the same
            // in the two
            // If everything is the same, remove this class' used
            // arrow for that thing
            for (UMLMethod thisMethod : this.methods) {
              boolean wasUsed = false;
              // Check to see if this method uses the used class
              // at all
              for (TypeData d : thisMethod.getClassesUsed()) {
                if (d.getFullBaseDataType().equals(usedClass.getName())) {
                  wasUsed = true;
                  break;
                }
              }
              // The class was used in the method. Check to see if
              // there is an identical method in the other.
              if (wasUsed) {
                boolean isSame = false;
                for (UMLMethod extendedMethod : extendedClass.getMethods()) {
                  // If the methods have the same signature
                  if (thisMethod.sameSignature(extendedMethod)) {
                    isSame = true;
                    break;
                  }
                }
                if (!isSame) {
                  removeArrow = false;
                  break;
                }
              }
            }
          }
          if (removeArrow) {
            for (UMLArrow arrow : new ArrayList<UMLArrow>(this.arrows)) {
              if (arrow.isUsesArrow()
                  && arrow.getEndClass().getName().equals(usedClass.getName())) {
                this.arrows.remove(arrow);
                break;
              }
            }
          }
        }
      }
    }
  }