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 <string>
#include <type_traits> // Required for std::is_integral_v and std::make_unsigned_t
 
 
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; }
};
}

template <detail::FixedString FormatStr>
class HexString {
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 HexString(T context) {
        static_assert(std::is_integral_v<T>, "HexString only accepts integer types.");
 
        constexpr char digits[] = "0123456789ABCDEF";
        
        // 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
        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) {
            std::size_t shift = (HexDigits - 1 - i) * 4;
            m_text[s_PrefixLen + i] = digits[(value >> shift) & 0xFU];
        }
 
        // 4. Write postfix
        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 HexString& rhs) {
        lhs.append(static_cast<std::string_view>(rhs));
        return lhs;
    }
 
    friend constexpr std::string operator+(const HexString& 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;
    }
 
    friend constexpr std::string operator+(const char* lhs, const HexString& rhs) {
        return std::string(lhs) + rhs;
    }
 
    friend constexpr std::string operator+(const HexString& 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; }
};
}