All Classes and Interfaces
Class
Description
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 Filter is a companion to the CachingAsyncDatastoreService, and must be
installed any time the CachingAsyncDatastoreService is used without Objectify.
The new datastore SDK has a neat structure of interfaces and implementations (transaction, datastorereader, etc)
but doesn't currently support async operations.
The new datastore SDK has a neat structure of interfaces and implementations (transaction, datastorereader, etc)
but doesn't currently support async operations.
The new datastore SDK has a neat structure of interfaces and implementations (transaction, datastorereader, etc)
but doesn't currently support async operations.
The new datastore SDK has a neat structure of interfaces and implementations (transaction, datastorereader, etc)
but doesn't currently support async operations.
This a simple strategy for storing BigDecimal in the datastore.
Stores BigMoney as its string representation.
Handle the native datastore Blob
Handle Boolean and boolean types
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 write-through memcache for Entity objects that works for both transactional
and nontransactional sessions.
A write-through memcache for Entity objects that works for both transactional
and nontransactional sessions.
CaptureType represents a wildcard that has gone through capture conversion.
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.
Stores a joda DateTimeZone as its String id.
The datastore can't store java.util.Date natively
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.
Translator which turns a Map<String, ?> into an EmbeddedEntity.
This annotation must be placed on your entity POJOs.
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.
Gives us the ability to compose arbitrarily complex filters with OR and AND sections.
The cloud sdk filtering API is somewhat hostile to programmatic query generation, so we need this adaptor
Floats are funky in the datastore.
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.
JMS: Copied verbatum from the original GAE SDK.
Utility class for doing reflection on types.
Just holds a value.
Converts keys-only query results into hybrid query results.
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 Ifinvalid input: '<'?, ?> condition class implements this interface, it will be called once just after construction.
If a Stringifierinvalid input: '<'?> implements this interface, it will be called once just after construction
with the actual Type of the key to stringify.
Handle java.time.Instant
Integers are funky in the datastore.
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 Keyinvalid input: '<'?> that was serialized with the KeySerializer
The new Cloud SDK has a new format for "url safe strings".
Configuring this serializer will make Keyinvalid input: '<'?> objects render as their web-safe string *when they are used as Map keys*.
Like MemcacheService but translates keys and values into forms more palatable to the low level service.
Figures out what to do with key fields on POJO entities.
Populates the @Id/@Parent fields from an Entity key
Deprecated.
Gives us a slightly more organized interface for manipulating keys.
Configuring this serializer will make Keyinvalid input: '<'?> objects render as their web-safe string.
Converts Objectify Keyinvalid input: '<'?>s to String.
Knows how to convert Keyinvalid input: '<'?> objects to datastore-native Key objects and vice-versa.
Handle the native datastore LatLng
A lifecycle method that can be executed on a POJO
Placed on an entity field of type Refinvalid input: '<'?>, 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.
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 Resultinvalid input: '<'?> 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.
The interface that all memory cache services must implement.
Dynamic proxy which wraps a MemcacheService and adds retries when an exception occurs.
Interface for tracking hit rates of the entity memcache.
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.
When placed on an entity field of type String, the value will be used as a namespace
for saving the entity.
A simple thread local namespace manager, similar to legacy GAE's
NamespaceManager.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.
This is the main "business end" of Objectify.
ObjectifyFactory encapsulates a connection to a single datastore, and allows the datastore
to be queries and manipulated.
Deprecated.
use
ObjectifyService.Filter or ObjectifyService.FilterJavax insteadImplementation of the Objectify interface.
Call jackson's
ObjectMapper.registerModule(new ObjectifyJacksonModule()) to enable
intelligent serialization and deserialization of various Objectify and GAE classes.Encapsulates the various options that can be twiddled in an objectify session.
Most applications connect to a single datastore.
This version is for the newer jakarta.servlet.* API.
This version is for the older javax.servlet.* API.
In case someone has a field of type Object or uses a raw collection without specifying the generic type.
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 Futureinvalid input: '<'?> 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 the native datastore representation.
A private interface for manipulating transactions.
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.
Some static utility methods for interacting with basic datastore objects like keys and queries.
The basic options for a typed Query.
The SDK Query hierarchy and associated builders make it hard to convert between keys-only
entity, and projection.
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.
Replaces a class from the old GAE SDK.
Handle the native datastore FullEntity
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.
Handle the native datastore Key
Just in case anyone has a
Value<?> field.Converts Joda ReadableInstants (DateTime, DateMidnight, etc) into Timestamp
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.
Refinvalid input: '<'?> is a Keyinvalid input: '<'?> which allows the entity value to be fetched directly.
Will deserialize an Objectify Refinvalid input: '<'?> that was serialized with the RefSerializer.
Like RefSerializer, but handles Refs when they are used as Map keys.
Serializing Refinvalid input: '<'?> 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 Refinvalid input: '<'?> 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 Resultinvalid input: '<'?>
A dynamic proxy that wraps a Resultinvalid input: '<'?> value.
Translates from one arbitrary thing to a Result of another arbitrary thing, caching the value.
Associates a result value with a cursor.
Turns QueryResults into an iterator of the {result, cursor} tuple
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).
Simplest base class for most value translations.
Thrown by any Translator that wants its value to be skipped.
Among the issues this impl needs to be concerned with is that memcached doesn't store nulls.
The datastore can't store java.sql.Date natively
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.
Handle the native datastore Timestamp
Converts java.util.TimeZone
Simple pass-through to the base methods.
Determines the transactional behavior of an ObjectifyImpl instance.
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
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 Futureinvalid input: '<'?> 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.
Some static utility methods for interacting with
Value<?>Translator that should be extended for typical atomic values.
Provides a little boilerplate for translators that work on simple atomic types.
Deprecated.
There are overloads for etc that take a instead.
For executing transactions, this is a unit of work.
This is the master logic for saving and deleting entities from the datastore.
List<Key<T>>instead.