Updates to use the latest versions of all dependencies.

Author: LTLA

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.14)
 
 project(singlepp_loaders
-    VERSION 0.1.1
+    VERSION 0.2.0
     DESCRIPTION "Load pre-prepared reference datasets for SingleR"
     LANGUAGES CXX)
 
@@ -22,9 +22,9 @@ option(SINGLEPP_LOADERS_FETCH_EXTERN "Automatically fetch singlepp_loaders's ext
 if(SINGLEPP_LOADERS_FETCH_EXTERN)
     add_subdirectory(extern)
 else()
-    find_package(singler_singlepp 2.0.0 CONFIG REQUIRED)
-    find_package(tatami_tatami 3.0.0 CONFIG REQUIRED)
-    find_package(ltla_byteme 1.2.0 CONFIG REQUIRED)
+    find_package(singler_singlepp 3.0.0 CONFIG REQUIRED)
+    find_package(tatami_tatami 4.0.0 CONFIG REQUIRED)
+    find_package(ltla_byteme 2.0.0 CONFIG REQUIRED)
 endif()
 
 target_link_libraries(singlepp_loaders INTERFACE singler::singlepp tatami::tatami ltla::byteme)

cmake/Config.cmake.in

@@ -1,8 +1,8 @@
 @PACKAGE_INIT@
 
 include(CMakeFindDependencyMacro)
-find_dependency(tatami_tatami 3.0.0 CONFIG REQUIRED)
-find_dependency(singler_singlepp 2.0.0 CONFIG REQUIRED)
-find_dependency(ltla_byteme 1.2.0 CONFIG REQUIRED)
+find_dependency(tatami_tatami 4.0.0 CONFIG REQUIRED)
+find_dependency(singler_singlepp 3.0.0 CONFIG REQUIRED)
+find_dependency(ltla_byteme 2.0.0 CONFIG REQUIRED)
 
 include("${CMAKE_CURRENT_LIST_DIR}/singler_singlepp_loadersTargets.cmake")

extern/CMakeLists.txt

@@ -3,19 +3,19 @@ include(FetchContent)
 FetchContent_Declare(
   singlepp
   GIT_REPOSITORY https://github.com/SingleR-inc/singlepp
-  GIT_TAG master  # ^2.0.0
+  GIT_TAG master  # ^3.0.0
 )
 
 FetchContent_Declare(
   tatami
   GIT_REPOSITORY https://github.com/tatami-inc/tatami
-  GIT_TAG master # ^3.0.0
+  GIT_TAG master # ^4.0.0
 )
 
 FetchContent_Declare(
   byteme
   GIT_REPOSITORY https://github.com/LTLA/byteme
-  GIT_TAG master # ^1.2.0
+  GIT_TAG master # ^2.0.0
 )
 
 FetchContent_MakeAvailable(singlepp)

include/singlepp_loaders/labels.hpp

@@ -42,13 +42,20 @@ struct LoadLabelsOptions {
  */
 namespace internal {
 
-template<typename Label_, bool parallel_>
-std::vector<Label_> load_labels(byteme::Reader& reader) {
+template<typename Label_>
+std::vector<Label_> load_labels(byteme::Reader& reader, bool parallel) {
     bool non_empty = false;
     int current = 0;
     std::vector<Label_> labels;
 
-    typename std::conditional<parallel_, byteme::PerByte<char>, byteme::PerByteParallel<char> >::type pb(&reader);
+    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();
@@ -77,15 +84,6 @@ std::vector<Label_> load_labels(byteme::Reader& reader) {
     return labels;
 }
 
-template<typename Label_>
-std::vector<Label_> load_labels(byteme::Reader& reader, bool parallel) {
-    if (parallel) {
-        return load_labels<Label_, true>(reader);
-    } else {
-        return load_labels<Label_, false>(reader);
-    }
-}
-
 }
 /** 
  * @endcond
@@ -106,7 +104,9 @@ std::vector<Label_> load_labels(byteme::Reader& reader, bool parallel) {
  */
 template<typename Label_ = singlepp::DefaultLabel>
 std::vector<Label_> load_labels_from_text_file(const char* path, const LoadLabelsOptions& options) {
-    byteme::RawFileReader reader(path, options.buffer_size);
+    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);
 }
 
@@ -122,7 +122,9 @@ std::vector<Label_> load_labels_from_text_file(const char* path, const LoadLabel
  */
 template<typename Label_ = singlepp::DefaultLabel>
 std::vector<Label_> load_labels_from_gzip_file(const char* path, const LoadLabelsOptions& options) {
-    byteme::GzipFileReader reader(path, options.buffer_size);
+    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);
 }
 
@@ -139,7 +141,10 @@ std::vector<Label_> load_labels_from_gzip_file(const char* path, const LoadLabel
  */
 template<typename Label_ = singlepp::DefaultLabel>
 std::vector<Label_> load_labels_from_zlib_buffer(const unsigned char* buffer, size_t len, const LoadLabelsOptions& options) {
-    byteme::ZlibBufferReader reader(buffer, len, 3, options.buffer_size);
+    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);
 }
 

include/singlepp_loaders/markers.hpp

@@ -42,10 +42,17 @@ struct LoadMarkersOptions {
  */
 namespace internal {
 
-template<typename Index_, bool parallel_>
-singlepp::Markers<Index_> load_markers(byteme::Reader& reader) {
+template<typename Index_>
+singlepp::Markers<Index_> load_markers(byteme::Reader& reader, bool parallel) {
     singlepp::Markers<Index_> markers;
-    typename std::conditional<parallel_, byteme::PerByte<char>, byteme::PerByteParallel<char> >::type pb(&reader);
+
+    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) {
@@ -142,15 +149,6 @@ singlepp::Markers<Index_> load_markers(byteme::Reader& reader) {
     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);
-    }
-}
-
 }
 /** 
  * @endcond
@@ -172,7 +170,9 @@ singlepp::Markers<Index_> load_markers(byteme::Reader& reader, bool parallel) {
  */
 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);
+    byteme::RawFileReaderOptions read_opt;
+    read_opt.buffer_size = options.buffer_size;
+    byteme::RawFileReader reader(path, read_opt);
     return internal::load_markers<Index_>(reader, options.parallel);
 }
 
@@ -188,7 +188,9 @@ singlepp::Markers<Index_> load_markers_from_text_file(const char* path, const Lo
  */
 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);
+    byteme::GzipFileReaderOptions read_opt;
+    read_opt.buffer_size = options.buffer_size;
+    byteme::GzipFileReader reader(path, read_opt);
     return internal::load_markers<Index_>(reader, options.parallel);
 }
 
@@ -205,7 +207,10 @@ singlepp::Markers<Index_> load_markers_from_gzip_file(const char* path, const Lo
  */
 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);
+    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_markers<Index_>(reader, options.parallel);
 }
 

include/singlepp_loaders/rankings.hpp

@@ -55,8 +55,8 @@ struct LoadRankingsOptions {
  */
 namespace internal {
 
-template<typename Value_, typename Index_, bool parallel_>
-RankMatrix<Value_, Index_> load_rankings(byteme::Reader& reader) {
+template<typename Value_, typename Index_>
+RankMatrix<Value_, Index_> load_rankings(byteme::Reader& reader, bool parallel) {
     size_t nfeatures = 0;
     size_t line = 0;
     std::vector<int> values;
@@ -75,7 +75,14 @@ RankMatrix<Value_, Index_> load_rankings(byteme::Reader& reader) {
         }
     };
 
-    typename std::conditional<parallel_, byteme::PerByte<char>, byteme::PerByteParallel<char> >::type pb(&reader);
+    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();
@@ -123,15 +130,6 @@ RankMatrix<Value_, Index_> load_rankings(byteme::Reader& reader) {
     return RankMatrix<Value_, Index_>(nfeatures, line, std::move(values), false);
 }
 
-template<typename Value_, typename Index_>
-RankMatrix<Value_, Index_> load_rankings(byteme::Reader& reader, bool parallel) {
-    if (parallel) {
-        return load_rankings<Value_, Index_, true>(reader);
-    } else {
-        return load_rankings<Value_, Index_, false>(reader);
-    }
-}
-
 }
 /** 
  * @endcond
@@ -154,7 +152,9 @@ RankMatrix<Value_, Index_> load_rankings(byteme::Reader& reader, bool parallel)
  */
 template<typename Value_ = singlepp::DefaultValue, typename Index_ = singlepp::DefaultIndex>
 RankMatrix<Value_, Index_> load_rankings_from_text_file(const char* path, const LoadRankingsOptions& options) {
-    byteme::RawFileReader reader(path, options.buffer_size);
+    byteme::RawFileReaderOptions read_opt;
+    read_opt.buffer_size = options.buffer_size;
+    byteme::RawFileReader reader(path, read_opt);
     return internal::load_rankings<Value_, Index_>(reader, options.parallel);
 }
 
@@ -172,7 +172,9 @@ RankMatrix<Value_, Index_> load_rankings_from_text_file(const char* path, const
  */
 template<typename Value_ = singlepp::DefaultValue, typename Index_ = singlepp::DefaultIndex>
 RankMatrix<Value_, Index_> load_rankings_from_gzip_file(const char* path, const LoadRankingsOptions& options) {
-    byteme::GzipFileReader reader(path, options.buffer_size);
+    byteme::GzipFileReaderOptions read_opt;
+    read_opt.buffer_size = options.buffer_size;
+    byteme::GzipFileReader reader(path, read_opt);
     return internal::load_rankings<Value_, Index_>(reader, options.parallel);
 }
 
@@ -191,7 +193,10 @@ RankMatrix<Value_, Index_> load_rankings_from_gzip_file(const char* path, const
  */
 template<typename Value_ = singlepp::DefaultValue, typename Index_ = singlepp::DefaultIndex>
 RankMatrix<Value_, Index_> load_rankings_from_zlib_buffer(const unsigned char* buffer, size_t len, const LoadRankingsOptions& options) {
-    byteme::ZlibBufferReader reader(buffer, len, 3, options.buffer_size);
+    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_rankings<Value_, Index_>(reader, options.parallel);
 }
 

tests/src/labels.cpp

@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 
 #include "singlepp_loaders/labels.hpp"
-#include "byteme/temp_file_path.hpp"
+#include "temp_file_path.h"
 #include "zlib.h"
 
 #include "utils.h"
@@ -13,7 +13,7 @@
 class LoadLabelsTest : public ::testing::TestWithParam<std::tuple<int, bool> > {};
 
 TEST_P(LoadLabelsTest, TextFile) {
-    auto path = byteme::temp_file_path("lab_text");
+    auto path = temp_file_path("lab_text");
     std::vector<int> labels;
     {
         std::ofstream out(path, std::ofstream::out);
@@ -33,7 +33,7 @@ TEST_P(LoadLabelsTest, TextFile) {
 }
 
 TEST_P(LoadLabelsTest, GzipFile) {
-    auto path = byteme::temp_file_path("lab_gzip");
+    auto path = temp_file_path("lab_gzip");
     std::vector<int> labels;
     {
         std::string output;
@@ -84,20 +84,20 @@ void quick_label_err(std::string path, std::string msg) {
 
 TEST(LoadLabels, EdgeCases) {
     {
-        auto path = byteme::temp_file_path("label_err");
+        auto path = temp_file_path("label_err");
         quick_dump(path, "1\n2\n3a\n4\n");
         quick_label_err(path, "must be an integer");
     }
 
     {
-        auto path = byteme::temp_file_path("label_err");
+        auto path = temp_file_path("label_err");
         quick_dump(path, "1\n2\n\n4\n");
         quick_label_err(path, "must be an integer");
     }
 
     // Non-newline termination is ok, as are empty fields.
     {
-        auto path = byteme::temp_file_path("feat_ok");
+        auto path = temp_file_path("feat_ok");
         quick_dump(path, "1\n2");
         auto output = singlepp_loaders::load_labels_from_text_file(path.c_str(), singlepp_loaders::LoadLabelsOptions());
         EXPECT_EQ(output.size(), 2);