rankings.hpp

Go to the documentation of this file.

#ifndef SINGLEPP_LOADERS_RANKINGS_HPP
#define SINGLEPP_LOADERS_RANKINGS_HPP
 
#include "byteme/PerByte.hpp"
#include "byteme/RawFileReader.hpp"
#include "byteme/GzipFileReader.hpp"
#include "byteme/ZlibBufferReader.hpp"
 
#include "tatami/tatami.hpp"
#include "singlepp/singlepp.hpp"
 
#include <string>
#include <vector>
#include <cctype>
#include <type_traits>
#include <stdexcept>
 
namespace singlepp_loaders {
 
template<typename Value_ = double, typename Index_ = int, typename Rank_ = int>
using RankMatrix = tatami::DenseMatrix<Value_, Index_, std::vector<Rank_> >;
 
struct LoadRankingsOptions {
    bool parallel = false;
 
    size_t buffer_size = 65536;
};
 
 
namespace internal {
 
template<typename Value_, typename Index_>
RankMatrix<Value_, Index_> load_rankings(byteme::Reader& reader, bool parallel) {
    size_t nfeatures = 0;
    size_t line = 0;
    std::vector<int> values;
 
    size_t field = 0;
    bool non_empty = false;
    int current = 0;
 
    bool has_nfeatures = false;
    auto check_nfeatures = [&]() -> void {
        if (!has_nfeatures) {
            has_nfeatures = true;
            nfeatures = field + 1;
        } else if (field + 1 != nfeatures) {
            throw std::runtime_error("number of fields on each line should be equal to the number of features");
        }
    };
 
    std::unique_ptr<byteme::PerByteInterface<char> > pbptr;
    if (parallel) {
        pbptr.reset(new byteme::PerByteParallel<char, byteme::Reader*>(&reader));
    } else {
        pbptr.reset(new byteme::PerByteSerial<char, byteme::Reader*>(&reader));
    }
    auto& pb = *pbptr;
 
    bool okay = pb.valid();
    while (okay) {
        char x = pb.get();
        okay = pb.advance();
 
        if (x == '\n') {
            check_nfeatures();
            if (!non_empty) {
                throw std::runtime_error("fields should not be empty");
            }
            values.push_back(current);
            current = 0;
            field = 0;
            non_empty = false;
            ++line;
 
        } else if (x == ',') {
            if (!non_empty) {
                throw std::runtime_error("fields should not be empty");
            }
            values.push_back(current);
            current = 0;
            ++field;
            non_empty = false;
 
        } else if (std::isdigit(x)) {
            non_empty = true;
            current *= 10;
            current += (x - '0');
 
        } else {
            throw std::runtime_error("fields should only contain integer ranks");
        }
    }
 
    if (field || non_empty) { // aka no terminating newline.
        check_nfeatures();
        if (!non_empty) {
            throw std::runtime_error("fields should not be empty");
        }
        values.push_back(current);
        ++line;
    }
 
    return RankMatrix<Value_, Index_>(nfeatures, line, std::move(values), false);
}
 
}
template<typename Value_ = singlepp::DefaultValue, typename Index_ = singlepp::DefaultIndex>
RankMatrix<Value_, Index_> load_rankings_from_text_file(const char* path, const LoadRankingsOptions& options) {
    byteme::RawFileReaderOptions read_opt;
    read_opt.buffer_size = options.buffer_size;
    byteme::RawFileReader reader(path, read_opt);
    return internal::load_rankings<Value_, Index_>(reader, options.parallel);
}
 
template<typename Value_ = singlepp::DefaultValue, typename Index_ = singlepp::DefaultIndex>
RankMatrix<Value_, Index_> load_rankings_from_gzip_file(const char* path, const LoadRankingsOptions& options) {
    byteme::GzipFileReaderOptions read_opt;
    read_opt.buffer_size = options.buffer_size;
    byteme::GzipFileReader reader(path, read_opt);
    return internal::load_rankings<Value_, Index_>(reader, options.parallel);
}
 
template<typename Value_ = singlepp::DefaultValue, typename Index_ = singlepp::DefaultIndex>
RankMatrix<Value_, Index_> load_rankings_from_zlib_buffer(const unsigned char* buffer, size_t len, const LoadRankingsOptions& options) {
    byteme::ZlibBufferReaderOptions read_opt;
    read_opt.mode = 3;
    read_opt.buffer_size = options.buffer_size;
    byteme::ZlibBufferReader reader(buffer, len, read_opt);
    return internal::load_rankings<Value_, Index_>(reader, options.parallel);
}
 
}
 
#endif