LocalMemStorage.java

package edu.harvard.mcb.leschziner.storage;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;

import com.hazelcast.core.AtomicNumber;
import com.hazelcast.core.MultiMap;

import edu.harvard.mcb.leschziner.event.BufferedQueue;
import edu.harvard.mcb.leschziner.storage.localstorage.EventBlockingQueue;
import edu.harvard.mcb.leschziner.storage.localstorage.HashMultiMap;
import edu.harvard.mcb.leschziner.storage.localstorage.LocalAtomicNumber;

public class LocalMemStorage implements StorageEngine {
    private final Map<String, Map>           maps;
    private final Map<String, BlockingQueue> queues;
    private final Map<String, BufferedQueue> bufferedQueues;
    private final Map<String, Set>           sets;
    private final Map<String, MultiMap>      multiMaps;
    private final Map<String, AtomicNumber>  atomicNumbers;

    public LocalMemStorage() {
        maps = new ConcurrentHashMap<String, Map>();
        queues = new ConcurrentHashMap<String, BlockingQueue>();
        bufferedQueues = new ConcurrentHashMap<String, BufferedQueue>();
        sets = new ConcurrentHashMap<String, Set>();
        multiMaps = new ConcurrentHashMap<String, MultiMap>();
        atomicNumbers = new ConcurrentHashMap<String, AtomicNumber>();
    }

    @Override public AtomicNumber getAtomicNumber(String name) {
        // Look the key up
        if (!atomicNumbers.containsKey(name)) {
            // If it doesnt exist, create a new one
            AtomicNumber newNumber = new LocalAtomicNumber(name);
            atomicNumbers.put(name, newNumber);
            return newNumber;
        } else {
            return atomicNumbers.get(name);
        }
    }

    @Override public <K, V> Map<K, V> getMap(String name) {
        // Look the key up
        if (!maps.containsKey(name)) {
            // If it doesnt exist, create a new one
            Map<K, V> newMap = new HashMap<>();
            maps.put(name, newMap);
            return newMap;
        } else {
            return maps.get(name);
        }
    }

    @Override public <K, V> MultiMap<K, V> getMultiMap(String name) {
        // Look the key up
        if (!multiMaps.containsKey(name)) {
            // If it doesnt exist, create a new one
            MultiMap<K, V> newMap = new HashMultiMap<>(name);
            multiMaps.put(name, newMap);
            return newMap;
        } else {
            return multiMaps.get(name);
        }
    }

    @Override public <T> BlockingQueue<T> getQueue(String name) {
        // Look the key up
        if (!queues.containsKey(name)) {
            // If it doesnt exist, create a new one
            BlockingQueue<T> newQueue = new EventBlockingQueue<>(name);
            queues.put(name, newQueue);
            return newQueue;
        } else {
            return queues.get(name);
        }
    }

    @Override public <T> Set<T> getSet(String name) {
        // Look the key up
        if (!sets.containsKey(name)) {
            // If it doesnt exist, create a new one
            Set<T> newSet = new HashSet<>();
            sets.put(name, newSet);
            return newSet;
        } else {
            return sets.get(name);
        }
    }

    @Override public <T> BufferedQueue<T> getBufferedQueue(String name) {
        // Look the key up
        if (!bufferedQueues.containsKey(name)) {
            // If it doesnt exist, create a new one
            BufferedQueue<T> newQueue = new BufferedQueue<>(name);
            bufferedQueues.put(name, newQueue);
            return newQueue;
        } else {
            return bufferedQueues.get(name);
        }
    }

}