HexString.h

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration.
 */
#include <string_view>
#include <type_traits>
namespace CxxUtils {
namespace detail {
template <std::size_t N>
struct FixedString {
    char buf[N]{};
    constexpr FixedString(const char (&str)[N]) {
        for (std::size_t i = 0; i < N; ++i) buf[i] = str[i];
    }

    constexpr std::size_t length() const { return N - 1; }
};
inline constexpr char UpperHexDigits[] = "0123456789ABCDEF";
inline constexpr char LowerHexDigits[] = "0123456789abcdef";
template <FixedString FormatStr, const char* Digits>
class BasicHexString {
private:
    static constexpr std::size_t s_FormatLen = FormatStr.length();
    static constexpr std::size_t get_placeholder_pos() {
        for (std::size_t i = 0; i + 1 < s_FormatLen; ++i) {
            if (FormatStr.buf[i] == '{' && FormatStr.buf[i + 1] == '}') return i;
        }
        return static_cast<std::size_t>(-1);
    }

 
    static constexpr std::size_t s_PlaceholderPos = get_placeholder_pos();
    static_assert(s_PlaceholderPos != static_cast<std::size_t>(-1), "Format string must contain a '{}' placeholder.");
    static constexpr std::size_t s_PrefixLen = s_PlaceholderPos;
    static constexpr std::size_t s_PostfixLen = s_FormatLen - s_PrefixLen - 2;
    static constexpr std::size_t s_MaxHexDigits = 16;
    char m_text[s_PrefixLen + s_MaxHexDigits + s_PostfixLen + 1]{};
    std::size_t m_actual_size = 0;
public:
    template <typename T>
    constexpr explicit BasicHexString(T context) {
        static_assert(std::is_integral_v<T>, "HexString only accepts integer types.");
        // 1. Calculate hex digits needed for this specific type (e.g., sizeof(uint16_t) * 2 = 4 digits)
        constexpr std::size_t HexDigits = sizeof(T) * 2;
        m_actual_size = s_PrefixLen + HexDigits + s_PostfixLen;
        static_assert(HexDigits <= s_MaxHexDigits);
        // Cast to an unsigned equivalent of the same size to prevent sign-extension bugs during shifting
        using UnsignedT = std::make_unsigned_t<T>;
        UnsignedT value = static_cast<UnsignedT>(context);
        // 2. Write prefix
        if constexpr (s_PrefixLen>0){
          for (std::size_t i = 0; i < s_PrefixLen; ++i) {
              m_text[i] = FormatStr.buf[i];
          }
        }
        // 3. Write hex digits dynamically based on type size
        for (std::size_t i = 0; i < HexDigits; ++i) {
            const std::size_t shift = (HexDigits - 1 - i) * 4;
            m_text[s_PrefixLen + i] = Digits[(value >> shift) & static_cast<UnsignedT>(0xF)];
        }
        // 4. Write postfix
        if constexpr (s_PostfixLen>0){
          for (std::size_t i = 0; i < s_PostfixLen; ++i) {
              m_text[s_PrefixLen + HexDigits + i] = FormatStr.buf[s_PrefixLen + 2 + i];
          }
        }
        // 5. Null terminator
        m_text[m_actual_size] = '\0';
    }

    constexpr operator std::string_view() const noexcept {
        return std::string_view(m_text, m_actual_size);
    }
    //Helper friend functions to allow compilation of common use-cases.
    friend constexpr std::string operator+(std::string lhs, const BasicHexString& rhs) {
        lhs.append(static_cast<std::string_view>(rhs));
        return lhs;
 
    }
    friend constexpr std::string operator+(const BasicHexString& lhs, const std::string& rhs) {
        std::string_view lhs_view = lhs;
        std::string result;
        result.reserve(lhs_view.size() + rhs.size());
        result.append(lhs_view).append(rhs);
        return result;
    }
 
    // Needed to prevent ambiguities.
    friend constexpr std::string operator+(const BasicHexString& lhs, std::string&& rhs) {
        const std::string& rhs_l = rhs;
        return lhs + rhs_l;
    }
 
    friend constexpr std::string operator+(const char* lhs, const BasicHexString& rhs) {
        return std::string(lhs) + rhs;
    }
    friend constexpr std::string operator+(const BasicHexString& lhs, const char* rhs) {
        return lhs + std::string(rhs);
    }

    constexpr std::size_t size() const noexcept { return m_actual_size;}
    const char* c_str() const noexcept { return m_text; }
};
} // namespace detail
template <detail::FixedString FormatStr> using HexString = detail::BasicHexString<FormatStr, detail::UpperHexDigits>;
template <detail::FixedString FormatStr> using hexstring = detail::BasicHexString<FormatStr, detail::LowerHexDigits>;
} // namespace CxxUtils