/*

 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.lang;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.WeakReference;

import java.util.Collection;

import java.util.Objects;

import java.util.concurrent.ConcurrentHashMap;

import java.util.function.BiFunction;

/**

 * A WeakHashMap-like data structure that uses a pair of weakly-referenced keys

 * with identity equality semantics to associate a strongly-referenced value.

 * Unlike WeakHashMap, this data structure is thread-safe.

 *

 * @param <K1> the type of 1st key in key pair

 * @param <K2> the type of 2nd key in key pair

 * @param <V>  the type of value

 * @author Peter Levart

 */

final class WeakPairMap<K1, K2, V> {

    private final ConcurrentHashMap<Pair<K1, K2>, V> map = new ConcurrentHashMap<>();

    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();

    /**

     * Tests if the specified pair of keys are associated with a value

     * in the WeakPairMap.

     *

     * @param k1 the 1st of the pair of keys

     * @param k2 the 2nd of the pair of keys

     * @return true if and only if the specified key pair is in this WeakPairMap,

     * as determined by the identity comparison; false otherwise

     * @throws NullPointerException if any of the specified keys is null

     */

    public boolean containsKeyPair(K1 k1, K2 k2) {

        expungeStaleAssociations();

        return map.containsKey(Pair.lookup(k1, k2));

    }

    /**

     * Returns the value to which the specified pair of keys is mapped, or null

     * if this WeakPairMap contains no mapping for the key pair.

     * <p>More formally, if this WeakPairMap contains a mapping from a key pair

     * {@code (_k1, _k2)} to a value {@code v} such that

     * {@code k1 == _k1 && k2 == _k2}, then this method returns {@code v};

     * otherwise it returns {@code null}.

     * (There can be at most one such mapping.)

     *

     * @param k1 the 1st of the pair of keys for which the mapped value is to

     *           be returned

     * @param k2 the 2nd of the pair of keys for which the mapped value is to

     *           be returned

     * @return the value to which the specified key pair is mapped, or null if

     * this map contains no mapping for the key pair

     * @throws NullPointerException if any of the specified keys is null

     */

    public V get(K1 k1, K2 k2) {

        expungeStaleAssociations();

        return map.get(Pair.lookup(k1, k2));

    }

    /**

     * Maps the specified key pair to the specified value in this WeakPairMap.

     * Neither the keys nor the value can be null.

     * <p>The value can be retrieved by calling the {@link #get} method

     * with the same keys (compared by identity).

     *

     * @param k1 the 1st of the pair of keys with which the specified value is to

     *           be associated

     * @param k2 the 2nd of the pair of keys with which the specified value is to

     *           be associated

     * @param v  value to be associated with the specified key pair

     * @return the previous value associated with key pair, or {@code null} if

     * there was no mapping for key pair

     * @throws NullPointerException if any of the specified keys or value is null

     */

    public V put(K1 k1, K2 k2, V v) {

        expungeStaleAssociations();

        return map.put(Pair.weak(k1, k2, queue), v);

    }

    /**

     * If the specified key pair is not already associated with a value,

     * associates it with the given value and returns {@code null}, else does

     * nothing and returns the currently associated value.

     *

     * @param k1 the 1st of the pair of keys with which the specified value is to

     *           be associated

     * @param k2 the 2nd of the pair of keys with which the specified value is to

     *           be associated

     * @param v  value to be associated with the specified key pair

     * @return the previous value associated with key pair, or {@code null} if

     * there was no mapping for key pair

     * @throws NullPointerException if any of the specified keys or value is null

     */

    public V putIfAbsent(K1 k1, K2 k2, V v) {

        expungeStaleAssociations();

        return map.putIfAbsent(Pair.weak(k1, k2, queue), v);

    }

    /**

     * If the specified key pair is not already associated with a value,

     * attempts to compute its value using the given mapping function

     * and enters it into this WeakPairMap unless {@code null}. The entire

     * method invocation is performed atomically, so the function is

     * applied at most once per key pair. Some attempted update operations

     * on this WeakPairMap by other threads may be blocked while computation

     * is in progress, so the computation should be short and simple,

     * and must not attempt to update any other mappings of this WeakPairMap.

     *

     * @param k1              the 1st of the pair of keys with which the

     *                        computed value is to be associated

     * @param k2              the 2nd of the pair of keys with which the

     *                        computed value is to be associated

     * @param mappingFunction the function to compute a value

     * @return the current (existing or computed) value associated with

     * the specified key pair, or null if the computed value is null

     * @throws NullPointerException  if any of the specified keys or

     *                               mappingFunction is null

     * @throws IllegalStateException if the computation detectably

     *                               attempts a recursive update to this map

     *                               that would otherwise never complete

     * @throws RuntimeException      or Error if the mappingFunction does so, in

     *                               which case the mapping is left unestablished

     */

    public V computeIfAbsent(K1 k1, K2 k2,

                             BiFunction<? super K1, ? super K2, ? extends V>

                                 mappingFunction) {

        expungeStaleAssociations();

        try {

            return map.computeIfAbsent(

                Pair.weak(k1, k2, queue),

                pair -> mappingFunction.apply(pair.first(), pair.second()));

        } finally {

            Reference.reachabilityFence(k1);

            Reference.reachabilityFence(k2);

        }

    }

    /**

     * Returns a {@link Collection} view of the values contained in this

     * WeakPairMap. The collection is backed by the WeakPairMap, so changes to

     * the map are reflected in the collection, and vice-versa.  The collection

     * supports element removal, which removes the corresponding

     * mapping from this map, via the {@code Iterator.remove},

     * {@code Collection.remove}, {@code removeAll},

     * {@code retainAll}, and {@code clear} operations.  It does not

     * support the {@code add} or {@code addAll} operations.

     *

     * @return the collection view

     */

    public Collection<V> values() {

        expungeStaleAssociations();

        return map.values();

    }

    /**

     * Removes associations from this WeakPairMap for which at least one of the

     * keys in key pair has been found weakly-reachable and corresponding

     * WeakRefPeer(s) enqueued. Called as part of each public operation.

     */

    private void expungeStaleAssociations() {

        WeakRefPeer<?> peer;

        while ((peer = (WeakRefPeer<?>) queue.poll()) != null) {

            map.remove(peer.weakPair());

        }

    }

    /**

     * Common interface of both {@link Weak} and {@link Lookup} key pairs.

     */

    private interface Pair<K1, K2> {

        static <K1, K2> Pair<K1, K2> weak(K1 k1, K2 k2,

                                          ReferenceQueue<Object> queue) {

            return new Weak<>(k1, k2, queue);

        }

        static <K1, K2> Pair<K1, K2> lookup(K1 k1, K2 k2) {

            return new Lookup<>(k1, k2);

        }

        /**

         * @return The 1st of the pair of keys (may be null for {@link Weak}

         * when it gets cleared)

         */

        K1 first();

        /**

         * @return The 2nd of the pair of keys (may be null for {@link Weak}

         * when it gets cleared)

         */

        K2 second();

        static int hashCode(Object first, Object second) {

            // assert first != null && second != null;

            return System.identityHashCode(first) ^

                   System.identityHashCode(second);

        }

        static boolean equals(Object first, Object second, Pair<?, ?> p) {

            return first != null && second != null &&

                   first == p.first() && second == p.second();

        }

        /**

         * A Pair where both keys are weakly-referenced.

         * It is composed of two instances of {@link WeakRefPeer}s:

         * <pre>{@code

         *

         *     +-referent-> [K1]                +-referent-> [K2]

         *     |                                |

         *   +----------------+               +----------------+

         *   | Pair.Weak <:   |-----peer----->| (anonymous) <: |

         *   | WeakRefPeer,   |               | WeakRefPeer    |

         *   | Pair           |<--weakPair()--|                |

         *   +----------------+               +----------------+

         *     |            ^

         *     |            |

         *     +-weakPair()-+

         *

         * }</pre>

         * <p>

         * Pair.Weak is used for CHM keys. Both peers are associated with the

         * same {@link ReferenceQueue} so when either of their referents

         * becomes weakly-reachable, the corresponding entries can be

         * {@link #expungeStaleAssociations() expunged} from the map.

         */

        final class Weak<K1, K2> extends WeakRefPeer<K1> implements Pair<K1, K2> {

            // saved hash so it can be retrieved after the reference is cleared

            private final int hash;

            // link to <K2> peer

            private final WeakRefPeer<K2> peer;

            Weak(K1 k1, K2 k2, ReferenceQueue<Object> queue) {

                super(k1, queue);

                hash = Pair.hashCode(k1, k2);

                peer = new WeakRefPeer<>(k2, queue) {

                    // link back to <K1> peer

                    @Override

                    Weak<?, ?> weakPair() { return Weak.this; }

                };

            }

            @Override

            Weak<?, ?> weakPair() {

                return this;

            }

            @Override

            public K1 first() {

                return get();

            }

            @Override

            public K2 second() {

                return peer.get();

            }

            @Override

            public int hashCode() {

                return hash;

            }

            @Override

            public boolean equals(Object obj) {

                return this == obj ||

                       (obj instanceof Pair &&

                        Pair.equals(first(), second(), (Pair<?, ?>) obj));

            }

        }

        /**

         * Optimized lookup Pair, used as lookup key in methods like

         * {@link java.util.Map#get(Object)} or

         * {@link java.util.Map#containsKey(Object)}) where

         * there is a great chance its allocation is eliminated

         * by escape analysis when such lookups are inlined by JIT.

         * All its methods are purposely designed so that 'this' is never

         * passed to any other method or used as identity.

         */

        final class Lookup<K1, K2> implements Pair<K1, K2> {

            private final K1 k1;

            private final K2 k2;

            Lookup(K1 k1, K2 k2) {

                this.k1 = Objects.requireNonNull(k1);

                this.k2 = Objects.requireNonNull(k2);

            }

            @Override

            public K1 first() {

                return k1;

            }

            @Override

            public K2 second() {

                return k2;

            }

            @Override

            public int hashCode() {

                return Pair.hashCode(k1, k2);

            }

            @Override

            public boolean equals(Object obj) {

                return obj instanceof Pair &&

                       Pair.equals(k1, k2, (Pair<?, ?>) obj);

            }

        }

    }

    /**

     * Common abstract supertype of a pair of WeakReference peers.

     */

    private static abstract class WeakRefPeer<K> extends WeakReference<K> {

        WeakRefPeer(K k, ReferenceQueue<Object> queue) {

            super(Objects.requireNonNull(k), queue);

        }

        /**

         * @return the {@link Pair.Weak} side of the pair of peers.

         */

        abstract Pair.Weak<?, ?> weakPair();

    }

}