tablecolumn.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2021  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 "tablecolumn.hpp"
#include "../ui/language.hpp"
#include "../utils/tools.hpp"
 
extern Language _lang;
 
 
std::vector<std::string> TableColumn::getValueAsString(const VectorIndex& idx) const
{
    idx.setOpenEndIndex(size()-1);
    std::vector<std::string> vVect(idx.size());
 
    for (size_t i = 0; i < idx.size(); i++)
    {
        vVect[i] = getValueAsString(idx[i]);
    }
 
    return vVect;
}
 
 
std::vector<std::string> TableColumn::getValueAsInternalString(const VectorIndex& idx) const
{
    idx.setOpenEndIndex(size()-1);
    std::vector<std::string> vVect(idx.size());
 
    for (size_t i = 0; i < idx.size(); i++)
    {
        vVect[i] = getValueAsInternalString(idx[i]);
    }
 
    return vVect;
}
 
 
std::vector<mu::value_type> TableColumn::getValue(const VectorIndex& idx) const
{
    idx.setOpenEndIndex(size()-1);
    std::vector<mu::value_type> vVect(idx.size());
 
    for (size_t i = 0; i < idx.size(); i++)
    {
        vVect[i] = getValue(idx[i]);
    }
 
    return vVect;
}
 
 
void TableColumn::setValue(const VectorIndex& idx, const std::vector<std::string>& vValue)
{
    for (size_t i = 0; i < idx.size(); i++)
    {
        if (i >= vValue.size())
            break;
 
        setValue(idx[i], vValue[i]);
    }
}
 
 
void TableColumn::setValue(const VectorIndex& idx, const std::vector<mu::value_type>& vValue)
{
    for (size_t i = 0; i < idx.size(); i++)
    {
        if (i >= vValue.size())
            break;
 
        setValue(idx[i], vValue[i]);
    }
}
 
 
void TableColumn::setValue(const VectorIndex& idx, mu::value_type* _dData, unsigned int _nNum)
{
    for (size_t i = 0; i < idx.size(); i++)
    {
        if (i >= _nNum)
            break;
 
        setValue(idx[i], _dData[i]);
    }
}
 
 
TableColumn* TableColumn::copy() const
{
    return copy(VectorIndex(0, VectorIndex::OPEN_END));
}
 
 
void TableColumn::shrink()
{
    for (int i = size()-1; i >= 0; i--)
    {
        if (isValid(i))
        {
            resize(i+1);
            return;
        }
    }
 
    // If the code reaches this point, it is either empty
    // or full of invalid values
    resize(0);
}
 
 
size_t TableColumn::getNumFilledElements() const
{
    for (size_t i = size(); i > 0; i--)
    {
        if (isValid(i-1))
            return i;
    }
 
    return 0;
}
 
 
std::string TableColumn::getDefaultColumnHead(size_t colNo)
{
    return _lang.get("COMMON_COL") + "_" + toString(colNo+1);
}
 
 
std::string TableColumn::typeToString(TableColumn::ColumnType type)
{
    switch (type)
    {
    case TYPE_NONE:
        return "none";
    case TYPE_VALUE:
        return "value";
    case TYPE_STRING:
        return "string";
    case TYPE_DATETIME:
        return "datetime";
    case TYPE_LOGICAL:
        return "logical";
    case TYPE_CATEGORICAL:
        return "category";
    default:
        return "unknown";
    }
 
    return "";
}
 
 
TableColumn::ColumnType TableColumn::stringToType(const std::string& sType)
{
    if (sType == "value")
        return TYPE_VALUE;
    else if (sType == "string")
        return TYPE_STRING;
    else if (sType == "datetime")
        return TYPE_DATETIME;
    else if (sType == "logical")
        return TYPE_LOGICAL;
    else if (sType == "category")
        return TYPE_CATEGORICAL;
 
    return TYPE_NONE;
}
 
 
std::vector<std::string> TableColumn::getTypesAsString()
{
    return {"value", "string", "datetime", "logical", "category"};
}