Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2014 Zach Melamed
   * 
   * Latest version available online at https://github.com/zach-m/tectonica-commons
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.tectonica.kvs.impl;
 
 import java.util.List;
 import java.util.Set;
 
 
 public class InMemKeyValueStore<K, V extends Serializableextends AbstractKeyValueStore<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
 //			return KryoUtil.copyOf(_value);
 		}
 
 		public void dbPut(V value)
 		{
 			V oldEntry = ;
 			 = value;
 			reindex(oldEntryvalue);
 		}
	}

GETTERS /
	protected V dbGet(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()
	{
	}
	public Iterator<K> keyIterator()
	{
		return .keySet().iterator();
	}
	protected Iterator<KeyValue<K, V>> dbOrderedIterator(Collection<K> keys)
	{
		List<KeyValue<K, V>> list = new ArrayList<>();
		for (K key : keys)
		{
			KeyValue<K, V> kv = .get(key);
			if (kv != null)
				list.add(kv);
		}
		return list.iterator();
	}
	public Set<K> keySet()
	{
		return .keySet();
	}
	public boolean containsKey(K key)
	{
		return .containsKey(key);
	}

SETTERS (UTILS) /
	protected Modifier<K, V> getModifier(K keyModificationType purpose)
	{
		return .get(key);
	}
	public Lock getModificationLock(K key)
	{
		// TODO: in this simplistic implementation we always increase the size of the 'locks' map
		// if important, use the AutoEvictMap here
		Lock lock;
		Lock existing = .putIfAbsent(keylock = new ReentrantLock());
		if (existing != null)
			lock = existing;
		return lock;
	}

SETTERS /
	protected void dbInsert(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 /
	protected boolean dbDelete(K key)
	{
		InMemEntry removed = null;
		if (.size() == 0)
			removed = .remove(key); // without indexes to update, this is a primitive operation
		else
		{
			KeyValue<K, V> kv = .get(key);
			if (kv != null)
			{
oldValue = kv.getValue();
				removed = .remove(key);
				reindex(keyoldValuenull);
			}
		}
		return (removed != null);
	}
	protected int dbDeleteAll()
	{
		int removed = .size();
		return removed;
	}

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 AbstractIndex<K, V, F>
	{
		public InMemIndexImpl(IndexMapper<V, F> mapperString name)
		{
			super(mappername);
			this. = new ConcurrentMultimap<>();
		}
		public Iterator<KeyValue<K, V>> iteratorOf(F f)
		{
			final Iterator<K> iter = keyIteratorOf(f);
			return new Iterator<KeyValue<K, V>>()
			{
				public boolean hasNext()
				{
					return iter.hasNext();
				}
				public KeyValue<K, V> next()
				{
key = iter.next();
					return KvsUtil.keyValueOf(key.get(key).getValue());
				}
				public void remove()
				{
				}
			};
		}
		public Iterator<K> keyIteratorOf(F f)
		{
			Set<K> keys = .get(f);
			if (keys == null)
				return Collections.emptyIterator();
			return keys.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()
				{
				}
			};
		}
		private F getIndexedFieldOf(V value)
		{
			return .getIndexedFieldOf(value);
		}
		private void map(Object indexField, K toKey)
		{
			.put(indexFieldtoKey);
		}
		private void unMap(Object indexField, K toKey)
		{
			.remove(indexFieldtoKey);
		}
		private 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.getIndexedFieldOf(oldEntry);
			Object newField = (newEntry == null) ? null : index.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