1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
// Copyright Epic Games, Inc. All Rights Reserved.
#include <zencore/uid.h>
#include <zencore/string.h>
#if _WIN32
# include <zencore/windows.h>
# include <bcrypt.h>
# pragma comment(lib, "bcrypt.lib")
#endif
#include <atomic>
#include <bit>
#include <set>
#include <unordered_map>
#include <doctest/doctest.h>
namespace zen {
//////////////////////////////////////////////////////////////////////////
template<typename T>
T
EndianSwap(T value)
{
uint8_t dest[sizeof value];
memcpy(dest, &value, sizeof value);
for (int i = 0; i < sizeof(value); i++)
{
uint8_t& other = dest[sizeof(value) - i - 1];
uint8_t temp = dest[i];
dest[i] = other;
other = temp;
}
T ret;
memcpy(&ret, &value, sizeof value);
return ret;
}
#if _WIN32
__forceinline uint16_t
EndianSwap(uint16_t value)
{
return _byteswap_ushort(value);
}
__forceinline uint32_t
EndianSwap(uint32_t value)
{
return _byteswap_ulong(value);
}
__forceinline uint64_t
EndianSwap(uint64_t value)
{
return _byteswap_uint64(value);
}
#endif
//////////////////////////////////////////////////////////////////////////
namespace detail {
static bool OidInitialised;
static uint32_t RunId;
static std::atomic_uint32_t Serial;
// Number of 100 nanosecond units from 1/1/1601 to 1/1/1970 - used for Windows impl
constexpr int64_t kEpochBias = 116'444'736'000'000'000ull;
} // namespace detail
//////////////////////////////////////////////////////////////////////////
const Oid Oid::Zero = {{0u, 0u, 0u}};
const Oid Oid::Max = {{~0u, ~0u, ~0u}};
void
Oid::Initialize()
{
using namespace detail;
if (OidInitialised)
return;
OidInitialised = true;
#if _WIN32
char rng[8];
BCryptGenRandom(NULL, (PUCHAR)rng, sizeof rng, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
memcpy(&RunId, &rng[0], sizeof(RunId));
memcpy((void*)&Serial, &rng[4], sizeof(Serial));
#else
# error Must implement Oid::Initialize
#endif
}
const Oid&
Oid::Generate()
{
using namespace detail;
if (!OidInitialised)
{
Oid::Initialize();
}
#if _WIN32
FILETIME filetime;
GetSystemTimeAsFileTime(&filetime); // Time is UTC
uint64_t filetime64;
memcpy(&filetime64, &filetime, sizeof filetime);
OidBits[0] = EndianSwap(uint32_t((filetime64 - kEpochBias) / 10'000'000l));
OidBits[1] = EndianSwap(uint32_t(Serial++));
OidBits[2] = RunId;
#else
# error Must implement Oid::Generate
#endif
return *this;
}
Oid
Oid::NewOid()
{
return Oid().Generate();
}
Oid
Oid::FromHexString(const std::string_view String)
{
ZEN_ASSERT(String.size() == 2 * sizeof(Oid::OidBits));
Oid Id;
if (ParseHexBytes(String.data(), String.size(), reinterpret_cast<uint8_t*>(Id.OidBits)))
{
return Id;
}
else
{
return Oid::Zero;
}
}
StringBuilderBase&
Oid::ToString(StringBuilderBase& OutString) const
{
char str[25];
ToHexBytes(reinterpret_cast<const uint8_t*>(OidBits), sizeof(Oid::OidBits), str);
str[2 * sizeof(Oid)] = '\0';
OutString.AppendRange(str, &str[25]);
return OutString;
}
TEST_CASE("Oid")
{
SUBCASE("Basic")
{
Oid id1 = Oid::NewOid();
std::vector<Oid> ids;
std::set<Oid> idset;
std::unordered_map<Oid, int, Oid::Hasher> idmap;
const int Count = 1000;
for (int i = 0; i < Count; ++i)
{
Oid id;
id.Generate();
ids.emplace_back(id);
idset.insert(id);
idmap.insert({id, i});
}
CHECK(ids.size() == Count);
CHECK(idset.size() == Count); // All ids should be unique
CHECK(idmap.size() == Count); // Ditto
}
}
void
uid_forcelink()
{
}
} // namespace zen
|