AbstractClassRep Class Reference

#include <consoleObject.h>

Inheritance diagram for AbstractClassRep:

Classes
struct	Field

Public Types
enum	ACRFieldTypes { StartGroupFieldType = 0xFFFFFFFD , EndGroupFieldType = 0xFFFFFFFE , DepricatedFieldType = 0xFFFFFFFF }
typedef bool(*	SetDataNotify) (void *obj, const char *data)
	This is a function pointer typedef to support get/set callbacks for fields.
typedef const char *(*	GetDataNotify) (void *obj, const char *data)
typedef bool(*	WriteDataNotify) (void *obj, const char *pFieldName)
	This is a function pointer typedef to support optional writing for fields.
typedef void(*	WriteCustomTamlSchema) (const AbstractClassRep *pClassRep, TiXmlElement *pParentElement)
	Allows the writing of a custom TAML schema.
typedef Vector< Field >	FieldList

Public Member Functions
	AbstractClassRep ()
virtual	~AbstractClassRep ()
S32	getClassId (U32 netClassGroup) const
const char *	getClassName () const
Namespace *	getNameSpace ()
AbstractClassRep *	getNextClass ()
AbstractClassRep *	getParentClass ()
virtual AbstractClassRep *	getContainerChildClass (const bool recurse)=0
virtual WriteCustomTamlSchema	getCustomTamlSchema (void)=0
bool	isClass (AbstractClassRep *acr)
	Helper class to see if we are a given class, or a subclass thereof.
virtual ConsoleObject *	create () const =0
const Field *	findField (StringTableEntry fieldName) const
AbstractClassRep *	findFieldRoot (StringTableEntry fieldName)
AbstractClassRep *	findContainerChildRoot (AbstractClassRep *pChild)

Static Public Member Functions
static void	registerClassRep (AbstractClassRep *)
static AbstractClassRep *	findClassRep (const char *in_pClassName)
static void	initialize ()
static void	destroyFieldValidators (AbstractClassRep::FieldList &mFieldList)
static U32	getClassCRC (U32 netClassGroup)
static AbstractClassRep *	getClassList ()

Public Attributes
FieldList	mFieldList
bool	mDynamicGroupExpand
S32	mClassGroupMask
	Mask indicating in which NetGroups this object belongs.
S32	mClassType
	Stores the NetClass of this class.
S32	mNetEventDir
	Stores the NetDirection of this class.
S32	mClassId [NetClassGroupsCount]
	Stores the IDs assigned to this class for each group.

Static Public Attributes
static U32	NetClassCount [NetClassGroupsCount][NetClassTypesCount] = {{0, },}
static U32	NetClassBitSize [NetClassGroupsCount][NetClassTypesCount] = {{0, },}

Protected Member Functions
virtual void	init () const =0

Static Protected Member Functions
static ConsoleObject *	create (const char *in_pClassName)
static ConsoleObject *	create (const U32 groupId, const U32 typeId, const U32 in_classId)

Protected Attributes
const char *	mClassName
AbstractClassRep *	nextClass
AbstractClassRep *	parentClass
Namespace *	mNamespace

Static Protected Attributes
static AbstractClassRep **	classTable [NetClassGroupsCount][NetClassTypesCount]
static AbstractClassRep *	classLinkList = NULL
static U32	classCRC [NetClassGroupsCount] = {INITIAL_CRC_VALUE, }
static bool	initialized = false

Friends
class	ConsoleObject

Detailed Description

Core functionality for class manipulation.

Introduction (or, Why AbstractClassRep?)

Many of Torque's subsystems, especially network, console, and sim, require the ability to programatically instantiate classes. For instance, when objects are ghosted, the networking layer needs to be able to create an instance of the object on the client. When the console scripting language runtime encounters the "new" keyword, it has to be able to fill that request.

Since standard C++ doesn't provide a function to create a new instance of an arbitrary class at runtime, one must be created. This is what AbstractClassRep and ConcreteClassRep are all about. They allow the registration and instantiation of arbitrary classes at runtime.

In addition, ACR keeps track of the fields (registered via addField() and co.) of a class, allowing programmatic access of class fields.

See also

ConsoleObject

Note

In general, you will only access the functionality implemented in this class via ConsoleObject::create(). Most of the time, you will only ever need to use this part part of the engine indirectly - ie, you will use the networking system or the console, or ConsoleObject, and they will indirectly use this code. The following discussion is really only relevant for advanced engine users.

NetClasses and Class IDs

Torque supports a notion of group, type, and direction for objects passed over the network. Class IDs are assigned sequentially per-group, per-type, so that, for instance, the IDs assigned to Datablocks are seperate from the IDs assigned to NetObjects or NetEvents. This can translate into significant bandwidth savings (especially since the size of the fields for transmitting these bits are determined at run-time based on the number of IDs given out.

AbstractClassRep Internals

Much like ConsoleConstructor, ACR does some preparatory work at runtime before execution is passed to main(). In actual fact, this preparatory work is done by the ConcreteClassRep template. Let's examine this more closely.

If we examine ConsoleObject, we see that two macros must be used in the definition of a properly integrated objects. From the ConsoleObject example:

     // This is from inside the class definition...
     DECLARE_CONOBJECT(TorqueObject);
 
// And this is from outside the class definition...
IMPLEMENT_CONOBJECT(TorqueObject);

What do these things actually do?

Not all that much, in fact. They expand to code something like this:

// This is from inside the class definition...
static ConcreteClassRep<TorqueObject> dynClassRep;
static AbstractClassRep* getParentStaticClassRep();
static AbstractClassRep* getStaticClassRep();
virtual AbstractClassRep* getClassRep() const;

// And this is from outside the class definition...
AbstractClassRep* TorqueObject::getClassRep() const { return &TorqueObject::dynClassRep; }
AbstractClassRep* TorqueObject::getStaticClassRep() { return &dynClassRep; }
AbstractClassRep* TorqueObject::getParentStaticClassRep() { return Parent::getStaticClassRep(); }
ConcreteClassRep<TorqueObject> TorqueObject::dynClassRep("TorqueObject", 0, -1, 0);

As you can see, getClassRep(), getStaticClassRep(), and getParentStaticClassRep() are just accessors to allow access to various ConcreteClassRep instances. This is where the Parent typedef comes into play as well - it lets getParentStaticClassRep() get the right class rep.

In addition, dynClassRep is declared as a member of TorqueObject, and defined later on. Much like ConsoleConstructor, ConcreteClassReps add themselves to a global linked list in their constructor.

Then, when AbstractClassRep::initialize() is called, from Con::init(), we iterate through the list and perform the following tasks:

• Sets up a Namespace for each class.
• Call the init() method on each ConcreteClassRep. This method:
  • Links namespaces between parent and child classes, using Con::classLinkNamespaces.
  • Calls initPersistFields() and consoleInit().
• As a result of calling initPersistFields, the field list for the class is populated.
• Assigns network IDs for classes based on their NetGroup membership. Determines bit allocations for network ID fields.

Member Typedef Documentation

FieldList

typedef Vector<Field> FieldList

GetDataNotify

typedef const char *(* GetDataNotify) (void *obj, const char *data)

SetDataNotify

typedef bool(* SetDataNotify) (void *obj, const char *data)

This is a function pointer typedef to support get/set callbacks for fields.

WriteCustomTamlSchema

typedef void(* WriteCustomTamlSchema) (const AbstractClassRep *pClassRep, TiXmlElement *pParentElement)

Allows the writing of a custom TAML schema.

WriteDataNotify

typedef bool(* WriteDataNotify) (void *obj, const char *pFieldName)

This is a function pointer typedef to support optional writing for fields.

Member Enumeration Documentation

ACRFieldTypes

enum ACRFieldTypes

Enumerator
StartGroupFieldType
EndGroupFieldType
DepricatedFieldType

Constructor & Destructor Documentation

AbstractClassRep()

AbstractClassRep ( )

inline

~AbstractClassRep()

virtual ~AbstractClassRep ( )

inlinevirtual

Member Function Documentation

create() [1/3]

virtual ConsoleObject * create ( ) const

pure virtual

Implemented in ConcreteClassRep< T >.

create() [2/3]

ConsoleObject * create ( const char * in_pClassName )

staticprotected

create() [3/3]

ConsoleObject * create ( const U32 groupId, const U32 typeId, const U32 in_classId )

staticprotected

destroyFieldValidators()

void destroyFieldValidators ( AbstractClassRep::FieldList & mFieldList )

static

findClassRep()

AbstractClassRep * findClassRep ( const char * in_pClassName )

static

findContainerChildRoot()

AbstractClassRep * findContainerChildRoot

(

AbstractClassRep *

pChild

)

findField()

const AbstractClassRep::Field * findField

(

StringTableEntry

fieldName

)

const

findFieldRoot()

AbstractClassRep * findFieldRoot

(

StringTableEntry

fieldName

)

getClassCRC()

U32 getClassCRC ( U32 netClassGroup )

inlinestatic

getClassId()

S32 getClassId ( U32 netClassGroup ) const

inline

getClassList()

AbstractClassRep * getClassList ( )

inlinestatic

getClassName()

const char * getClassName ( ) const

inline

getContainerChildClass()

virtual AbstractClassRep * getContainerChildClass ( const bool recurse )

pure virtual

Implemented in ConcreteClassRep< T >.

getCustomTamlSchema()

virtual WriteCustomTamlSchema getCustomTamlSchema ( void )

pure virtual

Implemented in ConcreteClassRep< T >.

getNameSpace()

Namespace * getNameSpace ( )

inline

getNextClass()

AbstractClassRep * getNextClass ( )

inline

getParentClass()

AbstractClassRep * getParentClass ( )

inline

init()

virtual void init ( ) const

protectedpure virtual

Implemented in ConcreteClassRep< T >.

initialize()

void initialize ( )

static

isClass()

bool isClass ( AbstractClassRep * acr )

inline

Helper class to see if we are a given class, or a subclass thereof.

registerClassRep()

void registerClassRep ( AbstractClassRep * in_pRep )

static

Friends And Related Symbol Documentation

ConsoleObject

friend class ConsoleObject

friend

Member Data Documentation

classCRC

U32 classCRC = {INITIAL_CRC_VALUE, }

staticprotected

classLinkList

AbstractClassRep * classLinkList = NULL

staticprotected

classTable

AbstractClassRep ** classTable

staticprotected

initialized

bool initialized = false

staticprotected

mClassGroupMask

S32 mClassGroupMask

Mask indicating in which NetGroups this object belongs.

mClassId

S32 mClassId[NetClassGroupsCount]

Stores the IDs assigned to this class for each group.

mClassName

const char* mClassName

protected

mClassType

S32 mClassType

Stores the NetClass of this class.

mDynamicGroupExpand

bool mDynamicGroupExpand

mFieldList

FieldList mFieldList

mNamespace

Namespace* mNamespace

protected

mNetEventDir

S32 mNetEventDir

Stores the NetDirection of this class.

NetClassBitSize

U32 NetClassBitSize = {{0, },}

static

NetClassCount

U32 NetClassCount = {{0, },}

static

nextClass

AbstractClassRep* nextClass

protected

parentClass

AbstractClassRep* parentClass

protected

---

The documentation for this class was generated from the following files:

• console/consoleObject.h
• console/consoleObject.cc