/**

\page doc_use_script_class Using script classes 

When there are multiple objects controlled by the same script implementation it may be favourable to use script classes,
rather than global script functions. Using script classes each instance can have it's own set of variables within the 
class, contrary to the global functions that needs to rely on global variables to store persistent information. 

Of course, it would be possible to duplicate the script modules, so that there is one module for each object instance, but
that would be impose a rather big overhead for the application. Script classes don't have that overhead, as all instances
share the same module, and thus the same bytecode and function ids, etc. 





\section doc_use_script_class_1 Instanciating the script class

Before instanciating the script class you need to know which class to instanciate. Exactly how this is done 
depends on the application, but here are some suggestions.

If the application knows the name of the class, either hardcoded or from some configuration, the class type
can easily be obtained by calling the module's \ref asIScriptModule::GetTypeIdByDecl "GetTypeIdByDecl" with the name
of the class. The application can also choose to identify the class through some properties of the class, e.g.
if the class implements a predefined \ref asIScriptEngine::RegisterInterface "interface". Then the application 
can enumerate the class types implemented in the script with \ref asIScriptModule::GetObjectTypeByIndex "GetObjectTypeByIndex"
and then examine the type through the \ref asIObjectType interface.

A third option, if you're using the \ref doc_addon_build "script builder add-on", is to use the metadata to identify
the class. If you choose this option, use the \ref asIScriptModule to enumerate the declared types and then query the
\ref doc_addon_build "CScriptBuilder" for their metadata.

Once the object type is known you create the instance by calling the class' factory function, passing it the necessary
arguments, e.g. a pointer to the application object which the script class should be bound to. The factory function id
is found by querying the \ref asIObjectType. 

\code
// Get the object type
asIScriptModule *module = engine->GetModule("MyModule");
asIObjectType *type = engine->GetObjectTypeById(module->GetTypeIdByDecl("MyClass"));

// Get the factory function id from the object type
int factoryId = type->GetFactoryIdByDecl("MyClass @MyClass()");

// Prepare the context to call the factory function
ctx->Prepare(factoryId);

// Execute the call
ctx->Execute();

// Get the object that was created
asIScriptObject *obj = *(asIScriptObject**)ctx->GetAddressOfReturnValue();

// If you're going to store the object you must increase the reference,
// otherwise it will be destroyed when the context is reused or destroyed.
obj->AddRef();
\endcode

The factory function is \ref doc_call_script_func "called as a regular global function" and returns a handle to 
the newly instanciated class.





\section doc_use_script_class_2 Calling a method on the script class

Calling the methods of the script classes are similar to \ref doc_call_script_func "calling global functions" except
that you obtain the function id from the \ref asIObjectType, and you must set the object pointer along with the 
rest of the function arguments.

\code
// Obtain the id of the class method
int funcId = type->GetMethodIdByDecl("void method()");

// Prepare the context for calling the method
ctx->Prepare(funcId);

// Set the object pointer
ctx->SetObject(obj);

// Execute the call
ctx->Execute();
\endcode





\section doc_use_script_class_3 Receiving script classes

In order for the application to register a function that receives a script class it must first know the type. Of course,
since the class is declared in the script it isn't possible to know the type before the script is compiled. Instead the 
application can register an interface with the engine. The function can then be registered to receive a handle to that interface.

\code
// Register an interface
engine->RegisterInterface("IMyObj");

// You can also register methods with the interface if you wish to force the script class to implement them
engine->RegisterInterfaceMethod("IMyObj", "void RequiredMethod()");

// Register a function that receives a handle to the interface
engine->RegisterGlobalFunction("void ReceiveMyObj(IMyObj @obj)", asFUNCTION(ReceiveMyObj), asCALL_CDECL);
\endcode

The function that receives the interface should be implemented to take a pointer to an \ref asIScriptObject. 

\code
asIScriptObject *gObj = 0;
void ReceiveMyObj(asIScriptObject *obj)
{
  // Do something with the object
  if( obj )
  {
    if( doStore )
    {
      // If the object is stored, we shouldn't release the handle
      gObj = obj;
    }
    else
    {
      // If the object is not stored, we must release the handle before returning
      obj->Release();
    }
  }
}
\endcode

If you don't want to use interfaces like this, then you may want to look into the \ref doc_adv_var_type "variable argument type" or the generic container \ref doc_addon_any "any add-on", which are ways that can be used to receive values and objects of which the type is not known beforehand.



*/
