labels.hpp

Go to the documentation of this file.

#ifndef SINGLEPP_LOADERS_LABELS_HPP
#define SINGLEPP_LOADERS_LABELS_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 {
 
struct LoadLabelsOptions {
    bool parallel = false;
 
    size_t buffer_size = 65536;
};
 
namespace internal {
 
template<typename Label_>
std::vector<Label_> load_labels(byteme::Reader& reader, bool parallel) {
    bool non_empty = false;
    int current = 0;
    std::vector<Label_> labels;
 
    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') {
            if (!non_empty) {
                throw std::runtime_error("label index must be an integer");
            }
            labels.push_back(current);
            current = 0;
            non_empty = false;
        } else if (std::isdigit(x)) {
            non_empty = true;
            current *= 10;
            current += (x - '0');
        } else {
            throw std::runtime_error("label index must be an integer");
        }
    } 
 
    if (non_empty) {
        labels.push_back(current);
    }
 
    return labels;
}
 
}
template<typename Label_ = singlepp::DefaultLabel>
std::vector<Label_> load_labels_from_text_file(const char* path, const LoadLabelsOptions& options) {
    byteme::RawFileReaderOptions read_opt;
    read_opt.buffer_size = options.buffer_size;
    byteme::RawFileReader reader(path, read_opt);
    return internal::load_labels<Label_>(reader, options.parallel);
}
 
template<typename Label_ = singlepp::DefaultLabel>
std::vector<Label_> load_labels_from_gzip_file(const char* path, const LoadLabelsOptions& options) {
    byteme::GzipFileReaderOptions read_opt;
    read_opt.buffer_size = options.buffer_size;
    byteme::GzipFileReader reader(path, read_opt);
    return internal::load_labels<Label_>(reader, options.parallel);
}
 
template<typename Label_ = singlepp::DefaultLabel>
std::vector<Label_> load_labels_from_zlib_buffer(const unsigned char* buffer, size_t len, const LoadLabelsOptions& 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_labels<Label_>(reader, options.parallel);
}
 
}
 
#endif