csv_data_frame.hpp

Go to the documentation of this file.

#ifndef TAKANE_CSV_DATA_FRAME_HPP
#define TAKANE_CSV_DATA_FRAME_HPP
 
#include "comservatory/comservatory.hpp"
 
#include "WrappedOption.hpp"
#include "data_frame.hpp"
#include "utils_csv.hpp"
 
#include <unordered_set>
#include <string>
#include <stdexcept>
 
namespace takane {
 
namespace csv_data_frame {
 
struct Parameters {
    size_t num_rows = 0;
 
    bool has_row_names = false;
 
    WrappedOption<std::vector<data_frame::ColumnDetails> > columns;
 
    bool parallel = false;
 
    int df_version = 2;
};
 
template<class ParseCommand>
CsvContents validate_base(ParseCommand parse, const Parameters& params, CsvFieldCreator* creator) {
    DummyCsvFieldCreator default_creator;
    if (creator == NULL) {
        creator = &default_creator;
    }
 
    comservatory::Contents contents;
    CsvContents output;
    if (params.has_row_names) {
        auto ptr = creator->string();
        output.fields.emplace_back(ptr); 
        contents.fields.emplace_back(new CsvNameField(true, ptr));
    }
 
    const auto& columns = *(params.columns);
    size_t ncol = columns.size();
    std::unordered_set<std::string> present;
 
    for (size_t c = 0; c < ncol; ++c) {
        const auto& col = columns[c];
        if (present.find(col.name) != present.end()) {
            throw std::runtime_error("duplicate column name '" + col.name + "'");
        }
        present.insert(col.name);
 
        if (col.type == data_frame::ColumnType::INTEGER) {
            auto ptr = creator->integer();
            output.fields.emplace_back(ptr); 
            contents.fields.emplace_back(new CsvIntegerField(c, ptr));
 
        } else if (col.type == data_frame::ColumnType::NUMBER) {
            output.fields.emplace_back(nullptr); 
            contents.fields.emplace_back(creator->number());
 
        } else if (col.type == data_frame::ColumnType::STRING) {
            if (col.string_format == data_frame::StringFormat::DATE) {
                auto ptr = creator->string();
                output.fields.emplace_back(ptr); 
                contents.fields.emplace_back(new CsvDateField(c, ptr));
 
            } else if (col.string_format == data_frame::StringFormat::DATE_TIME) {
                auto ptr = creator->string();
                output.fields.emplace_back(ptr); 
                contents.fields.emplace_back(new CsvDateTimeField(c, ptr));
 
            } else {
                output.fields.emplace_back(nullptr);
                contents.fields.emplace_back(creator->string());
            }
 
        } else if (col.type == data_frame::ColumnType::BOOLEAN) {
            output.fields.emplace_back(nullptr);
            contents.fields.emplace_back(creator->boolean());
 
        } else if (col.type == data_frame::ColumnType::FACTOR) {
            if (params.df_version == 1) {
                auto ptr = creator->string();
                output.fields.emplace_back(ptr); 
                contents.fields.emplace_back(new CsvFactorV1Field(c, col.factor_levels.get(), ptr));
            } else {
                auto ptr = creator->integer();
                output.fields.emplace_back(ptr);
                contents.fields.emplace_back(new CsvFactorV2Field(c, col.factor_levels->size(), ptr));
            }
 
        } else if (col.type == data_frame::ColumnType::OTHER) {
            output.fields.emplace_back(nullptr);
            contents.fields.emplace_back(new comservatory::UnknownField); // This can be anything.
 
        } else {
            throw std::runtime_error("unknown code for the expected column type");
        }
    }
 
    comservatory::ReadOptions opt;
    opt.parallel = params.parallel;
    parse(contents, opt);
    if (contents.num_records() != params.num_rows) {
        throw std::runtime_error("number of records in the CSV file does not match the expected number of rows");
    }
 
    for (size_t c = 0; c < ncol; ++c) {
        const auto& col = columns[c];
        if (col.name != contents.names[c + params.has_row_names]) {
            throw std::runtime_error("observed and expected header names do not match");
        }
    }
 
    output.reconstitute(contents.fields);
    return output;
}
template<class Reader>
CsvContents validate(Reader& reader, const Parameters& params, CsvFieldCreator* creator = NULL) {
    return validate_base(
        [&](comservatory::Contents& contents, const comservatory::ReadOptions& opt) -> void { comservatory::read(reader, contents, opt); },
        params,
        creator
    );
}
 
inline CsvContents validate(const char* path, const Parameters& params, CsvFieldCreator* creator = NULL) {
    return validate_base(
        [&](comservatory::Contents& contents, const comservatory::ReadOptions& opt) -> void { comservatory::read_file(path, contents, opt); },
        params,
        creator
    );
}
 
}
 
}
 
#endif