Shared Class Facility (SCF)
Classes | |
struct | iBase |
This is the basic interface: all other interfaces should be derived from this one, this will allow us to always use at least some minimal functionality given any interface pointer. More... | |
struct | iFactory |
iFactory is an interface that is used to create instances of shared classes. More... | |
class | scfInterface< T > |
Interface query class. More... | |
struct | iSCF |
iSCF is the interface that allows using SCF functions from shared classes. More... | |
struct | iComponent |
This interface describes a generic component in Crystal Space. More... | |
struct | iObjectRegistry |
This interface serves as a registry of other objects. More... | |
struct | iObjectRegistryIterator |
Use an instance of this class to iterate over objects in the object registry. More... | |
struct | iPluginIterator |
An iterator to iterate over all plugins in the plugin manager. More... | |
struct | iPluginManager |
This is the plugin manager. More... | |
Defines | |
#define | SCF_DECLARE_IBASE_POOLED(parentClass) SCF_DECLARE_IBASE_POOLED_DECL(class, parentClass) |
Embed this macro instead of SCF_DECLARE_IBASE into an SCF class that is to be pooled. | |
#define | SCF_DECLARE_IBASE_POOLED_EXTERN(Extern, parentClass) SCF_DECLARE_IBASE_POOLED_DECL(class Extern, parentClass) |
Same as SCF_DECLARE_IBASE_POOLED, use for external classes. | |
#define | SCF_CONSTRUCT_IBASE_POOLED(Pool) |
Has to be invoked inside the class constructor instead of SCF_CONSTRUCT_IBASE. | |
#define | SCF_IMPLEMENT_IBASE_POOL_CTOR(Class) |
Implement the constructor for the pool manager of Class. | |
#define | SCF_IMPLEMENT_IBASE_POOL_DTOR(Class) |
Implement the destructor for the pool manager of Class. | |
#define | SCF_IMPLEMENT_IBASE_POOL_ALLOC(Class) |
Implement Alloc() for the pool manager of Class. | |
#define | SCF_IMPLEMENT_IBASE_POOL_RECYCLE(Class) |
Implement Recycle() for the pool manager of Class. | |
#define | SCF_IMPLEMENT_IBASE_POOL(Class) |
Implement pool manager for Class. | |
#define | SCF_IMPLEMENT_IBASE_INCREF_POOLED(Class) |
Implement IncRef() for a pooled class. | |
#define | SCF_IMPLEMENT_IBASE_DECREF_POOLED(Class) |
Implement DecRef() for a pooled class. | |
#define | SCF_IMPLEMENT_IBASE_POOLED(Class) |
Use this in the source module instead of SCF_IMPLEMENT_IBASE. | |
#define | SCF_IMPLEMENT_DEFAULT_POOLRECYCLE(Class) void Class::PoolRecycle () { } |
Implement a default Class::PoolRecycle(). | |
#define | SCF_TRACE(x) |
Macro for typing debug strings: Add #define SCF_DEBUG at the top of modules you want to track miscelaneous SCF activity and recompile. | |
#define | SCF_PRINT_CALL_ADDRESS |
Macro for getting the address we were called from (stack backtracing). | |
#define | SCF_CONSTRUCT_VERSION(Major, Minor, Micro) ((Major << 24) | (Minor << 16) | Micro) |
Use this macro to construct interface version numbers. | |
#define | SCF_DECLARE_IBASE |
This macro should be embedded into any SCF-capable class definition to declare the minimal functionality required by iBase interface. | |
#define | SCF_DECLARE_EMBEDDED_IBASE(OuterClass) |
SCF_DECLARE_EMBEDDED_IBASE is used to declare the methods of iBase inside an embedded class that is exposed via QueryInterface... | |
#define | SCF_CONSTRUCT_IBASE(Parent) |
The SCF_CONSTRUCT_IBASE macro should be invoked inside the constructor of a class (not inside an embedded interface). | |
#define | SCF_CONSTRUCT_EMBEDDED_IBASE(Interface) |
The SCF_CONSTRUCT_EMBEDDED_IBASE macro should be invoked inside the constructor of a class that has an embedded interface (not inside the constructor of the embedded interface). | |
#define | SCF_DESTRUCT_IBASE() |
The SCF_DESTRUCT_IBASE macro should be invoked inside the destructor of a class (not inside an embedded interface). | |
#define | SCF_DESTRUCT_EMBEDDED_IBASE(Interface) |
The SCF_DESTRUCT_EMBEDDED_IBASE macro should be invoked inside the destructor of a class that has an embedded interface (not inside the destructor of the embedded interface). | |
#define | SCF_IMPLEMENT_IBASE_INCREF(Class) |
The SCF_IMPLEMENT_IBASE_INCREF() macro implements the IncRef() method for a class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_DECREF(Class) |
The SCF_IMPLEMENT_IBASE_DECREF() macro implements the DecRef() method for a class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_REMOVE_REF_OWNERS(Class) |
The SCF_IMPLEMENT_IBASE_REMOVE_REF_OWNERS() macro implements the scfRemoveRefOwners() method for a class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_REFOWNER(Class) |
The SCF_IMPLEMENT_IBASE_REFOWNER() macro implements the AddRefOwner() and RemoveRefOwner() for a weak reference. | |
#define | SCF_IMPLEMENT_IBASE_GETREFCOUNT(Class) |
The SCF_IMPLEMENT_IBASE_GETREFCOUNT() macro implements GetRefCount() for a class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_QUERY(Class) |
The SCF_IMPLEMENT_IBASE_QUERY() macro implements the opening boilerplate for the QueryInterface() method for a class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_QUERY_END |
The SCF_IMPLEMENT_IBASE_QUERY_END macro implements the closing boilerplate for the QueryInterface() method for a class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE(Class) |
The SCF_IMPLEMENT_IBASE() macro should be used within the C++ source module that implements a interface derived from iBase. | |
#define | SCF_IMPLEMENT_IBASE_END SCF_IMPLEMENT_IBASE_QUERY_END |
The SCF_IMPLEMENT_IBASE_END macro is used to finish an SCF_IMPLEMENT_IBASE definition. | |
#define | SCF_IMPLEMENT_EMBEDDED_IBASE_INCREF(Class) |
The SCF_IMPLEMENT_EMBEDDED_IBASE_INCREF() macro implements the IncRef() method for an embedded class in a C++ source module. | |
#define | SCF_IMPLEMENT_EMBEDDED_IBASE_DECREF(Class) |
The SCF_IMPLEMENT_EMBEDDED_IBASE_DECREF() macro implements the DecRef() method for an embedded class in a C++ source module. | |
#define | SCF_IMPLEMENT_EMBEDDED_IBASE_GETREFCOUNT(Class) |
The SCF_IMPLEMENT_EMBEDDED_IBASE_GETREFCOUNT() macro implements the GetRefCount() method for an embedded class in a C++ source module. | |
#define | SCF_IMPLEMENT_EMBEDDED_IBASE_REFOWNER(Class) |
The SCF_IMPLEMENT_EMBEDDED_IBASE_REFOWNER() macro implements the AddRefOwner() and RemoveRefOwner() for a weak reference. | |
#define | SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY(Class) |
The SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY() macro implements the opening boilerplate for the QueryInterface() method for an embedded class in a C++ source module. | |
#define | SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY_END |
The SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY_END macro implements the closing boilerplate for the QueryInterface() method for a class in an embedded C++ source module. | |
#define | SCF_IMPLEMENT_EMBEDDED_IBASE(Class) |
SCF_IMPLEMENT_EMBEDDED_IBASE should be used to implement embedded interfaces derived from iBase. | |
#define | SCF_IMPLEMENT_EMBEDDED_IBASE_END SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY_END |
The SCF_IMPLEMENT_EMBEDDED_IBASE_END macro is used to finish an SCF_IMPLEMENT_EMBEDDED_IBASE definition. | |
#define | SCF_IMPLEMENTS_INTERFACE(Interface) |
The IMPLEMENT_INTERFACE macro is used inside QueryInterface function to check if user requested a specific interface, whenever requested version of the interface correspond to the version we have and to return a pointer to that interface if everything is correct. | |
#define | SCF_IMPLEMENTS_EMBEDDED_INTERFACE(Interface) SCF_IMPLEMENTS_INTERFACE_COMMON (Interface, (&scf##Interface)) |
IMPLEMENT_EMBEDDED_INTERFACE is same as IMPLEMENT_INTERFACE but is used when class implements the interface as an embedded member. | |
#define | SCF_IMPLEMENTS_INTERFACE_COMMON(Interface, Object) |
This is a common macro used in all IMPLEMENTS_XXX_INTERFACE macros. | |
#define | SCF_DECLARE_IBASE_EXT(ParentClass) |
The following macro is used in "expansion SCF classes". | |
#define | SCF_IMPLEMENT_IBASE_EXT_INCREF(Class) |
The SCF_IMPLEMENT_IBASE_EXT_INCREF() macro implements the IncRef() method for a class extending another SCF class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_EXT_DECREF(Class) |
The SCF_IMPLEMENT_IBASE_EXT_DECREF() macro implements the DecRef() method for a class extending another SCF class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_EXT_GETREFCOUNT(Class) |
The SCF_IMPLEMENT_IBASE_EXT_GETREFCOUNT() macro implements the GetRefCount() method for a class extending another SCF class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_EXT_REFOWNER(Class) |
The SCF_IMPLEMENT_IBASE_EXT_REFOWNER() macro implements the AddRefOwner() and RemoveRefOwner() for a weak reference. | |
#define | SCF_IMPLEMENT_IBASE_EXT_QUERY(Class) |
The SCF_IMPLEMENT_IBASE_EXT_QUERY() macro implements the opening boilerplate for the QueryInterface() method for a class extending another SCF class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_EXT_QUERY_END |
The SCF_IMPLEMENT_IBASE_EXT_QUERY_END macro implements the closing boilerplate for the QueryInterface() method for a class extending another SCF class in a C++ source module. | |
#define | SCF_IMPLEMENT_IBASE_EXT(Class) |
This macro implements same functionality as SCF_IMPLEMENT_IBASE except that it should be used for expansion SCF classes. | |
#define | SCF_IMPLEMENT_IBASE_EXT_END SCF_IMPLEMENT_IBASE_EXT_QUERY_END |
This macro implements same functionality as SCF_IMPLEMENT_IBASE_END except that it is used for expansion SCF classes. | |
#define | SCF_IMPLEMENT_FACTORY_INIT(Class) |
The SCF_IMPLEMENT_FACTORY_INIT macro defines initialization code for a plugin module. | |
#define | SCF_IMPLEMENT_FACTORY_FINIS(Class) |
The SCF_IMPLEMENT_FACTORY_FINIS macro defines finalization code for a plugin module. | |
#define | SCF_IMPLEMENT_FACTORY_CREATE(Class) |
The SCF_IMPLEMENT_FACTORY_CREATE macro is used to define a factory for one of exported classes. | |
#define | SCF_IMPLEMENT_FACTORY(Class) |
The SCF_IMPLEMENT_FACTORY macro is used to define a factory for one of exported classes. | |
#define | SCF_REGISTER_STATIC_CLASS(Class, Ident, Desc, Dep) |
Automatically register a built-in class with SCF during startup. | |
#define | SCF_REGISTER_STATIC_LIBRARY(Module, MetaInfo) |
Automatically register a static library with SCF during startup. | |
#define | SCF_DEFINE_FACTORY_FUNC_REGISTRATION(Class) |
Define the C++ class needed to register an SCF class, but don't do any automatic registration. | |
#define | SCF_USE_STATIC_PLUGIN(Module) |
Register a statically linked plugin. | |
#define | SCF_REGISTER_FACTORY_FUNC(Class) |
Used in conjunction with SCF_REGISTER_STATIC_LIBRARY to ensure that a reference to the class(es) registered via SCF_REGISTER_STATIC_LIBRARY are actually linked into the application. | |
#define | SCF_CREATE_INSTANCE(ClassID, Interface) |
Handy macro to create an instance of a shared class. | |
#define | SCF_VERSION(Name, Major, Minor, Micro) |
SCF_VERSION can be used to define an interface's version number; you should specify interface name and major, minor and micro version components. | |
#define | SCF_QUERY_INTERFACE(Object, Interface) |
Shortcut macro to query given interface from given object. | |
#define | SCF_QUERY_INTERFACE_SAFE(Object, Interface) |
Shortcut macro to query given interface from given object. | |
#define | CS_QUERY_PLUGIN_CLASS(Object, ClassID, Interface) |
Find a plugin by its class ID. | |
#define | CS_LOAD_PLUGIN(Object, ClassID, Interface) |
Tell plugin manager to load a plugin. | |
#define | CS_LOAD_PLUGIN_ALWAYS(Object, ClassID) csPtr<iBase> ((Object)->LoadPlugin (ClassID, 0, 0)) |
Same as CS_LOAD_PLUGIN() but does nott bother asking for a interface. | |
#define | CS_QUERY_REGISTRY_PLUGIN(obj, object_reg, scf_id, interface) |
Use this macro to query the object registry, loading a plugin if needed. | |
Typedefs | |
typedef unsigned long | scfInterfaceID |
Type of registered interface handle used by iBase::QueryInterface(). | |
typedef void *(* | scfFactoryFunc )(iBase *) |
Type of factory function which creates an instance of an SCF class. | |
Functions | |
void | scfInitialize (csPluginPaths *pluginPaths, bool verbose=false) |
This function should be called to initialize client SCF library. | |
void | scfInitialize (int argc, const char *const argv[]) |
This function should be called to initialize client SCF library. | |
bool | scfCompatibleVersion (int iVersion, int iItfVersion) |
This function checks whenever an interface is compatible with given version. |
Define Documentation
|
Value: csPtr<Interface> ((Interface *)((Object)->LoadPlugin \ (ClassID, #Interface, scfInterface<Interface>::GetVersion())))
|
|
Same as CS_LOAD_PLUGIN() but does nott bother asking for a interface. This is useful for unconditionally loading plugins. |
|
Value: csPtr<Interface> ((Interface *)((Object)->QueryPlugin \ (ClassID, #Interface, scfInterface<Interface>::GetVersion()))) First the plugin with requested class identifier is found, and after this it is queried for the respective interface; if it does not implement the requested interface, 0 is returned.
|
|
Value: do { \ obj = CS_QUERY_REGISTRY(object_reg, interface); \ if (!obj.IsValid()) \ { \ csRef<iPluginManager> mgr = CS_QUERY_REGISTRY(object_reg,iPluginManager); \ if (!mgr.IsValid()) \ { \ csReport(object_reg, CS_REPORTER_SEVERITY_ERROR, \ "crystalspace.plugin.query", "Plugin manager missing from " \ "object-registry when attempting to query/load class: %s", scf_id); \ } \ obj = CS_LOAD_PLUGIN(mgr, scf_id, interface); \ if (!obj.IsValid()) \ { \ csReport(object_reg, CS_REPORTER_SEVERITY_WARNING, \ "crystalspace.plugin.query", "Failed to load class \"%s\" with " \ "interface \"" #interface "\"", scf_id); \ } \ if (!object_reg->Register(obj, #interface)) \ { \ csReport(object_reg, CS_REPORTER_SEVERITY_WARNING, \ "crystalspace.plugin.query", "Failed to register class \"%s\" with " \ "tag \"" #interface "\" in the object-registry.", scf_id); \ } \ } \ } while (0) If an object with a given interface exists in an object registry, get that object from the registry. If the registry query fails, try to load a plugin and get the interface from there. If that succeeds, the interface is added to the registry for future use and given a tag the same name as the requested interface. Example use:
csRef\<iDynamics\> dynamic_system; CS_QUERY_REGISTRY_PLUGIN(dynamic_system, object_reg, "crystalspace.dynamics.ode", iDynamics);
|
|
Value: Interface.scfParent = this; \ csRefTrackerAccess::AddAlias (&Interface, this); The macro will initialize the pointer to the parent object (to the object this one is embedded into). The argument to this macro is the name of the parent's instance variable by which the embedded object is known (typically something like `scfiFooBar'). |
|
Value: csRefTrackerAccess::TrackConstruction (this); \ csRefTrackerAccess::SetDescription (this, CS_TYPENAME(*this)); \ scfRefCount = 1; \ scfWeakRefOwners = 0; \ scfParent = Parent; if (scfParent) scfParent->IncRef(); \ SCF_INIT_TRACKER_ALIASES Normally each constructor should accept an iBase* parameter (that is passed by scfCreateInstance function) which should be passed to this macro. The macro will zero the reference count and initialize the pointer to the parent object. If the object is unparented (a common case), it is okay to use null as the argument to this macro. Definition at line 150 of file scf.h. Referenced by csDataBuffer::csDataBuffer(), csParasiticDataBuffer::csParasiticDataBuffer(), csPath::csPath(), csPolygonMesh::csPolygonMesh(), csPolygonMeshBox::csPolygonMeshBox(), csScfStringSet::csScfStringSet(), scfString::scfString(), and scfStringArray::scfStringArray(). |
|
Value: SCF_CONSTRUCT_IBASE(0); \ poolNext = 0; \ scfPool = (Pool)
Definition at line 87 of file pooledscfclass.h. |
|
Use this macro to construct interface version numbers.
|
|
Value: csPtr<Interface> ( \ (Interface *)iSCF::SCF->CreateInstance ( \ ClassID, #Interface, scfInterface<Interface>::GetVersion())) This is a simple wrapper around scfCreateInstance. |
|
Value: public: \ OuterClass *scfParent; /* The parent object */ \ virtual void IncRef (); \ virtual void DecRef (); \ virtual int GetRefCount (); \ virtual void AddRefOwner (iBase** ref_owner); \ virtual void RemoveRefOwner (iBase** ref_owner); \ virtual void *QueryInterface (scfInterfaceID iInterfaceID, int iVersion)
|
|
Value: int scfRefCount; /* Reference counter */ \ csArray<iBase**>* scfWeakRefOwners; \ void scfRemoveRefOwners (); \ SCF_DECLARE_EMBEDDED_IBASE (iBase)
|
|
Value: typedef ParentClass __scf_superclass; \ virtual void IncRef (); \ virtual void DecRef (); \ virtual int GetRefCount (); \ virtual void AddRefOwner (iBase** ref_owner); \ virtual void RemoveRefOwner (iBase** ref_owner); \ virtual void *QueryInterface (scfInterfaceID iInterfaceID, int iVersion) An expansion class is a class that extends the functionality of another SCF class. For example, suppose a class TheWolf that implements the iWolf interface. Separately it is a useful class per se, but if you want to implement an additional class TheDog that is a subclass of TheWolf and which implements an additional interface iDog in theory you should just override the QueryInterface method and return the corresponding pointer when asked. The following macro makes such overrides simpler to write. |
|
Embed this macro instead of SCF_DECLARE_IBASE into an SCF class that is to be pooled.
Definition at line 74 of file pooledscfclass.h. |
|
Same as SCF_DECLARE_IBASE_POOLED, use for external classes.
Definition at line 80 of file pooledscfclass.h. |
|
Value: CS_EXPORTED_FUNCTION void* CS_EXPORTED_NAME(Class,_Create)(iBase*); \ class Class##_StaticInit \ { \ public: \ Class##_StaticInit() \ { \ scfInitialize(0); \ iSCF::SCF->RegisterFactoryFunc(CS_EXPORTED_NAME(Class,_Create),#Class); \ } \ };
|
|
Value: csRefTrackerAccess::RemoveAlias (&Interface, this); \
Interface.scfParent = 0;
It reverses the initialization performed by the SCF_CONSTRUCT_EMBEDDED_IBASE() macro. |
|
Value: csRefTrackerAccess::TrackDestruction (this, scfRefCount); \
scfRemoveRefOwners ();
It reverses the initialization performed by the SCF_CONSTRUCT_IBASE() macro. Definition at line 176 of file scf.h. Referenced by csDataBuffer::~csDataBuffer(), csPath::~csPath(), csScfStringSet::~csScfStringSet(), scfString::~scfString(), and scfStringArray::~scfStringArray(). |
|
Implement a default Class::PoolRecycle().
Definition at line 191 of file pooledscfclass.h. |
|
Value: SCF_IMPLEMENT_EMBEDDED_IBASE_INCREF(Class) \ SCF_IMPLEMENT_EMBEDDED_IBASE_DECREF(Class) \ SCF_IMPLEMENT_EMBEDDED_IBASE_GETREFCOUNT(Class) \ SCF_IMPLEMENT_EMBEDDED_IBASE_REFOWNER(Class) \ SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY(Class) It differs from SCF_IMPLEMENT_IBASE because embedded interface don't have reference counts themselves, but instead use the reference count of their parent object. |
|
Value: void Class::DecRef () \ { \ SCF_TRACE ((" (%s *)%p->DecRef (%d)\n", #Class, this, \ scfParent->GetRefCount ()-1)); \ scfParent->DecRef (); \ } Typically, this macro is automatically employed by the SCF_IMPLEMENT_EMBEDDED_IBASE() convenience macro. |
|
The SCF_IMPLEMENT_EMBEDDED_IBASE_END macro is used to finish an SCF_IMPLEMENT_EMBEDDED_IBASE definition.
|
|
Value: int Class::GetRefCount () \ { \ return scfParent->GetRefCount (); \ }
|
|
Value: void Class::IncRef () \ { \ SCF_TRACE ((" (%s *)%p->IncRef (%d)\n", #Class, this, \ scfParent->GetRefCount () + 1)); \ scfParent->IncRef (); \ } Typically, this macro is automatically employed by the SCF_IMPLEMENT_EMBEDDED_IBASE() convenience macro. |
|
Value: void *Class::QueryInterface (scfInterfaceID iInterfaceID, int iVersion) \ { \ SCF_TRACE ((" (%s *)%p->QueryInterface (%u, %08X)\n", \ #Class, this, iInterfaceID, iVersion)); Typically, this macro is automatically employed by the SCF_IMPLEMENT_EMBEDDED_IBASE() convenience macro. |
|
Value: return scfParent->QueryInterface (iInterfaceID, iVersion); \
}
Typically, this macro is automatically employed by the SCF_IMPLEMENT_EMBEDDED_IBASE_END convenience macro. |
|
Value: void Class::AddRefOwner (iBase** ref_owner) \ { \ scfParent->AddRefOwner (ref_owner); \ } \ void Class::RemoveRefOwner (iBase** ref_owner) \ { \ scfParent->RemoveRefOwner (ref_owner); \ }
|
|
Value: SCF_IMPLEMENT_FACTORY_INIT(Class) \ SCF_IMPLEMENT_FACTORY_FINIS(Class) \ SCF_IMPLEMENT_FACTORY_CREATE(Class) You can define the function manually, of course, if the constructor for your class has some specific constructor arguments (that is, more than one iBase* argument). |
|
Value: CS_EXPORTED_FUNCTION \ void* CS_EXPORTED_NAME(Class,_Create)(iBase *iParent) \ { \ void *ret = new Class (iParent); \ SCF_TRACE ((" %p = new %s ()\n", ret, #Class)); \ return ret; \ } You can define the function manually, of course, if the constructor for your class has some specific constructor arguments (that is, more than one iBase* argument). |
|
Value: CS_EXPORTED_FUNCTION \ void CS_EXPORTED_NAME(Class,_scfFinalize)() \ { \ CS_STATIC_VARIABLE_CLEANUP \ } As with SCF_IMPLEMENT_FACTORY_INIT, only one instance of this function will be invoked to finalize the module. |
|
Value: static inline void Class ## _scfUnitInitialize(iSCF* SCF) \ { iSCF::SCF = SCF; } \ CS_EXPORTED_FUNCTION \ void CS_EXPORTED_NAME(Class,_scfInitialize)(iSCF* SCF) \ { Class ## _scfUnitInitialize(SCF); } This function should set the plugin-global iSCF::SCF variable, and otherwise initialize the plugin module. Although a version of this function will be created for each SCF factory exported by the plugin, SCF will call one, and only one, to perform the plugin initialization. The choice of which function will be invoked to initialize the plugin is an SCF implementation detail. You should not attempt to predict which class_scfInitialize() function will be used, nor should use try to sway SCF's choice. Implementation note: There are some rare instances where a particularly picky (and probably buggy) compiler does not allow C++ expressions within a function declared `extern "C"'. For this reason, the iSCF::SCF variable is instead initialized in the Class_scfUnitInitialize() function which is not qualified as `extern "C"'. |
|
Value: SCF_IMPLEMENT_IBASE_INCREF(Class) \ SCF_IMPLEMENT_IBASE_DECREF(Class) \ SCF_IMPLEMENT_IBASE_GETREFCOUNT(Class) \ SCF_IMPLEMENT_IBASE_REFOWNER(Class) \ SCF_IMPLEMENT_IBASE_REMOVE_REF_OWNERS(Class) \ SCF_IMPLEMENT_IBASE_QUERY(Class) Of course, you can still implement those methods manually, if you desire ... |
|
Value: void Class::DecRef () \ { \ csRefTrackerAccess::TrackDecRef (this, scfRefCount); \ if (scfRefCount == 1) \ { \ SCF_TRACE ((" delete (%s *)%p\n", #Class, this)); \ scfRemoveRefOwners (); \ if (scfParent) \ scfParent->DecRef (); \ delete this; \ return; \ } \ scfRefCount--; \ } Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE() convenience macro. A note about the implementation: We do the "if" before the "scRefCount--" to make sure that calling Inc/DecRef doesn't result in a 2nd delete |
|
Value: void Class::DecRef () \ { \ if (scfRefCount == 1) \ { \ scfPool->Recycle (this); \ return; \ } \ scfRefCount--; \ }
Definition at line 165 of file pooledscfclass.h. |
|
The SCF_IMPLEMENT_IBASE_END macro is used to finish an SCF_IMPLEMENT_IBASE definition.
|
|
Value: SCF_IMPLEMENT_IBASE_EXT_INCREF(Class) \ SCF_IMPLEMENT_IBASE_EXT_DECREF(Class) \ SCF_IMPLEMENT_IBASE_EXT_GETREFCOUNT(Class) \ SCF_IMPLEMENT_IBASE_EXT_REFOWNER(Class) \ SCF_IMPLEMENT_IBASE_EXT_QUERY(Class)
|
|
Value: void Class::DecRef () \
{ \
__scf_superclass::DecRef (); \
}
Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE_EXT() convenience macro. |
|
This macro implements same functionality as SCF_IMPLEMENT_IBASE_END except that it is used for expansion SCF classes.
|
|
Value: int Class::GetRefCount () \ { \ return __scf_superclass::GetRefCount (); \ } Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE_EXT() convenience macro. |
|
Value: void Class::IncRef () \
{ \
__scf_superclass::IncRef (); \
}
Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE_EXT() convenience macro. |
|
Value: void *Class::QueryInterface (scfInterfaceID iInterfaceID, int iVersion) \ { Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE_EXT() convenience macro. |
|
Value: return __scf_superclass::QueryInterface (iInterfaceID, iVersion); \
}
Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE_EXT_END convenience macro. |
|
Value: void Class::AddRefOwner (iBase** ref_owner) \ { \ __scf_superclass::AddRefOwner (ref_owner); \ } \ void Class::RemoveRefOwner (iBase** ref_owner) \ { \ __scf_superclass::RemoveRefOwner (ref_owner); \ }
|
|
Value: int Class::GetRefCount () \ { \ return scfRefCount; \ }
|
|
Value: void Class::IncRef () \ { \ SCF_TRACE ((" (%s *)%p->IncRef (%d)\n", #Class, this, scfRefCount + 1));\ csRefTrackerAccess::TrackIncRef (this, scfRefCount); \ scfRefCount++; \ } Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE() convenience macro. |
|
Value: void Class::IncRef () \
{ \
scfRefCount++; \
}
Definition at line 156 of file pooledscfclass.h. |
|
Value: SCF_IMPLEMENT_IBASE_POOL_CTOR(Class) \ SCF_IMPLEMENT_IBASE_POOL_DTOR(Class) \ SCF_IMPLEMENT_IBASE_POOL_ALLOC(Class) \ SCF_IMPLEMENT_IBASE_POOL_RECYCLE(Class)
Definition at line 147 of file pooledscfclass.h. |
|
Value: Class* Class::Pool::Alloc () \ { \ Class* newInst; \ if (pool != 0) \ { \ newInst = pool; \ pool = pool->poolNext; \ } \ else \ newInst = new Class (this); \ return newInst; \ }
Definition at line 119 of file pooledscfclass.h. |
|
Value: Class::Pool::Pool () \ { \ pool = 0; \ }
Definition at line 95 of file pooledscfclass.h. |
|
Value: Class::Pool::~Pool () \ { \ while (pool != 0) \ { \ Class* n = pool->poolNext; \ pool->PoolRecycle (); \ delete pool; \ pool = n; \ } \ }
Definition at line 104 of file pooledscfclass.h. |
|
Value: void Class::Pool::Recycle (Class* instance) \
{ \
instance->PoolRecycle (); \
instance->poolNext = pool; \
pool = instance; \
}
Definition at line 136 of file pooledscfclass.h. |
|
Value: SCF_IMPLEMENT_IBASE_POOL(Class) \ SCF_IMPLEMENT_IBASE_INCREF_POOLED(Class) \ SCF_IMPLEMENT_IBASE_DECREF_POOLED(Class) \ SCF_IMPLEMENT_IBASE_GETREFCOUNT(Class) \ SCF_IMPLEMENT_IBASE_REFOWNER(Class) \ SCF_IMPLEMENT_IBASE_REMOVE_REF_OWNERS(Class) \ SCF_IMPLEMENT_IBASE_QUERY(Class)
Definition at line 179 of file pooledscfclass.h. |
|
Value: void *Class::QueryInterface (scfInterfaceID iInterfaceID, int iVersion) \ { \ SCF_TRACE ((" (%s *)%p->QueryInterface (%u, %08X)\n", \ #Class, this, iInterfaceID, iVersion)); Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE() convenience macro. |
|
Value: return scfParent ? \
scfParent->QueryInterface (iInterfaceID, iVersion) : 0; \
}
Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE_END convenience macro. |
|
Value: void Class::AddRefOwner (iBase** ref_owner) \ { \ if (!scfWeakRefOwners) \ scfWeakRefOwners = new csArray<iBase**> (0, 4); \ scfWeakRefOwners->InsertSorted (ref_owner); \ } \ void Class::RemoveRefOwner (iBase** ref_owner) \ { \ if (!scfWeakRefOwners) \ return; \ size_t index = scfWeakRefOwners->FindSortedKey ( \ csArrayCmp<iBase**, iBase**> (ref_owner)); \ if (index != csArrayItemNotFound) scfWeakRefOwners->DeleteIndex ( \ index); \ }
|
|
Value: void Class::scfRemoveRefOwners () \ { \ if (!scfWeakRefOwners) return; \ for (size_t i = 0 ; i < scfWeakRefOwners->Length () ; i++) \ { \ iBase** p = (*scfWeakRefOwners)[i]; \ *p = 0; \ } \ delete scfWeakRefOwners; \ scfWeakRefOwners = 0; \ } Typically, this macro is automatically employed by the SCF_IMPLEMENT_IBASE() convenience macro. |
|
IMPLEMENT_EMBEDDED_INTERFACE is same as IMPLEMENT_INTERFACE but is used when class implements the interface as an embedded member.
|
|
Value: csRefTrackerAccess::AddAlias (CS_STATIC_CAST(Interface*, this), this);\ SCF_IMPLEMENTS_INTERFACE_COMMON (Interface, this)
|
|
Value: static scfInterfaceID Interface##_scfID = (scfInterfaceID)-1; \ if (Interface##_scfID == (scfInterfaceID)-1) \ Interface##_scfID = iSCF::SCF->GetInterfaceID (#Interface); \ if (iInterfaceID == Interface##_scfID && \ scfCompatibleVersion (iVersion, scfInterface<Interface>::GetVersion())) \ { \ (Object)->IncRef (); \ return CS_STATIC_CAST(Interface*, Object); \ }
|
|
Macro for getting the address we were called from (stack backtracing). This works ONLY For GCC >= 2.8.0 |
|
Value: csPtr<Interface> ((Interface *)(Object)->QueryInterface ( \ scfInterface<Interface>::GetID (), scfInterface<Interface>::GetVersion())) This is a wrapper around iBase::QueryInterface method. |
|
Value: csPtr<Interface> ((Interface *)(iBase::QueryInterfaceSafe ((Object), \ scfInterface<Interface>::GetID (), scfInterface<Interface>::GetVersion()))) This is a wrapper around iBase::QueryInterface method. This version tests if Object is 0 and will return 0 in that case. |
|
Value: SCF_DEFINE_FACTORY_FUNC_REGISTRATION(Class) \ Class##_StaticInit Class##_static_init__; Invoke this macro once for each <implementation> node mentioned in the MetaInfo registered with SCF_REGISTER_STATIC_LIBRARY. Invocations of this macro must appear after the the invocation of SCF_REGISTER_STATIC_LIBRARY. |
|
Value: CS_EXPORTED_FUNCTION void* CS_EXPORTED_NAME(Class,_Create)(iBase*); \ class Class##_StaticInit__ \ { \ public: \ Class##_StaticInit__() \ { \ scfInitialize(0); \ iSCF::SCF->RegisterClass( \ CS_EXPORTED_NAME(Class,_Create), Ident, Desc, Dep, \ SCF_STATIC_CLASS_CONTEXT); \ } \ } Class##_static_init__; When SCF classes are statically linked (vs dynamic linking) they should be referenced from somewhere inside your program, otherwise the static libraries won't be linked into the static executable. This macro defines a dummy variable that registers the class during initialization and ensures that it gets linked into the program |
|
Value: class Module##_StaticInit \ { \ public: \ Module##_StaticInit() \ { \ scfInitialize(0); \ iSCF::SCF->RegisterClasses(MetaInfo, SCF_STATIC_CLASS_CONTEXT); \ } \ } Module##_static_init__; Employ this macro along with one or more invocations of SCF_REGISTER_FACTORY_FUNC. |
|
Macro for typing debug strings: Add #define SCF_DEBUG at the top of modules you want to track miscelaneous SCF activity and recompile.
|
|
Value: namespace csStaticPluginInit \ { \ class Module { public: Module(); }; \ Module Module##_StaticInit; \ } The _static version of the plugin needs to be linked in, too. |
|
Value: struct Name; \ CS_SPECIALIZE_TEMPLATE \ class scfInterface<Name> \ { \ public: \ static int GetVersion() \ { \ return SCF_CONSTRUCT_VERSION(Major, Minor, Micro); \ } \ static scfInterfaceID GetID() \ { \ static scfInterfaceID ID = (scfInterfaceID)-1; \ if (ID == (scfInterfaceID)(-1)) \ ID = iSCF::SCF->GetInterfaceID(#Name); \ return ID; \ } \ static char const* GetName() \ { \ return #Name; \ } \ } This way: SCF_VERSION (iSomething, 0, 0, 1); struct iSomething : public iBase { ... }; |
Typedef Documentation
|
Type of factory function which creates an instance of an SCF class.
|
|
Type of registered interface handle used by iBase::QueryInterface().
Definition at line 41 of file scf.h. Referenced by scfInterface< T >::GetID(). |
Function Documentation
|
This function checks whenever an interface is compatible with given version. SCF uses the following comparison criteria: if the major version numbers are equal and required minor and micro version is less or equal than target version minor and micro numbers, the versions are considered compatible. |
|
This function should be called to initialize client SCF library. It uses the default plugin paths provided by csGetPluginPaths(). |
|
This function should be called to initialize client SCF library. If a number of plugin paths are provided, the directories will be scanned for plugins and their SCF-related registry data will be retrieved. The root node within the registry data document should be named "plugin", and the SCF-related information should be in a child node of the root named "scf". It is legal to call scfInitialize more than once (possibly providing a different set of directories each time).
|
Generated for Crystal Space by doxygen 1.3.9.1