com.github.tonivade.purefun.data.ImmutableArray Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2018-2019, Antonio Gabriel Muñoz Conejo 
 * Distributed under the terms of the MIT License
 */
package com.github.tonivade.purefun.data;

import static com.github.tonivade.purefun.data.Sequence.narrowK;
import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.collectingAndThen;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import com.github.tonivade.purefun.Equal;
import com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Higher1;
import com.github.tonivade.purefun.Matcher1;

public interface ImmutableArray extends Sequence {

  List toList();

  @Override
  ImmutableArray append(E element);
  @Override
  ImmutableArray remove(E element);
  @Override
  ImmutableArray appendAll(Sequence other);
  @Override
  ImmutableArray removeAll(Sequence other);

  @Override
  ImmutableArray reverse();
  ImmutableArray sort(Comparator comparator);

  E get(int position);
  ImmutableArray remove(int position);
  ImmutableArray replace(int position, E element);
  ImmutableArray insert(int position, E element);
  ImmutableArray insertAll(int position, Sequence elements);

  default ImmutableArray drop(int n) {
    return ImmutableArray.from(stream().skip(n));
  }

  @Override
  default  ImmutableArray map(Function1 mapper) {
    return ImmutableArray.from(stream().map(mapper::apply));
  }

  @Override
  default  ImmutableArray flatMap(Function1> mapper) {
    return ImmutableArray.from(stream().flatMap(element -> narrowK(mapper.apply(element)).stream()));
  }

  @Override
  default ImmutableArray filter(Matcher1 matcher) {
    return ImmutableArray.from(stream().filter(matcher::match));
  }

  static  ImmutableArray from(Iterable iterable) {
    return from(Sequence.asStream(iterable.iterator()));
  }

  static  ImmutableArray from(Stream stream) {
    return new JavaBasedImmutableArray<>(stream.collect(Collectors.toList()));
  }

  @SafeVarargs
  static  ImmutableArray of(T... elements) {
    return new JavaBasedImmutableArray<>(Arrays.asList(elements));
  }

  static  ImmutableArray empty() {
    return new JavaBasedImmutableArray<>(Collections.emptyList());
  }

  static  Collector> toImmutableArray() {
    return collectingAndThen(Collectors.toList(), JavaBasedImmutableArray::new);
  }

  final class JavaBasedImmutableArray implements ImmutableArray, Serializable {

    private static final long serialVersionUID = 5728385935547829871L;

    private final List backend;

    private JavaBasedImmutableArray(List backend) {
      this.backend = requireNonNull(backend);
    }

    @Override
    public int size() {
      return backend.size();
    }

    @Override
    public boolean contains(E element) {
      return backend.contains(element);
    }

    @Override
    public ImmutableArray reverse() {
      List list = toList();
      Collections.reverse(list);
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public Iterator iterator() {
      return backend.iterator();
    }

    @Override
    public ImmutableArray append(E element) {
      List list = toList();
      list.add(element);
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public ImmutableArray remove(E element) {
      List list = toList();
      list.remove(element);
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public ImmutableArray appendAll(Sequence other) {
      List list = toList();
      for (E element : other) {
        list.add(element);
      }
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public ImmutableArray removeAll(Sequence other) {
      List list = toList();
      for (E element : other) {
        list.remove(element);
      }
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public ImmutableArray sort(Comparator comparator) {
      List list = toList();
      Collections.sort(list, comparator);
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public E get(int position) {
      return backend.get(position);
    }

    @Override
    public ImmutableArray replace(int position, E element) {
      List list = toList();
      list.set(position, element);
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public ImmutableArray remove(int position) {
      List list = toList();
      list.remove(position);
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public ImmutableArray insert(int position, E element) {
      List list = toList();
      list.add(position, element);
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public ImmutableArray insertAll(int position, Sequence elements) {
      List list = toList();
      list.addAll(position, elements.stream().collect(Collectors.toList()));
      return new JavaBasedImmutableArray<>(list);
    }

    @Override
    public List toList() {
      return new ArrayList<>(backend);
    }

    @Override
    public int hashCode() {
      return Objects.hash(backend);
    }

    @Override
    public boolean equals(Object obj) {
      return Equal.of(this)
          .append((a, b) -> Objects.equals(a.backend, b.backend))
          .applyTo(obj);
    }

    @Override
    public String toString() {
      return "ImmutableArray(" + backend + ")";
    }
  }
}