org.javimmutable.collections.array.JImmutableTrieArray Maven / Gradle / Ivy
///###////////////////////////////////////////////////////////////////////////
//
// Burton Computer Corporation
// http://www.burton-computer.com
//
// Copyright (c) 2018, Burton Computer Corporation
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materials provided with the
// distribution.
//
// Neither the name of the Burton Computer Corporation nor the names
// of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package org.javimmutable.collections.array;
import org.javimmutable.collections.Cursor;
import org.javimmutable.collections.Holder;
import org.javimmutable.collections.Holders;
import org.javimmutable.collections.Indexed;
import org.javimmutable.collections.JImmutableArray;
import org.javimmutable.collections.JImmutableMap;
import org.javimmutable.collections.MutableBuilder;
import org.javimmutable.collections.SplitableIterator;
import org.javimmutable.collections.common.AbstractJImmutableArray;
import org.javimmutable.collections.common.MutableDelta;
import org.javimmutable.collections.cursors.Cursors;
import org.javimmutable.collections.serialization.JImmutableArrayProxy;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
@Immutable
public class JImmutableTrieArray
extends AbstractJImmutableArray
implements Serializable
{
@SuppressWarnings("unchecked")
private static final JImmutableTrieArray EMPTY = new JImmutableTrieArray(TrieNode.of(), 0);
private static final long serialVersionUID = -121805;
private final TrieNode root;
private final int size;
private JImmutableTrieArray(TrieNode root,
int size)
{
this.root = root;
this.size = size;
}
public static Builder builder()
{
return new Builder<>();
}
@SuppressWarnings("unchecked")
public static JImmutableTrieArray of()
{
return EMPTY;
}
/**
* Efficiently constructs a TrieArray containing the objects from source (in the specified range).
* In the constructed TrieArray objects will have array indexes starting at 0 (i.e. indexes
* from the source are not carried over) so if offset is 10 then source.get(10) will map to
* array.get(0).
*
* @deprecated use builder() instead
*/
@Deprecated
public static JImmutableArray of(Indexed source,
int offset,
int limit)
{
return JImmutableTrieArray.builder().add(source, offset, limit).build();
}
// made obsolete by Builder but retained for use in unit test
@SuppressWarnings("SameParameterValue")
static JImmutableArray oldof(Indexed source,
int offset,
int limit)
{
final int size = limit - offset;
if (size == 0) {
return of();
}
// small lists can be directly constructed from a single leaf array
if (size <= 32) {
return new JImmutableTrieArray<>(TrieNode.fromSource(0, source, offset, limit), size);
}
// first construct an array containing a single level of arrays of leaves
final int numBranches = Math.min(32, ((limit - offset) + 31) / 32);
@SuppressWarnings("unchecked") final TrieNode[] branchArray = (TrieNode[])new TrieNode[numBranches];
int index = 0;
for (int b = 0; b < numBranches; ++b) {
int branchSize = Math.min(32, limit - offset);
branchArray[b] = TrieNode.fromSource(index, source, offset, limit);
offset += branchSize;
index += branchSize;
}
// then add any extras left over above that size
JImmutableArray array = new JImmutableTrieArray<>(MultiBranchTrieNode.forEntries(5, branchArray), index);
while (offset < limit) {
array = array.assign(index++, source.get(offset++));
}
return array;
}
@Override
@Nullable
public T getValueOr(int index,
@Nullable T defaultValue)
{
if (root.getShift() < TrieNode.shiftForIndex(index)) {
return defaultValue;
} else {
return root.getValueOr(root.getShift(), index, defaultValue);
}
}
@Nonnull
@Override
public Holder find(int index)
{
if (root.getShift() < TrieNode.shiftForIndex(index)) {
return Holders.of();
} else {
return root.find(root.getShift(), index);
}
}
@Nonnull
@Override
public JImmutableTrieArray assign(int index,
@Nullable T value)
{
MutableDelta sizeDelta = new MutableDelta();
TrieNode newRoot = root.paddedToMinimumDepthForShift(TrieNode.shiftForIndex(index));
newRoot = newRoot.assign(newRoot.getShift(), index, value, sizeDelta);
return (newRoot == root) ? this : new JImmutableTrieArray<>(newRoot, size + sizeDelta.getValue());
}
@Nonnull
@Override
public JImmutableTrieArray delete(int index)
{
if (root.getShift() < TrieNode.shiftForIndex(index)) {
return this;
} else {
MutableDelta sizeDelta = new MutableDelta();
final TrieNode newRoot = root.delete(root.getShift(), index, sizeDelta).trimmedToMinimumDepth();
return (newRoot == root) ? this : new JImmutableTrieArray<>(newRoot, size + sizeDelta.getValue());
}
}
@Override
public int size()
{
return size;
}
@Nonnull
@Override
public JImmutableTrieArray deleteAll()
{
return of();
}
@Override
@Nonnull
public Cursor> cursor()
{
return root.cursor();
}
@Nonnull
@Override
public SplitableIterator> iterator()
{
return root.iterator();
}
@Override
public void checkInvariants()
{
root.checkInvariants();
}
@Override
public boolean equals(Object o)
{
return (o == this) || ((o instanceof JImmutableArray) && Cursors.areEqual(cursor(), ((JImmutableArray)o).cursor()));
}
@Override
public int hashCode()
{
return Cursors.computeHashCode(cursor());
}
@Override
public String toString()
{
return Cursors.makeString(cursor());
}
private Object writeReplace()
{
return new JImmutableArrayProxy(this);
}
public static class Builder
implements MutableBuilder>
{
private final List> leaves = new ArrayList<>();
@Nonnull
@Override
public Builder add(T value)
{
final TrieNode leaf = LeafTrieNode.of(leaves.size(), value);
leaves.add(leaf);
return this;
}
@Nonnull
@Override
public JImmutableTrieArray build()
{
int nodeCount = leaves.size();
if (nodeCount == 0) {
return of();
}
if (nodeCount == 1) {
return new JImmutableTrieArray<>(leaves.get(0), 1);
}
List> dst = new ArrayList<>(1 + (leaves.size() / 32));
List> src = leaves;
int shift = 0;
while (nodeCount > 1) {
int dstOffset = 0;
int srcOffset = 0;
while (srcOffset < nodeCount) {
final int count = Math.min(32, nodeCount - srcOffset);
final TrieNode[] nodes = allocate(count);
for (int i = 0; i < count; ++i) {
nodes[i] = src.get(srcOffset++);
}
TrieNode branch;
switch (count) {
case 1:
branch = SingleBranchTrieNode.forBranchIndex(shift, 0, nodes[0]);
break;
case 32:
branch = new FullBranchTrieNode<>(shift, nodes);
break;
default:
branch = MultiBranchTrieNode.forEntries(shift, nodes);
break;
}
set(dst, dstOffset++, branch);
}
shift += 5;
src = dst;
nodeCount = dstOffset;
}
assert nodeCount == 1;
return new JImmutableTrieArray<>(dst.get(0), leaves.size());
}
@Nonnull
@Override
public Builder add(Cursor source)
{
for (Cursor cursor = source.start(); cursor.hasValue(); cursor = cursor.next()) {
add(cursor.getValue());
}
return this;
}
@Nonnull
@Override
public Builder add(Iterator source)
{
while (source.hasNext()) {
add(source.next());
}
return this;
}
@Nonnull
@Override
public Builder add(Iterable source)
{
add(source.iterator());
return this;
}
@SafeVarargs
@Nonnull
@Override
public final Builder add(K... source)
{
for (T value : source) {
add(value);
}
return this;
}
@Nonnull
@Override
public Builder add(Indexed source)
{
return add(source, 0, source.size());
}
@Nonnull
@Override
public Builder add(Indexed source,
int offset,
int limit)
{
for (int i = offset; i < limit; ++i) {
add(source.get(i));
}
return this;
}
private void set(List> dst,
int index,
TrieNode node)
{
if (index < dst.size()) {
dst.set(index, node);
} else {
assert index == dst.size();
dst.add(node);
}
}
@SuppressWarnings("unchecked")
private TrieNode[] allocate(int size)
{
return new TrieNode[size];
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy