table.cc

Go to the documentation of this file.

#include "config.h"

#include <iostream>
#include <algorithm>

#include "asserts.h"
#include "types.h"
#include "error.h"
#include "estring.h"
#include "table.h"

//----------------------------------------------------------------------------

const table_cell_base::size_type table_cell_base::npos = estring::npos;

table_cell_base::table_cell_base()
{
        x = npos;
        y = npos;
        repeat = false;
}

table_cell_base::table_cell_base(const table_cell_base& a_class)
{
        assign(a_class);
}

table_cell_base::~table_cell_base()
{
}

void table_cell_base::assign(const table_cell_base& a_class)
{
}

table_cell_base::size_type table_cell_base::height(void) const
{
        return(0);
}

table_cell_base::size_type table_cell_base::width(void) const
{
        return(0);
}

void table_cell_base::write(
        std::ostream& a_out, 
        size_type a_line,
        size_type a_width
        ) const
{
}

table_cell_base& table_cell_base::operator=(const table_cell_base& a_class)
{
        assign(a_class);

        return(*this);
}

bool operator==(const table_cell_base& a_1, const table_cell_base& a_2)
{
        bool value;

        value = (&a_1 == &a_2);

        return(value);
}

//----------------------------------------------------------------------------

table_cell_estring::table_cell_estring()
{
}

table_cell_estring::table_cell_estring(const table_cell_estring& a_class)
{
        assign(a_class);
}

table_cell_estring::table_cell_estring(const estring& a_class)
{
        assign(a_class);
}

table_cell_estring::~table_cell_estring()
{
}

void table_cell_estring::assign(const table_cell_estring& a_class)
{
        assign(a_class.m_value);
        x = a_class.x;
        y = a_class.y;
        repeat = a_class.repeat;
}

void table_cell_estring::assign(const estring& a_class)
{
        m_value = a_class;
}

table_cell_estring::size_type table_cell_estring::height(void) const
{
        return(1);
}

table_cell_estring::size_type table_cell_estring::width(void) const
{
        size_type value;

        value = m_value.size();

        return(value);
}

void table_cell_estring::write(
        std::ostream& a_out, 
        size_type a_line,
        size_type a_width
        ) const
{
        estring str;

        if (repeat) {
                a_line = 0;
        }
        if (a_line == 0) {
                str = m_value;
                str.width(a_width);
                a_out << str.fmt_str();
                a_out.flush();
        }
        else {
                str = "";
                str.width(a_width);
                a_out << str.fmt_str();
                a_out.flush();
        }
}

table_cell_estring& 
table_cell_estring::operator=(const table_cell_estring& a_class)
{
        assign(a_class);

        return(*this);
}

table_cell_estring&
table_cell_estring::operator=(const estring& a_class)
{
        assign(a_class);

        return(*this);
}

//----------------------------------------------------------------------------

table_cell_table::table_cell_table()
{
        m_value = new table;
        if (m_value == 0)
                throw(err_nomem);
}

table_cell_table::table_cell_table(const table_cell_table& a_class)
{
        m_value = 0;
        assign(a_class);
}

table_cell_table::table_cell_table(const table& a_class)
{
        m_value = 0;
        assign(a_class);
}

table_cell_table::~table_cell_table()
{
        if (m_value != 0)
                delete(m_value);
}

void table_cell_table::assign(const table_cell_table& a_class)
{
        ASSERT(a_class.m_value != 0);
        assign(*a_class.m_value);
        x = a_class.x;
        y = a_class.y;
        repeat = a_class.repeat;
}

void table_cell_table::assign(const table& a_class)
{
        if (m_value != 0) {
                delete(m_value);
        }
        m_value = new table(a_class);
}

table_cell_table::size_type table_cell_table::height(void) const
{
        size_type value;

        value = m_value->height();

        return(value);
}

table_cell_table::size_type table_cell_table::width(void) const
{
        size_type value;

        value = m_value->width();

        return(value);
}

void table_cell_table::write(
        std::ostream& a_out, 
        size_type a_line,
        size_type a_width
        ) const
{
        if (repeat) {
                a_line %= m_value->height();
        }
        if (a_line < m_value->height()) {
                m_value->write(a_out, a_line, a_width);
        }
        else {
                estring str;

                str = "";
                str.width(a_width);
                a_out << str.fmt_str();
                a_out.flush();
        }
}

table_cell_table&
table_cell_table::operator=(const table_cell_table& a_class)
{
        assign(a_class);

        return(*this);
}

table_cell_table&
table_cell_table::operator=(const table& a_class)
{
        assign(a_class);

        return(*this);
}

//----------------------------------------------------------------------------

table::table()
{
        mf_init();
}

table::table(const table::size_type a_ncols, const table::size_type a_nrows)
{
        size_type cx, cy;

        mf_init();
        for (cy = 0; cy != a_nrows; ++cy) {
                table_row_type new_row;

                for (cx = 0; cx != a_ncols; ++cx) {
                        new_row.push_back(static_cast<table_cell_base *>(0));
                }

                TRY_nomem(m_table.push_back(new_row));
        }
}

table::table(const table& a_class)
{
        mf_init();
        assign(a_class);
}

table::~table()
{
}

void table::resize(const size_type a_x, const size_type a_y)
{
        size_type cy;

        while (m_table.size() > a_y)
                mf_remove_row(m_table.size()-1);
        
        for (cy = 0; cy != m_table.size(); ++cy) {
                while (m_table[cy].size() > a_x)
                        mf_remove_elt(m_table[cy].size()-1,cy);
        }

        while (m_table.size() < a_y) {
                table_row_type new_row;

                TRY_nomem(m_table.push_back(new_row));
        }

        for (cy = 0; cy != m_table.size(); ++cy) {
                while (m_table[cy].size() < a_x)
                        TRY_nomem(m_table[cy].push_back(static_cast<table_cell_base *>(0)));
        }
}

void table::insert_row(const table::size_type a_y)
{
        size_type num_cols;
        table_row_type new_row;
        table_type::iterator ti;

        while (a_y > m_table.size())
                insert_row(m_table.size());

        num_cols = ncols();
        while (new_row.size() < num_cols)
                TRY_nomem(new_row.push_back(static_cast<table_cell_base *>(0)));
        ti = m_table.begin();
        ti += a_y;
        TRY_nomem(m_table.insert(ti,new_row));
}

void table::insert_col(const table::size_type a_x)
{
        table_type::iterator cy;
        table_row_type::iterator cx;

        for (cy = m_table.begin(); cy != m_table.end(); ++cy) {
                while (a_x > cy->size()) {
                        TRY_nomem(cy->push_back(static_cast<table_cell_base *>(0)));
                }
                cx = cy->begin();
                cx += a_x;
                TRY_nomem(cy->insert(cx,static_cast<table_cell_base *>(0)));
        }
}

void table::assign(const table& a_class)
{
        std::list<table_cell_estring>::const_iterator ctce;
        std::list<table_cell_table>::const_iterator ctct;

        m_table.clear();
        m_list_estring.clear();
        m_list_table.clear();

        resize(a_class.ncols(),a_class.nrows());

        for (
                ctce = a_class.m_list_estring.begin(); 
                ctce != a_class.m_list_estring.end(); 
                ++ctce
        ) {
                mf_add_elt(*ctce);
        }
        for (
                ctct = a_class.m_list_table.begin(); 
                ctct != a_class.m_list_table.end(); 
                ++ctct
        ) {
                mf_add_elt(*ctct);
        }
}

void table::assign(
        const size_type a_x,
        const size_type a_y,
        const estring& a_class
        )
{
        estring es;
        table_cell_estring new_cell(a_class);

        if (a_y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_y);
                throw(INTERNAL_ERROR(0,es));
        }
        if (a_x >= m_table[a_y].size()) {
                es = "Row index out of bounds: ";
                es += estring(a_x);
                throw(INTERNAL_ERROR(0,es));
        }
        if (m_table[a_y][a_x] != 0)
                mf_remove_elt(a_x,a_y);
        new_cell.x = a_x;
        new_cell.y = a_y;
        new_cell.repeat = m_repeat;
        m_repeat = false;
        mf_add_elt(new_cell);
}

void table::assign(
        const size_type a_x,
        const size_type a_y,
        const table& a_class
        )
{
        estring es;
        table_cell_table new_cell(a_class);

        if (a_y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_y);
                throw(INTERNAL_ERROR(0,es));
        }
        if (a_x >= m_table[a_y].size()) {
                es = "Row index out of bounds: ";
                es += estring(a_x);
                throw(INTERNAL_ERROR(0,es));
        }
        if (m_table[a_y][a_x] != 0)
                mf_remove_elt(a_x,a_y);
        
        new_cell.x = a_x;
        new_cell.y = a_y;
        new_cell.repeat = m_repeat;
        m_repeat = false;
        mf_add_elt(new_cell);
}

table::size_type table::col_width(const table::size_type a_x) const
{
        estring es;
        table_type::const_iterator cy;
        size_type width = 0;

        if (m_table.size() == 0) {
                return(0);
        }

        for (cy = m_table.begin(); cy != m_table.end(); cy++) {
                if (a_x >= cy->size()) {
                        es = "Column index out of bounds: ";
                        es += estring(a_x);
                        throw(INTERNAL_ERROR(0,es));
                }
                if ((*cy)[a_x] != 0)
                        width = std::max(width,(*cy)[a_x]->width());
        }

        return(width);
}

table::size_type table::row_width(void) const
{
        size_type cx;
        size_type width = 0;

        if (m_table.size() == 0) {
                return(0);
        }

        for (cx = 0; cx != m_table.begin()->size(); ++cx) {
                width += col_width(cx);
        }

        return(width);
}

table::size_type table::col_height(void) const
{
        size_type y;
        size_type height = 0;

        for (y = 0; y != m_table.size(); ++y) {
                height += row_height(y);
        }

        return(height);
}

table::size_type table::row_height(const table::size_type a_y) const
{
        estring es;
        table_row_type::const_iterator cx;
        size_type height = 0;

        if (m_table.size() == 0) {
                return(0);
        }
        if (a_y >= m_table.size()) {
                es = "Row index out of bounds: ";
                es += estring(a_y);
                throw(INTERNAL_ERROR(0,es));
        }
        for (cx = m_table[a_y].begin(); cx != m_table[a_y].end(); ++cx) {
                if (*cx != 0)
                height = std::max(height, (*cx)->height());
        }

        return(height);
}

table::size_type table::height(void) const
{
        table_type::const_iterator cy;
        table_row_type::const_iterator cx;
        size_type height = 0;

        for (cy = m_table.begin(); cy != m_table.end(); ++cy) {
                size_type row_height = 0;

                for (cx = cy->begin(); cx != cy->end(); ++cx) {
                        if (*cx != 0)
                                row_height = std::max(row_height, (*cx)->height());
                }

                height += row_height;
        }

        return(height);
}

table::size_type table::width(void) const
{
        table_type::const_iterator cy;
        size_type x, max_x = 0;
        size_type width = 0;

        for (cy = m_table.begin(); cy != m_table.end(); ++cy) {
                max_x = std::max(max_x, cy->size());
        }

        for (x = 0; x < max_x; ++x) {
                size_type col_width = 0;

                for (cy = m_table.begin(); cy != m_table.end(); ++cy) {
                        if ((x < cy->size()) && ((*cy)[x] != 0)) {
                                col_width = std::max(col_width, (*cy)[x]->width());
                        }
                }

                width += col_width;
        }

        return(width);
}

const table::size_type table::ncols(void) const
{
        table_type::const_iterator cy;
        size_type cols = 0;

        for (cy = m_table.begin(); cy != m_table.end(); ++cy) {
                cols = std::max(cols,cy->size());
        }

        return(cols);
}

const table::size_type table::nrows(void) const
{
        size_type value;

        value = m_table.size();

        return(value);
}

void table::write(
        std::ostream& a_out, 
        size_type a_line,
        size_type a_width
        ) const
{
        size_type row = 0;
        size_type height;
        size_type col = 0;
        size_type width;

        if (m_table.size() == 0)
                return;
        
        while ((m_table.size() > row) && (a_line >= (height = row_height(row))))
        {
                a_line -= height;
                ++row;
        }
        for (col = 0; col != m_table[row].size(); ++col) {
                width = std::min(col_width(col), a_width);
                if (m_table[row][col] != 0)
                        m_table[row][col]->write(a_out,a_line,width);
                else {
                        estring estr;

                        estr = "";
                        estr.width(width);
                        a_out << estr.fmt_str();
                        a_out.flush();
                }
                a_width -= width;
        }

        if (a_width > 0) {
                estring estr;

                estr = "";
                estr.width(a_width);
                a_out << estr.fmt_str();
                a_out.flush();
        }
}

table& table::operator=(const table& a_class)
{
        assign(a_class);

        return(*this);
}

table::size_type table::cursor_x(void) const
{
        return(m_cursor_x);
}

table::size_type table::cursor_y(void) const
{
        return(m_cursor_y);
}

void table::set_cursor(table::size_type a_x, table::size_type a_y)
{
        estring es;

        if (a_y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_y);
                throw(ERROR(0,es));
        }
        if (a_x >= m_table[a_y].size()) {
                es = "Row index out of bounds: ";
                es += estring(a_x);
                throw(ERROR(0,es));
        }

        m_cursor_x = a_x;
        m_cursor_y = a_y;
}

bool table::eot(void) const
{
        if ((m_cursor_x == ncols()-1) && (m_cursor_y == nrows()-1)) {
                return(true);
        }

        return(false);
}

void table::repeat(const bool a_bool)
{
        m_repeat = a_bool;
}

void table::mf_init(void)
{
        m_cursor_x = 0;
        m_cursor_y = 0;
        m_repeat = false;
}

void table::mf_add_elt(const table_cell_estring& a_class)
{
        estring es;

        if (a_class.y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_class.y);
                throw(INTERNAL_ERROR(0,es));
        }
        if (a_class.x >= m_table[a_class.y].size()) {
                es = "Row index out of bounds: ";
                es += estring(a_class.x);
                throw(INTERNAL_ERROR(0,es));
        }
        TRY_nomem(m_list_estring.push_back(a_class));
        m_table[a_class.y][a_class.x] = &(*m_list_estring.rbegin());
}

void table::mf_add_elt(const table_cell_table& a_class)
{
        estring es;

        if (a_class.y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_class.y);
                throw(INTERNAL_ERROR(0,es));
        }
        if (a_class.x >= m_table[a_class.y].size()) {
                es = "Row index out of bounds: ";
                es += estring(a_class.x);
                throw(INTERNAL_ERROR(0,es));
        }
        TRY_nomem(m_list_table.push_back(a_class));
        m_table[a_class.y][a_class.x] = &(*m_list_table.rbegin());
}

void table::mf_remove_elt(const table_cell_estring& a_class)
{
        estring es;

        if (a_class.y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_class.y);
                throw(INTERNAL_ERROR(0,es));
        }
        if (a_class.x >= m_table[a_class.y].size()) {
                es = "Row index out of bounds: ";
                es += estring(a_class.x);
                throw(INTERNAL_ERROR(0,es));
        }
        m_table[a_class.y][a_class.x] = static_cast<table_cell_base *>(0);
        m_list_estring.erase(
                find(m_list_estring.begin(), m_list_estring.end(), a_class)
                );
}

void table::mf_remove_elt(const table_cell_table& a_class)
{
        estring es;

        if (a_class.y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_class.y);
                throw(INTERNAL_ERROR(0,es));
        }
        if (a_class.x >= m_table[a_class.y].size()) {
                es = "Row index out of bounds: ";
                es += estring(a_class.x);
                throw(INTERNAL_ERROR(0,es));
        }
        m_table[a_class.y][a_class.x] = static_cast<table_cell_base *>(0);
        m_list_table.erase(
                find(m_list_table.begin(), m_list_table.end(), a_class)
                );
}

void table::mf_remove_elt(
        table::size_type a_x,
        table::size_type a_y
        )
{
        estring es;
        std::list<table_cell_estring>::const_iterator ctce;
        std::list<table_cell_table>::const_iterator ctct;

        if (a_y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_y);
                throw(INTERNAL_ERROR(0,es));
        }
        if (a_x >= m_table[a_y].size()) {
                es = "Row index out of bounds: ";
                es += estring(a_x);
                throw(INTERNAL_ERROR(0,es));
        }
        if (m_table[a_y][a_x] != 0) {
                for (ctce = m_list_estring.begin(); ctce != m_list_estring.end(); ++ctce)
                {
                        if (*ctce == *m_table[a_y][a_x]) {
                                mf_remove_elt(*ctce);
                                return;
                        }
                }
                for (ctct = m_list_table.begin(); ctct != m_list_table.end(); ++ctct) {
                        if (*ctct == *m_table[a_y][a_x]) {
                                mf_remove_elt(*ctct);
                                return;
                        }
                }
                // This should never happen
                ASSERT(0);
        }
}

void table::mf_remove_row(table::size_type a_y)
{
        size_type cx;
        table_type::iterator ti;

        estring es;

        if (a_y >= m_table.size()) {
                es = "Column index out of bounds: ";
                es += estring(a_y);
                throw(INTERNAL_ERROR(0,es));
        }
        for (cx = 0; cx < m_table[a_y].size(); ++cx) {
                mf_remove_elt(cx,a_y);
        }
        ti = m_table.begin();
        ti += a_y;
        m_table.erase(ti);
}

//----------------------------------------------------------------------------

std::ostream& operator<<(std::ostream& a_out, table& a_class)
{
        table::size_type width, height, cy;

        height = a_class.col_height();
        width = a_class.row_width();

        for (cy = 0; cy != height; ++cy) {
                a_class.write(a_out, cy, width);
                a_out << std::endl;
                a_out.flush();
        }

        return(a_out);
}

//----------------------------------------------------------------------------

table& table_write(table& a_table, const estring& a_estr)
{
        if ((a_table.ncols() == 0) && (a_table.nrows() == 0)) {
                a_table.insert_row(0);
                a_table.insert_col(0);
        }
        a_table.assign(a_table.cursor_x(), a_table.cursor_y(), a_estr);
        if (a_table.cursor_x() == a_table.ncols()-1)
                a_table.insert_col(a_table.ncols());
        table_skip(a_table);

        return(a_table);
}

table& table_write(table& a_table, const table& a_subtable)
{
        if ((a_table.ncols() == 0) && (a_table.nrows() == 0)) {
                a_table.insert_row(0);
                a_table.insert_col(0);
        }
        a_table.assign(a_table.cursor_x(), a_table.cursor_y(), a_subtable);
        if (a_table.cursor_x() == a_table.ncols()-1)
                a_table.insert_col(a_table.ncols());
        table_skip(a_table);

        return(a_table);
}

table& table_endl(table& a_table)
{
        if (a_table.cursor_y() == a_table.nrows()-1)
                a_table.insert_row(a_table.nrows());
        a_table.set_cursor(0,a_table.cursor_y()+1);

        return(a_table);
}

table& table_rewind(table& a_table)
{
        a_table.set_cursor(0,0);

        return(a_table);
}

table& table_skip(table& a_table)
{
        if (a_table.cursor_x() == a_table.ncols()-1) {
                if (a_table.cursor_y() != a_table.nrows()-1) {
                        a_table.set_cursor(0,a_table.cursor_y()+1);
                }
        }
        else {
                a_table.set_cursor(a_table.cursor_x()+1,a_table.cursor_y());
        }

        return(a_table);
}

table& table_repeat(table& a_table)
{
        a_table.repeat(true);

        return(a_table);
}

table& operator<<(table& a_table, const estring& a_estr)
{
        table_write(a_table, a_estr);

        return(a_table);
}

table& operator<<(table& a_table, const table& a_subtable)
{
        table_write(a_table, a_subtable);

        return(a_table);
}

table& operator<<(table& a_table, table& (*a_arg)(table&))
{
        a_arg(a_table);

        return(a_table);
}

//----------------------------------------------------------------------------

---