ATLAS Offline Software
Loading...
Searching...
No Matches
Token Class Referencefinal

This class provides a token that identifies in a unique way objects on the persistent storage. More...

#include <Token.h>

Collaboration diagram for Token:

Classes

struct  OID_t

Public Member Functions

 Token ()
 Standard Constructor.
 Token (const Token *source)
 Constructor with data assignment.
 Token (Token &&source) noexcept
 Allow move.
 ~Token ()
 Standard destructor: release all allocated resources.
bool operator< (const Token &refToken) const
 Operator < to allow ordering.
bool operator> (const Token &refToken) const
 Operator > to allow ordering.
bool operator== (const Token &refToken) const
 Equality operator.
bool operator!= (const Token &refToken) const
 Equality operator.
bool less (const Token &pTok) const
 Fast token comparison: operator less.
bool equal (const Token &pTok) const
 Fast token comparison: operator equals.
int release ()
 Release token: Decrease reference count and eventually delete.
int addRef ()
 Increase reference count.
const Guid & dbID () const
 Access database identifier.
Token & setDb (const Guid &db)
 Set database name.
Token & setDb (const std::string &db)
const std::string & contID () const
 Access container identifier.
Token & setCont (const std::string &cnt)
 Set container name.
const Guid & classID () const
 Access database identifier.
Token & setClassID (const Guid &cl_id)
 Access database identifier.
int technology () const
 Access technology type.
Token & setTechnology (int t)
 Set technology type.
const OID_t & oid () const
 Access object identifier.
OID_t & oid ()
 Access object identifier.
Token & setOid (const OID_t &oid)
 Set object identifier.
int type () const
 Access token type.
Token & setType (int t)
 Set token type.
const std::string & auxString () const
 Access auxiliary string.
Token & setAuxString (std::string &&auxString)
 Set auxiliary string.
void setAuxString (std::string_view auxString)
std::string toString () const
 Retrieve the string representation of the token.
std::string key () const
 Retrieve token key.
Token & fromString (const std::string_view from)
 Build from the string representation of a token.
const Token & set (Token *pToken) const
 Set token information.
const Token & setData (Token *pToken) const
 Set all the data part of the token.

Static Public Member Functions

static int numInstances ()
 expose Token instance counter for debugging

Private Member Functions

 Token (const Token &copy)
 No copy allowed: put prototype to disable bit-wise copy.
Token & operator= (const Token &copy)
 No assignment allowed: put prototype to disable bit-wise assignment.

Private Attributes

int m_refCount
 Reference count.
unsigned int m_technology
 Technology identifier.
Guid m_dbID
 Database identifier.
std::string m_cntID
 Container identifier.
Guid m_classID
 Object global identifier.
OID_t m_oid
 Persistent object identifier.
int m_type
 Token type.
std::string m_auxString
 Auxiliary string.

Detailed Description

This class provides a token that identifies in a unique way objects on the persistent storage.

Definition at line 22 of file Token.h.

Constructor & Destructor Documentation

◆ Token() [1/4]

Token::Token ( const Token & copy)
private

No copy allowed: put prototype to disable bit-wise copy.

Copy constructor.

Definition at line 39 of file Token.cxx.

39 : m_refCount(1),
40 m_technology(copy.m_technology),
41 m_dbID(copy.m_dbID),
42 m_classID(copy.m_classID),
43 m_oid(copy.m_oid),
44 m_type(0) {
45 copy.setData(this);
46 s_numCount.fetch_add(1, std::memory_order_relaxed);
47}
static std::atomic< int > s_numCount
Definition Token.cxx:24
int m_refCount
Reference count.
Definition Token.h:113
Guid m_classID
Object global identifier.
Definition Token.h:121
unsigned int m_technology
Technology identifier.
Definition Token.h:115
OID_t m_oid
Persistent object identifier.
Definition Token.h:123
int m_type
Token type.
Definition Token.h:125
Guid m_dbID
Database identifier.
Definition Token.h:117
bool copy
Definition calibdata.py:26

◆ Token() [2/4]

Token::Token ( )

Standard Constructor.

Standard Constructor(1): Empty constructor.

Definition at line 29 of file Token.cxx.

29 : m_refCount(1),
30 m_technology(0),
33 m_oid(OID_t(~0x0LL, ~0x0LL)),
34 m_type(0) {
35 s_numCount.fetch_add(1, std::memory_order_relaxed);
36}
static const Guid & null() noexcept
NULL-Guid: static class method.
Definition Guid.cxx:14

◆ Token() [3/4]

Token::Token ( const Token * source)
explicit

Constructor with data assignment.

Copy constructor.

Definition at line 50 of file Token.cxx.

50 : m_refCount(1),
51 m_technology(0),
54 m_oid(OID_t(~0x0LL, ~0x0LL)),
55 m_type(0) {
56 if (source != 0) {
57 source->setData(this);
58 }
59 s_numCount.fetch_add(1, std::memory_order_relaxed);
60}

◆ Token() [4/4]

Token::Token ( Token && source)
explicitnoexcept

Allow move.

Move constructor.

Definition at line 63 of file Token.cxx.

64 : m_refCount (1),
65 m_technology (source.m_technology),
66 m_dbID (std::move (source.m_dbID)),
67 m_cntID (std::move (source.m_cntID)),
68 m_classID (std::move (source.m_classID)),
69 m_oid (std::move (source.m_oid)),
70 m_type (source.m_type),
71 m_auxString (std::move (source.m_auxString))
72{
73 s_numCount.fetch_add(1, std::memory_order_relaxed);
74}
std::string m_auxString
Auxiliary string.
Definition Token.h:127
std::string m_cntID
Container identifier.
Definition Token.h:119

◆ ~Token()

Token::~Token ( )

Standard destructor: release all allocated resources.

Definition at line 77 of file Token.cxx.

77 {
78 s_numCount.fetch_sub(1, std::memory_order_relaxed);
79}

Member Function Documentation

◆ addRef()

int Token::addRef ( )
inline

Increase reference count.

Definition at line 63 of file Token.h.

63{ return ++m_refCount; }

◆ auxString()

const std::string & Token::auxString ( ) const
inline

Access auxiliary string.

Definition at line 92 of file Token.h.

92{ return m_auxString; }

◆ classID()

const Guid & Token::classID ( ) const
inline

Access database identifier.

Definition at line 74 of file Token.h.

74{ return m_classID; }

◆ contID()

const std::string & Token::contID ( ) const
inline

Access container identifier.

Definition at line 70 of file Token.h.

70{ return m_cntID; }

◆ dbID()

const Guid & Token::dbID ( ) const
inline

Access database identifier.

Definition at line 65 of file Token.h.

65{ return m_dbID; }

◆ equal()

bool Token::equal ( const Token & pTok) const

Fast token comparison: operator equals.

Equality operator.

Definition at line 99 of file Token.cxx.

99 {
100 if (&copy != this) {
101 if (m_oid.second == copy.m_oid.second) {
102 if (m_classID == copy.m_classID) {
103 if (m_dbID == copy.m_dbID) {
104 if (m_cntID == copy.m_cntID) {
105 return true;
106 }
107 }
108 }
109 }
110 return false;
111 }
112 return true;
113}

◆ fromString()

Token & Token::fromString ( const std::string_view from)

Build from the string representation of a token.

Definition at line 148 of file Token.cxx.

148 {
149 m_auxString.clear();
150 size_t pos = 0;
151 while (pos < src.size()) {
152 size_t start = src.find('[', pos);
153 if (start == std::string_view::npos) break;
154 size_t eq = src.find('=', start);
155 size_t end = src.find(']', start);
156 if (eq != std::string_view::npos && end != std::string_view::npos) {
157 std::string_view label = src.substr(start, eq - start + 1);
158 if (label == LABEL_DB) {
159 m_dbID.fromString(src.substr(eq + 1, end - eq - 1));
160 } else if (label == LABEL_CNT) {
161 m_cntID = std::string(src.substr(eq + 1, end - eq - 1));
162 } else if (label == LABEL_CLID) {
163 m_classID.fromString(src.substr(eq + 1, end - eq - 1));
164 } else if (label == LABEL_TECH) {
165 std::string_view num_str = src.substr(eq + 1, end - eq - 1);
166 int tech = 0;
167 std::from_chars(num_str.data(), num_str.data() + num_str.size(), tech, 16);
168 m_technology = tech;
169 } else if (label == LABEL_OID) {
170 std::string_view oid_str = src.substr(eq + 1, end - eq - 1);
171 size_t dash = oid_str.find('-');
172 if (dash != std::string_view::npos) {
173 std::string_view first_str = oid_str.substr(0, dash);
174 std::string_view second_str = oid_str.substr(dash + 1);
175
176 // Check if this is legacy format (8 digits) vs modern format (16 digits)
177 // Legacy format: 5 + 8 + 1 + 8 + 1 = 23 characters total for [OID=XXXXXXXX-XXXXXXXX]
178 // Modern format: 5 + 16 + 1 + 16 + 1 = 39 characters total for [OID=XXXXXXXXXXXXXXXX-XXXXXXXXXXXXXXXX]
179 bool is_legacy = (end - start + 1) == 23; // Total bracket length check
180
181 uint64_t first = 0;
182 uint64_t second = 0;
183 std::from_chars(first_str.data(), first_str.data() + first_str.size(), first, 16);
184 std::from_chars(second_str.data(), second_str.data() + second_str.size(), second, 16);
185
186 if (is_legacy) {
187 // Handle legacy format: extend 32-bit ~0x0 to 64-bit ~0x0LL
188 if (static_cast<uint32_t>(first) == ~0x0U) first = ~0x0ULL;
189 if (static_cast<uint32_t>(second) == ~0x0U) second = ~0x0ULL;
190 }
191
192 m_oid.first = static_cast<long long int>(first);
193 m_oid.second = static_cast<long long int>(second);
194 }
195 } else {
196 m_auxString += src.substr(start, end - start + 1);
197 }
198 pos = end + 1;
199 } else {
200 break;
201 }
202 }
203 return *this;
204}
constexpr std::string_view LABEL_DB
Definition Token.cxx:17
constexpr std::string_view LABEL_TECH
Definition Token.cxx:20
constexpr std::string_view LABEL_CLID
Definition Token.cxx:19
constexpr std::string_view LABEL_CNT
Definition Token.cxx:18
constexpr std::string_view LABEL_OID
Definition Token.cxx:21
std::string label(const std::string &format, int i)
Definition label.h:19
bool first
Definition DeMoScan.py:534
setEventNumber uint32_t

◆ key()

std::string Token::key ( ) const

Retrieve token key.

Retrieve the string representation of the token.

Definition at line 207 of file Token.cxx.

207 {
208 // m_technology & KEY_MASK yields an unsigned int -> 8 hex digits
209 CxxUtils::HexString<"[TECH={}]"> techHex(m_technology & KEY_MASK);
210
211 return CxxUtils::strcat(
212 "[DB=", m_dbID, "][CNT=", m_cntID, "][CLID=", m_classID, ']',
213 techHex
214 );
215}
static const int KEY_MASK
Definition Token.cxx:23
constexpr std::string strcat(Args &&... args)
detail::BasicHexString< FormatStr, detail::UpperHexDigits > HexString
Definition HexString.h:158

◆ less()

bool Token::less ( const Token & pTok) const

Fast token comparison: operator less.

Operator to allow ordering.

Definition at line 116 of file Token.cxx.

116 {
117 if (&copy != this) {
118 if (m_oid.second < copy.m_oid.second)
119 return true;
120 else if (m_oid.second > copy.m_oid.second)
121 return false;
122 if (!(m_classID == copy.m_classID)) {
123 return (m_classID < copy.m_classID);
124 }
125 if (!(m_dbID == copy.m_dbID)) {
126 return (m_dbID < copy.m_dbID);
127 }
128 int res = m_cntID.compare(copy.m_cntID);
129 if (res != 0) {
130 return (res < 0);
131 }
132 }
133 return false;
134}
std::pair< std::vector< unsigned int >, bool > res

◆ numInstances()

int Token::numInstances ( )
static

expose Token instance counter for debugging

Definition at line 26 of file Token.cxx.

26{ return s_numCount; }

◆ oid() [1/2]

OID_t & Token::oid ( )
inline

Access object identifier.

Definition at line 84 of file Token.h.

84{ return m_oid; }

◆ oid() [2/2]

const OID_t & Token::oid ( ) const
inline

Access object identifier.

Definition at line 82 of file Token.h.

82{ return m_oid; }

◆ operator!=()

bool Token::operator!= ( const Token & refToken) const
inline

Equality operator.

Definition at line 55 of file Token.h.

55{ return !equal(refToken); }
bool equal(const Token &pTok) const
Fast token comparison: operator equals.
Definition Token.cxx:99

◆ operator<()

bool Token::operator< ( const Token & refToken) const
inline

Operator < to allow ordering.

Definition at line 46 of file Token.h.

46{ return less(refToken); }
bool less(const Token &pTok) const
Fast token comparison: operator less.
Definition Token.cxx:116

◆ operator=()

Token & Token::operator= ( const Token & copy)
private

No assignment allowed: put prototype to disable bit-wise assignment.

Assignment operator.

Definition at line 91 of file Token.cxx.

91 {
92 if (&copy != this) {
93 copy.setData(this);
94 }
95 return *this;
96}

◆ operator==()

bool Token::operator== ( const Token & refToken) const
inline

Equality operator.

Definition at line 53 of file Token.h.

53{ return equal(refToken); }

◆ operator>()

bool Token::operator> ( const Token & refToken) const
inline

Operator > to allow ordering.

Definition at line 48 of file Token.h.

48 {
49 if (less(refToken)) return false;
50 return !equal(refToken);
51 }

◆ release()

int Token::release ( )

Release token: Decrease reference count and eventually delete.

Definition at line 82 of file Token.cxx.

82 {
83 int cnt = --m_refCount;
84 if (0 >= cnt) {
85 delete this;
86 }
87 return cnt;
88}

◆ set()

const Token & Token::set ( Token * pToken) const

Set token information.

Definition at line 217 of file Token.cxx.

217 {
218 pToken->m_technology = m_technology;
219 pToken->m_dbID = m_dbID;
220 pToken->m_cntID = m_cntID;
221 pToken->m_classID = m_classID;
222 pToken->m_oid.first = m_oid.first;
223 return *this;
224}

◆ setAuxString() [1/2]

Token & Token::setAuxString ( std::string && auxString)
inline

Set auxiliary string.

Definition at line 94 of file Token.h.

94{ m_auxString = std::move(auxString); return *this; }
const std::string & auxString() const
Access auxiliary string.
Definition Token.h:92

◆ setAuxString() [2/2]

void Token::setAuxString ( std::string_view auxString)
inline

Definition at line 95 of file Token.h.

◆ setClassID()

Token & Token::setClassID ( const Guid & cl_id)
inline

Access database identifier.

Definition at line 76 of file Token.h.

76{ m_classID = cl_id; return *this; }

◆ setCont()

Token & Token::setCont ( const std::string & cnt)
inline

Set container name.

Definition at line 72 of file Token.h.

72{ m_cntID = cnt; return *this; }

◆ setData()

const Token & Token::setData ( Token * pToken) const

Set all the data part of the token.

Definition at line 226 of file Token.cxx.

226 {
227 this->set(pToken);
228 pToken->m_oid.second = m_oid.second;
229 pToken->m_type = m_type;
230 pToken->m_auxString = m_auxString;
231 return *this;
232}
const Token & set(Token *pToken) const
Set token information.
Definition Token.cxx:217

◆ setDb() [1/2]

Token & Token::setDb ( const Guid & db)
inline

Set database name.

Definition at line 67 of file Token.h.

◆ setDb() [2/2]

Token & Token::setDb ( const std::string & db)
inline

Definition at line 68 of file Token.h.

68{ m_dbID.fromString(db); return *this; }

◆ setOid()

Token & Token::setOid ( const OID_t & oid)
inline

Set object identifier.

Definition at line 86 of file Token.h.

86{ m_oid = oid; return *this; }
const OID_t & oid() const
Access object identifier.
Definition Token.h:82

◆ setTechnology()

Token & Token::setTechnology ( int t)
inline

Set technology type.

Definition at line 80 of file Token.h.

80{ m_technology = t; return *this; }

◆ setType()

Token & Token::setType ( int t)
inline

Set token type.

Definition at line 90 of file Token.h.

90{ m_type = t; return *this; }

◆ technology()

int Token::technology ( ) const
inline

Access technology type.

Definition at line 78 of file Token.h.

78{ return m_technology; }

◆ toString()

std::string Token::toString ( ) const

Retrieve the string representation of the token.

Definition at line 136 of file Token.cxx.

136 {
137 // Pre-compute the hex representations using the format strings
138 CxxUtils::HexString<"[TECH={}]"> techHex(m_technology);
139 CxxUtils::HexString<"[OID={}-"> oid1Hex(static_cast<uint64_t>(m_oid.first));
140 CxxUtils::HexString<"{}]"> oid2Hex(static_cast<uint64_t>(m_oid.second));
141
142 return CxxUtils::strcat(
143 "[DB=", m_dbID, "][CNT=", m_cntID, "][CLID=", m_classID, ']',
144 techHex, oid1Hex, oid2Hex, m_auxString
145 );
146}

◆ type()

int Token::type ( ) const
inline

Access token type.

Definition at line 88 of file Token.h.

88{ return m_type; }

Member Data Documentation

◆ m_auxString

std::string Token::m_auxString
private

Auxiliary string.

Definition at line 127 of file Token.h.

◆ m_classID

Guid Token::m_classID
private

Object global identifier.

Definition at line 121 of file Token.h.

◆ m_cntID

std::string Token::m_cntID
private

Container identifier.

Definition at line 119 of file Token.h.

◆ m_dbID

Guid Token::m_dbID
private

Database identifier.

Definition at line 117 of file Token.h.

◆ m_oid

OID_t Token::m_oid
private

Persistent object identifier.

Definition at line 123 of file Token.h.

◆ m_refCount

int Token::m_refCount
private

Reference count.

Definition at line 113 of file Token.h.

◆ m_technology

unsigned int Token::m_technology
private

Technology identifier.

Definition at line 115 of file Token.h.

◆ m_type

int Token::m_type
private

Token type.

Definition at line 125 of file Token.h.


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