Package repast.simphony.freezedry.freezedryers.proj

Class ProjectionDryer<T extends Projection>

java.lang.Object

repast.simphony.freezedry.freezedryers.proj.ProjectionDryer<T>

Direct Known Subclasses:

ContinuousProjectionDryer, GeographyProjectionDryer, GridProjectionDryer2, NetworkProjectionDryer

public abstract class ProjectionDryer<T extends Projection>
extends Object

Implementations of this class will handle storing settings for some projections. Implementations should override the handles(Class), #addProperties(Context, T, Map), instantiate(Context, Map), and #loadProperties(Context, T, Map) methods.

By default this adds (through it's static {}) a NetworkProjectionDryer, a ContinuousProjectionDryer, and a repast.simphony.freezedry.freezedryers.proj.GridProjectionDryer.

Author:

Jerry Vos

See Also:

handles(Class), #addProperties(Context, T, Map), instantiate(Context, Map), #loadProperties(Context, T, Map)

Field Summary

Fields

Modifier and Type	Field	Description
static String	CONTEXT_LISTENING_KEY
static String	NAME_KEY
static String	PROJ_LISTENING_KEY

Constructor Summary

Constructors

Constructor	Description
ProjectionDryer()

Method Summary

Modifier and Type	Method	Description
static void	addProjectionDryer(ProjectionDryer dryer)	Adds a dryer to be used by the ContextFreezeDryer.
protected abstract void	addProperties(Context<?> context, T t, Map<String,Object> properties)	Called when attempting to save the given projection.
T	buildAndAddProjection(Context<?> context, Map<String,Object> properties)	Creates a projection based on the given properties.
static <T extends Projection> ProjectionDryer<T>	getDryer(Class<T> type)	Retrieves the last added dryer that handles the given type.
Map<String,Object>	getProperties(Context<?> context, T t)	Retrieves the serializable properties for a given projection that is a member of the given context.
abstract boolean	handles(Class<?> type)	This should return true if the implementation handles projections of the given type.
protected abstract T	instantiate(Context<?> context, Map<String,Object> properties)	Should createa a Projection for the given context.
protected void	loadProperties(Context<?> context, T proj, Map<String,Object> properties)	This handles loading of properties into the instantiated projection.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

NAME_KEY

public static final String NAME_KEY

See Also:

Constant Field Values

PROJ_LISTENING_KEY

public static final String PROJ_LISTENING_KEY

See Also:

Constant Field Values

CONTEXT_LISTENING_KEY

public static final String CONTEXT_LISTENING_KEY

See Also:

Constant Field Values

Constructor Detail

ProjectionDryer

public ProjectionDryer()

Method Detail

addProperties

protected abstract void addProperties(Context<?> context,
                                      T t,
                                      Map<String,Object> properties)

Called when attempting to save the given projection. Implementations should store the settings they require to build the projection later during this method, and also call their super's method so that it can store its properties.

Parameters:

context - the context this projection is a member of

t - the projection to store properties for

properties - a place to store the properties for a projection

instantiate

protected abstract T instantiate(Context<?> context,
                                 Map<String,Object> properties)

Should createa a Projection for the given context. Implementing classes do not have to add the created projection to the context, that will be done after calling this method.

Parameters:

context - the context the projection will be a member of

properties - the properties specified when saving the projection

Returns:

a created projection

handles

public abstract boolean handles(Class<?> type)

This should return true if the implementation handles projections of the given type.

Parameters:

type - the type of the projection

Returns:

if the implementation handles the given type

loadProperties

protected void loadProperties(Context<?> context,
                              T proj,
                              Map<String,Object> properties)

This handles loading of properties into the instantiated projection. Implementations should override this method and load their properties here. If the properties are loaded in their instantiate(Context, Map) method, then if a subclass overrides the instantiate method it will have to duplicate the property loading (or that loading will not be done).

Implementations should call their super's #loadProperties(Context, T, Map) method so that all properties can be loaded.

This implementation loads the projection as a context listener (if it originally one) and the context as a projection listener if it was. This then adds the projection to the context.

Parameters:

context - the context the projection is a member of

proj - the projection that was instantiated

properties - the properties that should be used to loaded into the projection

getProperties

public Map<String,Object> getProperties(Context<?> context,
                                              T t)

Retrieves the serializable properties for a given projection that is a member of the given context. These properties should be reloaded and passed to the buildAndAddProjection(Context, Map) method when deserializing the projection.

Parameters:

context - the context the projection is a member of

t - the projection to serialize

Returns:

a Map of properties used to recreate the given projection

See Also:

for retrieving the dryer of the projection type

buildAndAddProjection

public T buildAndAddProjection(Context<?> context,
                               Map<String,Object> properties)

Creates a projection based on the given properties. It will also add the created projection to the given context.

Parameters:

context - the context to build a projection for

properties - the properties for building the projection

Returns:

the created projection

addProjectionDryer

public static void addProjectionDryer(ProjectionDryer dryer)

Adds a dryer to be used by the ContextFreezeDryer. This will be added to the front of the dryer list, so it will override any equivalent dryer added before it that dries the same class.

Parameters:

dryer - a projection dryer

getDryer

public static <T extends Projection> ProjectionDryer<T> getDryer(Class<T> type)

Retrieves the last added dryer that handles the given type. If none is found this returns null.

Parameters:

type - the projection type to dry

Returns:

a dryer for the given type