Use same enum to set traversal order for dataloader and pairing node

dorado/cli/duplex.cpp

@@ -28,6 +28,7 @@
 
 #include "utils/models.h"
 #include "utils/parameters.h"
+#include "utils/types.h"
 
 #include <argparse.hpp>
 #include <htslib/sam.h>
@@ -371,7 +372,7 @@ int duplex(int argc, char* argv[]) {
 
             std::unique_ptr<PairingNode> pairing_node =
                     template_complement_map.empty()
-                            ? std::make_unique<PairingNode>(stereo_node)
+                            ? std::make_unique<PairingNode>(stereo_node, ReadOrder::BY_CHANNEL)
                             : std::make_unique<PairingNode>(stereo_node,
                                                             std::move(template_complement_map));
 
@@ -410,7 +411,7 @@ int duplex(int argc, char* argv[]) {
                     kStatsPeriod, stats_reporters, stats_callables);
             // End stats counting setup.
 
-            loader.load_reads(reads, parser.get<bool>("--recursive"), DataLoader::BY_CHANNEL);
+            loader.load_reads(reads, parser.get<bool>("--recursive"), ReadOrder::BY_CHANNEL);
             bam_writer->join();  // Explicitly wait for all output rows to be written.
             stats_sampler->terminate();
         }

dorado/data_loader/DataLoader.cpp

@@ -164,7 +164,7 @@ void DataLoader::load_reads(const std::string& path,
 
     auto iterate_directory = [&](const auto& iterator_fn) {
         switch (traversal_order) {
-        case BY_CHANNEL:
+        case ReadOrder::BY_CHANNEL:
             // If traversal in channel order is required, the following algorithm
             // is used -
             // 1. iterate through all the read metadata to collect channel information
@@ -199,7 +199,7 @@ void DataLoader::load_reads(const std::string& path,
                 }
             }
             break;
-        case UNRESTRICTED:
+        case ReadOrder::UNRESTRICTED:
             for (const auto& entry : iterator_fn(path)) {
                 if (m_loaded_read_count == m_max_reads) {
                     break;
@@ -215,8 +215,8 @@ void DataLoader::load_reads(const std::string& path,
             }
             break;
         default:
-            throw std::runtime_error("Unsupported traversal order detected " +
-                                     std::to_string(traversal_order));
+            throw std::runtime_error("Unsupported traversal order detected: " +
+                                     dorado::to_string(traversal_order));
         }
     };
 

dorado/data_loader/DataLoader.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "utils/stats.h"
+#include "utils/types.h"
 
 #include <array>
 #include <map>
@@ -28,11 +29,6 @@ using Pod5Ptr = std::unique_ptr<Pod5FileReader, Pod5Destructor>;
 
 class DataLoader {
 public:
-    enum ReadOrder {
-        UNRESTRICTED,
-        BY_CHANNEL,
-    };
-
     DataLoader(MessageSink& read_sink,
                const std::string& device,
                size_t num_worker_threads,
@@ -42,7 +38,7 @@ class DataLoader {
     ~DataLoader() = default;
     void load_reads(const std::string& path,
                     bool recursive_file_loading = false,
-                    ReadOrder traversal_order = UNRESTRICTED);
+                    ReadOrder traversal_order = ReadOrder::UNRESTRICTED);
 
     static std::unordered_map<std::string, ReadGroup> load_read_groups(
             std::string data_path,

dorado/read_pipeline/PairingNode.cpp

@@ -201,10 +201,16 @@ PairingNode::PairingNode(MessageSink& sink,
           m_num_worker_threads(num_worker_threads),
           m_max_num_keys(std::numeric_limits<size_t>::max()),
           m_max_num_reads(std::numeric_limits<size_t>::max()) {
-    if (read_order == ReadOrder::pore_order) {
+    switch (read_order) {
+    case ReadOrder::BY_CHANNEL:
         m_max_num_keys = 10;
-    } else if (read_order == ReadOrder::time_order) {
+        break;
+    case ReadOrder::BY_TIME:
         m_max_num_reads = 10;
+        break;
+    default:
+        throw std::runtime_error("Unsupported read order detected: " +
+                                 dorado::to_string(read_order));
     }
 
     for (size_t i = 0; i < m_num_worker_threads; i++) {

dorado/read_pipeline/PairingNode.h

@@ -2,6 +2,7 @@
 
 #include "ReadPipeline.h"
 #include "utils/stats.h"
+#include "utils/types.h"
 
 #include <atomic>
 #include <deque>
@@ -16,8 +17,6 @@ namespace dorado {
 
 class PairingNode : public MessageSink {
 public:
-    enum class ReadOrder { pore_order = 0, time_order };
-
     // Template-complement map: uses the pair_list pairing method
     PairingNode(MessageSink& sink,
                 std::map<std::string, std::string> template_complement_map,
@@ -26,7 +25,7 @@ class PairingNode : public MessageSink {
 
     // No template-complement map: uses the pair_generation pairing method
     PairingNode(MessageSink& sink,
-                ReadOrder read_order = ReadOrder::pore_order,
+                ReadOrder read_order,
                 int num_worker_threads = 2,
                 size_t max_reads = 1000);
     ~PairingNode();

dorado/utils/types.h

@@ -21,4 +21,19 @@ struct BamDestructor {
 };
 using BamPtr = std::unique_ptr<bam1_t, BamDestructor>;
 
+enum class ReadOrder { UNRESTRICTED, BY_CHANNEL, BY_TIME };
+
+inline std::string to_string(ReadOrder read_order) {
+    switch (read_order) {
+    case ReadOrder::UNRESTRICTED:
+        return "UNRESTRICTED";
+    case ReadOrder::BY_CHANNEL:
+        return "BY_CHANNEL";
+    case ReadOrder::BY_TIME:
+        return "BY_TIME";
+    default:
+        return "Unknown";
+    }
+}
+
 }  // namespace dorado

tests/DuplexSplitTest.cpp

@@ -90,7 +90,7 @@ TEST_CASE("4 subread split tagging", TEST_GROUP) {
     MessageSinkToVector<std::shared_ptr<dorado::Read>> sink(3);
     dorado::SubreadTaggerNode tag_node(sink);
     dorado::StereoDuplexEncoderNode stereo_node(tag_node, read->model_stride);
-    dorado::PairingNode pairing_node(stereo_node);
+    dorado::PairingNode pairing_node(stereo_node, dorado::ReadOrder::BY_CHANNEL);
 
     dorado::DuplexSplitSettings splitter_settings;
     dorado::DuplexSplitNode splitter_node(pairing_node, splitter_settings, 1);

tests/PairingNodeTest.cpp

@@ -45,7 +45,7 @@ TEST_CASE("Split read pairing", TEST_GROUP) {
 
     MessageSinkToVector<dorado::Message> sink(5);
     // one thread, one read - force reads through in order
-    dorado::PairingNode pairing_node(sink, dorado::PairingNode::ReadOrder::pore_order, 1, 1);
+    dorado::PairingNode pairing_node(sink, dorado::ReadOrder::BY_CHANNEL, 1, 1);
     for (auto& read : reads) {
         pairing_node.push_message(std::move(read));
     }

tests/Pod5DataLoaderTest.cpp

@@ -124,7 +124,7 @@ TEST_CASE(TEST_GROUP "Load data sorted by channel id.") {
 
     MessageSinkToVector<std::shared_ptr<dorado::Read>> sink(100);
     dorado::DataLoader loader(sink, "cpu", 1, 0);
-    loader.load_reads(data_path, true, dorado::DataLoader::ReadOrder::BY_CHANNEL);
+    loader.load_reads(data_path, true, dorado::ReadOrder::BY_CHANNEL);
 
     auto reads = sink.get_messages();
     int start_channel_id = -1;