com.simplaex.bedrock.SeqGenerated Maven / Gradle / Ivy

Go to download
package com.simplaex.bedrock;

import lombok.AllArgsConstructor;

import javax.annotation.Nonnegative;
import javax.annotation.Nonnull;
import java.lang.reflect.Array;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.IntFunction;

class SeqGenerated extends Seq {

  private final IntFunction backingFunction;
  private final int length;

  SeqGenerated(@Nonnull final IntFunction function, @Nonnegative final int length) {
    this.backingFunction = function;
    this.length = length;
  }

  @SuppressWarnings("ConstantConditions")
  @Override
  public E get(@Nonnegative final int index) {
    if (index >= length || index < 0) {
      throw new IndexOutOfBoundsException();
    }
    return backingFunction.apply(index);
  }

  @Nonnull
  @Override
  public Seq sortedBy(@Nonnull final Comparator comparator) {
    return trimmedToSize().sortedBy(comparator);
  }

  @Nonnull
  @Override
  public E[] toArray(@Nonnull final Class evidence) {
    Objects.requireNonNull(evidence);
    final int length = size();
    @SuppressWarnings("unchecked") final E[] array = (E[]) Array.newInstance(evidence, length);
    for (int i = 0; i < length; i += 1) {
      array[i] = get(i);
    }
    return array;
  }

  @Nonnull
  @Override
  public Object[] toArray() {
    final Object[] array = new Object[size()];
    for (int i = 0; i < size(); i += 1) {
      array[i] = backingFunction.apply(i);
    }
    return array;
  }

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

  @AllArgsConstructor
  private static class ReversedFunction implements IntFunction {

    private int length;
    private IntFunction backingFunction;

    @Override
    public X apply(final int ix) {
      return backingFunction.apply(length - ix - 1);
    }
  }

  @Nonnull
  @Override
  public Seq reversed() {
    if (backingFunction instanceof ReversedFunction) {
      final ReversedFunction f = (ReversedFunction) backingFunction;
      return Seq.ofGenerator(f.backingFunction, f.length);
    }
    return Seq.ofGenerator(new ReversedFunction<>(length, backingFunction), length);
  }

  @SuppressWarnings("unchecked")
  @Nonnull
  @Override
  public Seq sorted() {
    return trimmedToSize().sorted();
  }

  @Nonnull
  @Override
  public Seq trimmedToSize() {
    return Seq.ofArrayZeroCopyInternal(toArray());
  }

  @Nonnull
  @Override
  public Seq subSequence(final int beginOffset, final int endOffset) {
    final int begin = Math.max(0, beginOffset);
    final int end = Math.min(length(), endOffset);
    final int len = end - begin;
    if (len <= 0) {
      return empty();
    }
    final Object[] array = new Object[len];
    for (int i = 0; i < len; i += 1) {
      array[i] = get(begin + i);
    }
    return Seq.ofArrayZeroCopyInternal(array);
  }

  @Nonnull
  @Override
  public Seq subSequenceView(final int beginOffset, final int endOffset) {
    return subSequence(beginOffset, endOffset);
  }
}