// Registering the reference type r = engine->RegisterObjectType("ref", 0, asOBJ_REF); assert( r >= 0 );
The default factory function doesn't take any parameters and should return an object handle for the new object. Make sure the object's reference counter is accounting for the reference being returned by the factory function, so that the object is properly released when all references to it are removed.
CRef::CRef() { // Let the constructor initialize the reference counter to 1 refCount = 1; } CRef *Ref_Factory() { // The class constructor is initializing the reference counter to 1 return new CRef(); } // Registering the factory behaviour r = engine->RegisterObjectBehaviour("ref", asBEHAVE_FACTORY, "ref@ f()", asFUNCTION(Ref_Factory), asCALL_CDECL); assert( r >= 0 );
You may also register factory functions that take parameters, which may then be used when initializing the object.
The factory function must be registered as a global function, but can be implemented as a static class method, common global function, or a global function following the generic calling convention.
void CRef::Addref() { // Increase the reference counter refCount++; } void CRef::Release() { // Decrease ref count and delete if it reaches 0 if( --refCount == 0 ) delete this; } // Registering the addref/release behaviours r = engine->RegisterObjectBehaviour("ref", asBEHAVE_ADDREF, "void f()", asMETHOD(CRef,AddRef), asCALL_THISCALL); assert( r >= 0 ); r = engine->RegisterObjectBehaviour("ref", asBEHAVE_RELEASE, "void f()", asMETHOD(CRef,Release), asCALL_THISCALL); assert( r >= 0 );
CRef &CRef::operator =(const CRef &other) { // Copy everything from the other class, except the reference counter } // Registering the assignment behaviour r = engine->RegisterObjectBehaviour("ref", asBEHAVE_ASSIGNMENT, "ref &f(const &in)", asMETHOD(CRef,operator=), asCALL_THISCALL); assert( r >= 0 );
The assignment behaviour can be overloaded with other types if that is desired, that way the script writer doesn't have to manually convert the expressions before assigning the values to the type.
This would be used when the application has a limited number of objects available and doesn't want to create new ones. For example singletons, or pooled objects.
The reference can be passed to the script through a property, either global or a class member, or it can be returned from an application registered function or class method.
// Registering the type so that it cannot be instanciated // by the script, nor allow scripts to store references to the type r = engine->RegisterObjectType("single", 0, asOBJ_REF | asOBJ_NOHANDLE); assert( r >= 0 );
This sort of type is most useful when you want to have complete control over references to an object, for example so that the application can destroy and recreate objects of the type without having to worry about potential references held by scripts. This allows the application to control when a script has access to an object and it's members.
A scoped reference type will have the life time controlled by the scope of the variable that instanciate it, i.e. as soon as the variable goes out of scope the instance is destroyed. This means that the type doesn't permit handles to be taken for the type.
A scoped reference type requires two behaviours to be registered, the factory and the release behaviour. The addref behaviour is not permitted.
Since no handles can be taken for the object type, there is no need to keep track of the number of references held to the object. This means that the release behaviour should simply destroy and deallocate the object as soon as it's called.
scoped *Scoped_Factory() { return new scoped; } void Scoped_Release(scoped *s) { if( s ) delete s; } // Registering a scoped reference type r = engine->RegisterObjectType("scoped", 0, asOBJ_REF | asOBJ_SCOPED); assert( r >= 0 ); r = engine->RegisterObjectBehaviour("scoped", asBEHAVE_FACTORY, "scoped @f()", asFUNCTION(Scoped_Factory), asCALL_CDECL); assert( r >= 0 ); r = engine->RegisterObjectBehaviour("scoped", asBEHAVE_RELEASE, "void f()", asFUNCTION(Scoped_Release), asCALL_CDECL_OBJLAST); assert( r >= 0 );