FastMap.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.util;
 
import static javolution.lang.Realtime.Limit.CONSTANT;
import static javolution.lang.Realtime.Limit.LINEAR;
 
import java.io.Serializable;
import java.util.ConcurrentModificationException;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
 
import javolution.lang.Immutable;
import javolution.lang.Parallelizable;
import javolution.lang.Realtime;
import javolution.text.TextContext;
import javolution.util.function.Consumer;
import javolution.util.function.Equalities;
import javolution.util.function.Equality;
import javolution.util.internal.map.AtomicMapImpl;
import javolution.util.internal.map.FastMapImpl;
import javolution.util.internal.map.ParallelMapImpl;
import javolution.util.internal.map.SequentialMapImpl;
import javolution.util.internal.map.SharedMapImpl;
import javolution.util.internal.map.UnmodifiableMapImpl;
import javolution.util.service.CollectionService;
import javolution.util.service.MapService;
 
@Realtime
public class FastMap<K, V> implements Map<K, V>, ConcurrentMap<K, V>,
        Serializable {
 
    private static final long serialVersionUID = 0x600L; // Version.
 
    private final MapService<K, V> service;
 
    public FastMap() {
        this(Equalities.STANDARD);
    }
 
    public FastMap(Equality<? super K> keyEquality) {
        this(keyEquality, Equalities.STANDARD);
    }
 
    public FastMap(Equality<? super K> keyEquality,
            Equality<? super V> valueEquality) {
        service = new FastMapImpl<K, V>(keyEquality, valueEquality);
    }
 
    protected FastMap(MapService<K, V> service) {
        this.service = service;
    }
 
    // Views.
    //
 
    @Parallelizable(mutexFree = true, comment = "Except for write operations, all read operations are mutex-free.")
    public FastMap<K, V> atomic() {
        return new FastMap<K, V>(new AtomicMapImpl<K, V>(service));
    }
 
    @Parallelizable(mutexFree = false, comment = "Use multiple-readers/single-writer lock.")
    public FastMap<K, V> shared() {
        return new FastMap<K, V>(new SharedMapImpl<K, V>(service));
    }
 
    public FastMap<K, V> parallel() {
        return new FastMap<K, V>(new ParallelMapImpl<K, V>(service));
    }
 
    public FastMap<K, V> sequential() {
        return new FastMap<K, V>(new SequentialMapImpl<K, V>(service));
    }
 
    public FastMap<K, V> unmodifiable() {
        return new FastMap<K, V>(new UnmodifiableMapImpl<K, V>(service));
    }
 
    public FastSet<K> keySet() {
        return new FastSet<K>(service.keySet());
    }
 
    public FastCollection<V> values() {
        return new FastCollection<V>() {
            private static final long serialVersionUID = 0x600L; // Version.
            private final CollectionService<V> serviceValues = service.values();
 
            @Override
            protected CollectionService<V> service() {
                return serviceValues;
            }
        };
    }
 
    public FastSet<Entry<K, V>> entrySet() {
        return new FastSet<Entry<K, V>>(service.entrySet());
    }
 
    // Closures operations.
    //
 
    @Realtime(limit = LINEAR)
    @SuppressWarnings("unchecked")
    public void perform(Consumer<? extends Map<K, V>> action) {
        service().perform((Consumer<MapService<K, V>>) action, service());
    }
 
    @Realtime(limit = LINEAR)
    @SuppressWarnings("unchecked")
    public void update(Consumer<? extends Map<K, V>> action) {
        service().update((Consumer<MapService<K, V>>) action, service());
    }
 
    // Map Interface.
    //
 
    @Override
    @Realtime(limit = CONSTANT)
    public int size() {
        return service.size();
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public boolean isEmpty() {
        return service.isEmpty();
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public boolean containsKey(Object key) {
        return service.containsKey(key);
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public boolean containsValue(Object value) {
        return service.containsValue(value);
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public V get(Object key) {
        return service.get(key);
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public V put(K key, V value) {
        return service.put(key, value);
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public void putAll(Map<? extends K, ? extends V> map) {
        service.putAll(map);
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public V remove(Object key) {
        return service.remove(key);
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public void clear() {
        service.clear();
    }
 
    // ConcurrentMap Interface.
    //
 
    @Override
    @Realtime(limit = CONSTANT)
    public V putIfAbsent(K key, V value) {
        return service.putIfAbsent(key, value);
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public boolean remove(Object key, Object value) {
        return service.remove(key, value);
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public boolean replace(K key, V oldValue, V newValue) {
        return service.replace(key, oldValue, newValue);
    }
 
    @Override
    @Realtime(limit = CONSTANT)
    public V replace(K key, V value) {
        return service.replace(key, value);
    }
 
    // Misc.
    //
 
    public FastMap<K, V> putAll(FastMap<? extends K, ? extends V> that) {
        putAll((Map<? extends K, ? extends V>) that);
        return this;
    }
 
    public <T extends Map<K, V>> Immutable<T> toImmutable() {
        return new Immutable<T>() {
            @SuppressWarnings("unchecked")
            final T value = (T) unmodifiable();
 
            @Override
            public T value() {
                return value;
            }
        };
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public String toString() {
        return TextContext.getFormat(FastCollection.class).format(entrySet());
    }
 
    protected MapService<K, V> service() {
        return service;
    }
 
}