/*

 * Copyright (c) 2010, 2013, 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.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file, and Oracle licenses the original version of this file under the BSD

 * license:

 */

/*

   Copyright 2009-2013 Attila Szegedi

*/

package jdk.dynalink;

import java.lang.ref.Reference;

import java.lang.ref.SoftReference;

import java.security.AccessControlContext;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.Map;

import java.util.WeakHashMap;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

import jdk.dynalink.internal.AccessControlContextFactory;

import jdk.dynalink.internal.InternalTypeUtilities;

/**

 * A dual map that can either strongly or weakly reference a given class depending on whether the class is visible from

 * a class loader or not.

 *

 * @param <T> the type of the values in the map

 */

abstract class ClassMap<T> {

    private static final AccessControlContext GET_CLASS_LOADER_CONTEXT =

            AccessControlContextFactory.createAccessControlContext("getClassLoader");

    private final ConcurrentMap<Class<?>, T> map = new ConcurrentHashMap<>();

    private final Map<Class<?>, Reference<T>> weakMap = new WeakHashMap<>();

    private final ClassLoader classLoader;

    /**

     * Creates a new class map. It will use strong references for all keys and values where the key is a class visible

     * from the class loader, and will use weak keys and soft values for all other classes.

     *

     * @param classLoader the classloader that determines strong referenceability.

     */

    ClassMap(final ClassLoader classLoader) {

        this.classLoader = classLoader;

    }

    /**

     * Compute the value associated with the given class. It is possible that the method will be invoked several times

     * (or even concurrently) for the same class parameter.

     *

     * @param clazz the class to compute the value for

     * @return the return value. Must not be null.

     */

    abstract T computeValue(Class<?> clazz);

    /**

     * Returns the value associated with the class

     *

     * @param clazz the class

     * @return the value associated with the class

     */

    T get(final Class<?> clazz) {

        // Check in fastest first - objects we're allowed to strongly reference

        final T v = map.get(clazz);

        if(v != null) {

            return v;

        }

        // Check objects we're not allowed to strongly reference

        Reference<T> ref;

        synchronized(weakMap) {

            ref = weakMap.get(clazz);

        }

        if(ref != null) {

            final T refv = ref.get();

            if(refv != null) {

                return refv;

            }

        }

        // Not found in either place; create a new value

        final T newV = computeValue(clazz);

        assert newV != null;

        final Boolean canReferenceDirectly = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {

            @Override

            public Boolean run() {

                return InternalTypeUtilities.canReferenceDirectly(classLoader, clazz.getClassLoader());

            }

        }, GET_CLASS_LOADER_CONTEXT);

        // If allowed to strongly reference, put it in the fast map

        if(canReferenceDirectly) {

            final T oldV = map.putIfAbsent(clazz, newV);

            return oldV != null ? oldV : newV;

        }

        // Otherwise, put it into the weak map

        synchronized(weakMap) {

            ref = weakMap.get(clazz);

            if(ref != null) {

                final T oldV = ref.get();

                if(oldV != null) {

                    return oldV;

                }

            }

            weakMap.put(clazz, new SoftReference<>(newV));

            return newV;

        }

    }

}