com.lhkbob.entreri.property

Interface Property

All Known Subinterfaces:

ShareableProperty<T>

All Known Implementing Classes:

BooleanProperty, ByteProperty, CharProperty, DoubleProperty, FloatProperty, IntProperty, LongProperty, ObjectProperty, ShortProperty

public interface Property

Property represents a generic field or property of a Component definition. A component can have multiple properties. A single property instance holds the corresponding values for every component of that type in an EntitySystem. It is effectively an indexed map from component index to property value.

This is an approach to mapped-objects where Components can be mapped onto primitive arrays so that iteration sees optimal cache locality. As an example, there could be two instances of type A, with properties a and b. The two 'a' properties would share the same data store, and the two 'b' properties would share another store.

All property implementations must expose two methods: T get(int) and void set(int, T) to get and set values at a particular index. To support primitives without boxing, they are not part of the interface definition but are required. The exposed get() and set() methods, and potentially a bulk accessor (such as returning the underlying array) are the supported methods for manipulating decorated property values.

Property instances are carefully managed by an EntitySystem. There is ever only one property instance per defined property in a component type for a system. Property instances are created by PropertyFactories. Every concrete Property class must be annotated with Factory to specify the PropertyFactory class that constructs it. That PropertyFactory must expose a no-argument constructor, or a constructor that takes an Attributes instance as its only argument.

Author:

Michael Ludwig

Method Summary

Methods

Modifier and Type	Method and Description
int	getCapacity() Get the current capacity of the property.
void	setCapacity(int size) Resize the internal storage to support indexed lookups from 0 to size - 1.
void	swap(int indexA, int indexB) Swap the value at indexA with indexB.

Method Detail

setCapacity

void setCapacity(int size)

Resize the internal storage to support indexed lookups from 0 to size - 1. If >size is less than the current capacity, all previous values with an index less than size must be preserved, and the remainder are discarded. If size is greater than the current capacity, all previous indexed values must be preserved and the new values can be undefined.

This is for internal use only to manage, and should not be called on decorated properties returned by EntitySystem.decorate(Class, PropertyFactory).

Parameters:

size - The new capacity, will be at least 1

getCapacity

int getCapacity()

Get the current capacity of the property. All instances must start with a capacity of at least 1. The capacity represents the number of component instances the property can handle. If a component property is decomposed into multiple primitives that is still a single value instance when considering the capacity.

This is for internal use only to manage, and should not be called on decorated properties returned by EntitySystem.decorate(Class, PropertyFactory).

Returns:

The current capacity of the property

swap

void swap(int indexA,
        int indexB)

Swap the value at indexA with indexB.

This is for internal use only to manage, and should not be called on decorated properties returned by EntitySystem.decorate(Class, PropertyFactory).

Parameters:

indexA - The index of the first value

indexB - The index of the second value