boost::random_device rd;

ng_.seed(rd());

uv_mutex_init(&mutex_);

last_timestamp_ = 0L;

CLOCK_SEQ_AND_NODE = make_clock_seq_and_node();

ScopedMutex lock(&mutex_);

uint64_t msb = ng_();

uint64_t lsb = ng_();

lock.unlock();

copy_timestamp(msb, 4, uuid);

lsb = (lsb & 0x3FFFFFFFFFFFFFFFLL) | 0x8000000000000000LL; // RFC4122 variant

copy_clock_seq_and_node(lsb, uuid);

uint64_t timestamp = 0;

if (get_version(uuid) != 1) {

return 0;

}

timestamp |= static_cast<uint64_t>(uuid[3]);

timestamp |= static_cast<uint64_t>(uuid[2]) << 8;

timestamp |= static_cast<uint64_t>(uuid[1]) << 16;

timestamp |= static_cast<uint64_t>(uuid[0]) << 24;

timestamp |= static_cast<uint64_t>(uuid[5]) << 32;

timestamp |= static_cast<uint64_t>(uuid[4]) << 40;

timestamp |= static_cast<uint64_t>(uuid[7]) << 48;

timestamp |= static_cast<uint64_t>(uuid[6]) << 56;

timestamp &= 0x0FFFFFFFFFFFFFFFLL; // Clear version

return to_milliseconds(timestamp - TIME_OFFSET_BETWEEN_UTC_AND_EPOCH);

size_t pos = 0;

for (int i = 0; i < 16; ++i) {

char buf[3] = {'\0'};

sprintf(buf, "%02x", uuid[i]);

if (i == 4 || i == 6 || i == 8 || i == 10) {

output[pos++] = '-';

}

output[pos++] = buf[0];

output[pos++] = buf[1];

}

output[pos] = '\0';

uuid[3] = timestamp & 0x00000000000000FFL;

timestamp >>= 8;

uuid[2] = timestamp & 0x00000000000000FFL;

timestamp >>= 8;

uuid[1] = timestamp & 0x00000000000000FFL;

timestamp >>= 8;

uuid[0] = timestamp & 0x00000000000000FFL;

timestamp >>= 8;

uuid[5] = timestamp & 0x00000000000000FFL;

timestamp >>= 8;

uuid[4] = timestamp & 0x00000000000000FFL;

timestamp >>= 8;

uuid[7] = timestamp & 0x00000000000000FFL;

timestamp >>= 8;

uuid[6] = (timestamp & 0x000000000000000FL) | (version << 4);

while (true) {

uint64_t now = from_unix_timestamp(get_time_since_epoch());

uint64_t last = last_timestamp_.load();

if (now > last) {

if (last_timestamp_.compare_exchange_strong(last, now)) {

return now;

}

} else {

uint64_t last_ms = to_milliseconds(last);

if (to_milliseconds(now) < last_ms) {

return last_timestamp_.fetch_add(1L);

}

uint64_t candidate = last + 1;

if (to_milliseconds(candidate) == last_ms &&

last_timestamp_.compare_exchange_strong(last, candidate)) {

return candidate;

}

}

}

int count = 0;

EVP_MD_CTX* mdctx = EVP_MD_CTX_create();

EVP_DigestInit(mdctx, EVP_md5());

uv_interface_address_t* addresses;

int address_count;

if (uv_interface_addresses(&addresses, &address_count).code == 0) {

for (int i = 0; i < address_count; ++i) {

char buf[256];

uv_interface_address_t address = addresses[i];

EVP_DigestUpdate(mdctx, address.name, strlen(address.name));

if (address.address.address4.sin_family == AF_INET) {

uv_ip4_name(&address.address.address4, buf, sizeof(buf));

EVP_DigestUpdate(mdctx, buf, strlen(buf));

count++;

} else if (address.address.address4.sin_family == AF_INET6) {

uv_ip6_name(&address.address.address6, buf, sizeof(buf));

EVP_DigestUpdate(mdctx, buf, strlen(buf));

count++;

}

}

uv_free_interface_addresses(addresses, address_count);

}

assert(count > 0 && "No unique information for UUID node portion");

uv_cpu_info_t* cpu_infos;

int cpu_count;

if (uv_cpu_info(&cpu_infos, &cpu_count).code == 0) {

for (int i = 0; i < cpu_count; ++i) {

uv_cpu_info_t cpu_info = cpu_infos[i];

EVP_DigestUpdate(mdctx, cpu_info.model, strlen(cpu_info.model));

}

uv_free_cpu_info(cpu_infos, cpu_count);

}

uint8_t hash[16];

EVP_DigestFinal_ex(mdctx, hash, NULL);

EVP_MD_CTX_destroy(mdctx);

uint64_t node = 0L;

for (int i = 0; i < 6; ++i) {

node |= (0x00000000000000FFLL & (long)hash[i]) << (i * 8);

}

node |= 0x0000010000000000LL; // Multicast bit

uint64_t clock = ng_();

uint64_t clock_seq_and_node = 0;

clock_seq_and_node |= (clock & 0x0000000000003FFFLL) << 48;

clock_seq_and_node |= 0x8000000000000000LL; // RFC4122 variant

clock_seq_and_node |= node;

return clock_seq_and_node;