Ejemplo n.º 1
0
  /**
   * @param rootValue
   * @param unfoldFunc
   * @param emptyTreeValue
   * @return
   */
  @Pure
  @ReturnNonnull
  @Recursive
  public static <TNode, TOut> IMultiTree<TNode> UnfoldLazy(
      @Nullable final TOut rootValue,
      final Func1<
              ? super TOut, ? extends Tuple2<? extends TNode, ? extends Iterable<? extends TOut>>>
          unfoldFunc,
      @Nullable final TOut emptyTreeValue) {
    com.google.common.base.Preconditions.checkNotNull(unfoldFunc);

    if (rootValue != emptyTreeValue) {
      final Tuple2<? extends TNode, ? extends Iterable<? extends TOut>> unfoldResult =
          unfoldFunc.DoFunc(rootValue);
      assert unfoldResult != null;

      final Iterable<IMultiTree<TNode>> subTrees =
          Iterables.Map(
              unfoldResult.GetItem2(),
              new Func1<TOut, IMultiTree<TNode>>() {

                @Override
                public IMultiTree<TNode> DoFunc(@Nullable final TOut input) {
                  return MultiTrees.UnfoldLazy(input, unfoldFunc, emptyTreeValue);
                }
              });
      assert subTrees != null;

      return MultiTreeNodeBase.<TNode, IMultiTree<TNode>>NewMultiTreeNode(
          unfoldResult.GetItem1(), subTrees);
    } else {
      return MultiTrees.EmptyMultiTree();
    }
  }
Ejemplo n.º 2
0
  @SuppressWarnings("unused")
  /**
   * @param tree
   * @return
   */
  @Pure
  @ExtensionMethod
  @ReturnNonnull
  private static <T> AbstractUnmodifiableIterable<T> NodeValuesPreOrder1(final IMultiTree<T> tree) {
    com.google.common.base.Preconditions.checkNotNull(tree);

    return MultiTrees.<T, AbstractUnmodifiableIterable<T>>Fold(
        tree,
        new Func2<T, Iterable<AbstractUnmodifiableIterable<T>>, AbstractUnmodifiableIterable<T>>() {

          @Override
          public AbstractUnmodifiableIterable<T> DoFunc(
              @Nullable final T nodeValue,
              final Iterable<AbstractUnmodifiableIterable<T>> subtreesNodeValues) {
            assert subtreesNodeValues != null;

            return Iterables.Concat(nodeValue, Iterables.Concat(subtreesNodeValues));
          }
        },
        Iterables.<T>EmptyUnmodifiableIterable());
  }
Ejemplo n.º 3
0
  /**
   * @param tree
   * @param foldTreeFunc
   * @param emptyTreeValue
   * @return
   */
  @Pure
  @ExtensionMethod
  @Recursive
  public static <TNode, TOut> TOut Fold(
      final IMultiTree<? extends TNode> tree,
      final Func2<? super TNode, ? super Iterable<TOut>, ? extends TOut> foldTreeFunc,
      @Nullable final TOut emptyTreeValue) {
    com.google.common.base.Preconditions.checkNotNull(foldTreeFunc);
    com.google.common.base.Preconditions.checkNotNull(tree);

    if (!tree.IsEmptyTree()) {
      final IMultiTreeNode<TNode> multiTreeNode = MultiTrees.AsMultiTreeNodeWhenReadOnly(tree);
      assert multiTreeNode != null;

      return foldTreeFunc.DoFunc(
          multiTreeNode.GetNodeValue(),
          Iterables.Map(
              multiTreeNode.GetSubtrees(),
              new Func1<IMultiTree<TNode>, TOut>() {

                @Override
                public TOut DoFunc(IMultiTree<TNode> subTree) {
                  return MultiTrees.Fold(subTree, foldTreeFunc, emptyTreeValue);
                }
              }));

    } else {
      return emptyTreeValue;
    }
  }
Ejemplo n.º 4
0
 /**
  * @param tree
  * @return
  */
 @SuppressWarnings("unchecked")
 @Pure
 @CheckForNull
 @ExtensionMethod
 public static <T> IMultiTreeNode<T> AsMultiTreeNodeWhenReadOnly(
     @Nullable final IMultiTree<? extends T> tree) {
   return MultiTrees.SafeCastWhenReadOnly(tree.AsTreeNode());
 }