markers.hpp

Go to the documentation of this file.

#ifndef SINGLEPP_LOADERS_MARKERS_HPP
#define SINGLEPP_LOADERS_MARKERS_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 LoadMarkersOptions {
    bool parallel = false;
 
    size_t buffer_size = 65536;
};
 
namespace internal {
 
template<typename Index_, bool parallel_>
singlepp::Markers<Index_> load_markers(byteme::Reader& reader) {
    singlepp::Markers<Index_> markers;
    typename std::conditional<parallel_, byteme::PerByte<char>, byteme::PerByteParallel<char> >::type pb(&reader);
 
    bool okay = pb.valid();
    while (okay) {
        // Processing the label IDs.
        size_t first = 0, second = 0;
        for (int l = 0; l < 2; ++l) {
            auto& current = (l == 0 ? first : second);
            bool non_empty = false;
 
            do {
                char x = pb.get();
                okay = pb.advance();
 
                if (x == '\t') {
                    if (!non_empty) {
                        throw std::runtime_error("empty field detected in the label indices");
                    }
                    break;
                } else if (x == '\n') {
                    okay = false; // hit the error below.
                    break;
                } else if (!std::isdigit(x)) {
                    throw std::runtime_error("label indices should be integers");
                }
 
                non_empty = true;
                current *= 10;
                current += (x - '0');
            } while (okay);
 
            if (!okay) {
                throw std::runtime_error("expected at least three tab-separated fields on each line");
            }
        }
 
        if (first >= markers.size()) {
            markers.resize(first + 1);
        }
        auto& fmarkers = markers[first];
        if (second >= fmarkers.size()) {
            fmarkers.resize(second + 1);
        }
        auto& values = fmarkers[second];
        if (!values.empty()) {
            throw std::runtime_error("multiple marker sets listed for a single pairwise comparison");
        }
 
        // Processing the actual gene indices.
        bool non_empty = false;
        Index_ current = 0;
        while (okay) {
            char x = pb.get();
            okay = pb.advance();
 
            if (std::isdigit(x)) {
                non_empty = true;
                current *= 10;
                current += (x - '0');
 
            } else if (x == '\t') {
                if (!non_empty) {
                    throw std::runtime_error("gene index fields should not be empty");
                }
                values.push_back(current);
                current = 0;
                non_empty = false;
 
            } else if (x == '\n') {
                break;
 
            } else {
                throw std::runtime_error("gene index fields should be integers");
            }
        }
 
        // Adding the last element. We don't do this inside the newline check,
        // as we need to account for cases where the file is not newline-terminated.
        if (!non_empty) {
            throw std::runtime_error("gene index fields should not be empty");
        }
        values.push_back(current);
    }
 
    // Now, making sure that every label has the same number of elements.
    size_t expected_nlabels = markers.size();
    for (const auto& m : markers) {
        expected_nlabels = std::max(expected_nlabels, m.size());
    }
    markers.resize(expected_nlabels);
    for (auto& m : markers) {
        m.resize(expected_nlabels);
    }
 
    return markers;
}
 
template<typename Index_>
singlepp::Markers<Index_> load_markers(byteme::Reader& reader, bool parallel) {
    if (parallel) {
        return load_markers<Index_, true>(reader);
    } else {
        return load_markers<Index_, false>(reader);
    }
}
 
}
template<typename Index_ = singlepp::DefaultIndex>
singlepp::Markers<Index_> load_markers_from_text_file(const char* path, const LoadMarkersOptions& options) {
    byteme::RawFileReader reader(path, options.buffer_size);
    return internal::load_markers<Index_>(reader, options.parallel);
}
 
template<typename Index_ = singlepp::DefaultIndex>
singlepp::Markers<Index_> load_markers_from_gzip_file(const char* path, const LoadMarkersOptions& options) {
    byteme::GzipFileReader reader(path, options.buffer_size);
    return internal::load_markers<Index_>(reader, options.parallel);
}
 
template<typename Index_ = singlepp::DefaultIndex>
singlepp::Markers<Index_> load_markers_from_zlib_buffer(const unsigned char* buffer, size_t len, const LoadMarkersOptions& options) {
    byteme::ZlibBufferReader reader(buffer, len, 3, options.buffer_size);
    return internal::load_markers<Index_>(reader, options.parallel);
}
 
}
 
#endif