home / products / comet / documentation

l a m b d a s o f t

c o m e t

features

documentation

faq

introduction

todo

troubleshooting

forum

download

uuid_fwd.h

Go to the documentation of this file.

/*
 * Copyright © 2001, 2002 Sofus Mortensen
 *
 * This material is provided "as is", with absolutely no warranty 
 * expressed or implied. Any use is at your own risk. Permission to 
 * use or copy this software for any purpose is hereby granted without 
 * fee, provided the above notices are retained on all copies. 
 * Permission to modify the code and to distribute modified code is 
 * granted, provided the above notices are retained, and a notice that 
 * the code was modified is included with the above copyright notice. 
 *
 * This header is part of comet.
 * http://www.lambdasoft.dk/comet
 */

#ifndef COMET_UUID_FWD_H
#define COMET_UUID_FWD_H

#include <rpc.h>
#include <string>
#include <algorithm>
#include <iostream>
#include <comet/tstring.h>

namespace comet{



class uuid_t : public COMET_GUID_BASE
{
        struct unitialized_t {};
        uuid_t(unitialized_t) {}

        friend class bstr_t;

public:
        uuid_t() 
        {
                UuidCreateNil(this);
        }

        uuid_t(const COMET_GUID_BASE& u)
        {
                memcpy(this, &u, sizeof(COMET_GUID_BASE));
        }

        uuid_t& operator=(const COMET_GUID_BASE& u)
        {
                memcpy(this, &u, sizeof(COMET_GUID_BASE));
                return *this;
        }


        explicit uuid_t(const std::string& s)
        {
                if (!init_from_str(s.c_str(), s.length())) 
                        throw std::runtime_error(err_msg());
        }

        explicit uuid_t(const char* s)
        {
                if (!init_from_str(s, strlen(s))) 
                        throw std::runtime_error(err_msg());
        }

        explicit uuid_t(const std::wstring& s)
        {
                if (!init_from_str(s.c_str(), s.length())) 
                        throw std::runtime_error(err_msg());
        }

        explicit uuid_t(const wchar_t* s)
        {
                if (!init_from_str(s, wcslen(s))) 
                        throw std::runtime_error(err_msg());
        }

        explicit uuid_t(const bstr_t& bs);

        static uuid_t create()
        {
                unitialized_t x;
                uuid_t g(x);
                UuidCreate(&g);
                return g;
        }

        void clear()
        {
                UuidCreateNil(this);
        }

        unsigned short hash() const
        {
                RPC_STATUS status;
                unsigned short r = UuidHash(const_cast<uuid_t*>(this), &status);
                if (status != RPC_S_OK) 
                        throw std::runtime_error("uuid_t::hash - UuidHash failed.");
                return r;
        }



        std::string str() const
        {
                std::string r;
                r.resize(36);
                copy_to_str(&r[0]);
                return r;
        }
        inline std::string s_str() const
        {
                return str();
        }

        std::wstring w_str() const
        {
                std::wstring r;
                r.resize(36);
                copy_to_str(&r[0]);
                return r;
        }

        tstring t_str() const
        {
                tstring r;
                r.resize(36);
                copy_to_str(&r[0]);
                return r;       
        }

        bool is_null() const throw()
        {
                return ((PLONG) this)[0] == 0 &&
                           ((PLONG) this)[1] == 0 &&
                           ((PLONG) this)[2] == 0 &&
                   ((PLONG) this)[3] == 0;
        }

        bool operator!() const throw()
        {
                return is_null();
        }

        template<class E, class TR>
        friend inline std::basic_ostream<E, TR>& operator<<(std::basic_ostream<E, TR>& os, const uuid_t& u);

        template<class E, class TR>
        friend inline std::basic_istream<E, TR>& operator>>(std::basic_istream<E, TR>& is, uuid_t& u);

        class bool_tester
        { void operator delete(void*); };

        template<typename C> void copy_to_str(C s[]) const throw();
        template<typename C> bool init_from_str(const C s[], size_t len) throw();

        static const int* uuid_table()
        {
                static const int table[] = { 3, 2, 1, 0, -1, 5, 4, -1, 7, 6, -1, 8, 9, -1, 10, 11, 12, 13, 14, 15 };
                return table;
        }

        static const char* hex_table()
        {
                static const char hex[] = "0123456789abcdef";
                return hex;
        }

        static const char* err_msg()
        {
                static const char msg[] = "uuid_t: invalid format";
                return msg;
        }
        
        static int parse_nibble(int c)
        {
                return c >= 'A' ? (c|0x20) - 'a' + 10 : c - '0';
        }

        inline long cmp(const comet::uuid_t &rhs) const
        {
                long i; // The code below may be a bit dense, but it is compact and works.
                if((i = (Data1 - rhs.Data1)) == 0 && (i = (Data2 - rhs.Data2)) == 0 && (i = (Data3 - rhs.Data3)) == 0)
                        (i = ::memcmp(Data4, rhs.Data4, 8));
                return i;
        }

        inline bool is_equal( const comet::uuid_t &rhs) const
        {
                // From ATL
                return ((PLONG) this)[0] == ((PLONG) &rhs)[0] &&
                        ((PLONG) this)[1] == ((PLONG) &rhs)[1] &&
                        ((PLONG) this)[2] == ((PLONG) &rhs)[2] &&
                        ((PLONG) this)[3] == ((PLONG) &rhs)[3];
        }

public:
        operator bool_tester*() const throw()
        { if (is_null()) return 0; static bool_tester test;     return &test; }

        static const uuid_t& create_const_reference(const COMET_GUID_BASE& x)
        {
                return *reinterpret_cast<const uuid_t*>(&x);
        }

        static uuid_t& create_reference(COMET_GUID_BASE& x)
        {
                return *reinterpret_cast<uuid_t*>(&x);
        }


        COMET_GUID_BASE* out() { return this; }
        COMET_GUID_BASE* inout() { return this; }
        COMET_GUID_BASE in() const { return *this; }
        COMET_GUID_BASE* in_ptr() const { return const_cast<COMET_GUID_BASE*>(static_cast<const COMET_GUID_BASE*>(this)); }
};



inline bool operator==(const comet::uuid_t& lhs, const comet::uuid_t& rhs)
{
        return lhs.is_equal(rhs);
}

inline bool operator!=(const comet::uuid_t& lhs, const comet::uuid_t& rhs)
{
        return !lhs.is_equal(rhs);
}

inline bool operator==(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs)
{
        return lhs.is_equal( comet::uuid_t::create_const_reference(rhs) );
}

inline bool operator!=(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs)
{
        return !lhs.is_equal( comet::uuid_t::create_const_reference(rhs) );
}

inline bool operator==(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs)
{
        return comet::uuid_t::create_const_reference(lhs).is_equal(rhs);
}

inline bool operator!=(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs)
{
        return !comet::uuid_t::create_const_reference(lhs).is_equal(rhs);
}

inline bool operator<(const comet::uuid_t& lhs, const comet::uuid_t& rhs)
{
        return lhs.cmp(rhs)<0;
}

inline bool operator<(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs)
{
        return lhs.cmp(comet::uuid_t::create_const_reference(rhs))<0;
}

inline bool operator<(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs)
{
        return comet::uuid_t::create_const_reference(lhs).cmp(rhs)<0;
}

inline bool operator>=(const comet::uuid_t& lhs, const comet::uuid_t& rhs)
{
        return lhs.cmp(rhs)>=0;
}

inline bool operator>=(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs)
{
        return lhs.cmp(comet::uuid_t::create_const_reference(rhs))>=0;
}

inline bool operator>=(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs)
{
        return comet::uuid_t::create_const_reference(lhs).cmp(rhs)>=0;
}

inline bool operator>(const comet::uuid_t& lhs, const comet::uuid_t& rhs)
{
        return lhs.cmp(rhs)>0;
}

inline bool operator>(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs)
{
        return lhs.cmp(comet::uuid_t::create_const_reference(rhs))>0;
}

inline bool operator>(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs)
{
        return comet::uuid_t::create_const_reference(lhs).cmp(rhs)>0;
}

inline bool operator<=(const comet::uuid_t& lhs, const comet::uuid_t& rhs)
{
        return lhs.cmp(rhs)<=0;
}

inline bool operator<=(const comet::uuid_t& lhs, const COMET_GUID_BASE& rhs)
{
        return lhs.cmp(comet::uuid_t::create_const_reference(rhs))<=0;
}

inline bool operator<=(const COMET_GUID_BASE& lhs, const comet::uuid_t& rhs)
{
        return comet::uuid_t::create_const_reference(lhs).cmp(rhs)<=0;
}


template<class E, class TR>
inline std::basic_ostream<E, TR>& operator<<(std::basic_ostream<E, TR>& os, const comet::uuid_t& u)
{
        E buf[36];
        u.copy_to_str(buf);
        os.write(buf, 36);
        return os;
}

template<class E, class TR>
inline std::basic_istream<E, TR>& operator>>(std::basic_istream<E, TR>& is, comet::uuid_t& u)
{
        std::basic_istream<E,TR>::sentry se(is);
        if (se)
        {
                E buf[36];
                is.read(buf, 36);
                if (!u.init_from_str(buf, is.gcount())) 
                        is.setstate(std::ios::badbit);
        }
        return is;
}

} // namespace comet

#endif

Copyright 2002 Sofus Mortensen. All rights reserved.