GuidMgr.h

// GuidMgr.h: interface for the CGuidMgr class.
//
//////////////////////////////////////////////////////////////////////
 
#ifndef GUIDMGR_CLASS_H
#define GUIDMGR_CLASS_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "XThreadSync.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
typedef unsigned int GuidValue32;
typedef longuint GuidValue;
typedef unsigned int GuidClass;
 
// This can be both used as a 64 bits GUID generator (with each 64 bits GUID are associated to a 32 bits guid), or use as a only 32 bits GUID generator
class DLL_TOOLSFUNCTION CGuidMgr
{
protected:
    typedef struct GuidBaseValue
    {
        GuidValue defaultValue;
        GuidValue currentValue;
        GuidValue32 currentValue32;
    } GuidBaseValue;
 
    typedef struct GuidInfo
    {
        GuidClass guidClass;
        GuidValue32 guid32;
    } GuidInfo;
 
    mutable CXCriticalSection threadLock;
    CHashMap<GuidValue, const GuidValue&, GuidInfo> guids;
    CHashTable<GuidValue32> guids32;
    CHashMap<GuidClass, GuidClass, GuidBaseValue> newGuidByClass;
    unsigned int flags;
 
    GuidValue32 MakeGuid32(const GuidValue& guid); // Get a 32 bit GUID from 64 bits GUID
 
public:
        typedef enum GuidFlags XEnumType(unsigned int)
        {
            GUIDMGR_NONE = 0x00,
            GUIDMGR_SILENT = 0x100000, // No message in debug
        } GuidFlags;
 
        typedef enum DefaultClass XEnumType(GuidClass)
        {
            UNDEFINED_CLASS = (GuidClass)-1,
            DEFAULT_CLASS = 0,
        } DefaultClass;
 
        typedef enum DefaultGUID XEnumType(GuidValue)
        {
            UNDEFINED_GUID = (GuidValue)-1,
            DEFAULT_GUID = 0, // CGuidMgr never returns 0, so 0 can be a default guid value for specific purpose
        } DefaultGUID;
 
        typedef enum DefaultGUID32 XEnumType(GuidValue32)
        {
            UNDEFINED_GUID32 = (GuidValue32)-1,
            DEFAULT_GUID32 = 0, // CGuidMgr never returns 0, so 0 can be a default guid value for specific purpose
            BASE_VALUE_GUID32 = 100, // The base value at which guid starts. Value above are supposed to be free
        } DefaultGUID32;
 
        CGuidMgr(GuidValue32 baseValue = BASE_VALUE_GUID32);
        virtual ~CGuidMgr();
 
        void SetFlags(unsigned int flags, bool set);
        inline bool IsFlagSet(GuidFlags flag) { return (flags & flag) != 0; }
 
        unsigned int GetCount();
        void RemoveAll(); // Remove all GUID
        
        void SetClassBaseValue(unsigned int classid, GuidValue startvalue);
        GuidValue GetClassBaseValue(unsigned int classid) const;
 
        GuidValue GetNewGuid(const GuidValue& guid = UNDEFINED_GUID, unsigned int GuidClass = DEFAULT_CLASS); // Provide a GUID proposition, and return the same GUID, or a different one if already used
        GuidValue32 GetNewGuid32(const GuidValue32& guid = UNDEFINED_GUID32, unsigned int guidClass = DEFAULT_CLASS); // Provide a GUID proposition, and return the same GUID, or a different one if already used
        GuidClass GetGuidClass(const GuidValue& guid) const; // Check if a guid exists. Return UNDEFINED_CLASS if does not exists
        GuidValue32 GetGuid32(const GuidValue& guid) const; // Get a Guid32 bit value from a 64 bits one
        bool IsGuidExist(const GuidValue& guid) const; // Check if a guid exists.
        bool IsGuid32Exist(const GuidValue32& guid) const; // Check if a 32 bits guid exists.
        bool ReleaseGuid(const GuidValue& guid); // The GUID is not used any longer
        bool ReleaseGuid32(const GuidValue32& guid); // The 32 bits GUID is not used any longer
};
 
inline GuidValue GetNewGuid(CGuidMgr& mgr, const GuidValue& guid = CGuidMgr::UNDEFINED_GUID, unsigned int GuidClass = CGuidMgr::DEFAULT_CLASS)
{
    return mgr.GetNewGuid(guid, GuidClass);
}
 
inline GuidValue32 GetNewGuid32(CGuidMgr& mgr, const GuidValue32& guid = CGuidMgr::UNDEFINED_GUID32, unsigned int GuidClass = CGuidMgr::DEFAULT_CLASS)
{
    return mgr.GetNewGuid32(guid, GuidClass);
}
 
inline GuidClass GetGuidClass(const CGuidMgr& mgr, const GuidValue& guid)
{
    return mgr.GetGuidClass(guid);
}
 
inline bool IsGuidExist(const CGuidMgr& mgr, const GuidValue& guid)
{
    return mgr.IsGuidExist(guid);
}
 
inline bool IsGuid32Exist(const CGuidMgr& mgr, const GuidValue32& guid)
{
    return mgr.IsGuid32Exist(guid);
}
 
inline bool ReleaseGuid(CGuidMgr& mgr, const GuidValue& guid)
{
    return mgr.ReleaseGuid(guid);
}
 
inline bool ReleaseGuid32(CGuidMgr& mgr, const GuidValue32& guid)
{
    return mgr.ReleaseGuid32(guid);
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // !GUIDMGR_CLASS_H