Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.tectonica.collections;
  
  import java.util.List;
  import java.util.Set;
 
 
 public class DocStoreInMem<K, V extends Serializableextends DocStore<K, V>
 {
 	protected class InMemDocument implements Document<K, V>
 	{
 		private final K _key// is never null
 		private V _entry// is never null
 
 		public InMemDocument(K key, V entry)
 		{
 			if (key == null || entry == null)
 				throw new NullPointerException();
 			 = key;
 			 = entry;
 		}
 
 		public K getKey()
 		{
 			return ;
 		}
 
 		public V get()
 		{
 			return ;
 		}
 
 		public V getForWrite()
 		{
 			return SerializeUtil.copyOf(); // TODO: replace with a more efficient implementation
 		}
 
 		public void commit(V entry)
 		{
 			V oldEntry = ;
 			 = entry;
 			reindex(oldEntryentry);
 		}
 	}
 
 	private final ConcurrentHashMap<K, Document<K, V>> entries;
 	private final ConcurrentHashMap<K, Locklocks;
 	private final List<InMemIndexImpl<?>> indices;
 
 	public DocStoreInMem(KeyMapper<K, V> keyMapper)
 	{
 		super(keyMapper);
 		this. = new ConcurrentHashMap<>();
 		this. = new ConcurrentHashMap<>();
 		this. = new ArrayList<>();
 	}
 
 	public <F> Index<K, V, F> createIndex(String indexNameIndexMapper<V, F> mapFunc)
 	{
 		if (.size() > 0)
 			throw new RuntimeException("adding indices on non-empty data set is not supported yet");
 
 		InMemIndexImpl<F> index = new InMemIndexImpl<>(mapFuncindexName);
 		.add(index);
 		return index;
 	}
 
 	public void insert(K key, V entry)
 	{
 		Document<K, V> existing = .putIfAbsent(keynew InMemDocument(keyentry));
 		if (existing == null)
 			reindex(keynullentry);
 		else
 			throw new RuntimeException("attempted to insert entry with existing key " + key);
 	}
 
 	public void truncate()
 	{
 	}
 
 	protected Set<K> getAllKeys()
	{
		return .keySet();
	}
	protected Document<K, V> getDocument(K keyDocumentPurpose purpose)
	{
		return .get(key);
	}
	public Lock lockForWrite(K key)
	{
		Lock lock;
		Lock existing = .putIfAbsent(keylock = new ReentrantLock());
		if (existing != null)
			lock = existing;
		return lock;
	}
	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.mapFunc.getIndexedFieldOf(oldEntry);
			Object newField = index.mapFunc.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);
			}
		}
	}

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> mapFuncString name)
		{
			super(mapFuncname);
			this. = new ConcurrentMultimap<>();
		}
		public Set<K> getKeysOf(F f)
		{
			return .get(f);
		}
		public Collection<V> getEntriesOf(F f)
		{
			Collection<V> list = new ArrayList<>();
			Set<K> keys = getKeysOf(f);
			if (keys == null)
				return null;
			for (K key : keys)
			{
				Document<K, V> doc = .get(key);
				if (doc != null// would be very strange if we get null here
					list.add(doc.get());
			}
			return list;
		}
		protected void map(Object indexField, K toKey)
		{
			.put(indexFieldtoKey);
		}
		protected void unMap(Object indexField, K toKey)
		{
			.remove(indexFieldtoKey);
		}
		protected void clear()
		{
		}
	}
New to GrepCode? Check out our FAQ X