swim.collections.FingerTrieSeq Maven / Gradle / Ivy

Go to download
// Copyright 2015-2019 SWIM.AI inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package swim.collections;

import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import swim.codec.Debug;
import swim.codec.Format;
import swim.codec.Output;
import swim.util.Builder;
import swim.util.Murmur3;

public final class FingerTrieSeq implements List, Debug {
  final Object[] prefix;
  final FingerTrieSeq branch;
  final Object[] suffix;
  final int length;

  FingerTrieSeq(Object[] prefix, FingerTrieSeq branch, Object[] suffix, int length) {
    this.prefix = prefix;
    this.branch = branch;
    this.suffix = suffix;
    this.length = length;
  }

  @SuppressWarnings("unchecked")
  FingerTrieSeq() {
    this.prefix = EMPTY_LEAF;
    this.branch = (FingerTrieSeq) this;
    this.suffix = EMPTY_LEAF;
    this.length = 0;
  }

  @Override
  public boolean isEmpty() {
    return this.length == 0;
  }

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

  @Override
  public boolean contains(Object elem) {
    final Iterator iter = iterator();
    while (iter.hasNext()) {
      final T next = iter.next();
      if (elem == null ? next == null : elem.equals(next)) {
        return true;
      }
    }
    return false;
  }

  @Override
  public boolean containsAll(Collection elems) {
    for (Object elem : elems) {
      if (!contains(elem)) {
        return false;
      }
    }
    return true;
  }

  @SuppressWarnings("unchecked")
  @Override
  public T get(int index) {
    final Object[] prefix = this.prefix;
    final int n = index - prefix.length;
    if (n < 0) {
      return (T) prefix[index];
    } else {
      final FingerTrieSeq branch = this.branch;
      final int j = n - (branch.length << 5);
      if (j < 0) {
        return (T) branch.get(n >> 5)[n & 0x1F];
      } else {
        return (T) this.suffix[j];
      }
    }
  }

  @Override
  public T set(int index, T nwElem) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean add(T newElem) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean addAll(Collection newElems) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void add(int index, T newElem) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean addAll(int index, Collection newElems) {
    throw new UnsupportedOperationException();
  }

  @Override
  public T remove(int index) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean remove(Object elem) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean removeAll(Collection elems) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean retainAll(Collection elems) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void clear() {
    throw new UnsupportedOperationException();
  }

  @Override
  public int indexOf(Object elem) {
    for (int i = 0, n = length; i < n; i += 1) {
      if (elem == null ? get(i) == null : elem.equals(get(i))) {
        return i;
      }
    }
    return -1;
  }

  @Override
  public int lastIndexOf(Object elem) {
    for (int i = length - 1; i >= 0; i -= 1) {
      if (elem == null ? get(i) == null : elem.equals(get(i))) {
        return i;
      }
    }
    return -1;
  }

  public FingerTrieSeq updated(int index, T elem) {
    final Object[] oldPrefix = this.prefix;
    final int a = oldPrefix.length;
    final int n = index - a;
    if (n < 0) {
      final Object[] newPrefix = new Object[a];
      System.arraycopy(oldPrefix, 0, newPrefix, 0, a);
      newPrefix[index] = elem;
      return new FingerTrieSeq(newPrefix, this.branch, this.suffix, this.length);
    } else {
      final FingerTrieSeq oldBranch = this.branch;
      final int j = n - (oldBranch.length << 5);
      if (j < 0) {
        final Object[] oldInfix = oldBranch.get(n >> 5);
        final Object[] newInfix = new Object[32];
        System.arraycopy(oldInfix, 0, newInfix, 0, 32);
        newInfix[n & 0x1F] = elem;
        final FingerTrieSeq newBranch = oldBranch.updated(n >> 5, newInfix);
        return new FingerTrieSeq(oldPrefix, newBranch, this.suffix, this.length);
      } else {
        final Object[] oldSuffix = this.suffix;
        final int b = oldSuffix.length;
        final Object[] newSuffix = new Object[b];
        System.arraycopy(oldSuffix, 0, newSuffix, 0, b);
        newSuffix[j] = elem;
        return new FingerTrieSeq(oldPrefix, oldBranch, newSuffix, this.length);
      }
    }
  }

  @SuppressWarnings("unchecked")
  public T head() {
    if (this.length == 0) {
      throw new NoSuchElementException();
    }
    return (T) this.prefix[0];
  }

  public FingerTrieSeq tail() {
    if (this.length == 0) {
      throw new UnsupportedOperationException();
    }
    return drop(1);
  }

  public FingerTrieSeq body() {
    if (this.length == 0) {
      throw new UnsupportedOperationException();
    }
    return take(this.length - 1);
  }

  @SuppressWarnings("unchecked")
  public T foot() {
    if (this.length == 0) {
      throw new NoSuchElementException();
    }
    if (this.length <= 32) {
      return (T) this.prefix[this.prefix.length - 1];
    } else {
      return (T) this.suffix[this.suffix.length - 1];
    }
  }

  @SuppressWarnings("unchecked")
  public FingerTrieSeq drop(int lower) {
    if (lower <= 0) {
      return this;
    } else if (lower >= this.length) {
      return (FingerTrieSeq) EMPTY;
    } else {
      final int n = lower - this.prefix.length;
      final int k = this.length - lower;
      final FingerTrieSeq oldBranch = this.branch;
      if (n == 0) {
        if (oldBranch.length > 0) {
          return new FingerTrieSeq(oldBranch.head(), oldBranch.tail(), this.suffix, k);
        } else {
          return new FingerTrieSeq(this.suffix, EMPTY_NODE, EMPTY_LEAF, k);
        }
      } else if (n < 0) {
        final Object[] newPrefix = new Object[-n];
        System.arraycopy(this.prefix, lower, newPrefix, 0, -n);
        return new FingerTrieSeq(newPrefix, oldBranch, this.suffix, k);
      } else {
        final int j = n - (oldBranch.length << 5);
        if (j < 0) {
          final FingerTrieSeq split = oldBranch.drop(n >> 5);
          final Object[] oldPrefix = split.head();
          final Object[] newPrefix = new Object[oldPrefix.length - (n & 0x1F)];
          System.arraycopy(oldPrefix, n & 0x1F, newPrefix, 0, newPrefix.length);
          return new FingerTrieSeq(newPrefix, split.tail(), this.suffix, k);
        } else {
          final Object[] newPrefix = new Object[k];
          System.arraycopy(this.suffix, j, newPrefix, 0, k);
          return new FingerTrieSeq(newPrefix, EMPTY_NODE, EMPTY_LEAF, k);
        }
      }
    }
  }

  @SuppressWarnings("unchecked")
  public FingerTrieSeq take(int upper) {
    if (upper <= 0) {
      return (FingerTrieSeq) EMPTY;
    } else if (upper >= this.length) {
      return this;
    } else {
      final int n = upper - this.prefix.length;
      if (n == 0) {
        return new FingerTrieSeq(this.prefix, EMPTY_NODE, EMPTY_LEAF, upper);
      } else if (n < 0) {
        final Object[] newPrefix = new Object[upper];
        System.arraycopy(this.prefix, 0, newPrefix, 0, upper);
        return new FingerTrieSeq(newPrefix, EMPTY_NODE, EMPTY_LEAF, upper);
      } else {
        final FingerTrieSeq oldBranch = this.branch;
        final int j = n - (oldBranch.length << 5);
        if (j == 0) {
          if (oldBranch.length > 0) {
            return new FingerTrieSeq(this.prefix, oldBranch.body(), oldBranch.foot(), upper);
          } else {
            return new FingerTrieSeq(this.suffix, EMPTY_NODE, EMPTY_LEAF, upper);
          }
        } else if (j < 0) {
          final FingerTrieSeq split = oldBranch.take(((n + 0x1F) & 0xFFFFFFE0) >> 5);
          final Object[] oldSuffix = split.foot();
          final Object[] newSuffix = new Object[((((n & 0x1F) ^ 0x1F) + 1) & 0x20) | (n & 0x1F)];
          System.arraycopy(oldSuffix, 0, newSuffix, 0, newSuffix.length);
          return new FingerTrieSeq(this.prefix, split.body(), newSuffix, upper);
        } else {
          final Object[] newSuffix = new Object[j];
          System.arraycopy(this.suffix, 0, newSuffix, 0, j);
          return new FingerTrieSeq(this.prefix, oldBranch, newSuffix, upper);
        }
      }
    }
  }

  @SuppressWarnings("unchecked")
  public FingerTrieSeq slice(int lower, int upper) {
    if (lower >= upper) {
      return (FingerTrieSeq) EMPTY;
    } else {
      return drop(lower).take(upper - Math.max(0, lower));
    }
  }

  public FingerTrieSeq appended(T elem) {
    final int i = this.prefix.length;
    final int j = this.suffix.length;
    final int n = this.branch.length;
    if (n == 0 && j == 0 && i < 32) {
      final Object[] newPrefix = new Object[i + 1];
      System.arraycopy(this.prefix, 0, newPrefix, 0, i);
      newPrefix[i] = elem;
      return new FingerTrieSeq(newPrefix, EMPTY_NODE, EMPTY_LEAF, this.length + 1);
    } else if (n == 0 && i + j < 32) {
      final Object[] newPrefix = new Object[i + j + 1];
      System.arraycopy(this.prefix, 0, newPrefix, 0, i);
      System.arraycopy(this.suffix, 0, newPrefix, i, j);
      newPrefix[i + j] = elem;
      return new FingerTrieSeq(newPrefix, EMPTY_NODE, EMPTY_LEAF, this.length + 1);
    } else if (n == 0 && i + j < 64) {
      final Object[] newPrefix = new Object[32];
      System.arraycopy(this.prefix, 0, newPrefix, 0, i);
      System.arraycopy(this.suffix, 0, newPrefix, i, 32 - i);
      final Object[] newSuffix = new Object[i + j - 32 + 1];
      System.arraycopy(this.suffix, 32 - i, newSuffix, 0, i + j - 32);
      newSuffix[i + j - 32] = elem;
      return new FingerTrieSeq(newPrefix, EMPTY_NODE, newSuffix, this.length + 1);
    } else if (j < 32) {
      final Object[] newSuffix = new Object[j + 1];
      System.arraycopy(this.suffix, 0, newSuffix, 0, j);
      newSuffix[j] = elem;
      return new FingerTrieSeq(this.prefix, this.branch, newSuffix, this.length + 1);
    } else {
      final Object[] newSuffix = new Object[1];
      newSuffix[0] = elem;
      final FingerTrieSeq newBranch = this.branch.appended(this.suffix);
      return new FingerTrieSeq(this.prefix, newBranch, newSuffix, this.length + 1);
    }
  }

  public FingerTrieSeq appended(Collection elems) {
    final FingerTrieSeqBuilder builder = new FingerTrieSeqBuilder(this);
    builder.addAll(elems);
    return builder.bind();
  }

  public FingerTrieSeq prepended(T elem) {
    final int i = this.prefix.length;
    final int j = this.suffix.length;
    final int n = this.branch.length;
    if (n == 0 && j == 0 && i < 32) {
      final Object[] newPrefix = new Object[1 + i];
      newPrefix[0] = elem;
      System.arraycopy(this.prefix, 0, newPrefix, 1, i);
      return new FingerTrieSeq(newPrefix, EMPTY_NODE, EMPTY_LEAF, 1 + this.length);
    } else if (n == 0 && i + j < 32) {
      final Object[] newPrefix = new Object[1 + i + j];
      newPrefix[0] = elem;
      System.arraycopy(this.prefix, 0, newPrefix, 1, i);
      System.arraycopy(this.suffix, 0, newPrefix, 1 + i, j);
      return new FingerTrieSeq(newPrefix, EMPTY_NODE, EMPTY_LEAF, 1 + this.length);
    } else if (n == 0 && i + j < 64) {
      final Object[] newPrefix = new Object[1 + i + j - 32];
      newPrefix[0] = elem;
      System.arraycopy(this.prefix, 0, newPrefix, 1, i + j - 32);
      final Object[] newSuffix = new Object[32];
      System.arraycopy(this.prefix, i + j - 32, newSuffix, 0, 32 - j);
      System.arraycopy(this.suffix, 0, newSuffix, 32 - j, j);
      return new FingerTrieSeq(newPrefix, EMPTY_NODE, newSuffix, 1 + this.length);
    } else if (i < 32) {
      final Object[] newPrefix = new Object[1 + i];
      newPrefix[0] = elem;
      System.arraycopy(this.prefix, 0, newPrefix, 1, i);
      return new FingerTrieSeq(newPrefix, this.branch, this.suffix, 1 + this.length);
    } else {
      final Object[] newPrefix = new Object[1];
      newPrefix[0] = elem;
      final FingerTrieSeq newBranch = this.branch.prepended(this.prefix);
      return new FingerTrieSeq(newPrefix, newBranch, this.suffix, 1 + this.length);
    }
  }

  public FingerTrieSeq prepended(Collection elems) {
    final FingerTrieSeqBuilder builder = new FingerTrieSeqBuilder();
    builder.addAll(elems);
    builder.addAll(this);
    return builder.bind();
  }

  public FingerTrieSeq removed(int index) {
    if (index < 0 || index >= length) {
      throw new IndexOutOfBoundsException(String.valueOf(index));
    }
    if (index == 0) {
      return drop(1);
    } else {
      final int newLength = length - 1;
      if (index == newLength) {
        return take(index);
      } else if (index > 0) {
        final FingerTrieSeqBuilder builder = new FingerTrieSeqBuilder(take(index));
        do {
          index += 1;
          builder.add(get(index));
        } while (index < newLength);
        return builder.bind();
      } else {
        return this;
      }
    }
  }

  public FingerTrieSeq removed(Object elem) {
    final int index = indexOf(elem);
    if (index >= 0) {
      return removed(index);
    } else {
      return this;
    }
  }

  @Override
  public FingerTrieSeq subList(int fromIndex, int toIndex) {
    if (fromIndex < 0 || toIndex > length || fromIndex > toIndex) {
      throw new IndexOutOfBoundsException(fromIndex + ", " + toIndex);
    }
    return drop(fromIndex).take(toIndex - fromIndex);
  }

  @Override
  public Object[] toArray() {
    final int n = length;
    final Object[] array = new Object[n];
    for (int i = 0; i < n; i += 1) {
      array[i] = get(i);
    }
    return array;
  }

  @SuppressWarnings("unchecked")
  @Override
  public  T[] toArray(T[] array) {
    final int n = length;
    if (array.length < n) {
      array = (T[]) Array.newInstance(array.getClass().getComponentType(), n);
    }
    for (int i = 0; i < n; i += 1) {
      array[i] = (T) get(i);
    }
    if (array.length > n) {
      array[n] = null;
    }
    return array;
  }

  @Override
  public Iterator iterator() {
    return new FingerTrieSeqIterator(this);
  }

  @Override
  public ListIterator listIterator() {
    return new FingerTrieSeqIterator(this);
  }

  @Override
  public ListIterator listIterator(int index) {
    return new FingerTrieSeqIterator(this, index);
  }

  @SuppressWarnings("unchecked")
  @Override
  public boolean equals(Object other) {
    if (this == other) {
      return true;
    } else if (other instanceof FingerTrieSeq) {
      final FingerTrieSeq that = (FingerTrieSeq) other;
      if (this.length == that.length) {
        final Iterator these = iterator();
        final Iterator those = that.iterator();
        while (these.hasNext() && those.hasNext()) {
          final T x = these.next();
          final T y = those.next();
          if (x == null ? y != null : !x.equals(y)) {
            return false;
          }
        }
        return true;
      }
    }
    return false;
  }

  @Override
  public int hashCode() {
    if (hashSeed == 0) {
      hashSeed = Murmur3.seed(FingerTrieSeq.class);
    }
    int h = hashSeed;
    final Iterator these = iterator();
    while (these.hasNext()) {
      h = Murmur3.mix(h, Murmur3.hash(these.next()));
    }
    return Murmur3.mash(h);
  }

  @Override
  public void debug(Output output) {
    output = output.write("FingerTrieSeq").write('.');
    final Iterator these = iterator();
    if (these.hasNext()) {
      output = output.write("of").write('(').debug(these.next());
      while (these.hasNext()) {
        output = output.write(", ").debug(these.next());
      }
    } else {
      output = output.write("empty").write('(');
    }
    output = output.write(')');
  }

  @Override
  public String toString() {
    return Format.debug(this);
  }

  private static int hashSeed;

  static final Object[] EMPTY_LEAF = new Object[0];

  static final FingerTrieSeq EMPTY = new FingerTrieSeq