HexFormatter.h

Go to the documentation of this file.

 
#pragma once
#include "StreamFormatGuard.h"
#include "traits/Traits.h"
#include <array>
#include <iostream>
#include <vector>
 
namespace catapult { namespace utils {
 
    template<size_t N>
    class IntegralHexFormatterGuard : public StreamFormatGuard {
    public:
        explicit IntegralHexFormatterGuard(std::ostream& out)
                : StreamFormatGuard(out, std::ios::hex | std::ios::uppercase, '0')
                , m_out(out)
        {}
 
    public:
        template<typename T>
        void output(T value) {
            Output(m_out, value);
        }
 
    private:
        template<typename T>
        static void OutputValue(std::ostream& out, T value, int size) {
            out << std::setw(2 * size) << +value;
        }
 
        template<typename T>
        static void Output(std::ostream& out, const T& value) {
            if constexpr (std::is_integral_v<T>) {
                OutputValue(out, value, N);
            } else {
                auto pData = reinterpret_cast<const uint8_t*>(&value);
                for (auto i = 0u; i < sizeof(T); ++i)
                    OutputValue(out, pData[sizeof(T) - 1 - i], 1);
            }
        }
 
    private:
        std::ostream& m_out;
    };
 
    template<typename T, size_t N = sizeof(T)>
    class IntegralHexFormatter {
    public:
        explicit IntegralHexFormatter(T value) : m_value(value)
        {}
 
    public:
        friend std::ostream& operator<<(std::ostream& out, const IntegralHexFormatter& formatter) {
            IntegralHexFormatterGuard<N> guard(out);
            guard.output(formatter.m_value);
            return out;
        }
 
    private:
        T m_value;
    };
 
    template<typename TInputIterator>
    class ContainerHexFormatter {
    public:
        ContainerHexFormatter(TInputIterator begin, TInputIterator end, char separator) :
                m_begin(begin),
                m_end(end),
                m_separator(separator)
        {}
 
    public:
        friend std::ostream& operator<<(std::ostream& out, const ContainerHexFormatter<TInputIterator>& formatter) {
            using T = decltype(*m_begin);
            IntegralHexFormatterGuard<sizeof(T)> guard(out);
            for (auto iter = formatter.m_begin; formatter.m_end != iter; ++iter) {
                guard.output(*iter);
 
                if (0 != formatter.m_separator && iter + 1 != formatter.m_end)
                    out << formatter.m_separator;
            }
 
            return out;
        }
 
    private:
        TInputIterator m_begin;
        TInputIterator m_end;
        char m_separator;
    };
 
    template<typename TInputIterator>
    auto HexFormat(TInputIterator begin, TInputIterator end, char separator = 0) {
        return ContainerHexFormatter<TInputIterator>(begin, end, separator);
    }
 
    template<typename TContainer>
    auto HexFormat(const TContainer& container, char separator) {
        return HexFormat(std::cbegin(container), std::cend(container), separator);
    }
 
    template<typename T>
    auto HexFormat(const T& data) {
        if constexpr (traits::is_scalar_v<T>) {
            return IntegralHexFormatter<T>(data);
        } else {
            auto pData = reinterpret_cast<const uint8_t*>(&data);
            return HexFormat(pData, pData + sizeof(T), 0);
        }
    }
 
    template<typename T>
    auto HexFormat(const std::vector<T>& container) {
        return HexFormat(container, 0);
    }
 
    template<typename T, size_t N>
    auto HexFormat(const std::array<T, N>& container) {
        return HexFormat(container, 0);
    }
}}