IHandleSys.h

Go to the documentation of this file.

#ifndef _INCLUDE_SOURCEMOD_HANDLESYSTEM_INTERFACE_H_
#define _INCLUDE_SOURCEMOD_HANDLESYSTEM_INTERFACE_H_

#include <IShareSys.h>
#include <sp_vm_types.h>

#define SMINTERFACE_HANDLESYSTEM_NAME                   "IHandleSys"
#define SMINTERFACE_HANDLESYSTEM_VERSION                5

#define DEFAULT_IDENTITY                        NULL

#define NO_HANDLE_TYPE                          0

#define BAD_HANDLE                                      0

namespace SourceMod
{
        typedef unsigned int HandleType_t;

        typedef unsigned int Handle_t;


        /*
         * About type checking:
         * Types can be inherited - a Parent type ("Supertype") can have child types.
         * When accessing handles, type checking is done.  This table shows how this is resolved:
         *
         * HANDLE               CHECK           ->  RESULT
         * ------               -----                   ------
         * Parent               Parent                  Success
         * Parent               Child                   Fail
         * Child                Parent                  Success
         * Child                Child                   Success
         */

        enum HandleError
        {
                HandleError_None = 0,           
                HandleError_Changed,            
                HandleError_Type,                       
                HandleError_Freed,                      
                HandleError_Index,                      
                HandleError_Access,                     
                HandleError_Limit,                      
                HandleError_Identity,           
                HandleError_Owner,                      
                HandleError_Version,            
                HandleError_Parameter,          
                HandleError_NoInherit,          
        };

        enum HTypeAccessRight
        {
                HTypeAccess_Create = 0,         
                HTypeAccess_Inherit,            
                /* -------------- */
                HTypeAccess_TOTAL,                      
        };

        enum HandleAccessRight
        {
                HandleAccess_Read,                      
                HandleAccess_Delete,            
                HandleAccess_Clone,                     
                /* ------------- */
                HandleAccess_TOTAL,                     
        };

        #define HANDLE_RESTRICT_IDENTITY        (1<<0)  

        #define HANDLE_RESTRICT_OWNER           (1<<1)

        struct TypeAccess
        {
                TypeAccess()
                {
                        hsVersion = SMINTERFACE_HANDLESYSTEM_VERSION;
                }
                unsigned int hsVersion;                 
                IdentityToken_t *ident;                 
                bool access[HTypeAccess_TOTAL]; 
        };

        struct HandleAccess
        {
                HandleAccess()
                {
                        hsVersion = SMINTERFACE_HANDLESYSTEM_VERSION;
                }
                unsigned int hsVersion;                                         
                unsigned int access[HandleAccess_TOTAL];        
        };

        struct HandleSecurity
        {
                HandleSecurity()
                {
                }
                HandleSecurity(IdentityToken_t *owner, IdentityToken_t *identity)
                        : pOwner(owner), pIdentity(identity)
                {
                }
                IdentityToken_t *pOwner;                        
                IdentityToken_t *pIdentity;                     
        };

        class IHandleTypeDispatch
        {
        public:
                virtual unsigned int GetDispatchVersion()
                {
                        return SMINTERFACE_HANDLESYSTEM_VERSION;
                }
        public:
                virtual void OnHandleDestroy(HandleType_t type, void *object) =0;

                virtual bool GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)
                {
                        return false;
                }
        };

        class IHandleSys : public SMInterface
        {
        public:
                virtual unsigned int GetInterfaceVersion()
                {
                        return SMINTERFACE_HANDLESYSTEM_VERSION;
                }
                virtual const char *GetInterfaceName()
                {
                        return SMINTERFACE_HANDLESYSTEM_NAME;
                }
        public:
                virtual HandleType_t CreateType(const char *name,
                                                                                  IHandleTypeDispatch *dispatch,
                                                                                  HandleType_t parent,
                                                                                  const TypeAccess *typeAccess,
                                                                                  const HandleAccess *hndlAccess,
                                                                                  IdentityToken_t *ident,
                                                                                  HandleError *err) =0;

                virtual bool RemoveType(HandleType_t type, IdentityToken_t *ident) =0;

                virtual bool FindHandleType(const char *name, HandleType_t *type) =0;

                virtual Handle_t CreateHandle(HandleType_t type, 
                                                                          void *object,
                                                                          IdentityToken_t *owner,
                                                                          IdentityToken_t *ident,
                                                                          HandleError *err) =0;

                virtual HandleError FreeHandle(Handle_t handle, const HandleSecurity *pSecurity) =0;

                virtual HandleError CloneHandle(Handle_t handle, 
                                                                                Handle_t *newhandle, 
                                                                                IdentityToken_t *newOwner,
                                                                                const HandleSecurity *pSecurity) =0;

                virtual HandleError ReadHandle(Handle_t handle, 
                                                                           HandleType_t type, 
                                                                           const HandleSecurity *pSecurity,
                                                                           void **object) =0;

                virtual bool InitAccessDefaults(TypeAccess *pTypeAccess, HandleAccess *pHandleAccess) =0;

                virtual Handle_t CreateHandleEx(HandleType_t type, 
                                                                                void *object,
                                                                                const HandleSecurity *pSec,
                                                                                const HandleAccess *pAccess,
                                                                                HandleError *err) =0;

                virtual Handle_t FastCloneHandle(Handle_t hndl) =0;

                virtual bool TypeCheck(HandleType_t given, HandleType_t actual) = 0;
        };
}

#endif //_INCLUDE_SOURCEMOD_HANDLESYSTEM_INTERFACE_H_