ForcedOracleWrapper.hpp

Go to the documentation of this file.

#ifndef TATAMI_TEST_FORCED_ORACLE_WRAPPER_HPP
#define TATAMI_TEST_FORCED_ORACLE_WRAPPER_HPP
 
#include <algorithm>
#include <memory>
 
#include "tatami/base/Matrix.hpp"
#include "tatami/utils/copy.hpp"
 
#include "utils.hpp"
 
namespace tatami_test {
 
template<typename Value_, typename Index_>
class ForcedOracleWrapper final : public tatami::Matrix<Value_, Index_> {
public:
    ForcedOracleWrapper(std::shared_ptr<const tatami::Matrix<Value_, Index_> > matrix) : my_matrix(std::move(matrix)) {}
 
private:
    std::shared_ptr<const tatami::Matrix<Value_, Index_> > my_matrix;
 
public:
    Index_ nrow() const {
        return my_matrix->nrow();
    }
 
    Index_ ncol() const {
        return my_matrix->ncol();
    }
 
    bool is_sparse() const {
        return my_matrix->is_sparse();
    }
 
    double is_sparse_proportion() const {
        return my_matrix->is_sparse_proportion();
    }
 
    bool prefer_rows() const {
        return my_matrix->prefer_rows();
    }
 
    double prefer_rows_proportion() const {
        return my_matrix->prefer_rows_proportion();
    }
 
    bool uses_oracle(bool) const {
        return true;
    }
 
public:
    std::unique_ptr<tatami::MyopicDenseExtractor<Value_, Index_> > dense(
        const bool row,
        const tatami::Options& opt
    ) const { 
        return my_matrix->dense(row, opt); 
    }
 
    std::unique_ptr<tatami::MyopicDenseExtractor<Value_, Index_> > dense(
        const bool row,
        Index_ bs,
        Index_ bl,
        const tatami::Options& opt
    ) const {
        return my_matrix->dense(row, bs, bl, opt);
    }
 
    std::unique_ptr<tatami::MyopicDenseExtractor<Value_, Index_> > dense(
        bool row,
        tatami::VectorPtr<Index_> idx,
        const tatami::Options& opt
    ) const {
        return my_matrix->dense(row, std::move(idx), opt);
    }
 
public:
    std::unique_ptr<tatami::MyopicSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        const tatami::Options& opt
    ) const { 
        return my_matrix->sparse(row, opt); 
    }
 
    std::unique_ptr<tatami::MyopicSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        const Index_ bs,
        const Index_ bl,
        const tatami::Options& opt
    ) const {
        return my_matrix->sparse(row, bs, bl, opt);
    }
 
    std::unique_ptr<tatami::MyopicSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        tatami::VectorPtr<Index_> idx,
        const tatami::Options& opt
    ) const {
        return my_matrix->sparse(row, std::move(idx), opt);
    }
 
public:
    std::unique_ptr<tatami::OracularDenseExtractor<Value_, Index_> > dense(
        const bool row,
        std::shared_ptr<const tatami::Oracle<Index_> > ora,
        const tatami::Options& opt
    ) const { 
        return my_matrix->dense(row, std::move(ora), opt); 
    }
 
    std::unique_ptr<tatami::OracularDenseExtractor<Value_, Index_> > dense(
        const bool row,
        std::shared_ptr<const tatami::Oracle<Index_> > ora,
        const Index_ bs,
        const Index_ bl,
        const tatami::Options& opt
    ) const {
        return my_matrix->dense(row, std::move(ora), bs, bl, opt);
    }
 
    std::unique_ptr<tatami::OracularDenseExtractor<Value_, Index_> > dense(
        const bool row,
        std::shared_ptr<const tatami::Oracle<Index_> > ora,
        tatami::VectorPtr<Index_> idx,
        const tatami::Options& opt
    ) const {
        return my_matrix->dense(row, std::move(ora), std::move(idx), opt);
    }
 
public:
    std::unique_ptr<tatami::OracularSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        std::shared_ptr<const tatami::Oracle<Index_> > ora,
        const tatami::Options& opt
    ) const { 
        return my_matrix->sparse(row, std::move(ora), opt); 
    }
 
    std::unique_ptr<tatami::OracularSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        std::shared_ptr<const tatami::Oracle<Index_> > ora,
        const Index_ bs,
        const Index_ bl,
        const tatami::Options& opt
    ) const {
        return my_matrix->sparse(row, std::move(ora), bs, bl, opt);
    }
 
    std::unique_ptr<tatami::OracularSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        std::shared_ptr<const tatami::Oracle<Index_> > ora,
        tatami::VectorPtr<Index_> idx,
        const tatami::Options& opt
    ) const {
        return my_matrix->sparse(row, std::move(ora), std::move(idx), opt);
    }
};
 
}
 
#endif