new_extractor.hpp

Go to the documentation of this file.

#ifndef TATAMI_NEW_EXTRACTOR_HPP
#define TATAMI_NEW_EXTRACTOR_HPP
 
#include "../base/Matrix.hpp"
 
namespace tatami {
 
template<bool oracle_, typename Index_>
using MaybeOracle = typename std::conditional<oracle_, std::shared_ptr<const Oracle<Index_> >, bool>::type;
 
template<bool sparse_, bool oracle_, typename Value_, typename Index_, typename ... Args_>
auto new_extractor(const Matrix<Value_, Index_>* ptr, bool row, MaybeOracle<oracle_, Index_> oracle, Args_&&... args) {
    // We could use 'sparse()' and 'dense()' directly here, but that assumes
    // that 'opt' is always supplied at the end of 'args', which might not be
    // the case... so we just spell it out and save ourselves the trouble
    // of implementing default option methods for 'sparse()' and 'dense()'.
    if constexpr(sparse_) {
        if constexpr(oracle_) {
            if (row) {
                return ptr->sparse_row(std::move(oracle), std::forward<Args_>(args)...);
            } else {
                return ptr->sparse_column(std::move(oracle), std::forward<Args_>(args)...);
            }
        } else {
            if (row) {
                return ptr->sparse_row(std::forward<Args_>(args)...);
            } else {
                return ptr->sparse_column(std::forward<Args_>(args)...);
            }
        }
    } else {
        if constexpr(oracle_) {
            if (row) {
                return ptr->dense_row(std::move(oracle), std::forward<Args_>(args)...);
            } else {
                return ptr->dense_column(std::move(oracle), std::forward<Args_>(args)...);
            }
        } else {
            if (row) {
                return ptr->dense_row(std::forward<Args_>(args)...);
            } else {
                return ptr->dense_column(std::forward<Args_>(args)...);
            }
        }
    }
}
 
// Provided for back-compatibility only.
template<bool row_, bool sparse_, typename Value_, typename Index_>
auto new_extractor(const Matrix<Value_, Index_>* ptr) {
    return new_extractor<sparse_, false, Value_, Index_>(ptr, row_, false);
}
 
template<bool row_, bool sparse_, typename Value_, typename Index_>
auto new_extractor(const Matrix<Value_, Index_>* ptr, const Options& opt) {
    return new_extractor<sparse_, false, Value_, Index_>(ptr, row_, false, opt);
}
 
template<bool row_, bool sparse_, typename Value_, typename Index_, typename ... Args_>
auto new_extractor(const Matrix<Value_, Index_>* ptr, Index_ start, Index_ len, Args_&&... args) {
    return new_extractor<sparse_, false, Value_, Index_>(ptr, row_, false, start, len, std::forward<Args_>(args)...);
}
 
template<bool row_, bool sparse_, typename Value_, typename Index_, typename ... Args_>
auto new_extractor(const Matrix<Value_, Index_>* ptr, std::vector<Index_> i, Args_&&... args) {
    return new_extractor<sparse_, false, Value_, Index_>(ptr, row_, false, std::move(i), std::forward<Args_>(args)...);
}
}
 
#endif