fj.data.fingertrees.Four Maven / Gradle / Ivy

Go to download
package fj.data.fingertrees;

import fj.P;
import fj.P2;
import fj.P3;
import fj.data.Option;
import fj.data.vector.V4;
import fj.F;

import static fj.data.Option.none;
import static fj.data.Option.some;
import static fj.data.fingertrees.FingerTree.mkTree;

/**
 * A four-element prefix or suffix of a finger tree.
 */
public final class Four extends Digit {
  private final V4 as;

  Four(final Measured m, final V4 as) {
    super(m);
    this.as = as;
  }

  public  B foldRight(final F> aff, final B z) {
    return aff.f(as._1()).f(aff.f(as._2()).f(aff.f(as._3()).f(aff.f(as._4()).f(z))));
  }

  public  B foldLeft(final F> bff, final B z) {
    return as.toStream().foldLeft(bff, z);
  }

  @Override public  B match(
      final F, B> one, final F, B> two, final F, B> three,
      final F, B> four) {
    return four.f(this);
  }

  /**
   * Returns the elements of this digit as a vector.
   *
   * @return the elements of this digit as a vector.
   */
  public V4 values() {
    return as;
  }

  @Override P3>, A, Option>> split1(final F predicate, final V acc) {
    final Measured m = measured();
    final MakeTree mk = mkTree(m);
    final F measure = m.measure();
    final V acc1 = m.sum(acc, measure.f(as._1()));
    if (predicate.f(acc1)) {
      return P.p(none(), as._1(), some(mk.three(as._2(), as._3(), as._4())));
    } else {
      final V acc2 = m.sum(acc1, measure.f(as._2()));
      if (predicate.f(acc2)) {
        return P.p(some(mk.one(as._1())), as._2(), some(mk.two(as._3(), as._4())));
      } else if (predicate.f(m.sum(acc2, measure.f(as._3())))) {
        return P.p(some(mk.two(as._1(), as._2())), as._3(), some(mk.one(as._4())));
      } else {
        return P.p(some(mk.three(as._1(), as._2(), as._3())), as._4(), none());
      }
    }
  }

  @Override public P2 lookup(final F o, final int i) {
    final F m = measured().measure();
    final int s1 = o.f(m.f(as._1()));
    if (i < s1) {
      return P.p(i, as._1());
    } else {
      final int s2 = s1 + o.f(m.f(as._2()));
      if (i < s2) {
        return P.p(i - s1, as._2());
      } else {
        final int s3 = s2 + o.f(m.f(as._3()));
        if (i < s3) {
          return P.p(i - s2, as._3());
        } else {
          return P.p(i - s3, as._4());
        }
      }
    }
  }

    @Override
    public int length() {
        return 4;
    }
}