uuid.cc

Go to the documentation of this file.

 
#include "uuid.h"
 
#if defined(__MSYS__) || defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
#include <uuid/uuid.h>
#endif
 
namespace ns3 {
 
namespace Internals {
 
uint8_t unhex(char ch)
{
    if ((ch >= '0') && (ch <= '9'))
        return ch - '0';
    else if ((ch >= 'a') && (ch <= 'f'))
        return 10 + ch - 'a';
    else if ((ch >= 'A') && (ch <= 'F'))
        return 10 + ch - 'A';
    else
        return 255;
}
 
} // namespace Internals
 
UUID::UUID(const std::string& uuid)
{
    char v1 = 0;
    char v2 = 0;
    bool pack = false;
    size_t index = 0;
 
    // Parse UUID string
    for (auto ch : uuid)
    {
        if ((ch == '-') || (ch == '{') || (ch == '}'))
            continue;
 
        if (pack)
        {
            v2 = ch;
            pack = false;
            uint8_t ui1 = Internals::unhex(v1);
            uint8_t ui2 = Internals::unhex(v2);
            if ((ui1 > 15) || (ui2 > 15))
                NS_FATAL_ERROR("Invalid UUID string: " + uuid);
            _data[index++] = ui1 * 16 + ui2;
            if (index >= 16)
                break;
        }
        else
        {
            v1 = ch;
            pack = true;
        }
    }
 
    // Fill remaining data with zeros
    for (; index < 16; ++index)
        _data[index++] = 0;
}
 
std::string UUID::string() const
{
    const char* digits = "0123456789abcdef";
 
    std::string result(36, '0');
 
    int index = 0;
    for (auto value : _data)
    {
        result[index++] = digits[(value >> 4) & 0x0F];
        result[index++] = digits[(value >> 0) & 0x0F];
        if ((index == 8) || (index == 13) || (index == 18) || (index == 23))
            result[index++] = '-';
    }
 
    return result;
}
 
UUID UUID::Sequential()
{
    UUID result;
#if defined(__MSYS__) || defined(_WIN32) || defined(_WIN64)
    ::UUID uuid;
    if (UuidCreateSequential(&uuid) != RPC_S_OK)
        NS_FATAL_ERROR("Cannot generate sequential UUID!");
 
    result._data[0] = (uuid.Data1 >> 24) & 0xFF;
    result._data[1] = (uuid.Data1 >> 16) & 0xFF;
    result._data[2] = (uuid.Data1 >>  8) & 0xFF;
    result._data[3] = (uuid.Data1 >>  0) & 0xFF;
 
    result._data[4] = (uuid.Data2 >>  8) & 0xFF;
    result._data[5] = (uuid.Data2 >>  0) & 0xFF;
 
    result._data[6] = (uuid.Data3 >>  8) & 0xFF;
    result._data[7] = (uuid.Data3 >>  0) & 0xFF;
 
    result._data[8] = uuid.Data4[0];
    result._data[9] = uuid.Data4[1];
 
    result._data[10] = uuid.Data4[2];
    result._data[11] = uuid.Data4[3];
    result._data[12] = uuid.Data4[4];
    result._data[13] = uuid.Data4[5];
    result._data[14] = uuid.Data4[6];
    result._data[15] = uuid.Data4[7];
#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
    uuid_t uuid;
    uuid_generate_time(uuid);
 
    result._data[0] = uuid[0];
    result._data[1] = uuid[1];
    result._data[2] = uuid[2];
    result._data[3] = uuid[3];
 
    result._data[4] = uuid[4];
    result._data[5] = uuid[5];
 
    result._data[6] = uuid[6];
    result._data[7] = uuid[7];
 
    result._data[8] = uuid[8];
    result._data[9] = uuid[9];
 
    result._data[10] = uuid[10];
    result._data[11] = uuid[11];
    result._data[12] = uuid[12];
    result._data[13] = uuid[13];
    result._data[14] = uuid[14];
    result._data[15] = uuid[15];
#endif
    return result;
}
 
UUID UUID::Random()
{
    UUID result;
#if defined(__MSYS__) || defined(_WIN32) || defined(_WIN64)
    ::UUID uuid;
    if (UuidCreate(&uuid) != RPC_S_OK)
        NS_FATAL_ERROR("Cannot generate random UUID!");
 
    result._data[0] = (uuid.Data1 >> 24) & 0xFF;
    result._data[1] = (uuid.Data1 >> 16) & 0xFF;
    result._data[2] = (uuid.Data1 >>  8) & 0xFF;
    result._data[3] = (uuid.Data1 >>  0) & 0xFF;
 
    result._data[4] = (uuid.Data2 >>  8) & 0xFF;
    result._data[5] = (uuid.Data2 >>  0) & 0xFF;
 
    result._data[6] = (uuid.Data3 >>  8) & 0xFF;
    result._data[7] = (uuid.Data3 >>  0) & 0xFF;
 
    result._data[8] = uuid.Data4[0];
    result._data[9] = uuid.Data4[1];
 
    result._data[10] = uuid.Data4[2];
    result._data[11] = uuid.Data4[3];
    result._data[12] = uuid.Data4[4];
    result._data[13] = uuid.Data4[5];
    result._data[14] = uuid.Data4[6];
    result._data[15] = uuid.Data4[7];
#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
    uuid_t uuid;
    uuid_generate_random(uuid);
 
    result._data[0] = uuid[0];
    result._data[1] = uuid[1];
    result._data[2] = uuid[2];
    result._data[3] = uuid[3];
 
    result._data[4] = uuid[4];
    result._data[5] = uuid[5];
 
    result._data[6] = uuid[6];
    result._data[7] = uuid[7];
 
    result._data[8] = uuid[8];
    result._data[9] = uuid[9];
 
    result._data[10] = uuid[10];
    result._data[11] = uuid[11];
    result._data[12] = uuid[12];
    result._data[13] = uuid[13];
    result._data[14] = uuid[14];
    result._data[15] = uuid[15];
#endif
    return result;
}
 
inline void 
UUID::swap(UUID& uuid) noexcept
{
    using std::swap;
    swap(_data, uuid._data);
}
 
inline void 
swap(UUID& uuid1, UUID& uuid2) noexcept
{
    uuid1.swap(uuid2);
}
 
 
} // namespace ns3
 
namespace std {
 
template <>
struct hash<ns3::UUID>
{
    typedef ns3::UUID argument_type;
    typedef size_t result_type;
 
    result_type operator() (const argument_type& value) const
    {
        result_type result = 17;
        std::hash<uint8_t> hasher;
        for (size_t i = 0; i < value.data().size(); ++i)
            result = result * 31 + hasher(value.data()[i]);
        return result;
    }
};
 
} // namespace std