/**
   * Comprueba el valor de verdad del predicado.
   *
   * @return <code>true</code> si no existe el método en ninguna superclase de la clase
   *     especificada; <code>false</code> en caso contrario.
   */
  public boolean isValid() {

    NotExistsMethodWithNameInClass subPredicate;
    ClassDef nextSuperclass;
    Name uniqueName;

    // Se obtiene la lista de parámetros del método buscado.
    int parameterTypesFirstIndex = method.getUniqueName().toString().indexOf('%');

    String parameterTypesPart = ""; // $NON-NLS-1$
    if (parameterTypesFirstIndex >= 0)
      parameterTypesPart = method.getUniqueName().toString().substring(parameterTypesFirstIndex);

    // Se obtienen todas las superclases de la clase seleccionada.
    Iterator<ClassDef> superClassIt = new SuperclassCollector(classDef).getCollection().iterator();

    while (superClassIt.hasNext()) {
      nextSuperclass = superClassIt.next();

      uniqueName =
          nextSuperclass
              .getUniqueName()
              .concat('~' + method.getName().toString() + parameterTypesPart);

      subPredicate = new NotExistsMethodWithNameInClass(nextSuperclass, uniqueName);

      if (!(subPredicate.isValid())) return false;
    }

    return true;
  }
  /**
   * Comprueba el valor de verdad del predicado.
   *
   * @return <code>true</code> si no existen llamadas al método en todo el modelo; <code>false
   *     </code>, en caso contrario.
   */
  @Override
  public boolean isValid() {

    Collection<ClassDef> allClasses = MOONRefactoring.getModel().getClassDefSourceAvailable();

    for (ClassDef nextClass : allClasses) {
      List<MethDec> modelMethods = nextClass.getMethDec();

      for (MethDec nextMethod : modelMethods) {
        MethodInstructionsCollector mic = new MethodInstructionsCollector(nextMethod);

        for (Instr instruction : mic.getCollection()) {

          if (instruction instanceof CallInstr) {
            if (!checkCallInstr((CallInstr) instruction)) return false;

          } else {
            if (instruction instanceof AssignmentInstr) {
              Expr expresion = ((AssignmentInstr) instruction).getRighSide();

              if (expresion instanceof CallExpr)
                if (!(checkCallExpr((CallExpr) expresion))) return false;
            }
          }
        }
      }
    }

    return true;
  }
  /**
   * Constructor.
   *
   * <p>Obtiene una nueva instancia de MethodIsNotAlreadyInSuperclasses.
   *
   * @param method el método cuyo equivalente en una superclase se desea buscar.
   * @param classDef la clase en cuyas superclases se busca el método.
   */
  public MethodIsNotAlreadyInSuperclasses(MethDec method, ClassDef classDef) {

    super(
        "MethodIsNotAlreadyInSuperclasses:\n\t"
            + //$NON-NLS-1$
            "Makes sure the given method "
            + '"'
            + method.getName().toString()
            + //$NON-NLS-1$
            '"'
            + " is not to be found within any of the superclasses of the "
            + //$NON-NLS-1$
            "class "
            + '"'
            + classDef.getName().toString()
            + '"'
            + ".\n\n"); //$NON-NLS-1$ //$NON-NLS-2$

    this.classDef = classDef;
    this.method = method;
  }