All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.shapesecurity.functional.data.HashTable Maven / Gradle / Ivy

    /*
 * Copyright 2014 Shape Security, 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 com.shapesecurity.functional.data;

import com.shapesecurity.functional.Effect;
import com.shapesecurity.functional.F;
import com.shapesecurity.functional.F2;
import com.shapesecurity.functional.Pair;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

/**
 * An immutable hash trie tree implementation.
 *
 * @param  Key type
 * @param  Value type
 */
public abstract class HashTable {
    private final static Hasher EQUALITY_HASHER = new Hasher() {
        @Override
        public int hash(@NotNull Object data) {
            return data.hashCode();
        }

        @Override
        public boolean eq(@NotNull Object o, @NotNull Object b) {
            return o.equals(b);
        }
    };

    public final static Hasher IDENTITY_HASHER = new Hasher() {
        @Override
        public int hash(@NotNull Object data) {
            return System.identityHashCode(data);
        }

        @Override
        public boolean eq(@NotNull Object o, @NotNull Object b) {
            return o == b;
        }
    };

    @NotNull
    public final Hasher hasher;
    public final int length;

    protected HashTable(@NotNull Hasher hasher, int length) {
        super();
        this.hasher = hasher;
        this.length = length;
    }

    @SuppressWarnings("unchecked")
    @NotNull
    public static  Hasher equalityHasher() {
        return (Hasher) EQUALITY_HASHER;
    }

    @SuppressWarnings("unchecked")
    @NotNull
    public static  Hasher identityHasher() {
        return (Hasher) IDENTITY_HASHER;
    }

    @NotNull
    public static  HashTable empty(@NotNull Hasher hasher) {
        return new Empty<>(hasher);
    }

    @NotNull
    public static  HashTable emptyUsingEquality() {
        return empty(HashTable.equalityHasher());
    }

    @NotNull
    public static  HashTable emptyUsingIdentity() {
        return empty(HashTable.identityHasher());
    }

    @NotNull
    public final HashTable put(@NotNull K key, @NotNull V value) {
        return this.put(key, value, this.hasher.hash(key));
    }

    @NotNull
    public final HashTable remove(@NotNull K key) {
        return this.remove(key, this.hasher.hash(key)).orJust(this);
    }

    @NotNull
    protected abstract HashTable put(@NotNull K key, @NotNull V value, int hash);

    @NotNull
    protected abstract Maybe> remove(@NotNull K key, int hash);

    @NotNull
    public final Maybe get(@NotNull K key) {
        return this.get(key, this.hasher.hash(key));
    }

    @NotNull
    protected abstract Maybe get(@NotNull K key, int hash);

    @SuppressWarnings("unchecked")
    @NotNull
    public final HashTable merge(@NotNull HashTable tree) {
        return this.merge(tree, (a, b) -> b);
    }

    @NotNull
    public abstract HashTable merge(@NotNull HashTable tree, @NotNull F2 merger);

    @NotNull
    public abstract  A foldLeft(@NotNull F2, A> f, @NotNull A init);

    @NotNull
    public abstract  A foldRight(@NotNull F2, A, A> f, @NotNull A init);

    @NotNull
    public ImmutableList> entries() {
        return this.foldRight((kvPair, pairs) -> pairs.cons(kvPair), ImmutableList.empty());
    }

    public abstract void foreach(@NotNull Effect> e);

    @NotNull
    public abstract Maybe> find(@NotNull F, Boolean> f);

    @NotNull
    public abstract  Maybe findMap(@NotNull F, Maybe> f);

    public abstract  HashTable map(@NotNull F f);

    public boolean containsKey(@NotNull K key) {
        return this.containsKey(key, this.hasher.hash(key));
    }

    public abstract boolean containsKey(@NotNull K key, int hash);

    public boolean containsValue(@NotNull V value) {
        return this.find(p -> p.right == value).isJust();
    }

    /**
     * An empty hash table.
     *
     * @param  Key type
     * @param  Value type
     */
    private final static class Empty extends HashTable {
        protected Empty(@NotNull Hasher hasher) {
            super(hasher, 0);
        }

        @NotNull
        @Override
        protected HashTable put(@NotNull K key, @NotNull V value, int hash) {
            return new Leaf<>(this.hasher, ImmutableList.of(new Pair<>(key, value)), hash, 1);
        }

        @NotNull
        @Override
        protected Maybe> remove(@NotNull K key, int hash) {
            return Maybe.empty();
        }

        @NotNull
        @Override
        protected Maybe get(@NotNull K key, int hash) {
            return Maybe.empty();
        }

        @NotNull
        @Override
        public HashTable merge(@NotNull HashTable tree, @NotNull F2 merger) {
            return tree;
        }

        @NotNull
        @Override
        public  A foldLeft(@NotNull F2, A> f, @NotNull A init) {
            return init;
        }

        @NotNull
        @Override
        public  A foldRight(@NotNull F2, A, A> f, @NotNull A init) {
            return init;
        }

        @Override
        public void foreach(@NotNull Effect> e) {

        }

        @NotNull
        @Override
        public Maybe> find(@NotNull F, Boolean> f) {
            return Maybe.empty();
        }

        @NotNull
        @Override
        public  Maybe findMap(@NotNull F, Maybe> f) {
            return Maybe.empty();
        }

        @Override
        public  HashTable map(@NotNull F f) {
            return emptyUsingEquality();
        }

        @Override
        public boolean containsKey(@NotNull K key, int hash) {
            return false;
        }
    }

    /**
     * A leaf node that contains a list of pairs where all the keys have exactly the same hash
     * code.
     *
     * @param  Key type
     * @param  Value type
     */
    private final static class Leaf extends HashTable {
        @NotNull
        private final ImmutableList> dataList;
        public int baseHash;

        protected Leaf(@NotNull Hasher hasher, @NotNull ImmutableList> dataList, int baseHash, int length) {
            super(hasher, length);
            this.dataList = dataList;
            this.baseHash = baseHash;
        }

        @NotNull
        @Override
        protected HashTable put(@NotNull final K key, @NotNull final V value, final int hash) {
            if (hash == this.baseHash) {
                Pair>> result = this.dataList.mapAccumL((found, kvPair) -> {
                    if (found) {
                        return new Pair<>(true, kvPair);
                    }
                    if (Leaf.this.hasher.eq(kvPair.left, key)) {
                        return new Pair<>(true, new Pair<>(key, value));
                    }
                    return new Pair<>(false, kvPair);
                }, false);
                if (result.left) {
                    return new Leaf<>(this.hasher, result.right, hash, this.length);
                }
                return new Leaf<>(this.hasher, this.dataList.cons(new Pair<>(key, value)), hash, this.length + 1);
            }
            return toFork().put(key, value, hash);
        }

        @NotNull
        @Override
        protected Maybe> remove(@NotNull final K key, int hash) {
            if (this.baseHash != hash) {
                return Maybe.empty();
            }
            Pair>> result = this.dataList.foldRight((i, p) -> {
                if (p.left) {
                    return new Pair<>(true, p.right.cons(i));
                }
                if (Leaf.this.hasher.eq(i.left, key)) {
                    return new Pair<>(true, p.right);
                }
                return new Pair<>(false, p.right.cons(i));
            }, new Pair<>(false, ImmutableList.empty()));
            if (result.left) {
                if (this.length == 1) {
                    return Maybe.of(HashTable.emptyUsingEquality());
                }
                return Maybe.of(new Leaf<>(this.hasher, result.right, this.baseHash, this.length - 1));
            }
            return Maybe.empty();
        }

        @SuppressWarnings("unchecked")
        private Fork toFork() {
            int subHash = this.baseHash & 31;
            HashTable[] children = new HashTable[32];
            children[subHash] = new Leaf<>(this.hasher, this.dataList, this.baseHash >>> 5, this.length);
            return new Fork<>(this.hasher, children, this.length);
        }

        @NotNull
        @Override
        protected Maybe get(@NotNull final K key, final int hash) {
            if (this.baseHash != hash) {
                return Maybe.empty();
            }
            Maybe> pairMaybe = this.dataList.find(kvPair -> Leaf.this.hasher.eq(kvPair.left, key));
            return pairMaybe.map(p -> p.right);
        }

        @SuppressWarnings("unchecked")
        @NotNull
        @Override
        public HashTable merge(@NotNull HashTable tree, @NotNull final F2 merger) {
            if (tree instanceof Empty) {
                return this;
            } else if (tree instanceof Leaf) {
                final Leaf leaf = (Leaf) tree;
                if (leaf.baseHash == this.baseHash) {
                    final Pair[] pairs = this.dataList.toArray(new Pair[this.dataList.length]);
                    ImmutableList> right = leaf.dataList.foldLeft(
                            (@NotNull ImmutableList> result, @NotNull Pair kvPair) -> {
                                for (int i = 0; i < pairs.length; i++) {
                                    if (Leaf.this.hasher.eq(pairs[i].left, kvPair.left)) {
                                        pairs[i] = new Pair<>(pairs[i].left, merger.apply(pairs[i].right, kvPair.right));
                                        return result;
                                    }
                                }
                                return result.cons(kvPair);
                            }, ImmutableList.empty());
                    ImmutableList> newList = ImmutableList.from(pairs).append(right);
                    return new Leaf<>(this.hasher, newList, this.baseHash, newList.length);
                }
            }
            return toFork().merge(tree, merger);
        }

        @NotNull
        public  A foldLeft(@NotNull F2, A> f, @NotNull A init) {
            return this.dataList.foldLeft(f, init);
        }

        @NotNull
        @Override
        public  A foldRight(@NotNull F2, A, A> f, @NotNull A init) {
            return this.dataList.foldRight(f, init);
        }

        @Override
        public void foreach(@NotNull Effect> e) {
            this.dataList.foreach(e);
        }

        @NotNull
        @Override
        public Maybe> find(@NotNull F, Boolean> f) {
            return this.dataList.find(f);
        }

        @NotNull
        @Override
        public  Maybe findMap(@NotNull F, Maybe> f) {
            return this.dataList.findMap(f);
        }

        @Override
        public  Leaf map(@NotNull F f) {
            return new Leaf<>(this.hasher, this.dataList.map(pair -> pair.mapRight(f)), baseHash, length);
        }

        @Override
        public boolean containsKey(@NotNull K key, int hash) {
            return hash == this.baseHash
                    && this.dataList.exists(kvPair -> Leaf.this.hasher.eq(kvPair.left, key));
        }
    }

    private final static class Fork extends HashTable {
        @NotNull
        private final HashTable[] children;

        private Fork(@NotNull Hasher hasher, @NotNull HashTable[] children, int length) {
            super(hasher, length);
            this.children = children;
        }

        @NotNull
        @Override
        protected HashTable put(@NotNull K key, @NotNull V value, int hash) {
            int subHash = hash & 31;
            HashTable[] cloned = Fork.this.children.clone();
            if (cloned[subHash] == null) {
                cloned[subHash] = new Leaf<>(Fork.this.hasher, ImmutableList.empty(), hash >>> 5, 0);
            }
            int length1 = cloned[subHash].length;
            cloned[subHash] = cloned[subHash].put(key, value, hash >>> 5);
            return new Fork<>(this.hasher, cloned, this.length - length1 + cloned[subHash].length);
        }

        @NotNull
        @Override
        protected Maybe> remove(@NotNull K key, int hash) {
            final int subHash = hash & 31;
            if (this.children[subHash] == null) {
                return Maybe.empty();
            }
            Maybe> removed = this.children[subHash].remove(key, hash >>> 5);
            return removed.map(newChild -> {
                HashTable[] cloned = Fork.this.children.clone();
                cloned[subHash] = newChild;
                return new Fork<>(Fork.this.hasher, cloned, Fork.this.length - 1);
            });
        }

        @NotNull
        @Override
        protected Maybe get(@NotNull K key, int hash) {
            int subHash = hash & 31;
            if (this.children[subHash] == null) {
                return Maybe.empty();
            }
            return this.children[subHash].get(key, hash >>> 5);
        }

        @NotNull
        @Override
        public Fork merge(@NotNull HashTable tree, @NotNull F2 merger) {
            if (tree instanceof Empty) {
                return this;
            } else if (tree instanceof Leaf) {
                Leaf leaf = (Leaf) tree;
                return this.mergeFork(leaf.toFork(), merger);
            }
            return this.mergeFork(((Fork) tree), merger);
        }

        @NotNull
        private Fork mergeFork(@NotNull Fork tree, @NotNull F2 merger) {
            // Mutable array.
            HashTable[] cloned = Fork.this.children.clone();
            int count = 0;
            for (int i = 0; i < cloned.length; i++) {
                if (cloned[i] == null) {
                    cloned[i] = tree.children[i];
                } else if (tree.children[i] != null) {
                    cloned[i] = cloned[i].merge(tree.children[i], merger);
                }
                if (cloned[i] != null) {
                    count += cloned[i].length;
                }
            }
            return new Fork<>(this.hasher, cloned, count);
        }

        @NotNull
        @Override
        public  A foldLeft(@NotNull F2, A> f, @NotNull A init) {
            for (@Nullable HashTable child : this.children) {
                if (child != null) {
                    init = child.foldLeft(f, init);
                }
            }
            return init;
        }

        @NotNull
        @Override
        public  A foldRight(@NotNull F2, A, A> f, @NotNull A init) {
            for (int i = this.children.length - 1; i >= 0; i--) {
                if (this.children[i] == null) {
                    continue;
                }
                init = this.children[i].foldRight(f, init);
            }
            return init;
        }

        @Override
        public void foreach(@NotNull Effect> e) {
            for (@Nullable HashTable child : this.children) {
                if (child != null) {
                    child.foreach(e);
                }
            }
        }

        @NotNull
        @Override
        public Maybe> find(@NotNull F, Boolean> f) {
            HashTable[] children = this.children;
            for (int i = 0, ln = children.length; i < ln; i++) {
                HashTable child = children[i];
                if (child != null) {
                    Maybe> p = child.find(f);
                    if (p.isJust()) {
                        return p;
                    }
                }
            }
            return Maybe.empty();
        }

        @NotNull
        @Override
        public  Maybe findMap(@NotNull F, Maybe> f) {
            HashTable[] children = this.children;
            for (int i = 0, ln = children.length; i < ln; i++) {
                HashTable child = children[i];
                if (child != null) {
                    Maybe p = child.findMap(f);
                    if (p.isJust()) {
                        return p;
                    }
                }
            }
            return Maybe.empty();
        }

        @SuppressWarnings("unchecked")
        @Override
        public  Fork map(@NotNull F f) {
            HashTable[] clone = new HashTable[this.children.length];
            for (int i = 0; i < clone.length; i++) {
                if (this.children[i] != null) {
                    clone[i] = this.children[i].map(f);
                }
            }
            return new Fork<>(hasher, clone, length);
        }

        @Override
        public boolean containsKey(@NotNull K key, int hash) {
            int subHash = hash & 31;
            if (this.children[subHash] == null) {
                return false;
            }
            return this.children[subHash].containsKey(key, hash >>> 5);
        }
    }
}
    
    
    
    

    




    
        






    




    © 2015 - 2025 Weber Informatics LLC | Privacy Policy