table.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2018  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
#include "table.hpp"
#include "../utils/tools.hpp"
#include "tablecolumnimpl.hpp"
#include <cmath>
#include <cstdio>
 
using namespace std;
 
namespace NumeRe
{
    Table::Table()
    {
        sTableName.clear();
    }
 
 
    Table::Table(int nLines, int nCols) : Table()
    {
        setSize(nLines, nCols);
    }
 
 
    Table::Table(const Table& _table) : sTableName(_table.sTableName), m_meta(_table.m_meta)
    {
        vTableData.resize(_table.vTableData.size());
 
        for (size_t i = 0; i < vTableData.size(); i++)
        {
            if (_table.vTableData[i])
                vTableData[i].reset(_table.vTableData[i]->copy());
        }
    }
 
 
    Table::Table(Table&& _table) : sTableName(_table.sTableName), m_meta(_table.m_meta)
    {
        // We move by using the std::swap() functions
        std::swap(vTableData, _table.vTableData);
    }
 
 
    Table::~Table()
    {
        vTableData.clear();
    }
 
 
    Table& Table::operator=(Table _table)
    {
        // We move by using the std::swap() functions
        std::swap(vTableData, _table.vTableData);
        sTableName = _table.sTableName;
        m_meta = _table.m_meta;
 
        return *this;
    }
 
 
    void Table::setMinSize(size_t i, size_t j)
    {
        if (vTableData.size() <= j)
            vTableData.resize(j);
    }
 
 
    bool Table::isNumerical(const std::string& sValue) const
    {
        return isConvertible(sValue, CONVTYPE_VALUE);
    }
 
 
    void Table::Clear()
    {
        vTableData.clear();
        sTableName.clear();
    }
 
 
    void Table::setSize(size_t i, size_t j)
    {
        this->setMinSize(i, j);
 
        for (auto& col : vTableData)
        {
            if (col)
                col->resize(i);
            else
                col.reset(new ValueColumn(i));
        }
    }
 
 
    void Table::setName(const std::string& _sName)
    {
        sTableName = _sName;
    }
 
 
    void Table::setMetaData(const TableMetaData& meta)
    {
        m_meta = meta;
    }
 
 
    void Table::setComment(const std::string& _comment)
    {
        m_meta.comment = _comment;
    }
 
 
    void Table::setHead(size_t i, const std::string& _sHead)
    {
        if (i >= vTableData.size())
            vTableData.resize(i+1);
 
        if (!vTableData[i])
            vTableData[i].reset(new ValueColumn);
 
        vTableData[i]->m_sHeadLine = _sHead;
    }
 
 
    void Table::setHeadPart(size_t i, size_t part, const std::string& _sHead)
    {
        if (i >= vTableData.size())
            vTableData.resize(i+1);
 
        if (!vTableData[i])
            vTableData[i].reset(new ValueColumn);
 
        std::string head;
 
        // Compose the new headline using the different
        // parts
        for (int j = 0; j < getHeadCount(); j++)
        {
            if (j == (int)part)
                head += _sHead + '\n';
            else
                head += getCleanHeadPart(i, j) + '\n';
        }
 
        head.pop_back();
 
        vTableData[i]->m_sHeadLine = head;
    }
 
 
    void Table::setValue(size_t i, size_t j, const mu::value_type& _dValue)
    {
        this->setMinSize(i+1, j+1);
 
        convert_if_empty(vTableData[j], j, TableColumn::TYPE_VALUE);
        vTableData[j]->setValue(i, _dValue);
    }
 
 
    void Table::setValueAsString(size_t i, size_t j, const std::string& _sValue)
    {
        // Resize the table if needed
        this->setMinSize(i+1, j+1);
 
        if (vTableData[j])
            vTableData[j]->deleteElements(VectorIndex(i));
 
        // Empty value means only deletion
        if (!_sValue.length())
            return;
 
        // Is it a numerical value?
        if (isConvertible(_sValue, CONVTYPE_DATE_TIME))
        {
            convert_if_needed(vTableData[j], j, TableColumn::TYPE_DATETIME);
            vTableData[j]->setValue(i, to_double(StrToTime(_sValue)));
        }
        else if (isConvertible(_sValue, CONVTYPE_VALUE))
        {
            convert_if_needed(vTableData[j], j, TableColumn::TYPE_VALUE);
            vTableData[j]->setValue(i, StrToCmplx(_sValue));
        }
        else if (isConvertible(_sValue, CONVTYPE_LOGICAL))
        {
            convert_if_needed(vTableData[j], j, TableColumn::TYPE_LOGICAL);
            vTableData[j]->setValue(i, StrToLogical(_sValue));
        }
        else
        {
            convert_if_needed(vTableData[j], j, TableColumn::TYPE_STRING);
            vTableData[j]->setValue(i, _sValue);
        }
    }
 
 
    void Table::setColumn(size_t j, TableColumn* column)
    {
        if (vTableData.size() <= j)
            vTableData.resize(j+1);
 
        vTableData[j].reset(column);
    }
 
 
    bool Table::setColumnType(size_t j, TableColumn::ColumnType _type)
    {
        if (j >= vTableData.size())
            return false;
 
        return convert_if_needed(vTableData[j], j, _type);
    }
 
 
    std::string Table::getName() const
    {
        return sTableName;
    }
 
 
    TableMetaData Table::getMetaData() const
    {
        return m_meta;
    }
 
 
    std::string Table::getComment() const
    {
        return m_meta.comment;
    }
 
 
    int Table::getHeadCount() const
    {
        int nHeadlineCount = 1;
 
        // Get the dimensions of the complete headline (i.e. including possible linebreaks)
        for (size_t j = 0; j < vTableData.size(); j++)
        {
            if (!vTableData[j])
                continue;
 
            // No linebreak? Continue
            if (vTableData[j]->m_sHeadLine.find('\n') == std::string::npos)
                continue;
 
            int nLinebreak = 0;
 
            // Count all linebreaks
            for (unsigned int n = 0; n < vTableData[j]->m_sHeadLine.length() - 2; n++)
            {
                if (vTableData[j]->m_sHeadLine[n] == '\n')
                    nLinebreak++;
            }
 
            // Save the maximal number
            if (nLinebreak + 1 > nHeadlineCount)
                nHeadlineCount = nLinebreak + 1;
        }
 
        return nHeadlineCount;
    }
 
 
    std::string Table::getHead(size_t i) const
    {
        if (vTableData.size() > i && vTableData[i])
            return vTableData[i]->m_sHeadLine;
 
        return TableColumn::getDefaultColumnHead(i);
    }
 
 
    std::string Table::getCleanHead(size_t i) const
    {
        if (vTableData.size() > i && vTableData[i])
            return vTableData[i]->m_sHeadLine;
 
        return TableColumn::getDefaultColumnHead(i);
    }
 
 
    std::string Table::getCleanHeadPart(size_t i, size_t part) const
    {
        if (vTableData.size() > i && vTableData[i] && part < (size_t)getHeadCount())
        {
            // get the cleaned headline
            std::string head = getCleanHead(i);
 
            // Simple case: only one line
            if (head.find('\n') == string::npos)
            {
                if (part)
                    return "";
                return head;
            }
 
            size_t pos = 0;
 
            // Complex case: find the selected part
            for (size_t j = 0; j < head.length(); j++)
            {
                if (head[j] == '\n')
                {
                    if (!part)
                        return head.substr(pos, j - pos);
 
                    part--;
                    pos = j+1;
                }
            }
 
            // part is zero and position not: return
            // the last part
            if (!part && pos)
                return head.substr(pos);
 
            return "";
        }
 
        if (!part)
            return TableColumn::getDefaultColumnHead(i);
 
        return "";
    }
 
 
    mu::value_type Table::getValue(size_t i, size_t j) const
    {
        if (vTableData.size() > j && vTableData[j])
            return vTableData[j]->getValue(i);
 
        return NAN;
    }
 
 
    std::string Table::getValueAsString(size_t i, size_t j) const
    {
        if (vTableData.size() > j && vTableData[j])
        {
            // Invalid number
            if (!vTableData[j]->isValid(i))
                return "---";
 
            return vTableData[j]->getValueAsStringLiteral(i);
        }
 
        return "---";
    }
 
 
    TableColumn* Table::getColumn(size_t j) const
    {
        if (j < vTableData.size() && vTableData[j])
            return vTableData[j]->copy();
 
        return nullptr;
    }
 
 
    TableColumn::ColumnType Table::getColumnType(size_t j) const
    {
        if (j < vTableData.size() && vTableData[j])
            return vTableData[j]->m_type;
 
        return TableColumn::TYPE_NONE;
    }
 
 
    size_t Table::getLines() const
    {
        size_t lines = 0;
 
        for (const TblColPtr& col : vTableData)
        {
            if (col && col->size() > lines)
                lines = col->size();
        }
 
        return lines;
    }
 
 
    size_t Table::getCols() const
    {
        return vTableData.size();
    }
 
 
    bool Table::isEmpty() const
    {
        return vTableData.empty();
    }
 
 
    bool Table::insertLines(size_t nPos, size_t nNum)
    {
        nPos -= getHeadCount();
 
        for (TblColPtr& col : vTableData)
        {
            if (col)
                col->insertElements(nPos, nNum);
        }
 
        return true;
    }
 
 
    bool Table::appendLines(size_t nNum)
    {
        for (TblColPtr& col : vTableData)
        {
            if (col)
                col->appendElements(nNum);
        }
 
        return true;
    }
 
 
    bool Table::deleteLines(size_t nPos, size_t nNum)
    {
        nPos -= getHeadCount();
 
        for (TblColPtr& col : vTableData)
        {
            if (col)
                col->removeElements(nPos, nNum);
        }
 
        return true;
    }
 
 
    bool Table::insertCols(size_t nPos, size_t nNum)
    {
        TableColumnArray arr(nNum);
        vTableData.insert(vTableData.begin()+nPos, std::make_move_iterator(arr.begin()), std::make_move_iterator(arr.end()));
        return true;
    }
 
 
    bool Table::appendCols(size_t nNum)
    {
        TableColumnArray arr(nNum);
        vTableData.insert(vTableData.end(), std::make_move_iterator(arr.begin()), std::make_move_iterator(arr.end()));
        return true;
    }
 
 
    bool Table::deleteCols(size_t nPos, size_t nNum)
    {
        vTableData.erase(vTableData.begin()+nPos, vTableData.begin()+nPos+nNum);
        return true;
    }
 
}