Dépôt officiel du code source de l'ERP OpenConcerto

/*

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

 *

 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.utils.cc;

import java.util.Arrays;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Objects;

import java.util.Set;

import java.util.function.Function;

import com.google.gson.reflect.TypeToken;

import net.jcip.annotations.GuardedBy;

import net.jcip.annotations.ThreadSafe;

/**

 * Type-safer map (e.g. can store multiple types and collections).

 *

 * @author Sylvain

 */

@ThreadSafe

public class Cookies {

    @GuardedBy("this")

    private final Map<Object, Object> map;

    @GuardedBy("this")

    private Map<Object, Object> collectionTypes;

    public Cookies() {

        this(8);

    }

    public Cookies(final int initialCapacity) {

        this.map = new HashMap<>(initialCapacity);

        this.collectionTypes = null;

    }

    public Cookies(final Cookies source) {

        synchronized (source) {

            this.map = new HashMap<>(source.map);

            this.collectionTypes = source.collectionTypes == null ? null : new HashMap<>(source.collectionTypes);

        }

    }

    public final void putAll(final Cookies other) {

        if (this == other)

            return;

        final Map<Object, Object> map;

        final Map<Object, Object> collectionTypes;

        synchronized (other) {

            map = new HashMap<>(other.map);

            collectionTypes = other.collectionTypes == null ? null : new HashMap<>(other.collectionTypes);

        }

        synchronized (this) {

            // don't just use putAll() since it won't remove entries from collectionTypes for

            // replaced items

            for (final Entry<Object, Object> e : map.entrySet()) {

                this.put(e.getKey(), e.getValue(), collectionTypes == null ? null : collectionTypes.get(e.getKey()));

            }

        }

    }

    public final Object put(Object k, Object v) {

        return this.put(k, v, null);

    }

    private final Object putCollectionType(Object k, Object v, Object type) {

        if (type == null)

            throw new IllegalArgumentException("Null type");

        return this.put(k, v, type);

    }

    private final synchronized Object put(Object k, Object v, Object type) {

        if (type != null) {

            if (this.collectionTypes == null)

                this.collectionTypes = new HashMap<>(4);

            this.collectionTypes.put(k, type);

        } else if (this.collectionTypes != null) {

            this.collectionTypes.remove(k);

        }

        return this.map.put(k, v);

    }

    public final <T> Object putCollection(Object k, Collection<T> v, Class<T> clazz) {

        return this.putCollectionType(k, v, clazz);

    }

    public final <K, V> Object putMap(Object k, Map<K, V> v, Class<K> keyClass, Class<V> valueClass) {

        Objects.requireNonNull(keyClass, "Key class");

        Objects.requireNonNull(valueClass, "value class");

        return this.putCollectionType(k, v, Arrays.asList(keyClass, valueClass));

    }

    public final <T> Object putGeneric(Object k, T v, TypeToken<T> clazz) {

        return this.putCollectionType(k, v, clazz);

    }

    public final synchronized boolean containsKey(Object k) {

        return this.map.containsKey(k);

    }

    public final synchronized Object getObject(Object k) {

        return this.map.get(k);

    }

    public final int getInt(Object k) {

        return getObjectAs(k, Number.class).intValue();

    }

    public final long getLong(Object k) {

        return getObjectAs(k, Number.class).longValue();

    }

    public final Boolean getBoolean(Object k) {

        return getObjectAs(k, Boolean.class);

    }

    public final boolean getBoolean(Object k, final boolean def) {

        final Boolean res = getBoolean(k);

        return res == null ? def : res.booleanValue();

    }

    public final String getString(Object k) {

        return getObjectAs(k, String.class);

    }

    public synchronized final <T> T getContainedObjectAs(Object key, Class<T> clazz) {

        if (!this.containsKey(key))

            throw new IllegalArgumentException(key + " not present in this : " + this.map.keySet());

        return this.getObjectAs(key, clazz);

    }

    public final <T> T getObjectAs(Object k, Class<T> clazz) {

        return this.getObjectAs(k, clazz, null);

    }

    public final <T> T getObjectAs(Object k, Class<T> clazz, final T defaultVal) {

        return this.getObjectAs(k, clazz, defaultVal, true);

    }

    public synchronized final <T> T getObjectAs(Object k, Class<T> clazz, final T defaultVal, final boolean useDefaultIfNullValue) {

        final Object res = this.getObject(k);

        if (res == null && (useDefaultIfNullValue || !this.containsKey(k)))

            return defaultVal;

        try {

            return clazz.cast(res);

        } catch (ClassCastException e) {

            throw new IllegalArgumentException("Couldn't access " + k + " in " + this + " as " + clazz.getSimpleName(), e);

        }

    }

    public final <T> Object checkType(Object k, Object wantedType, final String needMethodName) {

        final Object object;

        final Object type;

        synchronized (this) {

            object = this.getObject(k);

            type = this.collectionTypes == null ? null : this.collectionTypes.get(k);

        }

        // as getObject() : don't fail on null

        if (object == null)

            return null;

        if (type == null)

            throw new IllegalStateException("Wasn't stored with " + needMethodName + " : " + k);

        if (!type.equals(wantedType))

            throw new IllegalArgumentException("Wasn't stored with the passed type : " + wantedType + " != " + type);

        return object;

    }

    public final <T> Collection<T> getCollection(Object k, Class<T> clazz) {

        final Object object = checkType(k, clazz, "putCollection()");

        @SuppressWarnings("unchecked")

        final Collection<T> res = (Collection<T>) object;

        return res;

    }

    public final <T> Collection<T> computeCollectionIfAbsent(Object k, Class<T> clazz, Function<Object, ? extends Collection<T>> mappingFunction) {

        Collection<T> res;

        synchronized (this) {

            res = this.getCollection(k, clazz);

            // same algorithm as java.util.Map

            if (res == null) {

                res = mappingFunction.apply(k);

                if (res != null)

                    this.putCollection(k, res, clazz);

            }

        }

        return res;

    }

    public final <T> List<T> getList(Object k, Class<T> clazz) {

        return (List<T>) this.getCollection(k, clazz);

    }

    public final <T> Set<T> getSet(Object k, Class<T> clazz) {

        return (Set<T>) this.getCollection(k, clazz);

    }

    public final <K, V> Map<K, V> getMap(Object k, Class<K> keyClass, Class<V> valueClass) {

        final Object object = checkType(k, Arrays.asList(keyClass, valueClass), "putMap()");

        @SuppressWarnings("unchecked")

        final Map<K, V> res = (Map<K, V>) object;

        return res;

    }

    public final <K, V> Map<K, V> computeMapIfAbsent(Object k, Class<K> keyClass, Class<V> valueClass, Function<Object, ? extends Map<K, V>> mappingFunction) {

        Map<K, V> res;

        synchronized (this) {

            res = this.getMap(k, keyClass, valueClass);

            // same algorithm as java.util.Map

            if (res == null) {

                res = mappingFunction.apply(k);

                if (res != null)

                    this.putMap(k, res, keyClass, valueClass);

            }

        }

        return res;

    }

    public final <T> T getGeneric(Object k, TypeToken<T> clazz) {

        final Object object = checkType(k, clazz, "putGeneric()");

        @SuppressWarnings("unchecked")

        final T res = (T) object;

        return res;

    }

    public final <T> T computeIfAbsent(Object k, TypeToken<T> clazz, Function<Object, ? extends T> mappingFunction) {

        T res;

        synchronized (this) {

            res = this.getGeneric(k, clazz);

            // same algorithm as java.util.Map

            if (res == null) {

                res = mappingFunction.apply(k);

                if (res != null)

                    this.putGeneric(k, res, clazz);

            }

        }

        return res;

    }

    @Override

    public synchronized String toString() {

        return this.getClass().getSimpleName() + " of " + this.map.keySet();

    }

}