hexdump.h

Go to the documentation of this file.

 
#ifndef GUL14_HEXDUMP_H_
#define GUL14_HEXDUMP_H_
 
#include <iomanip>
#include <sstream>
#include <type_traits>
#include <utility>
#include "gul14/internal.h"
#include "gul14/string_view.h"
 
//
// std::string hexdump(IteratorT begin, IteratorT end, string_view prompt = "")
// std::string hexdump(const ContainerT& cont, string_view prompt = "")
//
// struct HexdumpParameterForward
//
// HexdumpParameterForward<...> hexdump_stream(IteratorT begin, IteratorT end, std::string prompt = "")
// HexdumpParameterForward<...> hexdump_stream(const ContainerT& cont, std::string prompt = "")
// HexdumpParameterForward<...> hexdump_stream(ContainerT&& cont, std::string prompt = "")
//
// std::ostream& operator<< (std::ostream& os, const HexdumpParameterForward<...>& hdp)
//
 
namespace gul14 {
 
namespace detail {
 
//
// Until we have concepts ;-)
//
 
// Helper to identify types that have cbegin() and cend() and have integral data
template <typename T, typename = int>
struct IsHexDumpContainer : std::false_type { };
 
template <typename T>
struct IsHexDumpContainer <T,
    typename std::enable_if_t<
        std::is_integral<typename std::iterator_traits<decltype(
                                    std::declval<T>().cbegin())>::value_type>::value,
        decltype(std::declval<T>().cbegin(),
                    std::declval<T>().cend(),
                    0)
    >>
    : std::true_type { };
 
// Helper to identify types that are ForwardIterators or Pointers
//
// We enforce that the data pointed to is integer.
// We assume that every iterator that is not an input_iterator is at least
// a forward_iterator.
// We also check the existence of dereference and increment operators (this might be superfluous).
// (Type int is used as a dummy.)
template <typename T, typename = int>
struct IsHexDumpIterator : std::false_type { };
 
template <typename T>
struct IsHexDumpIterator <T,
    typename std::enable_if_t<
        std::is_integral<typename std::iterator_traits<T>::value_type>::value
            and not std::is_same<typename std::iterator_traits<T>::iterator_category,
                    std::input_iterator_tag>::value,
        decltype(std::declval<T>().operator*(),
                    std::declval<T>().operator++(),
                    0)
    >>
    : std::true_type { };
 
template <typename T>
struct IsHexDumpIterator <T,
    typename std::enable_if_t<
        std::is_pointer<T>::value
        and std::is_integral<typename std::remove_pointer<T>::type>::value,
        int
    >>
    : std::true_type { };
 
// Helper to identify stream types that we can use for output
template <typename StreamT,
    typename = std::enable_if_t<std::is_convertible<
        StreamT*,
        std::basic_ostream<typename StreamT::char_type,
                            typename StreamT::traits_type>*>::value>>
struct IsHexDumpStream : std::true_type { };
 
 
// Here is the template actually doing the hexdump
// It is called by the different hexdump*() versions
template<typename StreamT, typename IteratorT,
    typename = std::enable_if_t<detail::IsHexDumpStream<StreamT>::value>,
    typename = std::enable_if_t<detail::IsHexDumpIterator<IteratorT>::value>>
StreamT& hexdump_stream(StreamT& dest, const IteratorT& begin, const IteratorT& end,
    string_view prompt = "")
{
    constexpr auto maxelem = 1000ul * 16; // 1000 lines with 16 elements each
 
    // Get the number of hex digits to represent any value of the given integral type
    constexpr auto nod = sizeof(*begin) * 2;
    constexpr bool is_char = (nod == 2);
 
    const std::string indent(prompt.length(), ' ');
    const std::string empty(nod + 1, ' ');
 
    dest << std::hex << std::setfill('0');
 
    auto it = IteratorT{ begin };
 
    // Inspired by epatel @ stack overflow, https://stackoverflow.com/a/29865
    for (size_t i = 0; (it != end and i < maxelem) or (i == 0); i += 16) {
        dest << (i ? indent : prompt) << std::setw(6) << i << ": ";
        auto line = it;
        for (size_t j = 0; j < 16; ++j) {
            if (it != end) {
                const unsigned long long ch = static_cast<
                        typename std::make_unsigned<
                            typename std::decay<decltype(*it)>::type
                        >::type
                    >(*it++);
                dest << std::setw(nod) << ch << ' ';
            } else {
                if (!is_char) {
                    break;
                }
                dest << empty;
            }
        }
        if (is_char) {
            // Here we re-visit the iterator from the beginning of the line, thus
            // requiring ForwardIterators over InputOperators
            dest << ' ';
            for (size_t j = 0; j < 16 and line != end; ++j, ++line) {
                const auto c = static_cast<unsigned char>(*line);
                dest << static_cast<char>(isprint(c) ? c : '.'); // isprint() is only defined for unsigned char, but only char creates character output
            }
        }
        dest << "\n";
    }
    if (it != end) {
        dest << indent << "[output truncated...]\n";
    }
    return dest;
}
 
} // namespace detail
 
// Functions returning a string
//
 
template<typename IteratorT,
    typename = std::enable_if_t<detail::IsHexDumpIterator<IteratorT>::value>>
std::string hexdump(IteratorT begin, IteratorT end, string_view prompt = "")
{
    std::stringstream o{ };
    return detail::hexdump_stream(o, begin, end, prompt).str();
}
 
template<typename ContainerT,
    typename = std::enable_if_t<detail::IsHexDumpContainer<ContainerT>::value>>
std::string hexdump(const ContainerT& cont, string_view prompt = "")
{
    std::stringstream o{ };
    return detail::hexdump_stream(o, cont.cbegin(), cont.cend(), prompt).str();
}
 
// Functions returning a forwarder object
// (Support for 'stream << hexdump' without intermediate data image)
//
 
template<typename IteratorT, typename ContainerT = void*>
class HexdumpParameterForward {
public:
    IteratorT begin_;
    IteratorT end_;
    std::string prompt_;
    ContainerT cont_;
 
    HexdumpParameterForward() = default;
    ~HexdumpParameterForward() = default;
 
    HexdumpParameterForward(
        IteratorT begin_it, IteratorT end_it, std::string prompt, ContainerT&& cont)
        : begin_ { begin_it }
        , end_ { end_it }
        , prompt_ { std::move(prompt) }
        , cont_ { std::forward<ContainerT>(cont) }
    {
        regenerate_iterators<ContainerT>();
    }
 
    HexdumpParameterForward(const HexdumpParameterForward& other) { *this = other; }
 
    HexdumpParameterForward(HexdumpParameterForward&& other) noexcept
    {
        *this = std::move(other);
    }
 
    HexdumpParameterForward& operator=(const HexdumpParameterForward& other)
    {
        if (this == &other)
            return *this;
 
        begin_ = other.begin_;
        end_ = other.end_;
        prompt_ = other.prompt_;
        cont_ = other.cont_;
 
        regenerate_iterators<ContainerT>();
 
        return *this;
    }
 
    HexdumpParameterForward& operator=(HexdumpParameterForward&& other) noexcept
    {
        if (this == &other)
            return *this;
 
        begin_ = std::move(other.begin_);
        end_ = std::move(other.end_);
        prompt_ = std::move(other.prompt_);
        cont_ = std::move(other.cont_);
 
        regenerate_iterators<ContainerT>();
 
        return *this;
    }
 
    friend std::ostream& operator<<(
        std::ostream& os, const HexdumpParameterForward<IteratorT, ContainerT>& hdp)
    {
        return detail::hexdump_stream(os, hdp.begin_, hdp.end_, hdp.prompt_);
    }
 
private:
    template <typename ContType,
        std::enable_if_t<!detail::IsHexDumpContainer<ContType>::value, int> = 0
        >
    void regenerate_iterators() noexcept
    {
        // This is empty, but we need this member function template so that we can
        // regenerate the iterators if need be for the other enable_if case, see
        // below...
    }
 
    template <typename ContType,
        std::enable_if_t<detail::IsHexDumpContainer<ContType>::value, int> = 0
        >
    void regenerate_iterators() noexcept
    {
        begin_ = cont_.begin();
        end_ = cont_.end();
    }
};
 
template<typename IteratorT,
    typename = std::enable_if_t<detail::IsHexDumpIterator<IteratorT>::value>>
HexdumpParameterForward<const IteratorT>
hexdump_stream(const IteratorT& begin, const IteratorT& end, std::string prompt = "")
{
    return { begin, end, std::move(prompt), nullptr };
}
 
template<typename ContainerT,
    typename = std::enable_if_t<detail::IsHexDumpContainer<ContainerT>::value>>
HexdumpParameterForward<const decltype(std::declval<ContainerT>().cbegin())>
hexdump_stream(const ContainerT& cont, std::string prompt = "")
{
    return { cont.cbegin(), cont.cend(), std::move(prompt), nullptr };
}
 
template<typename ContainerT,
    typename = std::enable_if_t<detail::IsHexDumpContainer<ContainerT>::value,
        decltype(HexdumpParameterForward<decltype(std::declval<ContainerT>().cbegin()),
                     ContainerT> {}, 0)>>
HexdumpParameterForward<decltype(std::declval<ContainerT>().cbegin()), ContainerT>
hexdump_stream(ContainerT&& cont, std::string prompt = "")
{
    // The temporary container must be moved to retain the values until we need them
    // after operator<<.
    return { cont.cbegin(), cont.cbegin(), std::move(prompt),
             std::forward<ContainerT>(cont) };
}
 
} // namespace gul14
 
#endif
 
// vi:ts=4:sw=4:et