Exponent::Basics::CClass Class Reference

Detailed Description

Class representation class.

CClass stores information about a class. Every object in the exponent
API that is dynamically available (ie - non static classes, and classes
without entirely static functions should have a CClass
Currently CClass only stores the name of the class, this will change in future
versions of the API.
Macros are setup so that you can easily implement the correct style of class handling
When you write a class, simply perform the following steps:

Include the macro EXPONENT_CLASS_DECLARATION BEFORE the openeing public statement. Ie it should be the first thing in your classes opening bracket
In the class cpp file place the macro EXPONENT_CLASS_IMPLEMENTATION at the top of the file
In the case of a template class use the macro EXPONENT_TEMPLATE_CLASS_IMPLEMENTATION instead
Inside the constructor place the macro EXPONENT_CLASS_CONSTRUCTION (This ensure that the correct class count is maintained)
Inside the destructor place the macro EXPONENT_CLASS_DESTRUCTION (This ensure that the correct class count is maintained)

Code is better than a thousand bullet points ;)

Header (myClass.hpp)

 class myClass : public CCountedObject
 {
      EXPONENT_CLASS_DECLARATION;
 public:

      // Whatever
      ...
 };

Implementation (myClass.cpp)

 EXPONENT_CLASS_IMPLEMENTATION(myClass, myClassParent);

 myClass::myClass()
 {
     EXPONENT_CLASS_CONSTRUCTION(myClass);
      // Whatever
      ...
 }

 myClass::~myClass()
 {
     EXPONENT_CLASS_DESTRUCTION(myClass);
       // Whatever
     // ...
 }

See also:

CClassManager

EXPONENT_CLASS_DECLARATION

EXPONENT_CLASS_IMPLEMENTATION

EXPONENT_CLASS_CONSTRUCTION

EXPONENT_CLASS_DESTRUCTION

EXPONENT_TEMPLATE_CLASS_IMPLEMENTATION

Date:: 28/02/2005

Author:: Paul Chana

Version:: 1.0.0 Initial version
1.1.0 Converted to split class/header files to ensure proper handling in other classes

Note:: All contents of this source code are copyright 2005 Exp Digital Uk.
This source file is covered by the licence conditions of the Infinity API. You should have recieved a copy
with the source code. If you didnt, please refer to http://www.expdigital.co.uk All content is the Intellectual property of Exp Digital Uk.
Certain sections of this code may come from other sources. They are credited where applicable.
If you have comments, suggestions or bug reports please visit http://support.expdigital.co.uk

Id: CClass.hpp,v 1.10 2007/02/08 21:06:44 paul Exp

Definition at line 96 of file CClass.hpp.

Public Member Functions

CClass (const CClass &theClass)
CClass ()
CClass (const char *templateName, const std::type_info &theType, const char *parentName, const std::type_info &parentType)
CClass (const char *templateName, const std::type_info &theType, const char *parentName)
CClass (const char *templateName, const std::type_info &theType)
CClass (const char *className, const char *parentName)
CClass (const char *className)
const char * getClassName () const
long getCurrentInstanceCount () const
long getTotalNumberOfClassConstructions () const
bool isSubClassOf (const CClass &other) const
bool isTypeOf (const CClass &other) const
bool isTypeOf (const char *className) const
void operator++ (int)
void operator-- (int)
CClass & operator= (const CClass &other)
bool operator== (const CClass &other) const
void setClassInformation (const char *className)
virtual ~CClass ()

Static Public Member Functions

static int compareClasses (const CClass **class1, const CClass **class2)
static void deleteClassManager (const char *filePath)
static CClassManager * getClassManager ()

Static Public Attributes

static const long CCLASS_MAX_CLASSNAME_LENGTH = 128

Static Protected Member Functions

static bool computeTemplateName (const char *templateName, const std::type_info &theType, char *theBuffer, const long bufferSize)

Protected Attributes

char m_className [CCLASS_MAX_CLASSNAME_LENGTH]
long m_instanceCount
long m_maxInstanceCount
char m_parentName [CCLASS_MAX_CLASSNAME_LENGTH]

Static Protected Attributes

static CClassManager * CCLASSCLASS_MANAGER

Constructor & Destructor Documentation

Exponent::Basics::CClass::CClass ( const char * className )

Construction with the name of the class

Parameters:

className

The name of the class

Exponent::Basics::CClass::CClass	(	const char *	className,
		const char *	parentName
	)

Construction with the name of the class and its parent

Parameters:

	className	The name of the class
	parentName	The name of the parent

Exponent::Basics::CClass::CClass	(	const char *	templateName,
		const std::type_info &	theType
	)

Construction for use with templates when the parent is nothing

Parameters:

	templateName	The name of the template (of the form Name<TypeName>)
	theType	The type of the type (whatever it is)

Exponent::Basics::CClass::CClass	(	const char *	templateName,
		const std::type_info &	theType,
		const char *	parentName
	)

Construction for use with templates when the parent is a counted object type

Parameters:

	templateName	The name of the template (of the form Name<TypeName>)
	theType	The type of the type (whatever it is)
	parentName	The name of the parent

Exponent::Basics::CClass::CClass	(	const char *	templateName,
		const std::type_info &	theType,
		const char *	parentName,
		const std::type_info &	parentType
	)

Construction for use with templates when the parent is a template

Parameters:

	templateName	The name of the template (of the form Name<TypeName>)
	theType	The type of the type (whatever it is)
	parentName	The name of the parent
	parentType	The type of the type (whatever it is)

Exponent::Basics::CClass::CClass ( )

Default construction

Exponent::Basics::CClass::CClass ( const CClass & theClass )

Copy construction

Parameters:

theClass

The class to copy

virtual Exponent::Basics::CClass::~CClass ( ) [virtual]

Destruction

Member Function Documentation

static int Exponent::Basics::CClass::compareClasses	(	const CClass **	class1,
		const CClass **	class2
	)			`[static]`

Comparison for a qsort

Parameters:

	class1	The first class
	class2	The second class

Return values:

class1 goes before class2 0 class1 == class2 >0 class1 goes after class2

See also:: CClassManager::classCompareFunction
TPointerCollection::qsortCompare

static bool Exponent::Basics::CClass::computeTemplateName	(	const char *	templateName,
		const std::type_info &	theType,
		char *	theBuffer,
		const long	bufferSize
	)			`[static, protected]`

Compute a template typename combination

Return values:

CClass

The class that is constructed

Parameters:

	templateName	The name of the template (of the form Name<TypeName>)
	theType	The type of the type (whatever it is)
	theBuffer	The buffer to write to
	bufferSize	The size of the buffer

Note:: NOT INTENDED FOR PUBLIC USE. THIS IS AN INTERNAL FUNCTION THAT IS REQUIRED TO BE PUBLIC BY ITS NATURE. YOU ARE NOT EXPECTED TO DIRECTLY CALL THIS
UNLESS YOU ABSOLUTELY TOTALLY KNOW WHAT YOU ARE DOING

static void Exponent::Basics::CClass::deleteClassManager ( const char * filePath ) [static]

Delete the class manager

Parameters:

filePath

The path to write out the class information

static CClassManager* Exponent::Basics::CClass::getClassManager ( ) [inline, static]

Get the class manager

Return values:

CClassManager*

The class manager

Definition at line 294 of file CClass.hpp.

References CCLASSCLASS_MANAGER.

const char* Exponent::Basics::CClass::getClassName ( ) const [inline]

Get the name of the class

Return values:

const

char* The class name

Definition at line 213 of file CClass.hpp.

References m_className.

long Exponent::Basics::CClass::getCurrentInstanceCount ( ) const [inline]

Get the current instance count

Return values:

long

The number of instances of this class that were created and not destroyed (ie still alive)

Definition at line 282 of file CClass.hpp.

References m_instanceCount.

long Exponent::Basics::CClass::getTotalNumberOfClassConstructions ( ) const [inline]

Get total number of this class constructed thus far

Return values:

long

The total number of classes created thus far

Definition at line 288 of file CClass.hpp.

References m_maxInstanceCount.

bool Exponent::Basics::CClass::isSubClassOf ( const CClass & other ) const

Check if this class is a sub class of another class

Note:

 class a {  };
 class b : public a {  }

 b *myObject = new b;

 if (myObject->getObjectClass().isSubClassOf(a::getClass()))
 {
     cout << "It is a sub type" << endl;
 }
 else
 {
     cout << "It is not a sub type" << endl;
 }

Parameters:

other

The class of the type that you want to check that this is

Return values:

bool

True if class passed is a parent type of this

bool Exponent::Basics::CClass::isTypeOf ( const CClass & other ) const

Check if this class is of a specific type

Note:

This is purely a run time type information. Do not rely on this information to be cross platform available or even
the same within different instanciations of the program. Inside the program you can rely on this information, however, dont assume that the name of the object
in the code (for example CString) will be the same as the name in the class info. They may be different!
Also note that this is the specific type of class ie if you have class a and class b : public a, this function will return false for:
objectOfClassB->isTypeOf(b::getClass())

 if (myObject->getObjectClass().isTypeOf(SomeClass::getClass()))
 {
     cout << "It is of the same type" << endl;
 }
 else
 {
     cout << "It is of a different type" << endl;
 }

 // Or for templates
 if (myObject->getObjectClass().isTypeOf(SomeClass<CString>::getClass()))
 // Handle here

Parameters:

other

The class of the type that you want to check that this is

Return values:

bool

True if class names are equal, false otherwise

bool Exponent::Basics::CClass::isTypeOf ( const char * className ) const

Check if this class is of a specific type.

Note:: that this function is not a recommended function, due to the name mangling which may occur during template use
although it is usually safe on CCountedObject inheritors that are not templates