common.h

Go to the documentation of this file.

// Copyright (c) 2021, Aalto University, developed by Erik Schultheis
// All rights reserved.
//
// SPDX-License-Identifier: MIT
 
#ifndef DISMEC_COMMON_H
#define DISMEC_COMMON_H
 
#include <stdexcept>
#include "matrix_types.h"
#include "spdlog/fmt/fmt.h"
#include "utils/throw_error.h"
#include "utils/conversion.h"
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define THROW_ERROR(...) THROW_EXCEPTION(std::runtime_error, __VA_ARGS__)
 
namespace dismec::io {
    namespace detail {
        std::string print_char(char c);
    }
 
    inline long parse_long(const char* string, const char** out) {
        char* out_ptr = nullptr;
        long result = std::strtol(string, &out_ptr, 10); // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        *out = out_ptr;
        return result;
    }
 
    template<class F>
    void parse_sparse_vector_from_text(const char* feature_part, F&& callback) {
        const char* start = feature_part;
        while(*feature_part) {
            const char* result = nullptr;
            errno = 0;
            long index = parse_long(feature_part, &result);
            if (result == feature_part) {
                // parsing failed -- either, wrong format, or we have reached some trailing spaces
                // we verify this here explicitly, again using IELF to keep this out of the hot code path
                bool is_error = [&](){
                    for(const char* scan = feature_part; *scan; ++scan) {
                        if(!std::isspace(*scan)) {
                            return true;
                        }
                    }
                    return false;
                }();
                if(!is_error) {
                    return;
                }
                THROW_ERROR("Error parsing feature. Missing feature index.");
            } else if(*result != ':') {
                THROW_ERROR("Error parsing feature index. Expected ':' at position {}, got '{}'", (result - start), detail::print_char(*result));
            } else if(errno != 0) {
                THROW_ERROR("Error parsing feature index. Errno={}: '{}'", errno, strerror(errno));
            }
 
            errno = 0;
            char* after_feature = nullptr;
            double value = std::strtod(result+1, &after_feature);
            if(result + 1 == after_feature) {
                THROW_ERROR("Error parsing feature: Missing feature value.");
            } else if(errno != 0) {
                THROW_ERROR("Error parsing feature value. Errno={}: '{}'", errno, strerror(errno));
            }
 
            feature_part = after_feature;
            callback(index, value);
        }
    }
 
    std::ostream& write_vector_as_text(std::ostream& stream, const Eigen::Ref<const DenseRealVector>& data);
 
    std::istream& read_vector_from_text(std::istream& stream, Eigen::Ref<DenseRealVector> data);
 
    // binary read and write functions
    template<class T>
    void binary_dump(std::streambuf& target, const T* begin, const T* end) {
        static_assert(std::is_pod_v<T>, "Can only binary dump POD types");
        std::streamsize num_bytes = (end - begin) * ssizeof<T>;
        auto wrote = target.sputn(reinterpret_cast<const char*>(begin), num_bytes);
        if(num_bytes != wrote) {
            THROW_ERROR("Expected to write {} bytes, but wrote only {}", num_bytes, wrote);
        }
    }
 
    template<class T>
    void binary_load(std::streambuf& target, T* begin, T* end) {
        static_assert(std::is_pod_v<T>, "Can only binary load POD types");
        std::streamsize num_bytes = (end - begin) * ssizeof<T>;
        auto read = target.sgetn(reinterpret_cast<char*>(begin), num_bytes);
        if(num_bytes != read) {
            THROW_ERROR("Expected to read {} bytes, but got only {}", num_bytes, read);
        }
    }
 
    struct MatrixHeader {
        long NumRows;
        long NumCols;
    };
 
    MatrixHeader parse_header(const std::string& content);
 
    struct LoLBinarySparse {
        long NumRows;
        long NumCols;
        std::vector<std::vector<long>> NonZeros;
    };
 
    LoLBinarySparse read_binary_matrix_as_lol(std::istream& source);
}
 
#endif //DISMEC_COMMON_H