All Classes
Class
Description
Get rid of some boilerplate.
Some common behavior of properties
Annotation which helps migrate schemas by loading one of several possible properties
in the entity into fields or methods.
Simple If condition that always returns true for any value.
Translator which can load an array of things.
This should be near the end of the translation discovery chain.
This Filter is a companion to the CachingAsyncDatastoreService, and must be
installed any time the CachingAsyncDatastoreService is used without Objectify.
This a simple strategy for storing BigDecimal in the datastore.
Stores BigMoney as its string representation.
Will deserialize a BlobKey that was serialized with the BlobKeySerializer
Configuring this serializer will make BlobKey objects render as their web-safe string.
Translates a byte[] to Blob.
Place this on any POJO entity class to cause it to be cached in the memcache.
Interface by which expiry times for cache entities is communicated to the cache system.
Implements CacheControl for Objectify
A write-through memcache for Entity objects that works for both transactional
and nontransactional sessions.
A synchronous facade for the CachingAsyncDatastoreService.
A convenience class with factory methods to create caching versions of DatastoreService
and AsyncDatastoreService.
CaptureType represents a wildcard that has gone through capture conversion.
A single chunk during a query.
Base class for normal and hybrid iterators, handles the chunking logic.
Splits a QueryResultIterator into a series of chunks which include the Cursor for
the beginning of the chunk.
Used by translators to populate properties between POJO and PropertiesContainer.
Some common code for Translators which know how to convert a POJO type into a PropertiesContainer.
Translator which maps classes, both normal embedded classes and Entity classes.
Get rid of the stupid checked exception
Translator which can load things into a collection field.
Place on one or more fields inside an embedded class.
Translator factory which lets users create @Container properties.
The context while creating translator factories.
Factory for POJO and PropertyContainer objects.
Lets us probe for certain datastore capabilities which may vary depending on dev/production/ms/hrd/etc
Some static utility methods for interacting with basic datastore objects like keys and queries.
Stores a joda DateTimeZone as its String id.
Implementation of Ref which is disconnected from the live system; for example, this will be used
if a Ref gets serialized or deserialized.
The top element in the command chain for deferred operations.
Terminator methods for a delete-by-key command chain which constructs the key implicitly from
type, id, and (optionally) parent.
Element in the command chain for deferred deleting entities from the datastore.
After a type is specified, the next step in a delete chain is to specify an optional parent
or a set of ids.
Implementation of the Deferrer interface.
Element in the command chain for deferred saving of entities.
Implementation of the DeferredSaver interface.
Manages all the logic of deferring operations
Terminator methods for a delete-by-key command chain which constructs the key implicitly from
type, id, and (optionally) parent.
The top element in the command chain for deleting entities from the datastore.
Implementation of the Delete command.
After a type is specified, the next step in a delete chain is to specify an optional parent
or a set of ids.
This version is for creating normal embedded objects.
Translator which turns a Map<String, ?> into an EmbeddedEntity.
This annotation must be placed on your entity POJOs.
This version is for creating entity objects, which could be embedded or top-level.
This is the facade used by Objectify to cache entities in the MemcacheService.
Tracks hit/miss statistics for the memcache.
Holds basic information about POJO entities, and can translate back and forth to the
datastore representation.
Translator which can translate arbitrary entities based on registered kinds.
Converts Enums back and forth with their string representation
Knows how to convert Enums to the datastore String
Property which encapsulates a simple field.
Interface for something that constructs objects.
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.
This provides some of the methods of Google's (package-private) FutureHelper
A simple Future impl that provides some already-obtained static data.
Utility class for doing reflection on types.
Just holds a value.
Place this annotation on a single Long, long, or String field of an entity POJO.
Identity-based Multimap that stores values in an ArrayList.
A simple interface that defines a condition test for a field value or whole
entity.
Utility that makes it easy to generate If conditions.
This condition tests against the default value of the field that it
is placed upon, whatever that default may be.
Simple If condition that returns true if the value is null or empty.
Simple If condition that returns true if the value is an empty string.
Simple If condition that returns true if the value is a boolean false.
The opposite of IfDefault
Satisfies the opposite of IfEmpty - returns true if the value
is not null and not an empty String, Collection, or Map.
Simple If condition that returns true if the value is not null.
Simple If condition that returns true if the value is anything other than zero.
Simple If condition that returns true if the value is null.
Simple If condition that returns true if the value is a boolean true.
Simple If condition that returns true if the value is a numeric zero.
Flags a field of a POJO entity that should be completely ignored by Objectify.
Flags a field of a POJO entity that should not be loaded by Objectify.
When placed on an entity field, the field will not be written to the datastore.
This annotation controls whether or not fields are indexed in the datastore.
If an If condition class implements this interface, it will be called once just after construction.
If a Stringifier implements this interface, it will be called once just after construction
with the actual Type of the key to stringify.
Function that converts Iterables into Iterators.
Extracts the first value of the iterator as the result value.
A convenient static method that adds all the joda-money related converters to your factory's conversions.
A convenient static method that adds all the joda-time related converters to your factory's conversions.
A typesafe wrapper for the datastore Key object.
Will deserialize an Objectify Key that was serialized with the KeySerializer
Configuring this serializer will make Key objects render as their web-safe string *when they are used as Map keys*.
Subset of MemcacheService used by EntityMemcache, but smart enough to translate Key into the stringified
version so that the memcache keys are intelligible.
Figures out what to do with key fields on POJO entities.
This is a typesafe version of the KeyRange object.
Gives us a slightly more organized interface for manipulating keys.
Configuring this serializer will make Key objects render as their web-safe string.
Converts Objectify Keys to String.
Knows how to convert Key objects to datastore-native Key objects and vice-versa.
A lifecycle method that can be executed on a POJO
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.
Placed on an entity field of type Ref, this will cause
Objectify to fetch that entity when the containing entity is loaded.
Simple typedef to keep the code sane.
A 'brain' class that determines whether or not refs should be loaded.
The context of a load operation, which may extend across several entities (for example, a batch).
Represents one "batch" of loading.
The top element in the command chain for retrieving entities from the datastore.
Implementation of the Loader interface.
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.
Terminator methods for a fetch-by-key command chain which constructs the key implicitly from
type, id, and (optionally) parent.
Enhances the basic Result with some additional methods useful when loading data.
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).Static methods that help out making log messages.
Simple ResultTranslator that converts from an Iterable to a List.
This annotation causes collection fields to be converted into a map by selecting
out a key field of your choosing.
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.
Used with the @Mapify annotation to convert collections (usually of embedded objects) into maps
with arbitrary keys.
Dynamic proxy which wraps a MemcacheService and adds retries when an exception occurs.
Interface for tracking hit rates of the entity memcache.
If you are using the ObjectifyService static factory, you can mount this servlet to see the
memcache stats for an instance.
A Future which merges some previously loaded values with the results of another
Future that is in progress.
Property which encapsulates a method with an @AlsoLoad parameter.
Stores Money as its string representation.
Multimap that stores values in an ArrayList.
Exception thrown when a fetch for something could not be found.
Populator which does nothing.
Handles null checking so we don't have to do it everywhere.
No-op stringifier used as a null object.
Numbers are funky in the datastore.
This is the main "business end" of Objectify.
Factory which allows us to construct implementations of the Objectify interface.
Configure this filter to use Objectify in your application.
Implementation of the Objectify interface.
Call jackson's
ObjectMapper.registerModule(new ObjectifyJacksonModule()) to enable
intelligent serialization and deserialization of various Objectify and GAE classes.Holder of the master ObjectifyFactory and provider of the current thread-local Objectify instance.
When placed on a method on a POJO entity, that method will be called just after being loaded from the
datastore.
When placed on a method on a POJO entity, that method will be called just prior to being saved in the
datastore.
When placed on an entity field of type Key, the key will be used as the parent
ancestor for entity grouping.
Path represents the individual steps from the root object to the current property.
This class maintains a thread local list of all the outstanding Future objects
that have pending triggers.
Base class for If classes that test against a whole POJO object.
A populator knows how to copy properties between POJO objects and a PropertiesContainer.
Projections bypass the session entirely, neither loading nor saving.
Watches out for RawValue and performs the necessary conversion if we get one.
Basic interface so we can wrap fields and methods so they look more or less the same.
Associates a Property with a Translator and provides a more convenient interface.
The basic options for a typed Query.
Logic for dealing with queries.
Most of the various methods that can end the definition of a query and start execution.
Implementation of Query.
After you call Query.keys(), you are executing a keys-only query.
Simple wrapper/decorator for a QueryResultIterator.
Will deserialize a google native datastore Key that was serialized with the RawKeySerializer
Configuring this serializer will make native datastore Key objects render as their web-safe string *when they are used as Map keys*.
Configuring this serializer will make native datastore Key objects render as their web-safe string.
Converts Joda ReadableInstants (DateTime, DateMidnight, etc) into java.util.Date
Converts Joda ReadablePartials (LocalDate, LocalDateTime, YearMonth, etc) into String (ISO-8601) representation
Marker interface for a translator that indicates that, when loading, it is sensitive to the previously
existing value in a field.
Ref is a Key which allows the entity value to be fetched directly.
Will deserialize an Objectify Ref that was serialized with the RefSerializer.
Like RefSerializer, but handles Refs when they are used as Map keys.
Serializing Ref is a little complicated - if we have a loaded value, render it as-is, but if not, just render the key string.
Knows how to convert Ref objects to datastore-native Key objects and vice-versa.
Maintains information about registered entity classes
This interface provides a return value for asynchronous Objectify calls,
nearly the same as
java.util.concurrent.Future.Adapts a Future object to a (much more convenient) Result object.
Caches a result value so it is only executed once
Simplistic result that holds a constant value.
Simple function that extracts the value of a Result
A dynamic proxy that wraps a Result value.
Translates from one arbitrary thing to a Result of another arbitrary thing, caching the value.
Associates a result value with a base cursor + offset to this particular item.
Wraps a Result, translating from one type to another and caching the result
The context of a save operation; might involve multiple entities (eg, batch save).
Thrown when something went wrong during the save translation process.
The top element in the command chain for saving entities in the datastore.
Implementation of the Put interface.
When placed on an entity field, the field will be written as a single Blob
property using java serialization.
Loader which can load any serialized thing from a Blob.
The basic session cache.
The information we maintain on behalf of an entity instance in the session cache.
Slightly more convenient than the GAE SDK version.
A restricted set of query operations that apply to both kindless queries and typed queries.
Base for command classes that include methods for defining a query (filter, order, limit, etc).
Thrown by any Translator that wants its value to be skipped.
The datastore can't store java.sql.Date, but it can do java.util.Date.
Used with the @Stringify annotation to convert arbitrary objects to Strings.
This annotation establishes a Stringifier for a field.
Knows how to convert Strings.
Indicates that a class is part of a polymorphic persistence hierarchy.
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.
Knows how to convert Texts.
Converts java.util.TimeZone
Simple pass-through to the base methods.
Determines the transactional behavior of an ObjectifyImpl instance.
Implementation for when we start a transaction.
Lets you define a particular translator for a specific property (field or @AlsoLoad method).
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.
Translator factory which lets users define a custom translator for a field.
Iterator wrapper that translates from one type to another
QueryResultIterable wrapper that creates iterators that translate from one type to another
QueryResultIterator wrapper that translates from one type to another
A translator knows how convert between POJO objects and the native datastore representation.
A translator knows how to convert between a POJO and a native datastore representation.
Combines Translator with Recycles, useful so that we can create anonymous classes.
Manages all the translators used to map between POJO fields and the
types that the Datastore can actually persist.
A Future wrapper that executes an abstract method with the result at some point after
the data becomes available.
Extends TriggerFuture so that it only gets triggered on successful (no exception)
completion of the Future.
Just like the EJB options.
Thrown to indicate that a type argument for a parameterized type is not within the bound declared on the type
parameter.
Utility class for creating instances of
Type.Unique identifier for a translator instance.
Wrapper around
Type.This annotation controls whether or not fields are indexed in the datastore.
The datastore can't store URL, so translate it to a String and back.
Base class for If classes that test against a simple value.
A bit of code that does the required type checking and casting so that we have nice typed methods.
Provides a little boilerplate for translators that work on simple atomic types.
Using Work is annoying because you must return a value from the run() method.
For executing transactions, this is a unit of work.
This is the master logic for saving and deleting entities from the datastore.