Guid Class Reference

This class provides a encapsulation of a GUID/UUID/CLSID/IID data structure (128 bit number). More...

#include <Guid.h>

Collaboration diagram for Guid:

Public Types
enum	GuidGenMethod { GuidGenDefault, GuidGenRandom, GuidGenByTime }

Public Member Functions
constexpr	Guid ()
	Standard constructor. More...
	Guid (bool assign)
	Standard constructor (With possible initialization) More...
constexpr	Guid (std::string_view s)
	Constructor for Guid from string_view. More...
constexpr	Guid (const char *s)
	Guid (const Guid &c)=default
	Copy constructor. More...
Guid &	operator= (const Guid &c)=default
auto	operator (const Guid &) const =default
	Magic spaceship operator. More...
bool	operator== (const Guid &) const =default
bool	operator== (std::string_view str) const
constexpr void	toString (std::span< char, 36 > buf, bool uppercase=true) const noexcept
	Automatic conversion to string representation. More...
constexpr std::string	toString (bool uppercase=true) const
constexpr Guid &	fromString (std::string_view s)
	Automatic conversion from string representation. More...
unsigned int	data1 () const
	Allow accessors to member data. More...
unsigned short	data2 () const
unsigned short	data3 () const
unsigned char	data4 (unsigned int i) const
void	setData1 (unsigned int data)
	Allow modifiers for member data. More...
void	setData2 (unsigned short data)
void	setData3 (unsigned short data)
void	setData4 (unsigned char data, unsigned int i)

Static Public Member Functions
static bool	isGuid (std::string_view) noexcept
static const Guid &	null () noexcept
	NULL-Guid: static class method. More...
static GuidGenMethod	initGuidGenMethod ()
	Checks for POOL_GUID_TIME or POOL_GUID_RANDOM env variables. More...
static void	create (Guid &guid, GuidGenMethod method=GuidGenDefault)
	Create a new Guid default method is currently Random, can be changed by param, API or environment. More...

Static Public Attributes
static const GuidGenMethod	m_guidGenMethod = Guid::initGuidGenMethod()

Private Member Functions
constexpr void	setToNull () noexcept

Private Attributes
unsigned int	m_data1 {}
unsigned short	m_data2 {}
unsigned short	m_data3 {}
std::array< unsigned char, 8 >	m_data4 {}

Friends
bool	operator== (std::string_view str, const Guid &rhs)
	Equality operator. More...
bool	operator!= (std::string_view str, const Guid &rhs)
	Non-equality operator. More...
std::ostream &	operator<< (std::ostream &os, const Guid &rhs)
	Extraction operators. More...

Detailed Description

This class provides a encapsulation of a GUID/UUID/CLSID/IID data structure (128 bit number).

Definition at line 24 of file Guid.h.

Member Enumeration Documentation

GuidGenMethod

enum Guid::GuidGenMethod

Enumerator
GuidGenDefault
GuidGenRandom
GuidGenByTime

Definition at line 55 of file Guid.h.

{ GuidGenDefault, GuidGenRandom, GuidGenByTime };

Constructor & Destructor Documentation

Guid() [1/5]

constexpr Guid::Guid ( )

inlineconstexpr

Standard constructor.

Definition at line 27 of file Guid.h.

: m_data1(0U), m_data2(0U), m_data3(0U), m_data4() {}

Guid() [2/5]

Guid::Guid ( bool  assign )

inlineexplicit

Standard constructor (With possible initialization)

Definition at line 29 of file Guid.h.

: Guid() { if (assign) create(*this); }

Guid() [3/5]

constexpr Guid::Guid ( std::string_view  s )

inlineconstexpr

Constructor for Guid from string_view.

Definition at line 31 of file Guid.h.

{ fromString(s); }

Guid() [4/5]

constexpr Guid::Guid ( const char *  s )

inlineconstexpr

Definition at line 33 of file Guid.h.

{ fromString(s); }

Guid() [5/5]

Guid::Guid ( const Guid &  c )

default

Copy constructor.

Member Function Documentation

create()

void Guid::create ( Guid &  guid, GuidGenMethod  method = GuidGenDefault  )

static

Create a new Guid default method is currently Random, can be changed by param, API or environment.

Create a new Guid.

Definition at line 29 of file Guid.cxx.

                                                  {
   uuid_t me_;
   if (method == GuidGenDefault) method = m_guidGenMethod;
   switch(method) {
    case GuidGenRandom:
      ::uuid_generate(me_);
      break;
    case GuidGenByTime:
      ::uuid_generate_time(me_);
      break;
    default:
      ::uuid_generate(me_);
      break;
   }
   unsigned int *d1 = (unsigned int*)me_;
   unsigned short *d2 = (unsigned short*)(me_ + 4);
   unsigned short *d3 = (unsigned short*)(me_ + 6);
   guid.m_data1 = *d1;
   guid.m_data2 = *d2;
   guid.m_data3 = *d3;
   for (unsigned int i = 0; i < 8; i++) {
      guid.m_data4[i] = me_[i + 8];
   }
}

data1()

unsigned int Guid::data1 ( ) const

inline

Allow accessors to member data.

Definition at line 65 of file Guid.h.

{ return m_data1; }

data2()

unsigned short Guid::data2 ( ) const

inline

Definition at line 66 of file Guid.h.

{ return m_data2; }

data3()

unsigned short Guid::data3 ( ) const

inline

Definition at line 67 of file Guid.h.

{ return m_data3; }

data4()

unsigned char Guid::data4 ( unsigned int  i ) const

inline

Definition at line 68 of file Guid.h.

{ if (i < 8) return m_data4[i]; return 0; }

fromString()

constexpr Guid & Guid::fromString ( std::string_view  s )

constexpr

Automatic conversion from string representation.

Definition at line 99 of file Guid.h.

                                                  {
   // Trim any whitespace
   if(std::is_constant_evaluated() && std::min(sv.find_first_not_of(' '), sv.size()) > 0){
        throw std::runtime_error("Remove spaces from GUID");
   }
   sv.remove_prefix(std::min(sv.find_first_not_of(' '), sv.size()));
   auto last_non_space = sv.find_last_not_of(' ');
   if (last_non_space == std::string_view::npos) {
      sv = {}; // String is empty or all spaces
   } else {
      if(std::is_constant_evaluated() && (sv.size() - last_non_space - 1)!=0){
         throw std::runtime_error("Remove spaces from GUID");
      }
      sv.remove_suffix(sv.size() - last_non_space - 1);
   }
 
   // Validate format
   if (sv.size() != 36 ||
       sv[8] != '-' || sv[13] != '-' || sv[18] != '-' || sv[23] != '-') {
      setToNull();
      if(std::is_constant_evaluated()){
         throw std::runtime_error("failed to compile time parse GUID");
      }
      return *this;
   }
   bool success = true;
   // Custom constexpr hex parser
   auto parse_hex = [&success](std::string_view part) -> unsigned long long {
      unsigned long long val = 0;
      for (char c : part) {
         val <<= 4; // Multiply by 16
         if (c >= '0' && c <= '9') {
            val += static_cast<unsigned long long>(c - '0');
         } else if (c >= 'a' && c <= 'f') {
            val += static_cast<unsigned long long>(10 + c - 'a');
         } else if (c >= 'A' && c <= 'F') {
            val += static_cast<unsigned long long>(10 + c - 'A');
         } else {
            success = false;
            return 0;
         }
      }
      return val;
   };
 
   // Parse m_data1 (positions 0-7)
   m_data1 = static_cast<unsigned int>(parse_hex(sv.substr(0, 8)));
 
   // Parse m_data2 (positions 9-12)
   m_data2 = static_cast<unsigned short>(parse_hex(sv.substr(9, 4)));
 
   // Parse m_data3 (positions 14-17)
   m_data3 = static_cast<unsigned short>(parse_hex(sv.substr(14, 4)));
 
 
   // Parse m_data4 bytes
   int pos = 19;
   for(int i =0; i< 2; i++){
       auto val = parse_hex(sv.substr(pos, 2));
       m_data4[i] = static_cast<unsigned char>(val);
       pos+=2;
   }
   //Skip the dash at pos 23
   pos = 24;
   for(int i =2; i< 8; i++){
       auto val = parse_hex(sv.substr(pos, 2));
       m_data4[i] = static_cast<unsigned char>(val);
       pos+=2;
   }
 
   if (!success) {
      setToNull();
      if(std::is_constant_evaluated()){
         throw std::runtime_error("failed to compile time parse GUID");
      }
   }
   return *this;
}

initGuidGenMethod()

Guid::GuidGenMethod Guid::initGuidGenMethod ( )

static

Checks for POOL_GUID_TIME or POOL_GUID_RANDOM env variables.

Definition at line 20 of file Guid.cxx.

                                          {
   char* envv = getenv("POOL_GUID_TIME");
   if (envv != 0 && *envv) return GuidGenByTime;
   envv = getenv("POOL_GUID_RANDOM");
   if (envv != 0 && *envv) return GuidGenRandom;
   return GuidGenDefault;
}

isGuid()

bool Guid::isGuid ( std::string_view  sv )

staticnoexcept

Definition at line 54 of file Guid.cxx.

                                           {
    // The GUID must be exactly 36 characters long
    if (sv.size() != 36) {
        return false;
    }
 
    // Check for hyphens at specific positions (0-based indices: 8, 13, 18, 23)
    if (sv[8] != '-' || sv[13] != '-' || sv[18] != '-' || sv[23] != '-') {
        return false;
    }
 
    // Validate that all other characters are hexadecimal digits (0-9, a-f, A-F)
    for (size_t i = 0; i < 36; ++i) {
        // Skip hyphen positions
        if (i == 8 || i == 13 || i == 18 || i == 23) {
            continue;
        }
 
        char c = sv[i];
        // Check if it's a valid hex digit
        if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
            return false;
        }
    }
    return true;
}

null()

const Guid & Guid::null ( )

staticnoexcept

NULL-Guid: static class method.

Definition at line 14 of file Guid.cxx.

                                {
   return clid_null;
}

operator()

auto Guid::operator ( const Guid &  ) const

default

Magic spaceship operator.

operator=()

Guid& Guid::operator= ( const Guid &  c )

default

operator==() [1/2]

bool Guid::operator== ( const Guid &  ) const

default

operator==() [2/2]

bool Guid::operator==

(

std::string_view

str

)

const

Definition at line 81 of file Guid.cxx.

                                              {
   return str.size() == 36 && *this == Guid(str);
}

setData1()

void Guid::setData1 ( unsigned int  data )

inline

Allow modifiers for member data.

Definition at line 71 of file Guid.h.

{ m_data1 = data; }

setData2()

void Guid::setData2 ( unsigned short  data )

inline

Definition at line 72 of file Guid.h.

{ m_data2 = data; }

setData3()

void Guid::setData3 ( unsigned short  data )

inline

Definition at line 73 of file Guid.h.

{ m_data3 = data; }

setData4()

void Guid::setData4 ( unsigned char  data, unsigned int  i  )

inline

Definition at line 74 of file Guid.h.

{ if (i < 8) m_data4[i] = data; }

setToNull()

constexpr void Guid::setToNull ( )

constexprprivatenoexcept

Definition at line 91 of file Guid.h.

                                        {
   m_data1 = 0U;
   m_data2 = 0U;
   m_data3 = 0U;
   m_data4.fill('\0');
}

toString() [1/2]

constexpr std::string Guid::toString ( bool  uppercase = true ) const

inlineconstexpr

Definition at line 44 of file Guid.h.

                                                            {
      std::string buf(36, ' ');
      toString(std::span<char, 36>(buf.data(), 36), uppercase);
      return buf;
   }

toString() [2/2]

constexpr void Guid::toString ( std::span< char, 36 >  buf, bool  uppercase = true  ) const

constexprnoexcept

Automatic conversion to string representation.

Definition at line 179 of file Guid.h.

                                                                                  {
 
    constexpr char lowhex[] = "0123456789abcdef";
    constexpr char uphex[]  = "0123456789ABCDEF";
    const char *hex = uppercase ? uphex : lowhex;
 
    // Unrolled for m_data1 (8 hex digits)
    unsigned int v1 = m_data1;
    buf[0] = hex[(v1 >> 28) & 0xF];
    buf[1] = hex[(v1 >> 24) & 0xF];
    buf[2] = hex[(v1 >> 20) & 0xF];
    buf[3] = hex[(v1 >> 16) & 0xF];
    buf[4] = hex[(v1 >> 12) & 0xF];
    buf[5] = hex[(v1 >> 8) & 0xF];
    buf[6] = hex[(v1 >> 4) & 0xF];
    buf[7] = hex[v1 & 0xF];
    buf[8] = '-';
 
    // Unrolled for m_data2 (4 hex digits)
    unsigned short v2 = m_data2;
    buf[9] = hex[(v2 >> 12) & 0xF];
    buf[10] = hex[(v2 >> 8) & 0xF];
    buf[11] = hex[(v2 >> 4) & 0xF];
    buf[12] = hex[v2 & 0xF];
    buf[13] = '-';
 
    // Unrolled for m_data3 (4 hex digits)
    unsigned short v3 = m_data3;
    buf[14] = hex[(v3 >> 12) & 0xF];
    buf[15] = hex[(v3 >> 8) & 0xF];
    buf[16] = hex[(v3 >> 4) & 0xF];
    buf[17] = hex[v3 & 0xF];
    buf[18] = '-';
 
    // Unrolled for m_data4[0] and [1] (2+2 hex digits)
    int pos = 19;
    for(int i =0; i<2;i++){
      unsigned char c = m_data4[i];
      buf[pos] = hex[c >> 4];
      buf[pos+1] = hex[c & 0xF];
      pos +=2;
    }
    buf[23] = '-';
    pos = 24;
    // Unrolled for remaining m_data4[2..7] (6 pairs of hex digits)
    for(int i =2; i<8;i++){
      unsigned char c = m_data4[i];
      buf[pos] = hex[c >> 4];
      buf[pos+1] = hex[c & 0xF];
      pos +=2;
    }
 
}

Friends And Related Function Documentation

operator!=

bool operator!= ( std::string_view  str, const Guid &  rhs  )

friend

Non-equality operator.

Definition at line 79 of file Guid.h.

{ return !(rhs.operator==(str)); }

operator<<

std::ostream& operator<< ( std::ostream &  os, const Guid &  rhs  )

friend

Extraction operators.

Definition at line 86 of file Guid.cxx.

                                                        {
  std::array<char, 36> buff;
  rhs.toString(buff);
  os.write(buff.data(), 36);
  return os; 
}

operator==

bool operator== ( std::string_view  str, const Guid &  rhs  )

friend

Equality operator.

Definition at line 77 of file Guid.h.

{ return (rhs.operator==(str)); }

Member Data Documentation

m_data1

unsigned int Guid::m_data1 {}

private

Definition at line 85 of file Guid.h.

m_data2

unsigned short Guid::m_data2 {}

private

Definition at line 86 of file Guid.h.

m_data3

unsigned short Guid::m_data3 {}

private

Definition at line 87 of file Guid.h.

m_data4

std::array<unsigned char,8> Guid::m_data4 {}

private

Definition at line 88 of file Guid.h.

m_guidGenMethod

const Guid::GuidGenMethod Guid::m_guidGenMethod = Guid::initGuidGenMethod()

static

Definition at line 56 of file Guid.h.

---

The documentation for this class was generated from the following files:

• Guid.h
• Guid.cxx