Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.tectonica.gae;
  
  import java.util.Iterator;
  import java.util.List;
 
 import  com.google.appengine.api.datastore.Blob;
 import  com.google.appengine.api.datastore.DatastoreService;
 import  com.google.appengine.api.datastore.DatastoreServiceFactory;
 import  com.google.appengine.api.datastore.Entity;
 import  com.google.appengine.api.datastore.EntityNotFoundException;
 import  com.google.appengine.api.datastore.Key;
 import  com.google.appengine.api.datastore.KeyFactory;
 import  com.google.appengine.api.datastore.Query;
 import  com.google.appengine.api.datastore.Query.Filter;
 import  com.google.appengine.api.datastore.Query.FilterOperator;
 import  com.google.appengine.api.datastore.Query.FilterPredicate;
 
 public class GaeKeyValueStore<V extends Serializableextends KeyValueStore<String, V>
 {
 	private static DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
 
 	private final Class<V> valueClass;
 	private final String kind;
 	private final Key ancestor// dummy parent for all entities to guarantee Datastore consistency
 	private final List<GaeIndexImpl<?>> indexes;
 
 	public GaeKeyValueStore(Class<V> valueClassKeyMapper<String, V> keyMapper)
 	{
 		super(keyMapper);
 		if (valueClass == null)
 			throw new NullPointerException();
 		this. = valueClass;
 		this. = valueClass.getSimpleName();
 		this. = KeyFactory.createKey();
 		this. = new ArrayList<>();
 	}
 
 	private Key keyOf(String key)
 	{
 		return KeyFactory.createKey(key);
 	}

GETTERS /
 
 
 	protected V doGet(String key)
 	{
 		try
 		{
 			return entityToValue(.get(keyOf(key)));
 		}
 		catch (EntityNotFoundException e)
 		{
 			return null;
 		}
 	}
 
 	public Iterator<KeyValue<String, V>> iterator()
 	{
 		return entryIteratorOfQuery(newQuery()); // query without filters = all
 	}
 
 	{
 		return keyIteratorOfQuery(newQuery().setKeysOnly());
 	}
 
 	public Iterator<V> valueIterator()
 	{
 	}
 
 	{
 		if (keySet.isEmpty())
 			return Collections.emptyIterator();
 
 		List<Key> gaeKeySet = new ArrayList<>(keySet.size());
 		for (String key : keySet)
 			gaeKeySet.add(keyOf(key));
 
 		Filter filter = new FilterPredicate(Entity.KEY_RESERVED_PROPERTY, FilterOperator.IN, gaeKeySet);
 		return entryIteratorOfQuery(newQuery().setFilter(filter));
 	}

SETTERS (UTILS) /
	protected Modifier<String, V> getModifier(final String keyModificationType purpose)
	{
		// insert, replace and update are all treated the same in GAE: all simply do save()
		return new Modifier<String, V>()
		{
			public V getModifiableValue()
			{
				return doGet(key); // same implementation as read-only get, as in both cases we deserialize a new instance
			}
			public void commit(V value)
			{
				save(keyvalue);
			}
		};
	}
	{
		return GaeMemcacheLock.getLock( + ":" + keytrue);
	}

SETTERS /
	protected void doInsert(String key, V value)
	{
		save(keyvalue);
	}

DELETERS /
	public void delete(String key)
	{
		.delete(keyOf(key));
	}
	public void truncate()
	{
		for (Entity entity : .prepare(newQuery().setKeysOnly()).asIterable())
			.delete(entity.getKey());
	}

INDEXES /
	public <F> Index<String, V, F> createIndex(String indexNameIndexMapper<V, F> mapFunc)
	{
		GaeIndexImpl<F> index = new GaeIndexImpl<>(mapFuncindexName);
		.add(index);
		return index;
	}

GAE implementation of an index - simply exposes the Datastore property filters

Author(s):
Zach Melamed
	public class GaeIndexImpl<F> extends Index<String, V, F>
	{
		public GaeIndexImpl(IndexMapper<V, F> mapFuncString name)
		{
			super(mapFuncname);
			if (name == null || name.isEmpty())
				throw new RuntimeException("index name is mandatory in " + GaeIndexImpl.class.getSimpleName());
		}
		public Iterator<KeyValue<String, V>> iteratorOf(F f)
		{
		}
		{
			return keyIteratorOfQuery(newIndexQuery(f).setKeysOnly());
		}
		public Iterator<V> valueIteratorOf(F f)
		{
		}
		private Query newIndexQuery(F f)
		{
			Filter filter = new FilterPredicate(propertyName(), FilterOperator.EQUAL, f);
			return newQuery().setFilter(filter);
		}
		private String propertyName()
		{
		}
		private F getIndexedFieldOf(V value)
		{
			return .getIndexedFieldOf(value);
		}
	}

DATASTORE UTILS /
	private static final String COL_NAME_ENTRY_VALUE = "value";
	private static final String COL_NAME_INDEX_PREFIX = "_i_";
	private static final String BOGUS_ANCESTOR_KEY_NAME = " ";
	private V entityToValue(Entity entity)
	{
		Blob blob = (Blob) entity.getProperty();
		return SerializeUtil.bytesToObj(blob.getBytes(), );
	}
	private Entity entryToEntity(String key, V value)
	{
		Entity entity = new Entity(key);
		entity.setProperty(new Blob(SerializeUtil.objToBytes(value)));
		for (int i = 0; i < .size(); i++)
		{
			GaeIndexImpl<?> index = .get(i);
			Object field = (value == null) ? null : index.getIndexedFieldOf(value);
			entity.setProperty(index.propertyName(), field);
		}
		return entity;
	}
	private void save(String key, V value)
	{
		.put(entryToEntity(keyvalue));
	}
	private Query newQuery()
	{
		return new Query().setAncestor();
	}
	private Iterator<KeyValue<String, V>> entryIteratorOfQuery(Query q)
	{
		final Iterator<Entity> iter = .prepare(q).asIterator();
		return new Iterator<KeyValue<String, V>>()
		{
			public boolean hasNext()
			{
				return iter.hasNext();
			}
			public KeyValue<String, V> next()
			{
				final Entity entity = iter.next();
				return new KeyValue<String, V>()
				{
					public String getKey()
					{
						return entity.getKey().getName();
					}
					public V getValue()
					{
						return entityToValue(entity);
					}
				};
			}
			public void remove()
			{
			}
		};
	}
	private Iterator<StringkeyIteratorOfQuery(Query q)
	{
		final Iterator<Entity> iter = .prepare(q).asIterator();
		return new Iterator<String>()
		{
			public boolean hasNext()
			{
				return iter.hasNext();
			}
			public String next()
			{
				return iter.next().getKey().getName();
			}
			public void remove()
			{
			}
		};
	}
	private Iterator<V> valueIteratorOfQuery(Query q)
	{
		final Iterator<Entity> iter = .prepare(q).asIterator();
		return new Iterator<V>()
		{
			public boolean hasNext()
			{
				return iter.hasNext();
			}
			public V next()
			{
				return entityToValue(iter.next());
			}
			public void remove()
			{
			}
		};
	}
New to GrepCode? Check out our FAQ X