csv_file_writer.h

Go to the documentation of this file.

#ifndef CSV_FILE_WRITER_H
#define CSV_FILE_WRITER_H
 
#include "bitrl/bitrl_types.h"
#include "bitrl/utils/io/file_writer_base.h"
 
#include <initializer_list>
#include <tuple>
#include <vector>
 
namespace bitrl
{
namespace utils
{
namespace io
{
 
class CSVWriter : public FileWriterBase
{
 
  public:
    static char default_delimiter() { return ','; }
 
    CSVWriter(const std::string &filename, char delim = CSVWriter::default_delimiter());
 
    void write_column_names(const std::vector<std::string> &col_names, bool write_header = true);
 
    void write_column_names(const std::vector<std::string_view> &col_names,
                            bool write_header = true);
 
    void write_column_names(const std::initializer_list<std::string_view> &col_names,
                            bool write_header = true);
 
    template <typename T> void write_row(const std::vector<T> &vals);
 
    template <typename T> void write_row(const DynVec<T> &vals);
 
    template <typename T> void write_column_vector(const std::vector<T> &vals);
 
    template <typename... T> void write_row(const std::tuple<T...> &row);
 
    void set_delimiter(char delim) noexcept { delim_ = delim; }
 
    char get_delimiter() const noexcept { return delim_; }
 
  private:
    char delim_;
};
 
template <typename T> void CSVWriter::write_row(const std::vector<T> &vals)
{
 
    if (!this->is_open())
    {
        throw std::logic_error("File " + this->file_name_ + " is not open");
    }
 
    auto &f = this->get_file_stream();
    for (uint_t c = 0; c < vals.size(); ++c)
    {
 
        f << vals[c];
 
        if (c == vals.size() - 1)
        {
            f << std::endl;
        }
        else
        {
            f << ",";
        }
    }
}
 
template <typename T> void CSVWriter::write_row(const DynVec<T> &vals)
{
 
    if (!this->is_open())
    {
        throw std::logic_error("File " + this->file_name_ + " is not open");
    }
 
    auto &f = this->get_file_stream();
    for (uint_t c = 0; c < static_cast<uint_t>(vals.size()); ++c)
    {
 
        f << vals[c];
 
        if (c == static_cast<uint_t>(vals.size()) - 1)
        {
            f << std::endl;
        }
        else
        {
            f << ",";
        }
    }
}
 
template <typename T> void CSVWriter::write_column_vector(const std::vector<T> &vals)
{
 
    if (!this->is_open())
    {
        throw std::logic_error("File " + this->file_name_ + " is not open");
    }
 
    auto &f = this->get_file_stream();
    for (uint_t c = 0; c < vals.size(); ++c)
    {
        f << vals[c] << std::endl;
    }
}
 
template <typename... T> void CSVWriter::write_row(const std::tuple<T...> &row)
{
 
    auto &f = this->get_file_stream();
    std::apply([&](auto &&...args) { ((f << args << ","), ...); }, row);
    f << std::endl;
}
 
} // namespace io
} // namespace utils
} // namespace bitrl
 
#endif // CSV_FILE_WRITER_H