Photon C++ Client API
Static Public Member Functions | Static Public Attributes | List of all members
CustomType< typeCode > Class Template Reference
Inheritance diagram for CustomType< typeCode >:
Inheritance graph
Collaboration diagram for CustomType< typeCode >:
Collaboration graph

Static Public Member Functions

static void constructClass (const CustomTypeFactory< typeCode > &factory)
static void deconstructClass (void)
- Static Public Member Functions inherited from Base
static void setListener (const BaseListener *baseListener)
static int getDebugOutputLevel (void)
static bool setDebugOutputLevel (int debugLevel)
static const LogFormatOptionsgetLogFormatOptions (void)
static void setLogFormatOptions (const LogFormatOptions &options)

Static Public Attributes

static const nByte TypeCode

Additional Inherited Members

- Public Member Functions inherited from CustomTypeBase
virtual void cleanup (void)=0
virtual bool compare (const CustomTypeBase &other) const =0
virtual void duplicate (CustomTypeBase *pRetVal) const =0
virtual void deserialize (const nByte *pData, short length)=0
virtual short serialize (nByte *pRetVal) const =0
- Public Member Functions inherited from Base
virtual ~Base (void)
- Public Member Functions inherited from ToString
virtual ~ToString (void)
virtual JString typeToString (void) const
virtual JStringtoString (JString &retStr, bool withTypes=false) const =0
JString toString (bool withTypes=false) const

Detailed Description

template<nByte typeCode>
class ExitGames::Common::CustomType< typeCode >

The CustomType class provides you with an interface, to add support for additional data-types.

We only support a certain subset of Datatypes out of the box. If you need support for further datatypes, then you can easily add this support yourself by subclassing this class template and providing suitable implementations for the pure virtual functions, which are inherited from CustomTypeBase, in your subclass. You should only subclass every typecode once. typeCode 0 should be considered as reserved. So your first custom type would inherit from CustomType<1>, the second one from CustomType<2> and so on. Subclassing the same typecode multiple times will lead into undefined behavior as the typecode will determine the class as instance of which serialized data should be interpreted.

When you are subclassing a specialization of CustomType, then you will also have to subclass the according specialization of CustomTypeFactory (the one for the same typecode).
See also
CustomTypeBase, CustomTypeFactory

Member Function Documentation

§ constructClass()

void constructClass ( const CustomTypeFactory< typeCode > &  factory)

This static function initializes the class and has to be called once before any instance of a concrete subclass gets created. It registers the typecode and sets the factory-class to a copy of the passed parameter.

See also
factoryan instance of the factory class, which will be used to create instances of this class

§ deconstructClass()

void deconstructClass ( void  )

This static function cleans up the class and has to be called once after the last instance of a concrete subclass has been deallocated. It will then deallocate the shared instance of the according CustomTypeFactory subclass.

See also

Member Data Documentation

§ TypeCode


Check this public constant to find out the typecode of a custom type at runtime. This should normally not be of any interest.