dumper.h

#ifndef DUMPER_H
#define DUMPER_H
 
#include <iostream>
#include <iomanip>
#include <set>
#include <vector>
#include "../common.h"
#include "../unicode.h"
#include "../linker/image.h"
 
namespace Dumper
{
 
enum display_option
{
    _Image,
    _Header,
    _Symbol,
    _Relocation,
    _Import,
    _Export,
    _Control,
    _String,
    _Debug,
    _Resource,
    _Dynamic,
    _Miscellaneous,
    _Redundant,
    _Generated,
 
    Image = 1 << _Image,
    Header = 1 << _Header,
    Symbol = 1 << _Symbol,
    Relocation = 1 << _Relocation,
    Import = 1 << _Import,
    Export = 1 << _Export,
    Control = 1 << _Control,
    String = 1 << _String,
    Debug = 1 << _Debug,
    Resource = 1 << _Resource,
    Dynamic = 1 << _Dynamic,
    Miscellaneous = 1 << _Miscellaneous,
    Redundant = 1 << _Redundant,
    Generated = 1 << _Generated,
 
    None = 0,
    All = Image | Header | Symbol | Relocation | Import | Export | Control | String | Debug | Resource | Dynamic | Miscellaneous | Redundant | Generated,
};
 
class Dumper;
 
class Encoding
{
public:
    virtual ~Encoding() = default;
 
    virtual char32_t GetChar(uint8_t const *& input, size_t& length) = 0;
 
    char32_t operator[](uint8_t input)
    {
        uint8_t const * input_pointer = &input;
        size_t length = 1;
        return GetChar(input_pointer, length);
    }
};
 
class SingleByteEncoding : public Encoding
{
public:
    char32_t (* codepage)[256];
 
    SingleByteEncoding() = delete;
    SingleByteEncoding(const SingleByteEncoding& ) = delete;
 
    SingleByteEncoding(char32_t (& codepage)[256])
        : codepage(&codepage)
    {
        assert(this->codepage != nullptr);
    }
 
    char32_t GetChar(uint8_t const *& input, size_t& length) override;
};
 
// TODO: untested
class UTF8Encoding : public Encoding
{
public:
    UTF8Encoding()
    {
    }
 
    char32_t GetChar(uint8_t const *& input, size_t& length) override;
};
 
class UTF16Encoding : public Encoding
{
public:
    ::EndianType endiantype;
 
    UTF16Encoding(::EndianType endiantype)
        : endiantype(endiantype)
    {
    }
 
    char32_t GetChar(uint8_t const *& input, size_t& length) override;
};
 
// TODO: untested
class UTF32Encoding : public Encoding
{
public:
    ::EndianType endiantype;
 
    UTF32Encoding(::EndianType endiantype)
        : endiantype(endiantype)
    {
    }
 
    char32_t GetChar(uint8_t const *& input, size_t& length) override;
};
 
class Dumper;
class RichText
{
public:
    enum Formatting
    {
        Bold,
        Underline,
    };
 
    std::string text;
    std::map<size_t, std::map<Formatting, bool>> formatting;
 
    RichText() = default;
 
    RichText(std::string text)
        : text(text)
    {
    }
 
    template <typename ... Ts>
        RichText(std::string text, Formatting format, Ts ... rest)
        : RichText{text, rest...}
    {
        formatting[0][format] = true;
        formatting[text.size()][format] = false;
    }
 
    RichText& operator +=(char c)
    {
        text += c;
        return *this;
    }
 
    RichText& operator +=(std::string s)
    {
        text += s;
        return *this;
    }
 
    RichText& operator +=(const RichText& other);
    void Dump(Dumper& dump) const;
 
    bool operator ==(const RichText& other) const
    {
        return text == other.text && formatting == other.formatting;
    }
};
 
static inline RichText operator +(const RichText& first, const RichText& second)
{
    RichText result = first;
    result += second;
    return result;
}
 
template <typename ... Ts>
    class Display
{
public:
    virtual ~Display() { }
 
    virtual bool IsMissing(std::tuple<Ts...>& values)
    {
        //return is_missing(values);
        return values == std::tuple<Ts...>();
    }
 
    virtual void DisplayValue(Dumper& dump, std::tuple<Ts...> values) = 0;
};
 
class ChoiceDisplay : public Display<offset_t>
{
public:
    std::map<offset_t, std::string> names;
    std::string default_name;
 
    bool missing_on_value;
    offset_t missing_value;
    std::shared_ptr<Display<offset_t>> secondary_display;
 
    ChoiceDisplay(std::map<offset_t, std::string> names, std::string default_name, bool missing_on_value, offset_t missing_value, std::shared_ptr<Display<offset_t>> secondary_display)
        : names(names), default_name(default_name), missing_on_value(true), missing_value(missing_value), secondary_display(secondary_display)
    {
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::map<offset_t, std::string> names, std::string default_name = "unknown", std::shared_ptr<Display<offset_t>> secondary_display = nullptr)
    {
        return std::make_shared<ChoiceDisplay>(names, default_name, false, 0, secondary_display);
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::map<offset_t, std::string> names, offset_t missing_value, std::string default_name = "unknown", std::shared_ptr<Display<offset_t>> secondary_display = nullptr)
    {
        return std::make_shared<ChoiceDisplay>(names, default_name, true, missing_value, secondary_display);
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::map<offset_t, std::string> names, std::shared_ptr<Display<offset_t>> secondary_display)
    {
        return std::make_shared<ChoiceDisplay>(names, "unknown", false, 0, secondary_display);
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::map<offset_t, std::string> names, offset_t missing_value, std::shared_ptr<Display<offset_t>> secondary_display)
    {
        return std::make_shared<ChoiceDisplay>(names, "unknown", true, missing_value, secondary_display);
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::string on_true, std::string on_false)
    {
        std::map<offset_t, std::string> names;
        /* TODO: alternative?
            default_name = on_true;
            names[0] = on_false;
        */
        names[0] = on_false;
        names[1] = on_true;
        return std::make_shared<ChoiceDisplay>(names, "", false, 0, nullptr);
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::string on_true)
    {
        std::map<offset_t, std::string> names;
        /* TODO: alternative?
            default_name = on_true;
            missing_on_value = true;
            missing_value = 0;
        */
        names[1] = on_true;
        return std::make_shared<ChoiceDisplay>(names, "unknown", false, 0, nullptr);
    }
 
    bool IsMissing(std::tuple<offset_t>& values) override;
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values) override;
};
 
class HexDisplay : public Display<offset_t>
{
public:
    unsigned width;
    HexDisplay(unsigned width)
        : width(width)
    {
    }
 
    static std::shared_ptr<HexDisplay> Make(unsigned width = 8)
    {
        return std::make_shared<HexDisplay>(width);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values) override;
};
 
class DecDisplay : public Display<offset_t>
{
public:
    std::string suffix;
    bool enable_signed = false;
    DecDisplay(std::string suffix, bool enable_signed)
        : suffix(suffix), enable_signed(enable_signed)
    {
    }
 
    static std::shared_ptr<DecDisplay> Make(bool enable_signed)
    {
        return std::make_shared<DecDisplay>("", enable_signed);
    }
 
    static std::shared_ptr<DecDisplay> Make(std::string suffix = "", bool enable_signed = false)
    {
        return std::make_shared<DecDisplay>(suffix, enable_signed);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values) override;
};
 
class SegmentedDisplay : public Display<offset_t, offset_t>
{
public:
    unsigned width;
    SegmentedDisplay(unsigned width)
        : width(width)
    {
    }
 
    static std::shared_ptr<SegmentedDisplay> Make(unsigned width = 4)
    {
        return std::make_shared<SegmentedDisplay>(width);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t, offset_t> values) override;
};
 
class VersionDisplay : public Display<offset_t, offset_t>
{
public:
    std::string separator;
    VersionDisplay(std::string separator)
        : separator(separator)
    {
    }
 
    static std::shared_ptr<VersionDisplay> Make(std::string separator = ".")
    {
        return std::make_shared<VersionDisplay>(separator);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t, offset_t> values) override;
};
 
template <typename ... Ts>
    class SectionedDisplay : public Display<offset_t, Ts...>
{
public:
    std::string suffix;
    std::shared_ptr<Display<Ts...>> offset_display;
 
    SectionedDisplay(std::string suffix, std::shared_ptr<Display<Ts...>> offset_display)
        : suffix(suffix), offset_display(offset_display)
    {
    }
 
    static std::shared_ptr<SectionedDisplay> Make(std::shared_ptr<Display<Ts...>> offset_display)
    {
        return Make("", offset_display);
    }
 
    static std::shared_ptr<SectionedDisplay> Make(std::string suffix, std::shared_ptr<Display<Ts...>> offset_display)
    {
        return std::make_shared<SectionedDisplay>(suffix, offset_display);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t, Ts...> values) override;
};
 
class BitFieldDisplay : public HexDisplay, public std::enable_shared_from_this<BitFieldDisplay>
{
public:
    class BitField
    {
    public:
        unsigned offset, length;
        std::shared_ptr<Display<offset_t>> display;
        bool optional_field;
        std::string label;
 
        BitField(unsigned offset, unsigned length, std::shared_ptr<Display<offset_t>> display, bool optional_field, std::string label)
            : offset(offset), length(length), display(display), optional_field(optional_field), label(label)
        {
        }
 
        bool ShouldDisplay(std::tuple<offset_t>& values)
        {
            return !optional_field || !display->IsMissing(values);
        }
    };
 
    std::map<unsigned, std::unique_ptr<BitField>> bitfields;
 
    BitFieldDisplay(unsigned width)
        : HexDisplay(width)
    {
    }
 
    static std::shared_ptr<BitFieldDisplay> Make(unsigned width = 8)
    {
        return std::make_shared<BitFieldDisplay>(width);
    }
 
    std::shared_ptr<BitFieldDisplay> AddBitField(unsigned offset, unsigned length, std::shared_ptr<Display<offset_t>> display, bool optional_field)
    {
        bitfields[offset] = std::make_unique<BitField>(offset, length, display, optional_field, "");
        return shared_from_this();
    }
 
    std::shared_ptr<BitFieldDisplay> AddBitField(unsigned offset, unsigned length, std::string label, std::shared_ptr<Display<offset_t>> display, bool optional_field = false)
    {
        bitfields[offset] = std::make_unique<BitField>(offset, length, display, optional_field, label);
        return shared_from_this();
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values) override;
};
 
template <typename Clock>
    class TimestampDisplay : public Display<::Timestamp<Clock>>
{
public:
    typedef ::Timestamp<Clock> Timestamp;
 
    static std::shared_ptr<TimestampDisplay> Make()
    {
        return std::make_shared<TimestampDisplay>();
    }
 
    bool IsMissing(std::tuple<Timestamp>& values) override
    {
        return Clock::to_ticks(std::get<0>(values)) == 0;
    }
 
    void DisplayValue(Dumper& dump, std::tuple<Timestamp> values) override;
 
    using Display<Timestamp>::IsMissing;
    bool IsMissing(std::tuple<offset_t>& values)
    {
        return std::get<0>(values) == 0;
    }
 
    using Display<Timestamp>::DisplayValue;
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values)
    {
        // convert the first value to the time corresponding to the specified number of ticks
        DisplayValue(dump, std::make_tuple(Clock::to_time_stamp(std::get<0>(values))));
    }
};
 
class BlobDisplay : public Display<std::vector<uint8_t>>
{
public:
    offset_t width;
 
    std::shared_ptr<Display<std::string>> secondary_display;
 
    BlobDisplay(size_t width, std::shared_ptr<Display<std::string>> secondary_display = nullptr)
        : width(width), secondary_display(secondary_display)
    {
    }
 
    static std::shared_ptr<BlobDisplay> Make(size_t width, std::shared_ptr<Display<std::string>> secondary_display = nullptr)
    {
        return std::make_shared<BlobDisplay>(width, secondary_display);
    }
 
    bool IsMissing(std::tuple<std::vector<uint8_t>>& values) override;
    void DisplayValue(Dumper& dump, std::tuple<std::vector<uint8_t>> values) override;
 
    using Display<std::vector<uint8_t>>::IsMissing;
    bool IsMissing(std::tuple<offset_t>& values);
    using Display<std::vector<uint8_t>>::DisplayValue;
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values);
};
 
class StringDisplay : public Display<std::string>
{
public:
    offset_t width;
    std::string open_quote, close_quote;
 
    StringDisplay(size_t width, std::string open_quote, std::string close_quote)
        : width(width), open_quote(open_quote), close_quote(close_quote)
    {
    }
 
    static std::shared_ptr<StringDisplay> Make(size_t width, std::string open_quote, std::string close_quote)
    {
        return std::make_shared<StringDisplay>(width, open_quote, close_quote);
    }
 
    static std::shared_ptr<StringDisplay> Make(size_t width, std::string quote = "")
    {
        return std::make_shared<StringDisplay>(width, quote, quote);
    }
 
    static std::shared_ptr<StringDisplay> Make(std::string quote = "")
    {
        return std::make_shared<StringDisplay>(-1, quote, quote);
    }
 
    bool IsMissing(std::tuple<std::string>& values) override;
    void DisplayValue(Dumper& dump, std::tuple<std::string> values) override;
 
    using Display<std::string>::IsMissing;
    bool IsMissing(std::tuple<offset_t>& values);
    using Display<std::string>::DisplayValue;
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values);
};
 
class RichTextDisplay : public Display<RichText>
{
public:
    std::string open_quote, close_quote;
 
    RichTextDisplay(std::string open_quote, std::string close_quote)
        : open_quote(open_quote), close_quote(close_quote)
    {
    }
 
    static std::shared_ptr<RichTextDisplay> Make(std::string open_quote, std::string close_quote)
    {
        return std::make_shared<RichTextDisplay>(open_quote, close_quote);
    }
 
    static std::shared_ptr<RichTextDisplay> Make(std::string quote = "")
    {
        return std::make_shared<RichTextDisplay>(quote, quote);
    }
 
    bool IsMissing(std::tuple<RichText>& values) override;
    void DisplayValue(Dumper& dump, std::tuple<RichText> values) override;
 
    using Display<RichText>::IsMissing;
    bool IsMissing(std::tuple<offset_t>& values);
    using Display<RichText>::DisplayValue;
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values);
};
 
class Field
{
public:
    std::string label;
    bool optional_field;
    bool internal;
 
    Field(std::string label, bool optional_field, bool internal)
        : label(label), optional_field(optional_field), internal(internal)
    {
    }
 
    virtual ~Field();
 
    virtual bool ShouldDisplay() = 0;
    virtual void DisplayValue(Dumper& dump) = 0;
};
 
template <typename ... Ts>
    class FieldOf : public Field
{
public:
    std::shared_ptr<Display<Ts...>> display;
    std::tuple<Ts...> values;
 
    FieldOf(std::string label, std::shared_ptr<Display<Ts...>> display, Ts... values, bool optional_field = false, bool internal = false)
        : Field(label, optional_field, internal), display{display}, values{values...}
    {
    }
 
    bool ShouldDisplay() override
    {
        return !internal && (!optional_field || !display->IsMissing(values));
    }
 
    void DisplayValue(Dumper& dump) override
    {
        display->DisplayValue(dump, values);
    }
};
 
class Container
{
public:
    std::string name;
 
    std::map<std::string, std::shared_ptr<Field>> field_names;
    std::vector<std::shared_ptr<Field>> fields;
 
    Container(std::string name = "")
        : name(name)
    {
    }
 
    virtual ~Container();
 
    std::shared_ptr<Field> FindField(std::string name)
    {
        auto it = field_names.find(name);
        if(it == field_names.end())
            return nullptr;
        return it->second;
    }
 
    template <typename T>
        T GetField(std::string name, offset_t default_value = T())
    {
        auto it = field_names.find(name);
        if(it == field_names.end())
            return default_value;
        if(auto field = std::dynamic_pointer_cast<FieldOf<T>>(it->second))
        {
            return std::get<0>(field->values);
        }
        return default_value;
    }
 
#if 0
    offset_t GetField(std::string name, int index, offset_t default_value)
    {
        auto it = field_names.find(name);
        if(it == field_names.end())
            return default_value;
        return it->second->values[index];
    }
#endif
 
    void AddField(std::shared_ptr<Field> field)
    {
        fields.push_back(field);
        field_names[field->label] = field;
    }
 
    void AddField(size_t index, std::shared_ptr<Field> field)
    {
        fields.insert(fields.begin() + index, field);
        field_names[field->label] = field;
    }
 
    template <typename D, typename ... Ts>
        void AddField(std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(std::make_shared<FieldOf<Ts...>>(label, display, values..., false, false));
    }
 
    template <typename D, typename ... Ts>
        void AddOptionalField(std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(std::make_shared<FieldOf<Ts...>>(label, display, values..., true, false));
    }
 
    template <typename D, typename ... Ts>
        void AddHiddenField(std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(std::make_shared<FieldOf<Ts...>>(label, display, values..., false, true));
    }
 
    template <typename D, typename ... Ts>
        void InsertField(size_t index, std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(index, std::make_shared<FieldOf<Ts...>>(label, display, values..., false, false));
    }
 
    template <typename D, typename ... Ts>
        void InsertOptionalField(size_t index, std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(index, std::make_shared<FieldOf<Ts...>>(label, display, values..., true, false));
    }
 
    template <typename D, typename ... Ts>
        void InsertHiddenField(size_t index, std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(index, std::make_shared<FieldOf<Ts...>>(label, display, values..., false, true));
    }
 
    virtual void Display(Dumper& dump, int options);
};
 
class Region : public Container
{
public:
    Region(std::string name, offset_t offset, offset_t length, unsigned display_width)
        : Container(name)
    {
        AddField("Offset", HexDisplay::Make(display_width), offset);
        AddField("Length", HexDisplay::Make(display_width), length);
    }
 
    static std::shared_ptr<Region> Make(std::string name, offset_t offset, offset_t length, unsigned display_width)
    {
        return std::make_shared<Region>(name, offset, length, display_width);
    }
 
//  void Display(Dumper& dump, int options);
};
 
class Entry : public Container
{
public:
    offset_t number;
    offset_t offset;
    unsigned display_width;
 
    Entry(std::string name, offset_t number, offset_t offset = offset_t(-1), unsigned display_width = 8)
        : Container(name), number(number), offset(offset), display_width(display_width)
    {
    }
 
    void Display(Dumper& dump, int options) override;
};
 
class Block : public Region
{
public:
    unsigned offset_display_width;
    unsigned position_display_width;
    unsigned address_display_width;
 
    static SingleByteEncoding encoding_default;
    static SingleByteEncoding encoding_cp437;
    static SingleByteEncoding encoding_st;
    static SingleByteEncoding encoding_iso8859_1;
    static SingleByteEncoding encoding_windows1252;
    static SingleByteEncoding encoding_macroman;
    static UTF8Encoding encoding_utf8;
    static UTF16Encoding encoding_utf16le;
    static UTF16Encoding encoding_utf16be;
    static UTF32Encoding encoding_utf32le;
    static UTF32Encoding encoding_utf32be;
 
    std::shared_ptr<Linker::Image> image;
 
    std::set<offset_t> signal_starts;
    std::set<offset_t> signal_ends;
 
    void AddSignal(offset_t off, offset_t len)
    {
        offset_t end = off + len - 1;
        signal_starts.insert(off);
        signal_ends.insert(end);
    }
 
    Block(std::string name, offset_t offset, std::shared_ptr<Linker::Image> image, offset_t address, unsigned display_width,
            unsigned offset_display_width = 8, unsigned address_display_width = -1u, unsigned position_display_width = -1u)
        : Region(name, offset, image ? image->ImageSize() : 0, display_width),
            offset_display_width(offset_display_width),
            position_display_width(position_display_width != -1u ? position_display_width
                : address_display_width != -1u ? address_display_width : offset_display_width),
            address_display_width(address_display_width != -1u ? address_display_width : offset_display_width),
            image(image)
    {
        AddField("Address", HexDisplay::Make(display_width), address);
    }
 
    static std::shared_ptr<Block> Make(std::string name, offset_t offset, std::shared_ptr<Linker::Image> image, offset_t address, unsigned display_width,
            unsigned offset_display_width = 8, unsigned address_display_width = -1u, unsigned position_display_width = -1u)
    {
        return std::make_shared<Block>(name, offset, image, address, display_width, offset_display_width, address_display_width, position_display_width);
    }
 
    void Display(Dumper& dump, int options) override;
};
 
class Dumper
{
public:
    std::ostream& out;
    bool use_ansi;
    int show_options = All;
    int hide_options = None;
 
    SingleByteEncoding * encoding;
    Encoding * string_encoding;
 
    Dumper(std::ostream& out)
        : out(out), use_ansi(true), encoding(nullptr), string_encoding(nullptr)
    {
    }
 
    SingleByteEncoding * SetEncoding(SingleByteEncoding& encoding, bool force = false)
    {
        SingleByteEncoding * old_encoding = this->encoding;
        if(this->encoding == nullptr || force)
        {
            this->encoding = &encoding;
        }
        return old_encoding;
    }
 
    Encoding * SetStringEncoding(Encoding& encoding)
    {
        Encoding * old_encoding = this->string_encoding;
        this->string_encoding = &encoding;
        return old_encoding;
    }
 
    void SetTitle(std::string title)
    {
        out << "=== " << title << " ===" << std::endl;
    }
 
//  std::vector<Field> fields;
 
    void PrintHex(offset_t value, unsigned width, std::string prefix = "0x")
    {
        out << prefix << std::hex << std::setw(width) << std::setfill('0') << value;
    }
 
#if 0
    void PrintHex(offset_t value, unsigned width, bool prefixed)
    {
        PrintHex(value, width, prefixed ? "0x" : "");
    }
#endif
 
    void PrintDec(offset_t value, std::string prefix = "#")
    {
        out << prefix << std::dec << value;
    }
 
    void PrintDecSigned(relative_offset_t value, std::string prefix = "#")
    {
        out << prefix << std::dec << value;
    }
 
#if 0
    void PrintDec(offset_t value, bool prefixed)
    {
        PrintDec(value, prefixed ? "#" : "");
    }
#endif
 
    void PutChar(char32_t c)
    {
        /* TODO: this should depend on the current locale */
        const char32_t * input = &c;
        char * output = nullptr;
        size_t size;
        UTF32ToUTF8(input, output, 0, size);
        std::vector<char> buffer(size);
        output = buffer.data();
        UTF32ToUTF8(input, output, size, size);
        out << std::string(buffer.data(), buffer.size());
    }
 
    void PutEncodedString(std::string encoded_string, bool terminate_at_null = false)
    {
        uint8_t const * input = reinterpret_cast<uint8_t *>(encoded_string.data());
        size_t length = encoded_string.size();
        char32_t c;
        while((c = (string_encoding ? string_encoding : encoding)->GetChar(input, length)) != char32_t(-1) || (terminate_at_null && c == U'\0'))
        {
            PutChar(c);
        }
    }
 
    void PutEncodedString(offset_t width, std::string encoded_string, char32_t padding)
    {
        uint8_t const * input = reinterpret_cast<uint8_t *>(encoded_string.data());
        size_t length = encoded_string.size();
        char32_t c;
        while(width > 0 && (c = (string_encoding ? string_encoding : encoding)->GetChar(input, length)) != char32_t(-1))
        {
            PutChar(c);
            width --;
        }
        while(width > 0)
        {
            PutChar(padding);
            width --;
        }
    }
 
    void BeginBold()
    {
        if(use_ansi)
            out << "\33[1m";
    }
 
    void EndBold()
    {
        if(use_ansi)
            out << "\33[22m";
    }
 
    void BeginUnderline()
    {
        if(use_ansi)
            out << "\33[4m";
    }
 
    void EndUnderline()
    {
        if(use_ansi)
            out << "\33[m";
    }
};
 
template <unsigned I, size_t ... Is, typename ... Ts>
    inline auto rest_(std::tuple<Ts...> elements, std::index_sequence<Is...> s)
{
    return std::make_tuple(std::get<I + Is>(elements)...);
}
 
template <unsigned I, typename ... Ts>
    inline auto rest(std::tuple<Ts...> elements)
{
    return rest_<I>(elements, std::make_index_sequence<sizeof...(Ts) - I>());
}
 
template <typename ... Ts>
    void SectionedDisplay<Ts...>::DisplayValue(Dumper& dump, std::tuple<offset_t, Ts...> values)
{
    dump.PrintDec(std::get<0>(values), "");
    dump.out << suffix << ':';
    offset_display->DisplayValue(dump, rest<1>(values));
}
 
template <typename Clock>
    void TimestampDisplay<Clock>::DisplayValue(Dumper& dump, std::tuple<Timestamp> values)
{
    dump.out << Clock::to_iso_time(std::get<0>(values));
}
 
}
 
#endif /* DUMPER_H */