Logo ROOT  
Reference Guide
TUUID.cxx
Go to the documentation of this file.
1 // @(#)root/base:$Id$
2 // Author: Fons Rademakers 30/9/2001
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class TUUID
13 \ingroup Base
14 
15 This class defines a UUID (Universally Unique IDentifier), also
16 known as GUIDs (Globally Unique IDentifier). A UUID is 128 bits
17 long, and if generated according to this algorithm, is either
18 guaranteed to be different from all other UUIDs/GUIDs generated
19 until 3400 A.D. or extremely likely to be different. UUIDs were
20 originally used in the Network Computing System (NCS) and
21 later in the Open Software Foundation's (OSF) Distributed Computing
22 Environment (DCE).
23 
24 Structure of universal unique IDs (UUIDs).
25 
26 Depending on the network data representation, the multi-
27 octet unsigned integer fields are subject to byte swapping
28 when communicated between dissimilar endian machines.
29 ~~~ {.cpp}
30 +-----------------------------------+
31 | low 32 bits of time | 0-3 .fTimeLow
32 +-------------------------------+----
33 | mid 16 bits of time | 4-5 .fTimeMid
34 +-------+-----------------------+
35 | vers. | hi 12 bits of time | 6-7 .fTimeHiAndVersion
36 +-------+-------+---------------+
37 |Res | clkSeqHi | 8 .fClockSeqHiAndReserved
38 +---------------+
39 | clkSeqLow | 9 .fClockSeqLow
40 +---------------+------------------+
41 | node ID | 10-15 .fNode
42 +----------------------------------+
43 ~~~
44 
45 The adjusted time stamp is split into three fields, and the
46 clockSeq is split into two fields.
47 
48 The timestamp is a 60-bit value. For UUID version 1, this
49 is represented by Coordinated Universal Time (UTC/GMT) as
50 a count of 100-nanosecond intervals since 00:00:00.00,
51 15 October 1582 (the date of Gregorian reform to the
52 Christian calendar).
53 
54 The version number is multiplexed in the 4 most significant
55 bits of the 'fTimeHiAndVersion' field. There are two defined
56 versions:
57 ~~~ {.cpp}
58  MSB <---
59 Version 4-Bit Code Description
60 ------------------------------------------------------------
61 | 1 0 0 0 1 DCE version, as specified herein.
62 | 2 0 0 1 0 DCE Security version, with
63 | embedded POSIX UIDs.
64 | 3 0 0 1 1 node id is a random value
65 ------------------------------------------------------------
66 ~~~
67 
68 ## Clock Sequence
69 
70 The clock sequence value must be changed whenever:
71 
72  The UUID generator detects that the local value of UTC
73  has gone backward; this may be due to re-syncing of the system
74  clock.
75 
76 While a node is operational, the UUID service always saves
77 the last UTC used to create a UUID. Each time a new UUID
78 is created, the current UTC is compared to the saved value
79 and if either the current value is less or the saved value
80 was lost, then the clock sequence is incremented modulo
81 16,384, thus avoiding production of duplicated UUIDs.
82 
83 The clock sequence must be initialized to a random number
84 to minimize the correlation across system. This provides
85 maximum protection against node identifiers that may move
86 or switch from system to system rapidly.
87 
88 ## Clock Adjustment
89 
90 UUIDs may be created at a rate greater than the system clock
91 resolution. Therefore, the system must also maintain an
92 adjustment value to be added to the lower-order bits of the
93 time. Logically, each time the system clock ticks, the
94 adjustment value is cleared. Every time a UUID is generated,
95 the current adjustment value is read and incremented, and
96 then added to the UTC time field of the UUID.
97 
98 ## Clock Overrun
99 
100 The 100-nanosecond granularity of time should prove sufficient
101 even for bursts of UUID production in the next generation of
102 high-performance multiprocessors. If a system overruns the
103 clock adjustment by requesting too many UUIDs within a single
104 system clock tick, the UUID generator will stall until the
105 system clock catches up.
106 */
107 
108 #include "TROOT.h"
109 #include "TDatime.h"
110 #include "TUUID.h"
111 #include "TBuffer.h"
112 #include "TError.h"
113 #include "TSystem.h"
114 #include "TInetAddress.h"
115 #include "TMD5.h"
116 #include "Bytes.h"
117 #include "TVirtualMutex.h"
118 #include "ThreadLocalStorage.h"
119 #include <string.h>
120 #include <stdlib.h>
121 #ifdef R__WIN32
122 #include "Windows4Root.h"
123 #include <Iphlpapi.h>
124 #include <process.h>
125 #define getpid() _getpid()
126 #define srandom(seed) srand(seed)
127 #define random() rand()
128 #else
129 #include <unistd.h>
130 #include <sys/time.h>
131 #if defined(R__LINUX) && !defined(R__WINGCC)
132 #include <sys/sysinfo.h>
133 #endif
134 #include <ifaddrs.h>
135 #include <netinet/in.h>
136 #endif
137 #include <chrono>
138 
139 ClassImp(TUUID);
140 
141 ////////////////////////////////////////////////////////////////////////////////
142 /// Create a UUID.
143 
145 {
146  TTHREAD_TLS(uuid_time_t) time_last;
147  TTHREAD_TLS(UShort_t) clockseq(0);
148  TTHREAD_TLS(Bool_t) firstTime(kTRUE);
149  uuid_time_t *time_last_ptr = TTHREAD_TLS_PTR(time_last);
150 
151  if (firstTime) {
152  R__LOCKGUARD(gROOTMutex); // rand and random are not thread safe.
153 
154  UInt_t seed;
155  if (gSystem) {
156  // try to get a unique seed per process
157  seed = (UInt_t)(Long64_t(gSystem->Now()) + gSystem->GetPid());
158  } else {
159  using namespace std::chrono;
160  system_clock::time_point today = system_clock::now();
161  seed = (UInt_t)(system_clock::to_time_t ( today )) + ::getpid();
162  }
163  srandom(seed);
164  GetCurrentTime(time_last_ptr);
165  clockseq = 1+(UShort_t)(65536*random()/(RAND_MAX+1.0));
166  firstTime = kFALSE;
167  }
168 
169  uuid_time_t timestamp;
170 
171  // get current time
172  GetCurrentTime(&timestamp);
173 
174  // if clock went backward change clockseq
175  if (CmpTime(&timestamp, time_last_ptr) == -1) {
176  clockseq = (clockseq + 1) & 0x3FFF;
177  if (clockseq == 0) clockseq++;
178  }
179 
180  Format(clockseq, timestamp);
181 
182  time_last = timestamp;
183  fUUIDIndex = 1<<30;
184 }
185 
186 ////////////////////////////////////////////////////////////////////////////////
187 /// delete this TUUID
188 
190 {
191  //gROOT->GetUUIDs()->RemoveUUID(fUUIDIndex);
192 }
193 
194 ////////////////////////////////////////////////////////////////////////////////
195 /// Compare two time values.
196 
198 {
199  if (t1->high < t2->high) return -1;
200  if (t1->high > t2->high) return 1;
201  if (t1->low < t2->low) return -1;
202  if (t1->low > t2->low) return 1;
203  return 0;
204 }
205 
206 ////////////////////////////////////////////////////////////////////////////////
207 /// Set this UUID to the value specified in uuid ((which must be in
208 /// TUUID::AsString() format).
209 
210 void TUUID::SetFromString(const char *uuid)
211 {
212  // Format is tttttttt-tttt-cccc-cccc-nnnnnnnnnnnn.
213  Long_t timeLo;
214  int timeMid;
215  int timeHiAndVersion;
216  int clockSeqHiAndRes;
217  int clockSeqLo;
218  int node[6];
219 
220  sscanf(uuid, "%8lx-%4x-%4x-%2x%2x-%2x%2x%2x%2x%2x%2x",
221  &timeLo,
222  &timeMid,
223  &timeHiAndVersion,
224  &clockSeqHiAndRes,
225  &clockSeqLo,
226  &node[0], &node[1], &node[2], &node[3], &node[4], &node[5]);
227 
228  // Note that we're going through this agony because scanf is
229  // defined to know only to scan into "int"s or "long"s.
230  fTimeLow = (UInt_t) timeLo;
231  fTimeMid = (UShort_t) timeMid;
232  fTimeHiAndVersion = (UShort_t) timeHiAndVersion;
233  fClockSeqHiAndReserved = (UChar_t) clockSeqHiAndRes;
234  fClockSeqLow = (UChar_t) clockSeqLo;
235  fNode[0] = (UChar_t) node[0];
236  fNode[1] = (UChar_t) node[1];
237  fNode[2] = (UChar_t) node[2];
238  fNode[3] = (UChar_t) node[3];
239  fNode[4] = (UChar_t) node[4];
240  fNode[5] = (UChar_t) node[5];
241  fUUIDIndex = 1<<30;
242 }
243 
244 ////////////////////////////////////////////////////////////////////////////////
245 /// Initialize a TUUID with uuid (which must be in TUUID::AsString() format).
246 
247 TUUID::TUUID(const char *uuid)
248 {
249  fTimeLow = 0;
250  fTimeMid = 0;
251  fTimeHiAndVersion = 0;
253  fClockSeqLow = 0;
254  fNode[0] = 0;
255  fUUIDIndex = 0;
256 
257  if (!uuid || !*uuid)
258  Error("TUUID", "null string not allowed");
259  else
260  SetFromString(uuid);
261 }
262 
263 ////////////////////////////////////////////////////////////////////////////////
264 /// Stream UUID into output buffer.
265 
266 void TUUID::FillBuffer(char *&buffer)
267 {
268  Version_t version = TUUID::Class_Version();
269  tobuf(buffer, version);
270  tobuf(buffer, fTimeLow);
271  tobuf(buffer, fTimeMid);
272  tobuf(buffer, fTimeHiAndVersion);
273  tobuf(buffer, fClockSeqHiAndReserved);
274  tobuf(buffer, fClockSeqLow);
275  for (Int_t i = 0; i < 6; i++)
276  tobuf(buffer, fNode[i]);
277 }
278 
279 ////////////////////////////////////////////////////////////////////////////////
280 /// Stream UUID from input buffer.
281 
282 void TUUID::ReadBuffer(char *&buffer)
283 {
284  Version_t version;
285  frombuf(buffer, &version);
286  frombuf(buffer, &fTimeLow);
287  frombuf(buffer, &fTimeMid);
288  frombuf(buffer, &fTimeHiAndVersion);
290  frombuf(buffer, &fClockSeqLow);
291  for (Int_t i = 0; i < 6; i++)
292  frombuf(buffer, &fNode[i]);
293 }
294 
295 ////////////////////////////////////////////////////////////////////////////////
296 /// Stream UUID from input buffer.
297 /// This function is for the exclusive use of TDirectory::Streamer() to
298 /// read a non-versioned version of TUUID.
299 
301 {
302  b >> fTimeLow;
303  b >> fTimeMid;
304  b >> fTimeHiAndVersion;
306  b >> fClockSeqLow;
307  for (UInt_t i = 0; i < 6; i++) {
308  b >> fNode[i];
309  }
310 }
311 
312 ////////////////////////////////////////////////////////////////////////////////
313 /// Make a UUID from timestamp, clockseq and node id.
314 
316 {
317  fTimeLow = ts.low;
318  fTimeMid = (UShort_t)(ts.high & 0xFFFF);
319  fTimeHiAndVersion = (UShort_t)((ts.high >> 16) & 0x0FFF);
320  fTimeHiAndVersion |= (1 << 12);
321  fClockSeqLow = clockseq & 0xFF;
322  fClockSeqHiAndReserved = (clockseq & 0x3F00) >> 8;
323  fClockSeqHiAndReserved |= 0x80;
325 }
326 
327 ////////////////////////////////////////////////////////////////////////////////
328 /// Get current time as 60 bit 100ns ticks since whenever.
329 /// Compensate for the fact that real clock resolution is less
330 /// than 100ns.
331 
333 {
334  const UShort_t uuids_per_tick = 1024;
335 
336  TTHREAD_TLS(uuid_time_t) time_last;
337  TTHREAD_TLS(UShort_t) uuids_this_tick(0);
338  TTHREAD_TLS(Bool_t) init(kFALSE);
339 
340  uuid_time_t *time_last_ptr = TTHREAD_TLS_PTR(time_last);
341 
342  if (!init) {
343  GetSystemTime(time_last_ptr);
344  uuids_this_tick = uuids_per_tick;
345  init = kTRUE;
346  }
347 
348  uuid_time_t time_now;
349 
350  while (1) {
351  GetSystemTime(&time_now);
352 
353  // if clock reading changed since last UUID generated
354  if (CmpTime(time_last_ptr, &time_now)) {
355  // reset count of uuid's generated with this clock reading
356  uuids_this_tick = 0;
357  break;
358  }
359  if (uuids_this_tick < uuids_per_tick) {
360  uuids_this_tick++;
361  break;
362  }
363  // going too fast for our clock; spin
364  }
365 
366  time_last = time_now;
367 
368  if (uuids_this_tick != 0) {
369  if (time_now.low & 0x80000000) {
370  time_now.low += uuids_this_tick;
371  if (!(time_now.low & 0x80000000))
372  time_now.high++;
373  } else
374  time_now.low += uuids_this_tick;
375  }
376 
377  timestamp->high = time_now.high;
378  timestamp->low = time_now.low;
379 }
380 
381 ////////////////////////////////////////////////////////////////////////////////
382 /// Get system time with 100ns precision. Time is since Oct 15, 1582.
383 
385 {
386 #ifdef R__WIN32
387  ULARGE_INTEGER time;
388  GetSystemTimeAsFileTime((FILETIME *)&time);
389  // NT keeps time in FILETIME format which is 100ns ticks since
390  // Jan 1, 1601. UUIDs use time in 100ns ticks since Oct 15, 1582.
391  // The difference is 17 Days in Oct + 30 (Nov) + 31 (Dec)
392  // + 18 years and 5 leap days.
393  time.QuadPart +=
394  (unsigned __int64) (1000*1000*10) // seconds
395  * (unsigned __int64) (60 * 60 * 24) // days
396  * (unsigned __int64) (17+30+31+365*18+5); // # of days
397 
398  timestamp->high = time.HighPart;
399  timestamp->low = time.LowPart;
400 #else
401  struct timeval tp;
402  gettimeofday(&tp, 0);
403  // Offset between UUID formatted times and Unix formatted times.
404  // UUID UTC base time is October 15, 1582.
405  // Unix base time is January 1, 1970.
406  ULong64_t uuid_time = ((ULong64_t)tp.tv_sec * 10000000) + (tp.tv_usec * 10) +
407  0x01B21DD213814000LL;
408  timestamp->high = (UInt_t) (uuid_time >> 32);
409  timestamp->low = (UInt_t) (uuid_time & 0xFFFFFFFF);
410 #endif
411 }
412 
413 ////////////////////////////////////////////////////////////////////////////////
414 /// Get node identifier. Try first to get network address, if no
415 /// network interface try random info based on some machine parameters.
416 
418 {
419  static UInt_t adr = 0;
420 
421  if (gSystem) {
422 #ifndef R__WIN32
423  if (!adr) {
424  UInt_t addr = 0;
425 
426  struct ifaddrs *ifAddrStruct = nullptr;
427  struct ifaddrs *ifa = nullptr;
428 
429  if (getifaddrs(&ifAddrStruct) != 0) {
430  adr = 1;
431  } else {
432  for (ifa = ifAddrStruct; ifa != NULL; ifa = ifa->ifa_next) {
433  if (!ifa->ifa_addr) {
434  continue;
435  }
436  if (ifa->ifa_addr->sa_family != AF_INET) { // check only IP4
437  continue;
438  }
439  if (strncmp(ifa->ifa_name,"lo",2) == 0) { // skip loop back.
440  continue;
441  }
442  addr = ntohl(((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr);
443  break;
444  }
445  }
446 
447  if (ifAddrStruct != nullptr)
448  freeifaddrs(ifAddrStruct);
449 
450  if (addr)
451  adr = addr;
452  else
453  adr = 1; // illegal address
454  }
455 #else
456  // this way to get the machine's IP address is needed because
457  // GetHostByName() on Win32 contacts the DNS which we don't want
458  // as firewall tools like ZoneAlarm are likely to catch it and
459  // alarm the user
460  if (!adr) {
461  PIP_ADAPTER_INFO ainfo = (PIP_ADAPTER_INFO) malloc(sizeof(IP_ADAPTER_INFO));
462  ULONG buflen = sizeof(IP_ADAPTER_INFO);
463  DWORD stat = GetAdaptersInfo(ainfo, &buflen);
464  if (stat == ERROR_BUFFER_OVERFLOW) {
465  free(ainfo);
466  ainfo = (PIP_ADAPTER_INFO) malloc(buflen);
467  stat = GetAdaptersInfo(ainfo, &buflen);
468  }
469  if (stat != ERROR_SUCCESS)
470  adr = 1; // illegal address
471  else {
472  // take address of first adapter
473  PIP_ADAPTER_INFO adapter = ainfo;
474  int a, b, c, d;
475  sscanf(adapter->IpAddressList.IpAddress.String, "%d.%d.%d.%d",
476  &a, &b, &c, &d);
477  adr = (a << 24) | (b << 16) | (c << 8) | d;
478  }
479  free(ainfo);
480  }
481 #endif
482  if (adr > 2) {
483  memcpy(fNode, &adr, 4);
484  fNode[4] = 0xbe;
485  fNode[5] = 0xef;
486  return;
487  }
488  }
489  static UChar_t seed[16];
490  if (adr < 2) {
491  GetRandomInfo(seed);
492  seed[0] |= 0x80;
493  if (gSystem) adr = 2; // illegal address
494  }
495  memcpy(fNode, seed, sizeof(fNode));
496  fTimeHiAndVersion |= (3 << 12); // version == 3: random node info
497 }
498 
499 ////////////////////////////////////////////////////////////////////////////////
500 /// Get random info based on some machine parameters.
501 
503 {
504 #ifdef R__WIN32
505  struct randomness {
506  MEMORYSTATUS m;
507  SYSTEM_INFO s;
508  FILETIME t;
509  LARGE_INTEGER pc;
510  DWORD tc;
511  DWORD l;
512  char hostname[MAX_COMPUTERNAME_LENGTH + 1];
513  };
514  randomness r;
515  memset(&r, 0, sizeof(r)); // zero also padding bytes
516 
517  // memory usage stats
518  GlobalMemoryStatus(&r.m);
519  // random system stats
520  GetSystemInfo(&r.s);
521  // 100ns resolution time of day
522  GetSystemTimeAsFileTime(&r.t);
523  // high resolution performance counter
524  QueryPerformanceCounter(&r.pc);
525  // milliseconds since last boot
526  r.tc = GetTickCount();
527  r.l = MAX_COMPUTERNAME_LENGTH + 1;
528  GetComputerName(r.hostname, &r.l);
529 #else
530  struct randomness {
531 #if defined(R__LINUX) && !defined(R__WINGCC)
532  struct sysinfo s;
533 #endif
534  struct timeval t;
535  char hostname[257];
536  };
537  randomness r;
538  memset(&r, 0, sizeof(r)); // zero also padding bytes
539 
540 #if defined(R__LINUX) && !defined(R__WINGCC)
541  sysinfo(&r.s);
542 #endif
543  gettimeofday(&r.t, 0);
544  gethostname(r.hostname, 256);
545 #endif
546  TMD5 md5;
547  md5.Update((UChar_t *)&r, sizeof(randomness));
548  md5.Final(seed);
549 }
550 
551 ////////////////////////////////////////////////////////////////////////////////
552 /// Print UUID.
553 
554 void TUUID::Print() const
555 {
556  printf("%s\n", AsString());
557 }
558 
559 ////////////////////////////////////////////////////////////////////////////////
560 /// Return UUID as string. Copy string immediately since it will be reused.
561 
562 const char *TUUID::AsString() const
563 {
564  static char uuid[40];
565 
566  snprintf(uuid,40, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
568  fClockSeqLow, fNode[0], fNode[1], fNode[2], fNode[3], fNode[4],
569  fNode[5]);
570 
571  return uuid;
572 }
573 
574 ////////////////////////////////////////////////////////////////////////////////
575 /// Compute 16-bit hash value of the UUID.
576 
578 {
579  Short_t c0 = 0, c1 = 0, x, y;
580  char *c = (char *) &fTimeLow;
581 
582  // For speed lets unroll the following loop:
583  // for (i = 0; i < 16; i++) {
584  // c0 += *c++;
585  // c1 += c0;
586  // }
587 
588  c0 += *c++; c1 += c0;
589  c0 += *c++; c1 += c0;
590  c0 += *c++; c1 += c0;
591  c0 += *c++; c1 += c0;
592 
593  c0 += *c++; c1 += c0;
594  c0 += *c++; c1 += c0;
595  c0 += *c++; c1 += c0;
596  c0 += *c++; c1 += c0;
597 
598  c0 += *c++; c1 += c0;
599  c0 += *c++; c1 += c0;
600  c0 += *c++; c1 += c0;
601  c0 += *c++; c1 += c0;
602 
603  c0 += *c++; c1 += c0;
604  c0 += *c++; c1 += c0;
605  c0 += *c++; c1 += c0;
606  c0 += *c++; c1 += c0;
607 
608  // Calculate the value for "First octet" of the hash
609  x = -c1 % 255;
610  if (x < 0)
611  x += 255;
612 
613  // Calculate the value for "second octet" of the hash
614  y = (c1 - c0) % 255;
615  if (y < 0)
616  y += 255;
617 
618  return UShort_t((y << 8) + x);
619 }
620 
621 ////////////////////////////////////////////////////////////////////////////////
622 /// Compare two UUIDs "lexically" and return
623 /// - -1 this is lexically before u
624 /// - 0 this is equal to u
625 /// - 1 this is lexically after u
626 
627 Int_t TUUID::Compare(const TUUID &u) const
628 {
629 #define CHECK(f1, f2) if (f1 != f2) return f1 < f2 ? -1 : 1;
635  for (int i = 0; i < 6; i++) {
636  if (fNode[i] < u.fNode[i])
637  return -1;
638  if (fNode[i] > u.fNode[i])
639  return 1;
640  }
641  return 0;
642 }
643 
644 ////////////////////////////////////////////////////////////////////////////////
645 /// Get address of host encoded in UUID. If host id is not an ethernet
646 /// address, but random info, then the returned TInetAddress is not valid.
647 
649 {
650  if ((fTimeHiAndVersion >> 12) == 1) {
651  UInt_t addr;
652  memcpy(&addr, fNode, 4);
653  return TInetAddress("????", addr, 0);
654  }
655  return TInetAddress();
656 }
657 
658 ////////////////////////////////////////////////////////////////////////////////
659 /// Get time from UUID.
660 
662 {
663  TDatime dt;
664  uuid_time_t ts;
665 
666  ts.low = fTimeLow;
667  ts.high = (UInt_t)fTimeMid;
668  ts.high |= (UInt_t)((fTimeHiAndVersion & 0x0FFF) << 16);
669 
670  // Offset between UUID formatted times and Unix formatted times.
671  // UUID UTC base time is October 15, 1582.
672  // Unix base time is January 1, 1970.
673  ULong64_t high = ts.high;
674  ULong64_t uuid_time = (high << 32) + ts.low;
675  uuid_time -= 0x01B21DD213814000LL;
676  uuid_time /= 10000000LL;
677  UInt_t tt = (UInt_t) uuid_time;
678  dt.Set(tt);
679 
680  return dt;
681 }
682 
683 ////////////////////////////////////////////////////////////////////////////////
684 /// Return uuid in specified buffer (16 byte = 128 bits).
685 
686 void TUUID::GetUUID(UChar_t uuid[16]) const
687 {
688  memcpy(uuid, &fTimeLow, 16);
689 }
690 
691 ////////////////////////////////////////////////////////////////////////////////
692 /// Set this UUID to the value specified in uuid ((which must be in
693 /// TUUID::AsString() format).
694 
695 void TUUID::SetUUID(const char *uuid)
696 {
697  if (!uuid || !*uuid)
698  Error("SetUUID", "null string not allowed");
699  else
700  SetFromString(uuid);
701 }
702 
703 ////////////////////////////////////////////////////////////////////////////////
704 /// Input operator. Delegate to Streamer.
705 
706 TBuffer &operator<<(TBuffer &buf, const TUUID &uuid)
707 {
708  R__ASSERT( buf.IsWriting() );
709 
710  const_cast<TUUID&>(uuid).Streamer(buf);
711  return buf;
712 }
TUUID::GetNodeIdentifier
void GetNodeIdentifier()
Get node identifier.
Definition: TUUID.cxx:417
c
#define c(i)
Definition: RSha256.hxx:119
TUUID::uuid_time_t
Definition: TUUID.h:53
l
auto * l
Definition: textangle.C:4
TUUID::Hash
UShort_t Hash() const
Compute 16-bit hash value of the UUID.
Definition: TUUID.cxx:577
m
auto * m
Definition: textangle.C:8
TUUID::fTimeLow
UInt_t fTimeLow
index in the list of UUIDs in TProcessUUID
Definition: TUUID.h:46
TUUID::FillBuffer
void FillBuffer(char *&buffer)
Stream UUID into output buffer.
Definition: TUUID.cxx:266
TUUID::TUUID
TUUID()
Create a UUID.
Definition: TUUID.cxx:144
Windows4Root.h
TUUID::uuid_time_t::low
UInt_t low
Definition: TUUID.h:55
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
tt
auto * tt
Definition: textangle.C:16
Version_t
short Version_t
Definition: RtypesCore.h:65
snprintf
#define snprintf
Definition: civetweb.c:1540
TUUID::~TUUID
virtual ~TUUID()
delete this TUUID
Definition: TUUID.cxx:189
TUUID::GetCurrentTime
void GetCurrentTime(uuid_time_t *timestamp)
Get current time as 60 bit 100ns ticks since whenever.
Definition: TUUID.cxx:332
UShort_t
unsigned short UShort_t
Definition: RtypesCore.h:40
TUUID::ReadBuffer
void ReadBuffer(char *&buffer)
Stream UUID from input buffer.
Definition: TUUID.cxx:282
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TDatime.h
tobuf
void tobuf(char *&buf, Bool_t x)
Definition: Bytes.h:55
r
ROOT::R::TRInterface & r
Definition: Object.C:4
Long64_t
long long Long64_t
Definition: RtypesCore.h:73
BatchHelpers::init
EvaluateInfo init(std::vector< RooRealProxy > parameters, std::vector< ArrayWrapper * > wrappers, std::vector< double * > arrays, size_t begin, size_t batchSize)
TMD5::Final
void Final()
MD5 finalization, ends an MD5 message-digest operation, writing the the message digest and zeroizing ...
Definition: TMD5.cxx:167
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:168
operator<<
TBuffer & operator<<(TBuffer &buf, const TUUID &uuid)
Input operator. Delegate to Streamer.
Definition: TUUID.cxx:706
TUUID::CmpTime
Int_t CmpTime(uuid_time_t *t1, uuid_time_t *t2)
Compare two time values.
Definition: TUUID.cxx:197
TGeant4Unit::pc
static constexpr double pc
Definition: TGeant4SystemOfUnits.h:136
x
Double_t x[n]
Definition: legend1.C:17
TMD5::Update
void Update(const UChar_t *buf, UInt_t len)
Update TMD5 object to reflect the concatenation of another buffer full of bytes.
Definition: TMD5.cxx:108
TUUID::GetTime
TDatime GetTime() const
Get time from UUID.
Definition: TUUID.cxx:661
TBuffer
Definition: TBuffer.h:43
b
#define b(i)
Definition: RSha256.hxx:118
bool
TDatime::Set
void Set()
Set Date/Time to current time as reported by the system.
Definition: TDatime.cxx:289
TUUID::fUUIDIndex
UInt_t fUUIDIndex
Definition: TUUID.h:45
TROOT.h
TUUID.h
malloc
#define malloc
Definition: civetweb.c:1536
TBuffer.h
TSystem.h
gROOTMutex
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:61
TSystem::GetPid
virtual int GetPid()
Get process id.
Definition: TSystem.cxx:708
TUUID::fTimeHiAndVersion
UShort_t fTimeHiAndVersion
Definition: TUUID.h:48
TBuffer::IsWriting
Bool_t IsWriting() const
Definition: TBuffer.h:87
a
auto * a
Definition: textangle.C:12
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
Long_t
long Long_t
Definition: RtypesCore.h:54
TInetAddress.h
R__LOCKGUARD
#define R__LOCKGUARD(mutex)
Definition: TVirtualMutex.h:104
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:46
TSystem::Now
virtual TTime Now()
Get current time in milliseconds since 0:00 Jan 1 1995.
Definition: TSystem.cxx:464
y
Double_t y[n]
Definition: legend1.C:17
TUUID
Definition: TUUID.h:42
TMD5
Definition: TMD5.h:44
Short_t
short Short_t
Definition: RtypesCore.h:39
TVirtualMutex.h
unsigned int
TUUID::StreamerV1
void StreamerV1(TBuffer &b)
Stream UUID from input buffer.
Definition: TUUID.cxx:300
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
CHECK
#define CHECK(f1, f2)
ULong64_t
unsigned long long ULong64_t
Definition: RtypesCore.h:74
TUUID::fNode
UChar_t fNode[6]
Definition: TUUID.h:51
TUUID::Compare
Int_t Compare(const TUUID &u) const
Compare two UUIDs "lexically" and return.
Definition: TUUID.cxx:627
TUUID::fClockSeqLow
UChar_t fClockSeqLow
Definition: TUUID.h:50
TUUID::SetUUID
void SetUUID(const char *uuid_str)
Set this UUID to the value specified in uuid ((which must be in TUUID::AsString() format).
Definition: TUUID.cxx:695
TUUID::uuid_time_t::high
UInt_t high
Definition: TUUID.h:54
TUUID::Format
void Format(UShort_t clockseq, uuid_time_t ts)
Make a UUID from timestamp, clockseq and node id.
Definition: TUUID.cxx:315
R__ASSERT
#define R__ASSERT(e)
Definition: TError.h:120
t1
auto * t1
Definition: textangle.C:20
frombuf
void frombuf(char *&buf, Bool_t *x)
Definition: Bytes.h:278
UChar_t
unsigned char UChar_t
Definition: RtypesCore.h:38
TUUID::GetHostAddress
TInetAddress GetHostAddress() const
Get address of host encoded in UUID.
Definition: TUUID.cxx:648
Bytes.h
d
#define d(i)
Definition: RSha256.hxx:120
TUUID::AsString
const char * AsString() const
Return UUID as string. Copy string immediately since it will be reused.
Definition: TUUID.cxx:562
TMD5.h
TDatime
Definition: TDatime.h:37
TUUID::GetRandomInfo
void GetRandomInfo(UChar_t seed[16])
Get random info based on some machine parameters.
Definition: TUUID.cxx:502
free
#define free
Definition: civetweb.c:1539
TUUID::fTimeMid
UShort_t fTimeMid
Definition: TUUID.h:47
TInetAddress
Definition: TInetAddress.h:36
TUUID::fClockSeqHiAndReserved
UChar_t fClockSeqHiAndReserved
Definition: TUUID.h:49
ThreadLocalStorage.h
TUUID::Print
void Print() const
Print UUID.
Definition: TUUID.cxx:554
TUUID::GetSystemTime
void GetSystemTime(uuid_time_t *timestamp)
Get system time with 100ns precision. Time is since Oct 15, 1582.
Definition: TUUID.cxx:384
int
TUUID::SetFromString
void SetFromString(const char *uuid_str)
Set this UUID to the value specified in uuid ((which must be in TUUID::AsString() format).
Definition: TUUID.cxx:210
Error
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:187
TError.h
c1
return c1
Definition: legend1.C:41
TUUID::GetUUID
void GetUUID(UChar_t uuid[16]) const
Return uuid in specified buffer (16 byte = 128 bits).
Definition: TUUID.cxx:686