All Classes

Class	Description
AbstractFilter	Get rid of some boilerplate.
AbstractProperty	Some common behavior of properties
AlsoLoad	Annotation which helps migrate schemas by loading one of several possible properties in the entity into fields or methods.
Always	Simple If condition that always returns true for any value.
ArrayTranslatorFactory	Translator which can load an array of things.
ArrayUtils
AsyncCacheFilter	This Filter is a companion to the CachingAsyncDatastoreService, and must be installed any time the CachingAsyncDatastoreService is used without Objectify.
AsyncDatastore	The new datastore SDK has a neat structure of interfaces and implementations (transaction, datastorereader, etc) but doesn't currently support async operations.
AsyncDatastoreImpl
AsyncDatastoreReaderWriter	The new datastore SDK has a neat structure of interfaces and implementations (transaction, datastorereader, etc) but doesn't currently support async operations.
AsyncDatastoreReaderWriterImpl	The new datastore SDK has a neat structure of interfaces and implementations (transaction, datastorereader, etc) but doesn't currently support async operations.
AsyncTransaction	The new datastore SDK has a neat structure of interfaces and implementations (transaction, datastorereader, etc) but doesn't currently support async operations.
AsyncTransactionImpl
BigDecimalLongTranslatorFactory	This a simple strategy for storing BigDecimal in the datastore.
BigMoneyStringTranslatorFactory	Stores BigMoney as its string representation.
BlobTranslatorFactory	Handle the native datastore Blob
BooleanTranslatorFactory	Handle Boolean and boolean types
ByteArrayTranslatorFactory	Translates a byte[] to Blob.
Cache	Place this on any POJO entity class to cause it to be cached in the memcache.
CacheControl	Interface by which expiry times for cache entities is communicated to the cache system.
CacheControlImpl	Implements CacheControl for Objectify
CachingAsyncDatastore	A write-through memcache for Entity objects that works for both transactional and nontransactional sessions.
CachingAsyncDatastoreReaderWriter	A write-through memcache for Entity objects that works for both transactional and nontransactional sessions.
CachingAsyncTransaction	A write-through memcache for Entity objects that works for both transactional and nontransactional sessions.
CaptureType	CaptureType represents a wildcard that has gone through capture conversion.
ClassPopulator<P>	Used by translators to populate properties between POJO and PropertiesContainer.
ClassTranslator<P>	Some common code for Translators which know how to convert a POJO type into a PropertiesContainer.
ClassTranslatorFactory<P>	Translator which maps classes, both normal embedded classes and Entity classes.
Closeable	Get rid of the stupid checked exception
CollectionTranslatorFactory	Translator which can load things into a collection field.
Container	Place on one or more fields inside an embedded class.
ContainerTranslatorFactory	Translator factory which lets users create @Container properties.
CreateContext	The context while creating translator factories.
DateTimeZoneTranslatorFactory	Stores a joda DateTimeZone as its String id.
DateTranslatorFactory	The datastore can't store java.util.Date natively
DeadRef<T>	Implementation of Ref which is disconnected from the live system; for example, this will be used if a Ref gets serialized or deserialized.
Deferred	The top element in the command chain for deferred operations.
DeferredDeleteIds	Terminator methods for a delete-by-key command chain which constructs the key implicitly from type, id, and (optionally) parent.
DeferredDeleter	Element in the command chain for deferred deleting entities from the datastore.
DeferredDeleteType	After a type is specified, the next step in a delete chain is to specify an optional parent or a set of ids.
DeferredImpl	Implementation of the Deferrer interface.
DeferredSaver	Element in the command chain for deferred saving of entities.
DeferredSaverImpl	Implementation of the DeferredSaver interface.
Deferrer	Manages all the logic of deferring operations
DeleteIds	Terminator methods for a delete-by-key command chain which constructs the key implicitly from type, id, and (optionally) parent.
Deleter	The top element in the command chain for deleting entities from the datastore.
DeleterImpl	Implementation of the Delete command.
DeleteType	After a type is specified, the next step in a delete chain is to specify an optional parent or a set of ids.
EmbeddedMapTranslatorFactory	Translator which turns a Map<String, ?> into an EmbeddedEntity.
Entity	This annotation must be placed on your entity POJOs.
EntityMemcache	This is the facade used by Objectify to cache entities in the MemcacheService.
EntityMemcacheStats	Tracks hit/miss statistics for the memcache.
EntityMetadata<P>	Holds basic information about POJO entities, and can translate back and forth to the datastore representation.
EntityTranslator	Translator which can translate arbitrary entities based on registered kinds.
EnumStringifier<E extends Enum>	Converts Enums back and forth with their string representation
EnumTranslatorFactory<E extends Enum<E>>	Knows how to convert Enums to the datastore String
FieldProperty	Property which encapsulates a simple field.
FloatTranslatorFactory	Floats are funky in the datastore.
Forge	Interface for something that constructs objects.
ForwardPath	This is a wrapper for a Path that makes it backwards; instead of going from tail to head, it has links from head to tail.
FutureHelper	This provides some of the methods of Google's (package-private) FutureHelper
FutureNow<T>	A simple Future impl that provides some already-obtained static data.
FutureWrapper<K,V>	JMS: Copied verbatum from the original GAE SDK.
GenericTypeReflector	Utility class for doing reflection on types.
GenericUtils
Holder<T>	Just holds a value.
HybridQueryResults<T>	Converts keys-only query results into hybrid query results.
Id	Place this annotation on a single Long, long, or String field of an entity POJO.
IdentifiableValue
IdentityMultimapList<K,V>	Identity-based Multimap that stores values in an ArrayList.
If<V,P>	A simple interface that defines a condition test for a field value or whole entity.
IfConditionGenerator	Utility that makes it easy to generate If conditions.
IfDefault	This condition tests against the default value of the field that it is placed upon, whatever that default may be.
IfEmpty	Simple If condition that returns true if the value is null or empty.
IfEmptyString	Simple If condition that returns true if the value is an empty string.
IfFalse	Simple If condition that returns true if the value is a boolean false.
IfNotDefault	The opposite of IfDefault
IfNotEmpty	Satisfies the opposite of IfEmpty - returns true if the value is not null and not an empty String, Collection, or Map.
IfNotNull	Simple If condition that returns true if the value is not null.
IfNotZero	Simple If condition that returns true if the value is anything other than zero.
IfNull	Simple If condition that returns true if the value is null.
IfTrue	Simple If condition that returns true if the value is a boolean true.
IfZero	Simple If condition that returns true if the value is a numeric zero.
Ignore	Flags a field of a POJO entity that should be completely ignored by Objectify.
IgnoreLoad	Flags a field of a POJO entity that should not be loaded by Objectify.
IgnoreSave	When placed on an entity field, the field will not be written to the datastore.
Index	This annotation controls whether or not fields are indexed in the datastore.
InitializeIf	If an If condition class implements this interface, it will be called once just after construction.
InitializeStringifier	If a Stringifier implements this interface, it will be called once just after construction with the actual Type of the key to stringify.
InstantTranslatorFactory	Handle java.time.Instant
IntegerTranslatorFactory	Integers are funky in the datastore.
IterateFunction<T>	Function that converts Iterables into Iterators.
IteratorFirstResult<T>	Extracts the first value of the iterator as the result value.
JodaMoneyTranslators	A convenient static method that adds all the joda-money related converters to your factory's conversions.
JodaTimeTranslators	A convenient static method that adds all the joda-time related converters to your factory's conversions.
Key<T>	A typesafe wrapper for the datastore Key object.
KeyDeserializer	Will deserialize an Objectify Key that was serialized with the KeySerializer
KeyFormat	The new Cloud SDK has a new format for "url safe strings".
KeyKeySerializer	Configuring this serializer will make Key objects render as their web-safe string *when they are used as Map keys*.
KeyMemcacheService	Like MemcacheService but translates keys and values into forms more palatable to the low level service.
KeyMetadata<P>	Figures out what to do with key fields on POJO entities.
KeyPopulator<P>	Populates the @Id/@Parent fields from an Entity key
KeyRange<T>	Deprecated. Use List<Key<T>> instead.
Keys	Gives us a slightly more organized interface for manipulating keys.
KeySerializer	Configuring this serializer will make Key objects render as their web-safe string.
KeyStringifier	Converts Objectify Keys to String.
KeyTranslatorFactory	Knows how to convert Key objects to datastore-native Key objects and vice-versa.
LatLngTranslatorFactory	Handle the native datastore LatLng
LifecycleMethod	A lifecycle method that can be executed on a POJO
LiveRef<T>	Implementation of Refs which are "live" and connected to the datastore so they can fetch entity values even if they have not already been loaded.
Load	Placed on an entity field of type Ref, this will cause Objectify to fetch that entity when the containing entity is loaded.
LoadArrangement	Simple typedef to keep the code sane.
LoadConditions	A 'brain' class that determines whether or not refs should be loaded.
LoadContext	The context of a load operation, which may extend across several entities (for example, a batch).
LoadEngine	Represents one "batch" of loading.
Loader	The top element in the command chain for retrieving entities from the datastore.
LoadException	Thrown when something went wrong during the load translation process; for example, the data in the datastore might be in a format incompatible with the intended pojo field.
LoadIds<T>	Terminator methods for a fetch-by-key command chain which constructs the key implicitly from type, id, and (optionally) parent.
LoadResult<T>	Enhances the basic Result with some additional methods useful when loading data.
LoadType<T>	Once you have narrowed your interest to a type (via load().type(SomeType.class)), the command pattern can diverge into two directions: Either defining a parent or ids (which corresponds to a batch get) or calling query-related methods (which will produce a query).
LogUtils	Static methods that help out making log messages.
MakeListResult<T>	Simple ResultTranslator that converts from an Iterable to a List.
Mapify	This annotation causes collection fields to be converted into a map by selecting out a key field of your choosing.
MapifyTranslatorFactory	This takes a datastore collection and converts it to a POJO Map by letting you select out the key value using a class of your own devising.
Mapper<K,V>	Used with the @Mapify annotation to convert collections (usually of embedded objects) into maps with arbitrary keys.
MemcacheService	The interface that all memory cache services must implement.
MemcacheService.CasPut
MemcacheServiceRetryProxy	Dynamic proxy which wraps a MemcacheService and adds retries when an exception occurs.
MemcacheStats	Interface for tracking hit rates of the entity memcache.
MemcacheStatsServlet	You can mount this servlet to see the memcache stats for an instance.
MergeFuture<K,V>	A Future which merges some previously loaded values with the results of another Future that is in progress.
MethodProperty	Property which encapsulates a method with an @AlsoLoad parameter.
MoneyStringTranslatorFactory	Stores Money as its string representation.
MultimapList<K,V>	Multimap that stores values in an ArrayList.
Namespace	When placed on an entity field of type String, the value will be used as a namespace for saving the entity.
NamespaceManager	A simple thread local namespace manager, similar to legacy GAE's NamespaceManager.
NotFoundException	Exception thrown when a fetch for something could not be found.
NullPopulator	Populator which does nothing.
NullSafeTranslator<P,D>	Handles null checking so we don't have to do it everywhere.
NullStringifier	No-op stringifier used as a null object.
Objectify	This is the main "business end" of Objectify.
ObjectifyFactory	Factory which allows us to construct implementations of the Objectify interface.
ObjectifyFilter	Configure this filter to use Objectify in your application.
ObjectifyImpl	Implementation of the Objectify interface.
ObjectifyJacksonModule	Call jackson's ObjectMapper.registerModule(new ObjectifyJacksonModule()) to enable intelligent serialization and deserialization of various Objectify and GAE classes.
ObjectifyOptions	Encapsulates the various options that can be twiddled in an objectify session.
ObjectifyService	Holder of the master ObjectifyFactory and provider of the current thread-local Objectify instance.
ObjectTranslatorFactory	In case someone has a field of type Object or uses a raw collection without specifying the generic type.
OnLoad	When placed on a method on a POJO entity, that method will be called just after being loaded from the datastore.
OnSave	When placed on a method on a POJO entity, that method will be called just prior to being saved in the datastore.
Parent	When placed on an entity field of type Key, the key will be used as the parent ancestor for entity grouping.
Path	Path represents the individual steps from the root object to the current property.
PendingFutures	This class maintains a thread local list of all the outstanding Future objects that have pending triggers.
PojoIf<P>	Base class for If classes that test against a whole POJO object.
Populator<P>	A populator knows how to copy properties between POJO objects and the native datastore representation.
PrivateAsyncTransaction	A private interface for manipulating transactions.
Property	Basic interface so we can wrap fields and methods so they look more or less the same.
PropertyPopulator<P,D>	Associates a Property with a Translator and provides a more convenient interface.
Queries	Some static utility methods for interacting with basic datastore objects like keys and queries.
Query<T>	The basic options for a typed Query.
QueryDef	The SDK Query hierarchy and associated builders make it hard to convert between keys-only entity, and projection.
QueryEngine	Logic for dealing with queries.
QueryExecute<T>	Most of the various methods that can end the definition of a query and start execution.
QueryImpl<T>	Implementation of Query.
QueryKeys<T>	After you call Query.keys(), you are executing a keys-only query.
QueryResultIterable<T>	Replaces a class from the old GAE SDK.
RawEntityTranslatorFactory	Handle the native datastore FullEntity
RawKeyDeserializer	Will deserialize a google native datastore Key that was serialized with the RawKeySerializer
RawKeyKeySerializer	Configuring this serializer will make native datastore Key objects render as their web-safe string *when they are used as Map keys*.
RawKeySerializer	Configuring this serializer will make native datastore Key objects render as their web-safe string.
RawKeyTranslatorFactory	Handle the native datastore Key
RawValueTranslatorFactory	Just in case anyone has a Value<?> field.
ReadableInstantTranslatorFactory	Converts Joda ReadableInstants (DateTime, DateMidnight, etc) into Timestamp
ReadablePartialTranslatorFactory	Converts Joda ReadablePartials (LocalDate, LocalDateTime, YearMonth, etc) into String (ISO-8601) representation
Recycles	Marker interface for a translator that indicates that, when loading, it is sensitive to the previously existing value in a field.
Ref<T>	Ref is a Key which allows the entity value to be fetched directly.
RefDeserializer	Will deserialize an Objectify Ref that was serialized with the RefSerializer.
RefKeySerializer	Like RefSerializer, but handles Refs when they are used as Map keys.
RefSerializer	Serializing Ref is a little complicated - if we have a loaded value, render it as-is, but if not, just render the key string.
RefTranslatorFactory	Knows how to convert Ref objects to datastore-native Key objects and vice-versa.
Registrar	Maintains information about registered entity classes
Result<T>	This interface provides a return value for asynchronous Objectify calls, nearly the same as java.util.concurrent.Future.
ResultAdapter<T>	Adapts a Future object to a (much more convenient) Result object.
ResultCache<T>	Caches a result value so it is only executed once
ResultNow<T>	Simplistic result that holds a constant value.
ResultNowFunction<T>	Simple function that extracts the value of a Result
ResultProxy<T>	A dynamic proxy that wraps a Result value.
ResultTranslator<F,T>	Translates from one arbitrary thing to a Result of another arbitrary thing, caching the value.
ResultWithCursor<T>	Associates a result value with a cursor.
ResultWithCursor.Iterator<T>	Turns QueryResults into an iterator of the {result, cursor} tuple
ResultWrapper<F,T>	Wraps a Result, translating from one type to another and caching the result
SaveContext	The context of a save operation; might involve multiple entities (eg, batch save).
SaveException	Thrown when something went wrong during the save translation process.
Saver	The top element in the command chain for saving entities in the datastore.
SaverImpl	Implementation of the Put interface.
Serialize	When placed on an entity field, the field will be written as a single Blob property using java serialization.
SerializeTranslatorFactory	Loader which can load any serialized thing from a Blob.
Session	The basic session cache.
SessionValue<T>	The information we maintain on behalf of an entity instance in the session cache.
SimpleFutureWrapper<K,V>	Slightly more convenient than the GAE SDK version.
SimpleQuery<T>	A restricted set of query operations that apply to both kindless queries and typed queries.
SimpleQueryImpl<T>	Base for command classes that include methods for defining a query (filter, order, limit, etc).
SimpleTranslatorFactory<P,D>	Simplest base class for most value translations.
SkipException	Thrown by any Translator that wants its value to be skipped.
SpyIdentifiableValue
SpyMemcacheService	Among the issues this impl needs to be concerned with is that memcached doesn't store nulls.
SqlDateTranslatorFactory	The datastore can't store java.sql.Date natively
Stringifier<T>	Used with the @Stringify annotation to convert arbitrary objects to Strings.
Stringify	This annotation establishes a Stringifier for a field.
StringTranslatorFactory	Knows how to convert Strings.
Subclass	Indicates that a class is part of a polymorphic persistence hierarchy.
Synthetic	Marker interface for a translator that indicates that on load, the property value in the entity should be ignored and instead the loader should just be run with a null value.
TimestampTranslatorFactory	Handle the native datastore Timestamp
TimeZoneTranslatorFactory	Converts java.util.TimeZone
TransactionWrapper	Simple pass-through to the base methods.
Transactor	Determines the transactional behavior of an ObjectifyImpl instance.
Translate	Lets you define a particular translator for a specific property (field or @AlsoLoad method).
TranslateException	Thrown when something went wrong during the entity translation process; for example, the data in the datastore might be in a format incompatible with the intended pojo field.
TranslateTranslatorFactory	Translator factory which lets users define a custom translator for a field.
TranslatingIterator<F,T>	Iterator wrapper that translates from one type to another
TranslatingQueryResults<F,T>	QueryResultIterator wrapper that translates from one type to another
Translator<P,D>	A translator knows how convert between POJO objects and the native datastore representation.
TranslatorFactory<P,D>	A translator knows how to convert between a POJO and a native datastore representation.
TranslatorRecycles<P,D>	Combines Translator with Recycles, useful so that we can create anonymous classes.
Translators	Manages all the translators used to map between POJO fields and the types that the Datastore can actually persist.
TriggerFuture<T>	A Future wrapper that executes an abstract method with the result at some point after the data becomes available.
TriggerSuccessFuture<T>	Extends TriggerFuture so that it only gets triggered on successful (no exception) completion of the Future.
TxnType	Just like the EJB options.
TypeArgumentNotInBoundException	Thrown to indicate that a type argument for a parameterized type is not within the bound declared on the type parameter.
TypeFactory	Utility class for creating instances of Type.
TypeKey<T>	Unique identifier for a translator instance.
TypeToken<T>	Wrapper around Type.
TypeUtils
Unindex	This annotation controls whether or not fields are indexed in the datastore.
URLTranslatorFactory	The datastore can't store URL, so translate it to a String and back.
ValueIf<V>	Base class for If classes that test against a simple value.
Values	Some static utility methods for interacting with Value<?>
ValueTranslator<P,D>	Translator that should be extended for typical atomic values.
ValueTranslatorFactory<P,D>	Provides a little boilerplate for translators that work on simple atomic types.
VoidWork	Deprecated. There are overloads for etc that take a instead.
Work<R>	For executing transactions, this is a unit of work.
WriteEngine	This is the master logic for saving and deleting entities from the datastore.