Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.tectonica.collections;
  
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
 
 
 public class InMemKeyValueStore<K, V extends Serializableextends KeyValueStore<K, V>
 {
 	private final ConcurrentHashMap<K, InMemEntryentries;
 	private final ConcurrentHashMap<K, Locklocks;
 	private final List<InMemIndexImpl<?>> indexes;

creates an in-memory data store, suitable mostly for development.

Parameters:
keyMapper this optional parameter is suitable in situations where the key of an entry can be inferred from its value directly (as opposed to when the key and value are stored separately). when provided, several convenience methods become applicable
 
 	public InMemKeyValueStore(KeyMapper<K, V> keyMapper)
 	{
 		super(keyMapper);
 		this. = new ConcurrentHashMap<>();
 		this. = new ConcurrentHashMap<>();
 		this. = new ArrayList<>();
 	}
 
 	protected class InMemEntry implements Modifier<K, V>, KeyValue<K, V>
 	{
 		private final K _key// never null
 		private V _value// never null
 
 		public InMemEntry(K key, V value)
 		{
 			if (key == null || value == null)
 				throw new NullPointerException();
 			 = key;
 			 = value;
 		}
 
 		public K getKey()
 		{
 			return ;
 		}
 
 		public V getValue()
 		{
 			return ;
 		}
 
 		public V getModifiableValue()
 		{
 			return SerializeUtil.copyOf(); // TODO: replace with a more efficient implementation
 		}
 
 		public void commit(V value)
 		{
 			V oldEntry = ;
 			 = value;
 			reindex(oldEntryvalue);
 		}
 	}

GETTERS /
 
 
 	public V get(K key)
 	{
 		KeyValue<K, V> kv = .get(key);
 		if (kv == null)
 			return null;
 		return kv.getValue();
 	}
 
 	@SuppressWarnings({ "unchecked""rawtypes" })
 	public Iterator<KeyValue<K, V>> iterator()
 	{
 		return (Iterator.values().iterator();
 	}
 
	public Iterator<K> keyIterator()
	{
		return .keySet().iterator();
	}
	public Iterator<KeyValue<K, V>> iteratorFor(Set<K> keySet)
	{
		List<KeyValue<K, V>> list = new ArrayList<>();
		for (K key : keySet)
		{
			KeyValue<K, V> kv = .get(key);
			if (kv != null)
				list.add(kv);
		}
		return list.iterator();
	}
	public Set<K> keySet()
	{
		return .keySet();
	}

SETTERS (UTILS) /
	protected Modifier<K, V> getModifier(K keyModificationType purpose)
	{
		return .get(key);
	}
	public Lock getModificationLock(K key)
	{
		Lock lock;
		Lock existing = .putIfAbsent(keylock = new ReentrantLock());
		if (existing != null)
			lock = existing;
		return lock;
	}

SETTERS /
	public void insert(K key, V value)
	{
		Modifier<K, V> existing = .putIfAbsent(keynew InMemEntry(keyvalue));
		if (existing == null)
			reindex(keynullvalue);
		else
			throw new RuntimeException("attempted to insert entry with existing key " + key);
	}

DELETERS /
	public void delete(K key)
	{
		if (.size() == 0)
			.remove(key); // without indexes to update, this is a primitive operation
		else
		{
			KeyValue<K, V> kv = .get(key);
			if (kv != null)
			{
oldValue = kv.getValue();
				reindex(keyoldValuenull);
			}
		}
	}
	public void truncate()
	{
	}

INDEXES /
	public <F> Index<K, V, F> createIndex(String indexNameIndexMapper<V, F> mapper)
	{
		if (.size() > 0)
			throw new RuntimeException("adding indexes on non-empty data set is not supported yet");
		InMemIndexImpl<F> index = new InMemIndexImpl<>(mapperindexName);
		.add(index);
		return index;
	}

straightforward in-memory implementation of an index

Author(s):
Zach Melamed
	public class InMemIndexImpl<F> extends Index<K, V, F>
	{
		public InMemIndexImpl(IndexMapper<V, F> mapperString name)
		{
			super(mappername);
			this. = new ConcurrentMultimap<>();
		}
		public Iterator<K> keyIteratorOf(F f)
		{
			Set<K> keySet = .get(f);
			if (keySet == null)
				return Collections.emptyIterator();
			return keySet.iterator();
		}
		public Iterator<V> valueIteratorOf(F f)
		{
			final Iterator<K> iter = keyIteratorOf(f);
			return new Iterator<V>()
			{
				public boolean hasNext()
				{
					return iter.hasNext();
				}
				public V next()
				{
					return .get(iter.next()).getValue();
				}
				public void remove()
				{
				}
			};
		}
		protected void map(Object indexField, K toKey)
		{
			.put(indexFieldtoKey);
		}
		protected void unMap(Object indexField, K toKey)
		{
			.remove(indexFieldtoKey);
		}
		protected void clear()
		{
		}
	}
	private void clearIndices()
	{
		for (InMemIndexImpl<?> index : )
			index.clear();
	}
	private void reindex(K key, V oldEntry, V newEntry)
	{
		for (int i = 0; i < .size(); i++)
		{
			InMemIndexImpl<?> index = .get(i);
			Object oldField = (oldEntry == null) ? null : index.mapper.getIndexedFieldOf(oldEntry);
			Object newField = (newEntry == null) ? null : index.mapper.getIndexedFieldOf(newEntry);
			boolean valueChanged = ((oldField == null) != (newField == null)) || ((oldField != null) && !oldField.equals(newField));
			if (valueChanged)
			{
				if (oldField != null)
					index.unMap(oldFieldkey);
				if (newField != null)
					index.map(newFieldkey);
			}
		}
	}
New to GrepCode? Check out our FAQ X