示例#1
0
 private GenPredicGroup addPredicsToExisting(Rule rul, GenPredicGroup previousConds) {
   List<GenPredicGroup> list = new ArrayList<GenPredicGroup>();
   GenPredicGroup gpg = getGroupConditions(rul.getRootCondition().getConditions(), null);
   list.add(gpg);
   list.add(previousConds);
   GenPredicGroup newGroup = new GenPredicGroup();
   newGroup.setMyGroups(list);
   newGroup.setOperator(EOperator.ANY);
   return newGroup;
 }
示例#2
0
  /**
   * recursive method to get all conditions from "condition tree"
   *
   * @param conds - at the beginning root conditions, at lower level conditions under
   *     CompoundCondition
   * @param op - at the beginning null, at lower level operator of Compound Condition
   * @return group of its subgroups and of conditions
   */
  private GenPredicGroup getGroupConditions(Conditions conds, GenPredicGroup.EOperator op) {
    GenPredicGroup myConds = new GenPredicGroup();
    myConds.setOperator((op != null) ? op : GenPredicGroup.EOperator.ALL);
    Iterator<Condition> it = conds.iterator();
    while (it.hasNext()) {
      Condition cond = it.next();
      // if true, a new condition group is created and filled
      if (cond instanceof CompoundCondition) {
        // set group operator
        GenPredicGroup.EOperator actualOp = null;
        if (cond instanceof ConditionAll) {
          actualOp = GenPredicGroup.EOperator.ALL;
        } else if (cond instanceof ConditionAny) {
          actualOp = GenPredicGroup.EOperator.ANY;
        } else if (cond instanceof ConditionNone) {
          actualOp = GenPredicGroup.EOperator.NONE;
        }

        if (myConds.getMyGroups() == null) {
          myConds.setMyGroups(new ArrayList<GenPredicGroup>());
        }
        // call recursively to get conditions of actual group
        myConds
            .getMyGroups()
            .add(getGroupConditions(((CompoundCondition) cond).getConditions(), actualOp));
      } else {
        // get condition
        if (myConds.getGeneratorPredicts() == null) {
          myConds.setGeneratorPredicts(new ArrayList<GeneratorPredicate>());
        }
        myConds.getGeneratorPredicts().add(getGP(cond));
      }
    }

    return myConds;
  }
示例#3
0
  /**
   * @param logger
   * @param context
   * @param typeName
   * @param gr
   * @return
   */
  public boolean isGenerate(
      TreeLogger logger, GeneratorContext context, String typeName, GenPredicGroup gr) {
    boolean result = false;
    if ((gr.getMyGroups() != null) && (gr.getMyGroups().size() > 0)) {
      for (GenPredicGroup group : gr.getMyGroups()) {
        switch (gr.getOperator()) {
          case ANY:
            result = result || isGenerate(logger, context, typeName, group);
            break;
          case NONE:
            result = !isGenerate(logger, context, typeName, group);
            if (!result) return false;
            break;
          case ALL:
            result = isGenerate(logger, context, typeName, group);
            if (!result) return false;
          default:
            break;
        }
      }
    }
    if ((gr.getGeneratorPredicts() != null) && (gr.getGeneratorPredicts().size() > 0)) {
      for (GeneratorPredicate entry : gr.getGeneratorPredicts()) {
        String value = null;
        try {
          switch (entry.getEPredict()) {
            case ASSIGNABLE:
              if (context
                  .getTypeOracle()
                  .findType(typeName)
                  .isAssignableTo(context.getTypeOracle().getType(entry.getValue()))) {
                value = entry.getValue();
              } else {
                value = typeName;
              }
              break;
            case TYPEIS:
              value = typeName;
              break;
            case PROPERTY:
              // ???he
              value =
                  context
                      .getPropertyOracle()
                      .getSelectionProperty(logger, entry.getName())
                      .getCurrentValue();
              break;
            default:
              value = null;
              break;
          }
        } catch (Exception e) {
          value = null;
          result = false;
        }

        if (value != null) {
          switch (gr.getOperator()) {
            case ANY:
              result = result || entry.getValue().equals(value);
              break;
            case NONE:
              result = !entry.getValue().equals(value);
              if (!result) return false;
              break;
            case ALL:
              result = entry.getValue().equals(value);
              if (!result) return false;
            default:
              break;
          }
        }
      }
    }
    return result;
  }