Table.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright © 2014-2024 Allan Leal
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library. If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
// Reaktoro includes
#include <Reaktoro/Common/Exception.hpp>
#include <Reaktoro/Common/TraitsUtils.hpp>
#include <Reaktoro/Common/Types.hpp>
 
namespace Reaktoro {
 
class TableColumn
{
public:
    enum class DataType
    {
        Float,     
        Integer,   
        String,    
        Boolean,   
        Undefined, 
    };
 
    TableColumn();
 
    auto appendFloat(double value) -> void;
 
    auto appendInteger(long value) -> void;
 
    auto appendString(String const& value) -> void;
 
    auto appendBoolean(bool value) -> void;
 
    auto dataType() const -> DataType;
 
    auto floats() const -> Deque<double> const&;
 
    auto floats() -> Deque<double>&; // TODO: These methods in Table that return Deque<T>& are dangerous in which the user can change its length, and this will not be reflected in mrows. Replace this by std::span when migrating to C++20.
 
    auto integers() const -> Deque<long> const&;
 
    auto integers() -> Deque<long>&;
 
    auto strings() const -> Deque<String> const&;
 
    auto strings() -> Deque<String>&;
 
    auto booleans() const -> Deque<bool> const&;
 
    auto booleans() -> Deque<bool>&;
 
    auto rows() const -> Index;
 
    auto operator[](Index row) const -> std::variant<double, long, String, bool>;
 
    template<typename T>
    auto append(T const& value) -> void
    {
        if constexpr(isSame<T, bool>)
            appendBoolean(value);
        else if constexpr(isInteger<T>) // keep integer check after booleans, as isInteger<bool> is true!
            if(datatype == DataType::Float)
                appendFloat(value); // allow integers to be cast to float and stored in a float column!
            else appendInteger(value);
        else if constexpr(isFloatingPoint<T> || isConvertible<T, double>)
            appendFloat(value);
        else if constexpr(isSame<T, String>)
            appendString(value);
        else errorif(true, "You cannot append this value with an unsupported type to a table column.");
    }
 
    auto append(Chars value) -> void
    {
        appendString(value);
    }
 
    template<typename T>
    auto operator<<(T const& value) -> TableColumn&
    {
        append(value);
        return *this;
    }
 
    auto operator<<(Chars value) -> TableColumn&
    {
        appendString(value);
        return *this;
    }
 
    template<typename T>
    auto cast() -> Deque<T>&
    {
        return const_cast<Deque<T>&>(std::as_const(*this).cast<T>());
    }
 
    template<typename T>
    auto cast() const -> Deque<T> const&
    {
        if constexpr(isSame<T, bool>)
            return booleans();
        else if constexpr(isFloatingPoint<T>)
            return floats();
        else if constexpr(isInteger<T>) // keep integer check after booleans, as isInteger<bool> is true!
            return integers();
        else if constexpr(isSame<T, String> || isSame<T, Chars>)
            return strings();
        else errorif(true, "You cannot cast this table column to a list of values with an unsupported type.");
    }
 
private:
    Any data;
 
    Index mrows = 0;
 
    DataType datatype = DataType::Undefined;
};
 
class Table
{
public:
    Table();
 
    auto columns() const -> Dict<String, TableColumn> const&;
 
    auto column(String const& columnname) const -> TableColumn const&;
 
    auto column(String const& columnname) -> TableColumn&;
 
    auto operator[](String const& columnname) const -> Deque<double> const&;
 
    auto operator[](String const& columnname) -> Deque<double>&;
 
    auto rows() const -> Index;
 
    auto cols() const -> Index;
 
    struct OutputOptions
    {
        OutputOptions();
 
        String delimiter;
 
        int precision;
 
        bool scientific;
 
        bool fixed;
    };
 
    auto dump(OutputOptions const& outputopts = {}) const -> String;
 
    auto save(String const& filepath, OutputOptions const& outputopts = {}) const -> void;
 
private:
    Dict<String, TableColumn> mcolumns;
};
 
} // namespace Reaktoro