package com.googlecode.objectify.impl.translate;
import com.google.appengine.api.datastore.PropertyContainer;
import com.googlecode.objectify.impl.Path;
/**
* <p>A populator knows how to copy properties between POJO objects and a PropertiesContainer.
* Unlike a translator, it doesn't create the POJO or container.</p>
*
* <p>P is the pojo type.</p>
*
* @author Jeff Schnitzer <jeff@infohazard.org>
*/
public interface Populator<P>
{
/**
* <p>Loads the content of the specified datastore node, returning the pojo equivalent.</p>
*
* <p>There is one special value for loading: If a Result<?> is returned from a translator, the content of the
* Result will be used instead, but delayed until ctx.done() is called. This happens at the end of a "round"
* of load operations and is the magic trick that makes populating entity references work efficiently.</p>
*
* @param node is the part of the native datastore entity tree we are transforming.
* @param ctx holds state information during an entity load.
* @param path is the current path to this translator
* @param into is an optional parameter; sometimes we need to create an object at a higher level and pass it
* down through a stack of translators. Most translators will ignore this, but some will have special
* behavior, for example, this allows collections to be recycled.
*/
void load(PropertyContainer node, LoadContext ctx, Path path, P into);
/**
* Translates a pojo (or some component thereof) into a format suitable for storage in the datastore.
*
* @param pojo is an object from the pojo entity graph; possibly the whole graph or possibly just a leaf field.
* @param index is whether the instruction so far is to index or not index property values
* @param path is the path that we have taken to get here, which could be long due to re-entrant translators (ie,
* an embedded pojo that also has a reference to the same class).
*/
void save(P pojo, boolean index, SaveContext ctx, Path path, PropertyContainer into);
}