fmt.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_fmt_h
#define INCL_evo_fmt_h

#include "substring.h"

namespace evo {


namespace impl {
    template<class T> struct FmtFieldType {
        typedef typename T::FmtFieldType Type;
    };
    template<> struct FmtFieldType<String> {
        typedef FmtString Type;
    };
}

struct FmtTable {
    enum Type {
        tTEXT,      
        tMARKDOWN   
    };

    struct Column {
        SubString name;     
        FmtAlign align;     
        int width;          

        Column() : align(fLEFT), width(0) {
        }

        Column(const SubString& name, FmtAlign align, int width=0) : name(name), align(align), width(width) {
        }

        Column(const SubString& name, int width=0) : name(name), align(fLEFT), width(width) {
        }

        Column(const Column& src) : name(src.name), align(src.align), width(src.width) {
        }

        Column& operator=(const Column& src) {
            name = src.name;
            align = src.align;
            width = src.width;
            return *this;
        }
    };

    List<Column> columns;   

    FmtTable() {
    }

    FmtTable(const Column* cols, SizeT size) {
        add_columns(cols, size);
    }

    FmtTable(const StringBase* names, SizeT size, int minwidth=0, FmtAlign align=fLEFT) {
        add_columns(names, size, minwidth, align);
    }

    FmtTable(const FmtTable& src) : columns(src.columns) {
    }

    FmtTable& operator=(const FmtTable& src) {
        columns = src.columns;
        return *this;
    }

    FmtTable& add_column(const Column& column) {
        Column& newcol = *(columns.add(column).lastM());
        if (newcol.width < 0 || (SizeT)newcol.width < newcol.name.size())
            newcol.width = (int)newcol.name.size();
        return *this;
    }

    FmtTable& add_column(const StringBase& name, FmtAlign align=fLEFT, int width=0) {
        if (width < 0 || (SizeT)width < name.size_)
            width = (int)name.size_;
        columns.add(Column(name, align, width));
        return *this;
    }

    FmtTable& add_column(const StringBase& name, int width) {
        if (width < 0 || (SizeT)width < name.size_)
            width = (int)name.size_;
        columns.add(Column(name, width));
        return *this;
    }

    FmtTable& add_columns(const Column* cols, SizeT size) {
        if (cols != NULL) {
            if (size == 0) {
                for (SizeT i = 0; cols[i].name.size_ > 0; ++i)
                    add_column(cols[i]);
            } else {
                columns.reserve(size);
                for (SizeT i = 0; i < size; ++i)
                    add_column(cols[i]);
            }
        }
        return *this;
    }

    FmtTable& add_columns(const StringBase* names, SizeT size, int minwidth=0, FmtAlign align=fLEFT) {
        if (names != NULL) {
            if (size == 0) {
                for (SizeT i = 0; names[i].size_ > 0; ++i)
                    add_column(names[i], align, minwidth);
            } else {
                columns.reserve(size);
                for (SizeT i = 0; i < size; ++i)
                    add_column(names[i], align, minwidth);
            }
        }
        return *this;
    }

    FmtTable& column_align(SizeT index, FmtAlign align) {
        if (index < columns.size())
            columns(index).align = align;
        return *this;
    }

    FmtTable& column_minsize(SizeT index, int width) {
        if (index < columns.size()) {
            int& col_width = columns(index).width;
            if (width > col_width)
                col_width = width;
        }
        return *this;
    }

    FmtTable& column_reset() {
        for (List<Column>::IterM iter(columns); iter; ++iter) {
            Column& col = *iter;
            col.align = fLEFT;
            col.width = (int)col.name.size();
        }
        return *this;
    }

    struct Writer {
        FmtTable& table;        
        Type type;              
        SizeT column_index;     
        SizeT rows;             
        bool started;           

        Writer(FmtTable& table, Type type=tTEXT) : table(table), type(type), column_index(0), rows(0), started(false) {
        }

        template<class T>
        T& write_header(T& out) {
            const SizeT sz = table.columns.size();
            if (sz > 0) {
                started = true;
                if (type == tMARKDOWN)
                    out.writebin("| ", 2);

                for (SizeT i = 0; i < sz; ++i) {
                    if (i > 0) {
                        if (type == tMARKDOWN)
                            out.writebin(" | ", 3);
                        else
                            out.writebin("  ", 2);
                    }
                    const Column& col = table.columns[i];
                    out << FmtString(col.name, col.align, col.width, ' ');
                }

                if (type == tMARKDOWN) {
                    out.writebin(" |", 2);
                    out << NL;
                    out.writebin("| ", 2);
                    for (SizeT i = 0; i < sz; ++i) {
                        if (i > 0)
                            out.writebin(" | ", 3);
                        const Column& col = table.columns[i];
                        switch (col.align) {
                            case fRIGHT:
                                out.writechar('-', table.columns[i].width - 1);
                                out.writechar(':');
                                break;
                            case fCENTER:
                                out.writechar(':');
                                out.writechar('-', table.columns[i].width - 2);
                                out.writechar(':');
                                break;
                            default:
                                out.writechar('-', table.columns[i].width);
                                break;
                        }
                    }
                    out.writebin(" |", 2);
                }
                out << NL;
            }
            return out;
        }

        template<class T, class U>
        T& write_value(T& out, const U& fmtval) {
            const SizeT col_sz = table.columns.size();
            if (started && col_sz > 0) {
                assert( column_index < table.columns.size() );
                const Column& col = table.columns[column_index];
                typename impl::FmtFieldType<U>::Type v(fmtval, col.align, col.width);
                if (type == tMARKDOWN) {
                    if (column_index == 0) {
                        out.writebin("| ", 2);
                        out << v;
                        ++column_index;
                    } else if (++column_index >= col_sz) {
                        ++rows;
                        column_index = 0;
                        out.writebin(" | ", 3);
                        out << v;
                        out.writebin(" |", 2);
                        out << NL;
                    } else {
                        out.writebin(" | ", 3);
                        out << v;
                    }
                } else {
                    if (column_index > 0)
                        out.writebin("  ", 2);
                    out << v;
                    if (++column_index >= col_sz) {
                        column_index = 0;
                        ++rows;
                        out << NL;
                    }
                }
            }
            return out;
        }

        template<class T>
        T& write_endrow(T& out) {
            if (started && column_index > 0) {
                if (type == tMARKDOWN) {
                    for (SizeT sz = table.columns.size(); column_index < sz; ++column_index) {
                        out.writebin(" | ", 3);
                        out.writechar(' ', table.columns[column_index].width);
                    }
                    out.writebin(" |", 2);
                }
                column_index = 0;
                ++rows;
                out << NL;
            }
            return out;
        }

        template<class T>
        T& write_finished(T& out) {
            if (started) {
                write_endrow(out);
                if (rows == 0 && table.columns.size() > 0) {
                    if (type == tMARKDOWN) {
                        out.writebin("| ", 2);
                        out.writechar(' ', table.columns[0].width);
                        for (SizeT i = 1, sz = table.columns.size(); i < sz; ++i) {
                            out.writebin(" | ", 3);
                            out.writechar(' ', table.columns[i].width);
                        }
                        out.writebin(" |", 2);
                    }
                    out << NL;
                }
                column_index = 0;
                rows = 0;
                started = false;
            }
            return out;
        }
    };

    struct CachedWriter {
        typedef List<String> StringList;    

        Writer writer;              
        List<StringList> rowcache;  
        StringList* current_row;    
        bool started;               

        CachedWriter(FmtTable& table, Type type=tTEXT) : writer(table, type), current_row(NULL) {
        }

        template<class T>
        T& write_header(T& out) {
            started = true;
            return out;
        }

        template<class T, class U>
        T& write_value(T& out, const U& fmtval) {
            const SizeT col_sz = writer.table.columns.size();
            if (started && col_sz > 0) {
                if (current_row == NULL) {
                    current_row = rowcache.addnew().lastM();
                    current_row->reserve(writer.table.columns.size());
                }
                const SizeT i = current_row->size();
                if (i >= col_sz) {
                    current_row = rowcache.addnew().lastM();
                    current_row->reserve(writer.table.columns.size());
                }

                String& val = *(current_row->addnew().lastM());
                val.clear() << fmtval;
                writer.table.column_minsize(i, (int)val.size());
            }
            return out;
        }

        template<class T>
        T& write_endrow(T& out) {
            if (started) {
                current_row = NULL;
                writer.write_endrow(out);
            }
            return out;
        }

        template<class T>
        T& write_finished(T& out) {
            if (started) {
                writer.write_header(out);
                for (SizeT i = 0, i_sz = rowcache.size(); i < i_sz; ++i) {
                    const StringList& row = rowcache[i];
                    for (SizeT j = 0, j_sz = row.size(); j < j_sz; ++j)
                        writer.write_value(out, row[j]);
                    writer.write_endrow(out);
                }
                writer.write_finished(out);
                rowcache.clear();
                started = false;
            }
            return out;
        }
    };
};


struct FmtTableAttribs {
    FmtTable& table;    
    SizeT column_index; 

    FmtTableAttribs(FmtTable& table) : table(table), column_index(0) {
    }

    FmtTableAttribs& operator<<(FmtAlign align) {
        const SizeT col_sz = table.columns.size();
        if (col_sz > 0) {
            table.columns(column_index).align = align;
            if (++column_index >= col_sz)
                column_index = 0;
        }
        return *this;
    }

    FmtTableAttribs& operator<<(int minwidth) {
        const SizeT col_sz = table.columns.size();
        if (col_sz > 0) {
            int& width = table.columns(column_index).width;
            if (minwidth > width)
                width = minwidth;
            if (++column_index >= col_sz)
                column_index = 0;
        }
        return *this;
    }

    FmtTableAttribs& operator<<(const FmtSetField& field) {
        const SizeT col_sz = table.columns.size();
        if (col_sz > 0) {
            FmtTable::Column& col = table.columns(column_index);
            col.align = field.align;
            int& width = col.width;
            if (field.width > width)
                width = field.width;
            if (++column_index >= col_sz)
                column_index = 0;
        }
        return *this;
    }

    FmtTableAttribs& operator<<(Newline) {
        column_index = 0;
        return *this;
    }
};


template<class T, class W=FmtTable::CachedWriter>
struct FmtTableOut {
    typedef FmtTableOut<T,W> This;  
    W writer;   
    T& out;     

    FmtTableOut(T& out, FmtTable& table, FmtTable::Type type=FmtTable::tTEXT) : writer(table, type), out(out)
        { writer.write_header(out); }

    ~FmtTableOut()
        { writer.write_finished(out); }

    This& operator<<(char val)
        { writer.write_value(out, FmtChar(val, 1)); return *this; }

    This& operator<<(const FmtChar& val)
        { writer.write_value(out, val); return *this; }

    This& operator<<(const char* val)
        { writer.write_value(out, FmtString(val)); return *this; }

    This& operator<<(const StringBase& val)
        { writer.write_value(out, FmtString(val)); return *this; }

    This& operator<<(const FmtString& val)
        { writer.write_value(out, val); return *this; }

    This& operator<<(short val)
        { writer.write_value(out, FmtShort(val)); return *this; }

    This& operator<<(int val)
        { writer.write_value(out, FmtInt(val)); return *this; }

    This& operator<<(long val)
        { writer.write_value(out, FmtLong(val)); return *this; }

    This& operator<<(longl val)
        { writer.write_value(out, FmtLongL(val)); return *this; }

    This& operator<<(ushort val)
        { writer.write_value(out, FmtUShort(val)); return *this; }

    This& operator<<(uint val)
        { writer.write_value(out, FmtUInt(val)); return *this; }

    This& operator<<(ulong val)
        { writer.write_value(out, FmtULong(val)); return *this; }

    This& operator<<(ulongl val)
        { writer.write_value(out, FmtULongL(val)); return *this; }

    This& operator<<(float val)
        { writer.write_value(out, FmtFloat(val)); return *this; }

    This& operator<<(double val)
        { writer.write_value(out, FmtFloatD(val)); return *this; }

    This& operator<<(ldouble val)
        { writer.write_value(out, FmtFloatL(val)); return *this; }

    template<class V>
    This& operator<<(const FmtIntT<V>& val)
        { writer.write_value(out, val); return *this; }

    template<class V>
    This& operator<<(const FmtFloatT<V>& val)
        { writer.write_value(out, val); return *this; }

    template<class V>
    This& operator<<(const IntegerT<V>& val) {
        if (val.null())
            writer.write_value(out, String("", 0));
        else
            writer.write_value(out, FmtIntT<V>(*val));
        return *this;
    }

    template<class V>
    This& operator<<(const FloatT<V>& val) {
        if (val.null())
            writer.write_value(out, String("", 0));
        else
            writer.write_value(out, FmtFloatT<V>(*val));
        return *this;
    }

    This& operator<<(Newline)
        { writer.write_endrow(out); return *this; }

    This& operator<<(Flush)
        { writer.write_finished(out); return *this; }
};


template<class T>
inline FmtTableOut<T,FmtTable::CachedWriter> fmt_table(T& out, FmtTable& table, FmtTable::Type type=FmtTable::tTEXT) {
    return FmtTableOut<T,FmtTable::CachedWriter>(out, table, type);
}

template<class T>
inline FmtTableOut<T,FmtTable::Writer> fmt_table_nocache(T& out, FmtTable& table, FmtTable::Type type=FmtTable::tTEXT) {
    return FmtTableOut<T,FmtTable::Writer>(out, table, type);
}


}
#endif