Token.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "PersistentDataModel/Token.h"
 
#include <cstdio>
#include <cstring>
#include <climits>
#include <atomic>
#include <format>
#include <charconv>
#include <string_view>
#include "CxxUtils/HexString.h"
 
constexpr std::string_view LABEL_DB   = "[DB=";
constexpr std::string_view LABEL_CNT  = "[CNT=";
constexpr std::string_view LABEL_CLID = "[CLID=";
constexpr std::string_view LABEL_TECH = "[TECH=";
constexpr std::string_view LABEL_OID  = "[OID=";
 
static const int KEY_MASK = (~0u) << CHAR_BIT;
static std::atomic<int> s_numCount { 0 };
 
int Token::numInstances() { return s_numCount; }

Token::Token() : m_refCount(1),
    m_technology(0),
    m_dbID(Guid::null()),
    m_classID(Guid::null()),
    m_oid(OID_t(~0x0LL, ~0x0LL)),
    m_type(0) {
   s_numCount.fetch_add(1, std::memory_order_relaxed);
}

Token::Token(const Token& copy) : m_refCount(1),
    m_technology(copy.m_technology),
    m_dbID(copy.m_dbID),
    m_classID(copy.m_classID),
    m_oid(copy.m_oid),
    m_type(0) {
   copy.setData(this);
   s_numCount.fetch_add(1, std::memory_order_relaxed);
}

Token::Token(const Token* source) : m_refCount(1),
    m_technology(0),
    m_dbID(Guid::null()),
    m_classID(Guid::null()),
    m_oid(OID_t(~0x0LL, ~0x0LL)),
    m_type(0) {
   if (source != 0) {
      source->setData(this);
   }
   s_numCount.fetch_add(1, std::memory_order_relaxed);
}

Token::Token(Token&& source) noexcept
  : m_refCount (1),
    m_technology (source.m_technology),
    m_dbID (std::move (source.m_dbID)),
    m_cntID (std::move (source.m_cntID)),
    m_classID (std::move (source.m_classID)),
    m_oid (std::move (source.m_oid)),
    m_type (source.m_type),
    m_auxString (std::move (source.m_auxString))
{
   s_numCount.fetch_add(1, std::memory_order_relaxed);
}
    
 
Token::~Token() {
   s_numCount.fetch_sub(1, std::memory_order_relaxed);
}

int Token::release() {
   int cnt = --m_refCount;
   if (0 >= cnt) {
      delete this;
   }
   return cnt;
}

Token& Token::operator=(const Token& copy) {
  if (&copy != this) {
     copy.setData(this);
  }
  return *this;
}

bool Token::equal(const Token& copy) const {
   if (&copy != this) {
      if (m_oid.second == copy.m_oid.second) {
         if (m_classID == copy.m_classID) {
            if (m_dbID == copy.m_dbID) {
               if (m_cntID == copy.m_cntID) {
                  return true;
               }
            }
         }
      }
      return false;
   }
   return true;
}

bool Token::less(const Token& copy) const {
   if (&copy != this) {
      if (m_oid.second < copy.m_oid.second)
         return true;
      else if (m_oid.second > copy.m_oid.second)
         return false;
      if (!(m_classID == copy.m_classID)) {
         return (m_classID < copy.m_classID);
      }
      if (!(m_dbID == copy.m_dbID)) {
         return (m_dbID < copy.m_dbID);
      }
      int res = m_cntID.compare(copy.m_cntID);
      if (res != 0) {
         return (res < 0);
      }
   }
   return false;
}
 
const std::string Token::toString() const {
// Pre-compute the hex representations using the format strings
   CxxUtils::HexString<"[TECH={}]"> techHex(m_technology);
   CxxUtils::HexString<"[OID={}-"> oid1Hex(static_cast<uint64_t>(m_oid.first));
   CxxUtils::HexString<"{}]"> oid2Hex(static_cast<uint64_t>(m_oid.second));
 
   std::string res;
   // Reserve exact capacity to prevent reallocations. 
   // "[DB=" (4) + Guid (36) + "][CNT=" (6) + CNT + "][CLID=" (7) + Guid (36) + "]" (1) 
   res.reserve(4 + 36 + 6 + m_cntID.size() + 7 + 36 + 1 + 
               techHex.size() + oid1Hex.size() + oid2Hex.size() + m_auxString.size());
   
   res += "[DB=";
   size_t pos = res.size();
   res.resize(pos + 36);
   m_dbID.toString(std::span<char, 36>(res.data() + pos, 36));
   
   res += "][CNT=";
   res += m_cntID;
   
   res += "][CLID=";
   pos = res.size();
   res.resize(pos + 36);
   m_classID.toString(std::span<char, 36>(res.data() + pos, 36));
   res += ']';
   
   res += static_cast<std::string_view>(techHex);
   res += static_cast<std::string_view>(oid1Hex);
   res += static_cast<std::string_view>(oid2Hex);
   res += m_auxString;
   
   return res;
}
 
Token& Token::fromString(const std::string_view src)    {
   m_auxString.clear();
   size_t pos = 0;
   while (pos < src.size()) {
      size_t start = src.find('[', pos);
      if (start == std::string_view::npos) break;
      size_t eq = src.find('=', start);
      size_t end = src.find(']', start);
      if (eq != std::string_view::npos && end != std::string_view::npos) {
         std::string_view label = src.substr(start, eq - start + 1);
         if (label == LABEL_DB) {
               m_dbID.fromString(src.substr(eq + 1, end - eq - 1));
         } else if (label == LABEL_CNT) {
               m_cntID = std::string(src.substr(eq + 1, end - eq - 1));
         } else if (label == LABEL_CLID) {
               m_classID.fromString(src.substr(eq + 1, end - eq - 1));
         } else if (label == LABEL_TECH) {
               std::string_view num_str = src.substr(eq + 1, end - eq - 1);
               int tech = 0;
               std::from_chars(num_str.data(), num_str.data() + num_str.size(), tech, 16);
               m_technology = tech;
         } else if (label == LABEL_OID) {
               std::string_view oid_str = src.substr(eq + 1, end - eq - 1);
               size_t dash = oid_str.find('-');
               if (dash != std::string_view::npos) {
                  std::string_view first_str = oid_str.substr(0, dash);
                  std::string_view second_str = oid_str.substr(dash + 1);
 
                  // Check if this is legacy format (8 digits) vs modern format (16 digits)
                  // Legacy format: 5 + 8 + 1 + 8 + 1 = 23 characters total for [OID=XXXXXXXX-XXXXXXXX]
                  // Modern format: 5 + 16 + 1 + 16 + 1 = 39 characters total for [OID=XXXXXXXXXXXXXXXX-XXXXXXXXXXXXXXXX]
                  bool is_legacy = (end - start + 1) == 23; // Total bracket length check
 
                  uint64_t first = 0;
                  uint64_t second = 0;
                  std::from_chars(first_str.data(), first_str.data() + first_str.size(), first, 16);
                  std::from_chars(second_str.data(), second_str.data() + second_str.size(), second, 16);
 
                  if (is_legacy) {
                     // Handle legacy format: extend 32-bit ~0x0 to 64-bit ~0x0LL
                     if (static_cast<uint32_t>(first) == ~0x0U) first = ~0x0ULL;
                     if (static_cast<uint32_t>(second) == ~0x0U) second = ~0x0ULL;
                  }
 
                  m_oid.first = static_cast<long long int>(first);
                  m_oid.second = static_cast<long long int>(second);
               }
         } else {
               m_auxString += src.substr(start, end - start + 1);
         }
         pos = end + 1;
      } else {
         break;
      }
   }
   return *this;
}

const std::string Token::key() const {
   //Do not replace with std::format unless it is found to be more performant
   // m_technology & KEY_MASK yields an unsigned int -> 8 hex digits
   CxxUtils::HexString<"[TECH={}]"> techHex(m_technology & KEY_MASK);
 
   std::string res;
   // "[DB=" (4) + Guid (36) + "][CNT=" (6) + CNT + "][CLID=" (7) + Guid (36) + "]" (1) 
   res.reserve(4 + 36 + 6 + m_cntID.size() + 7 + 36 + 1 + techHex.size());
   
   res += "[DB=";
   size_t pos = res.size();
   res.resize(pos + 36);
   m_dbID.toString(std::span<char, 36>(res.data() + pos, 36));
   
   res += "][CNT=";
   res += m_cntID;
   
   res += "][CLID=";
   pos = res.size();
   res.resize(pos + 36);
   m_classID.toString(std::span<char, 36>(res.data() + pos, 36));
   res += ']';
   
   res += static_cast<std::string_view>(techHex);
   
   return res;
}
 
const Token& Token::set(Token* pToken) const {
   pToken->m_technology = m_technology;
   pToken->m_dbID = m_dbID;
   pToken->m_cntID = m_cntID;
   pToken->m_classID = m_classID;
   pToken->m_oid.first = m_oid.first;
   return *this;
}
 
const Token& Token::setData(Token* pToken) const {
   this->set(pToken);
   pToken->m_oid.second = m_oid.second;
   pToken->m_type = m_type;
   pToken->m_auxString = m_auxString;
   return *this;
}