A light wrapper class for GUID

Here is a moments to be done left
operator= and constructor uses Convert without checking the result of conversion. I'd prefer to set a result flag rather than throwing an exception. Another moment is, ::UuidFromString() cannot convert regedit-style GUIDs (i.e. with braces:"{x-x-xx}"). It seems author solved it in Convert(BSTR bstrGuid, GUID& guid) method by cutting braces out but only here and not in any another place.
Here is my variant. You are free to change #define's THROW_INVALID* and CHECK_VALID* to change behavior in case of using an object in invalid state.

C++

// Guid.h: interface for the CGuid class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_GUID_H__BBBFB961_9EC0_4414_8B69_067CDD2FFB85__INCLUDED_)
#define AFX_GUID_H__BBBFB961_9EC0_4414_8B69_067CDD2FFB85__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CGuid  
{
protected:
    bool m_bValid;
public:
	CGuid();
	CGuid(BSTR guid);
	CGuid(const CString& csGuid);
	CGuid(LPCTSTR lpszGuid);
	CGuid(const CGuid& g);
	CGuid(const GUID& g);
	virtual ~CGuid();
 
	CGuid& operator=(const GUID& g);
	CGuid& operator=(const CGuid& g);
	CGuid& operator=(BSTR g);
	CGuid& operator=(const CComBSTR& g);
	CGuid& operator=(const CString& g);
	CGuid& operator=(LPCTSTR g);

	bool operator==(const GUID& g);
	bool operator==(const CGuid& g);

	bool operator!=(const GUID& g);
	bool operator!=(const CGuid& g);

	operator GUID&();
	operator GUID*();
	operator CComBSTR();
	operator CString();

	bool operator<(const CGuid& g1) const;
	bool operator>(const CGuid& g1) const;

	long HasKey(){ return HashKey(*this); };
    bool IsValid() const{ return m_bValid; }

	BOOL ProgID(CString& csProgID);
	BOOL ProgID(CComBSTR& bstrProgID);
	
	static bool Create(GUID& guid);
	static bool Create(CComBSTR& guid);

	static bool Convert(GUID& guid, CComBSTR& bstrGuid);
	static bool Convert(GUID& guid, CString& csGuid);

	static bool Convert(BSTR bstrGuid, GUID& guid);
	static bool Convert(const CComBSTR& bstrGuid, GUID& guid);
	static bool Convert(const CString& bstrGuid, GUID& guid);
	static bool Convert(LPCTSTR lpszGuid, GUID& guid);
	
	static long HashKey(GUID& guid);
	

protected:
	GUID m_guid;
	void copy(const CGuid& g);	
	void copy(const GUID& g);

};

#endif // !defined(AFX_GUID_H__BBBFB961_9EC0_4414_8B69_067CDD2FFB85__INCLUDED_)


// Guid.cpp: implementation of the CGuid class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Guid.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#pragma comment(lib, "rpcrt4.lib")

#define GUID_STRING_LEN	40

#define THROW_INVALID_OBJECT_USED throw CString("Invalid GUID object used")
#define CHECK_VALID_THIS if(!this->IsValid()) THROW_INVALID_OBJECT_USED
#define CHECK_VALID(g) if(!(g).IsValid()) THROW_INVALID_OBJECT_USED
#define CHECK_VALID_BOTH(g) if(!this->IsValid() || !(g).IsValid()) THROW_INVALID_OBJECT_USED

CGuid::CGuid()
{
	m_guid = GUID_NULL;
}

CGuid::CGuid(BSTR guid)
{
	operator=(guid);
}

CGuid::CGuid(const CString& csGuid)
{
	operator=(csGuid);
}

CGuid::CGuid(LPCTSTR lpszGuid)
{
	operator=(lpszGuid);
}

CGuid::~CGuid()
{

}

CGuid::CGuid(const CGuid& g)
{
	m_guid = g.m_guid;	
}

CGuid::CGuid(const GUID& g)
{
	m_guid = g;
}

bool CGuid::operator==(const GUID& g)
{
    CHECK_VALID_THIS;
	return !::memcmp(&m_guid, &g, sizeof(GUID));
}

bool CGuid::operator==(const CGuid& g)
{
    CHECK_VALID_BOTH(g);
	return operator==(g.m_guid);
}

CGuid::operator GUID&()
{ 
    CHECK_VALID_THIS;
	return m_guid; 
}

CGuid::operator GUID*()
{ 
    CHECK_VALID_THIS;
	return &m_guid; 
}

CGuid::operator CComBSTR()
{ 
    CHECK_VALID_THIS;
	CComBSTR bstrGuid;
	Convert(m_guid, bstrGuid);
	return bstrGuid; 
}

CGuid::operator CString()
{ 
    CHECK_VALID_THIS;
	CString csGuid;
	Convert(m_guid, csGuid);
	return csGuid; 
}

bool CGuid::operator!=(const GUID& g)
{
    CHECK_VALID_THIS;
	return ::memcmp(&m_guid, &g, sizeof(GUID)) != 0;
}

bool CGuid::operator!=(const CGuid& g)
{
    CHECK_VALID_BOTH(g);
	return operator!=(g.m_guid);
}

CGuid& CGuid::operator=(const GUID& g)
{
	if( ::memcmp(&m_guid, &g, sizeof(GUID)) != 0 )
	{
		copy(g);
        m_bValid = true;
	}
    else
        m_bValid = false;

	return *this;
}

CGuid& CGuid::operator=(const CComBSTR& g)
{
	ATLASSERT(g.m_str);
	m_bValid = Convert(g, m_guid);
	return *this;
}

CGuid& CGuid::operator=(BSTR g)
{
	ATLASSERT(g);
	m_bValid = Convert(g, m_guid);
	return *this;
}

CGuid& CGuid::operator=(LPCTSTR g)
{
	ATLASSERT(g);
	m_bValid = Convert(g, m_guid);
	return *this;
}

CGuid& CGuid::operator=(const CString& g)
{
	m_bValid = Convert(g, m_guid);
	return *this;
}

CGuid& CGuid::operator=(const CGuid& g)
{
	if(this != &g )
	{
		copy(g.m_guid);
	}
	
	return *this;
}

inline void CGuid::copy(const CGuid& g)
{
    CHECK_VALID(g);
	copy(g.m_guid);
}

inline void CGuid::copy(const GUID& g)
{
	::memcpy(&m_guid, (void*)&g, sizeof(GUID));
}

bool CGuid::operator<(const CGuid& g1) const
{
    CHECK_VALID_BOTH(g1);
	RPC_STATUS status;
	return ::UuidCompare(const_cast<GUID*>(&m_guid), const_cast<GUID*>(&g1.m_guid), &status)==-1;
}

bool CGuid::operator>(const CGuid& g1) const
{
    CHECK_VALID_BOTH(g1);
	return !this->operator<(g1) && ::memcmp(&g1.m_guid, &m_guid, sizeof(GUID));
}

bool CGuid::Convert(GUID& guid, CComBSTR& bstrGuid)
{
	OLECHAR szGuid[GUID_STRING_LEN]={0};
	int nCount = ::StringFromGUID2(guid, szGuid, GUID_STRING_LEN);
	bstrGuid = szGuid;
	
	return nCount !=0;
}

bool CGuid::Convert(GUID& guid, CString& csGuid)
{
	OLECHAR szGuid[GUID_STRING_LEN]={0};
	int nCount = ::StringFromGUID2(guid, szGuid, GUID_STRING_LEN);
	csGuid = szGuid;
	
	return nCount !=0;
}

bool CGuid::Convert(const CComBSTR& bstrGuid, GUID& guid)
{	
	return Convert(CString(bstrGuid), guid);
}

bool CGuid::Convert(BSTR bstrGuid, GUID& guid)
{
	if( bstrGuid == NULL )
	{
		return false;
	}
	
    return Convert(CString(bstrGuid), guid);
}

bool CGuid::Convert(const CString& csGuid, GUID& guid)
{
	if( csGuid.GetLength() < GUID_STRING_LEN - 4 )
	{
		return false;
	}
    CStringW cstringw;

	if( csGuid.GetAt(0) == TCHAR('{') )
	{
		ATLASSERT(csGuid.Find(TCHAR('}'))!=-1);
		return Convert((LPCTSTR)csGuid.Mid(1, csGuid.GetLength()-2), guid);
	}
	else
	{
		return Convert((LPCTSTR)csGuid, guid);
	}
}

bool CGuid::Convert(LPCTSTR lpszGuid, GUID& guid)
{
	ATLASSERT(lpszGuid);
    RPC_STATUS rpc_status = ::UuidFromString((RPC_WSTR)(LPCWSTR)CStringW(lpszGuid), &guid);
	return rpc_status == RPC_S_OK;
}

bool CGuid::Create(CComBSTR& bstrGuid)
{
	GUID guid;
	if( Create(guid) )
	{
		return Convert(guid, bstrGuid);
	}

	return false;
}

bool CGuid::Create(GUID& guid)
{
	return ::UuidCreate(&guid) == RPC_S_OK;
}

long CGuid::HashKey(GUID& guid)
{
	RPC_STATUS status=RPC_S_OK;
	return ::UuidHash(&guid, &status);
}

BOOL CGuid::ProgID(CString& csProgID)
{
	CComBSTR bstrTmp;
	BOOL bRet = ProgID(bstrTmp);
	csProgID = bstrTmp;
	return bRet;
}
	
BOOL CGuid::ProgID(CComBSTR& bstrProgID)
{
    CHECK_VALID_THIS;
	BOOL bRet=FALSE;
	if( *this == GUID_NULL )
	{
		return bRet;
	}

	LPOLESTR psz = NULL;
	if( ::ProgIDFromCLSID(m_guid, &psz) == S_OK )
	{
		bstrProgID=psz;
		::CoTaskMemFree(psz);
		psz=NULL;
		bRet=TRUE;
	}
	return bRet;
}

Update. Some more bugs fixed. Now it works good in our project

C++

// Guid.h: interface for the CGuid class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_GUID_H__BBBFB961_9EC0_4414_8B69_067CDD2FFB85__INCLUDED_)
#define AFX_GUID_H__BBBFB961_9EC0_4414_8B69_067CDD2FFB85__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <stdexcept>
struct EGuidException : public std::runtime_error
{
    EGuidException(const std::string& mess)
        :
    std::runtime_error(mess)
    {
    }
};

class CGuid
{
protected:
    bool m_bValid;
public:
    CGuid();
    CGuid(BSTR guid);
    CGuid(const CString& csGuid);
    CGuid(LPCTSTR lpszGuid);
    CGuid(const CGuid& g);
    CGuid(const GUID& g);
    virtual ~CGuid();

    CGuid& operator=(const GUID& g);
    CGuid& operator=(const CGuid& g);
    CGuid& operator=(BSTR g);
    CGuid& operator=(const CComBSTR& g);
    CGuid& operator=(const CString& g);
    CGuid& operator=(LPCTSTR g);

    bool operator==(const GUID& g) const;
    bool operator==(const CGuid& g) const;

    bool operator!=(const GUID& g) const;
    bool operator!=(const CGuid& g) const;

    operator GUID&();
    operator GUID*();
    operator const GUID&() const;
    operator const GUID*() const;
    operator CComBSTR() const;
    operator CString() const;

    bool operator<(const CGuid& g1) const;
    bool operator>(const CGuid& g1) const;

    long HashKey(){ return HashKey(*this); };
    bool IsValid() const{ return m_bValid; }

    BOOL ProgID(CString& csProgID);
    BOOL ProgID(CComBSTR& bstrProgID);

    static bool Create(GUID& guid);
    static bool Create(CComBSTR& guid);

    static bool Convert(const GUID& guid, CComBSTR& bstrGuid);
    static bool Convert(const GUID& guid, CString& csGuid);

    static bool Convert(BSTR bstrGuid, GUID& guid);
    static bool Convert(const CComBSTR& bstrGuid, GUID& guid);
    static bool Convert(const CString& bstrGuid, GUID& guid);

    static long HashKey(GUID& guid);


protected:
    GUID m_guid;
    void copy(const CGuid& g);	
    void copy(const GUID& g);
    static bool ConvertImpl(LPCTSTR lpszGuid, GUID& guid);
};

#endif // !defined(AFX_GUID_H__BBBFB961_9EC0_4414_8B69_067CDD2FFB85__INCLUDED_)


// Guid.cpp: implementation of the CGuid class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Guid.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#pragma comment(lib, "rpcrt4.lib")

#define GUID_STRING_LEN	40

#define THROW_INVALID_OBJECT_USED throw EGuidException("Invalid GUID object used")
#define CHECK_VALID_THIS if(!this->IsValid()) THROW_INVALID_OBJECT_USED
#define CHECK_VALID(g) if(!(g).IsValid()) THROW_INVALID_OBJECT_USED
#define CHECK_VALID_BOTH(g) if(!this->IsValid() || !(g).IsValid()) THROW_INVALID_OBJECT_USED

CGuid::CGuid()
{
    m_guid = GUID_NULL;
    m_bValid=true;
}

CGuid::CGuid(BSTR guid)
{
    operator=(guid);
}

CGuid::CGuid(const CString& csGuid)
{
    operator=(csGuid);
    CHECK_VALID_THIS;
}

CGuid::CGuid(LPCTSTR lpszGuid)
{
    operator=(lpszGuid);
    CHECK_VALID_THIS;
}

CGuid::~CGuid()
{

}

CGuid::CGuid(const CGuid& g)
{
    m_guid = g.m_guid;
    m_bValid=g.m_bValid;
    //CHECK_VALID_THIS;
}

CGuid::CGuid(const GUID& g)
{
    m_guid = g;
    m_bValid=true;
    //CHECK_VALID_THIS;
}

bool CGuid::operator==(const GUID& g) const
{
    CHECK_VALID_THIS;
    return !::memcmp(&m_guid, &g, sizeof(GUID));
}

bool CGuid::operator==(const CGuid& g) const
{
    CHECK_VALID_BOTH(g);
    return operator==(g.m_guid);
}

CGuid::operator GUID&()
{ 
    CHECK_VALID_THIS;
    return m_guid; 
}

CGuid::operator GUID*()
{ 
    CHECK_VALID_THIS;
    return &m_guid; 
}

CGuid::operator const GUID&() const
{ 
    CHECK_VALID_THIS;
    return m_guid; 
}

CGuid::operator const GUID*() const
{ 
    CHECK_VALID_THIS;
    return &m_guid; 
}

CGuid::operator CComBSTR() const
{ 
    CHECK_VALID_THIS;
    CComBSTR bstrGuid;
    Convert(m_guid, bstrGuid);
    return bstrGuid; 
}

CGuid::operator CString() const
{ 
    CHECK_VALID_THIS;
    CString csGuid;
    Convert(m_guid, csGuid);
    return csGuid; 
}

bool CGuid::operator!=(const GUID& g) const
{
    CHECK_VALID_THIS;
    return ::memcmp(&m_guid, &g, sizeof(GUID)) != 0;
}

bool CGuid::operator!=(const CGuid& g) const
{
    CHECK_VALID_BOTH(g);
    return operator!=(g.m_guid);
}

CGuid& CGuid::operator=(const GUID& g)
{
    if( ::memcmp(&m_guid, &g, sizeof(GUID)) != 0 )
    {
        copy(g);
        m_bValid = true;
    }
    else
        m_bValid = false;

    return *this;
}

CGuid& CGuid::operator=(const CComBSTR& g)
{
    ATLASSERT(g.m_str);
    m_bValid = Convert(g, m_guid);
    return *this;
}

CGuid& CGuid::operator=(BSTR g)
{
    ATLASSERT(g);
    m_bValid = Convert(g, m_guid);
    return *this;
}

CGuid& CGuid::operator=(LPCTSTR g)
{
    ATLASSERT(g);
    m_bValid = Convert(CString(g), m_guid);
    return *this;
}

CGuid& CGuid::operator=(const CString& g)
{
    m_bValid = Convert(g, m_guid);
    return *this;
}

CGuid& CGuid::operator=(const CGuid& g)
{
    if(this != &g )
    {
        copy(g.m_guid);
    }

    return *this;
}

inline void CGuid::copy(const CGuid& g)
{
    CHECK_VALID(g);
    copy(g.m_guid);
}

inline void CGuid::copy(const GUID& g)
{
    ::memcpy(&m_guid, (void*)&g, sizeof(GUID));
}

bool CGuid::operator<(const CGuid& g1) const
{
    CHECK_VALID_BOTH(g1);
    RPC_STATUS status;
    return ::UuidCompare(const_cast<GUID*>(&m_guid), const_cast<GUID*>(&g1.m_guid), &status)==-1;
}

bool CGuid::operator>(const CGuid& g1) const
{
    CHECK_VALID_BOTH(g1);
    return !this->operator<(g1) && ::memcmp(&g1.m_guid, &m_guid, sizeof(GUID));
}

bool CGuid::Convert(const GUID& guid, CComBSTR& bstrGuid)
{
    OLECHAR szGuid[GUID_STRING_LEN]={0};
    int nCount = ::StringFromGUID2(guid, szGuid, GUID_STRING_LEN);
    bstrGuid = szGuid;

    return nCount !=0;
}

bool CGuid::Convert(const GUID& guid, CString& csGuid)
{
    OLECHAR szGuid[GUID_STRING_LEN]={0};
    int nCount = ::StringFromGUID2(guid, szGuid, GUID_STRING_LEN);
    csGuid = szGuid;

    return nCount !=0;
}

bool CGuid::Convert(const CComBSTR& bstrGuid, GUID& guid)
{	
    return Convert(CString(bstrGuid), guid);
}

bool CGuid::Convert(BSTR bstrGuid, GUID& guid)
{
    if( bstrGuid == NULL )
    {
        return false;
    }

    return Convert(CString(bstrGuid), guid);
}

bool CGuid::Convert(const CString& csGuid, GUID& guid)
{
    if( csGuid.GetLength() < GUID_STRING_LEN - 4 )
    {
        return false;
    }
    CStringW cstringw;

    if( csGuid.GetAt(0) == TCHAR('{') )
    {
        ATLASSERT(csGuid.Find(TCHAR('}'))!=-1);
        return ConvertImpl((LPCTSTR)csGuid.Mid(1, csGuid.GetLength()-2), guid);
    }
    else
    {
        return ConvertImpl((LPCTSTR)csGuid, guid);
    }
}

bool CGuid::ConvertImpl(LPCTSTR lpszGuid, GUID& guid)
{
    ATLASSERT(lpszGuid);
#ifdef _UNICODE
    RPC_STATUS rpc_status = ::UuidFromString((RPC_WSTR)lpszGuid, &guid);
#else
    RPC_STATUS rpc_status = ::UuidFromString((RPC_CSTR)lpszGuid, &guid);
#endif
    ASSERT(RPC_S_INVALID_STRING_UUID!=rpc_status);
    return rpc_status == RPC_S_OK;
}

bool CGuid::Create(CComBSTR& bstrGuid)
{
    GUID guid;
    if( Create(guid) )
    {
        return Convert(guid, bstrGuid);
    }

    return false;
}

bool CGuid::Create(GUID& guid)
{
    return ::UuidCreate(&guid) == RPC_S_OK;
}

long CGuid::HashKey(GUID& guid)
{
    RPC_STATUS status=RPC_S_OK;
    return ::UuidHash(&guid, &status);
}

BOOL CGuid::ProgID(CString& csProgID)
{
    CComBSTR bstrTmp;
    BOOL bRet = ProgID(bstrTmp);
    csProgID = bstrTmp;
    return bRet;
}

BOOL CGuid::ProgID(CComBSTR& bstrProgID)
{
    CHECK_VALID_THIS;
    BOOL bRet=FALSE;
    if( *this == GUID_NULL )
    {
        return bRet;
    }

    LPOLESTR psz = NULL;
    if( ::ProgIDFromCLSID(m_guid, &psz) == S_OK )
    {
        bstrProgID=psz;
        ::CoTaskMemFree(psz);
        psz=NULL;
        bRet=TRUE;
    }
    return bRet;
}

Thank you, and thank the author, the important thing in your version is the ability to cast from (const CGuid&) to (const GUID&) the original code miss the const directive in many places.

Just what I needed!

Very Useful Class however article is missing "How to use" steps.
I used like below

    GUID guid;
HRESULT hr = CoCreateGuid(&guid);

CString guidCStr;
CGuid::Convert(guid, guidCStr);

modified on Sunday, December 12, 2010 1:39 AM

Thank you. Laugh | :laugh:

Todd Chen

My Blog: No Geek Here! - A blog about DirectShow, Network, and Windows Programming Techniques[^]

Helpful class thanks.

A couple of things though:

1) The implicit conversion functions could be made constant. The CObject::Dump function (for example) is declared constant so code such as:

MyCObjectDerivedClass::Dump(CDumpContext& dc) const
{
dc << (const String)m_TheGUID;
}
will not compile without a constant cast. So the operators below are easily rewritten as:

operator CComBSTR() const;
operator CString() const;

2) For similar reasons, the following two operators could be added:

operator const GUID&() const;
operator const GUID*() const;

The means changing the signatures for the static Convert functions to take const arguments but this is desirable in any case.

Regards,
Terry

Nice work mate, helped to get done with GUIDs much faster.

...insanity prevails!

Nice work mate, helped to get done with GUIDs much faster.

In the first, I wish to express gratitude for creation of this class.
In the second, I wish to state the small remark:
at attempt to compile guid.cpp the mistake in line 200 stands out:

I have replaced a line: "CString csguid=bstrGuid;"
for the line: "CString csguid (bstrGuid);"

and all was compiled without mistakes!

A light wrapper class for GUID

Introduction

Source Code

History

License

Comments and Discussions