Пример #1
0
  @Override
  public String evaluate(WalkedPath walkedPath) {

    Optional dataFromTranspose = objectEvaluate(walkedPath);

    if (dataFromTranspose.isPresent()) {

      Object data = dataFromTranspose.get();

      // Coerce a number into a String
      if (data instanceof Number) {
        // the idea here being we are looking for an array index value
        int val = ((Number) data).intValue();
        return Integer.toString(val);
      }

      // Coerce a boolean into a String
      if (data instanceof Boolean) {
        return Boolean.toString((Boolean) data);
      }

      if (data == null || !(data instanceof String)) {

        // If this output path has a TransposePathElement, and when we evaluate it
        //  it does not resolve to a String, then return null
        return null;
      }

      return (String) data;
    } else {
      return null;
    }
  }
Пример #2
0
  /**
   * This method is used when the TransposePathElement is used on the LFH as data.
   *
   * <p>Aka, normal "evaluate" returns either a Number or a String.
   *
   * @param walkedPath WalkedPath to evaluate against
   * @return The data specified by this TransposePathElement.
   */
  public Optional<Object> objectEvaluate(WalkedPath walkedPath) {
    // Grap the data we need from however far up the tree we are supposed to go
    PathStep pathStep = walkedPath.elementFromEnd(upLevel);

    if (pathStep == null) {
      return Optional.empty();
    }

    Object treeRef = pathStep.getTreeRef();

    // Now walk down from that level using the subPathReader
    if (subPathReader == null) {
      return Optional.of(treeRef);
    } else {
      return subPathReader.read(treeRef, walkedPath);
    }
  }
Пример #3
0
  public final Optional<DataType> traverse(
      StepType tree, Operation op, Iterator<String> keys, DataType data) {

    if (tree == null) {
      return Optional.empty();
    }

    if (getStepType().isAssignableFrom(tree.getClass())) {

      String key = keys.next();

      if (child == null) {
        // End of the Traversal so do the set or get
        switch (op) {
          case GET:
            return this.get(tree, key);
          case SET:
            return (Optional<DataType>) traversr.handleFinalSet(this, tree, key, data);
          case REMOVE:
            return this.remove(tree, key);
          default:
            throw new IllegalStateException("Invalid op:" + op.toString());
        }
      } else {

        // We just an intermediate step, so traverse and then hand over control to our child
        Optional<Object> optSub = traversr.handleIntermediateGet(this, tree, key, op);

        if (optSub.isPresent()) {
          return child.traverse(optSub.get(), op, keys, data);
        }
      }
    }

    return Optional.empty();
  }