Refactoring contaminants to avoid non-const global

CMakeLists.txt

@@ -97,7 +97,7 @@ add_library(quality_score OBJECT src/quality_score.cpp)
 add_library(tile_processor OBJECT src/tile_processor.cpp)
 add_library(falco_grade OBJECT src/falco_grade.cpp)
 add_library(kmer_counter OBJECT src/kmer_counter.cpp)
-add_library(contaminants OBJECT src/contaminants.cpp)
+add_library(contaminant_set OBJECT src/contaminant_set.cpp)
 add_library(duplication_results OBJECT src/duplication_results.cpp)
 add_library(adapter_matcher OBJECT src/adapter_matcher.cpp)
 add_library(report OBJECT src/report.cpp)
@@ -126,7 +126,7 @@ endif()
 add_executable(falco src/falco.cpp)
 target_link_libraries(falco PRIVATE
   tile_processor
-  contaminants
+  contaminant_set
   adapter_matcher
   adapter_set
   duplication_results

src/bamrec.cpp

@@ -13,15 +13,16 @@
 [[nodiscard]] auto
 bamrec::to_string() const -> std::string {
   const auto buffer_s = std::span(std::cbegin(buffer), std::cend(buffer));
-  const auto name_itr = std::cbegin(buffer_s);
-  const auto seq_itr = name_itr + name_len;
-  const auto qual_itr = seq_itr + seq_len;
-  std::string qual_fixed(seq_len, '\0');
-  std::transform(qual_itr, qual_itr + seq_len, std::begin(qual_fixed),
-                 [](const auto c) { return c + quality_score_offset; });
-  return std::format("@{}\n{}\n+\n{}",                //
-                     std::string(name_itr, seq_itr),  //
-                     std::string(seq_itr, qual_itr),  //
+  const auto name_s = buffer_s.subspan(0, name_len);
+  const auto seq_s = buffer_s.subspan(name_len, seq_len);
+  const auto qual_s = buffer_s.subspan(name_len + seq_len, seq_len);
+  auto qual_fixed = std::string(std::cbegin(qual_s), std::cend(qual_s));
+  std::ranges::transform(qual_fixed, std::begin(qual_fixed), [&](const auto c) {
+    return c + quality_score_offset;
+  });
+  return std::format("@{}\n{}\n+\n{}",  //
+                     std::string(std::cbegin(name_s), std::cend(name_s)),
+                     std::string(std::cbegin(seq_s), std::cend(seq_s)),
                      qual_fixed);
 }
 
@@ -33,33 +34,31 @@ bamrec::to_string() const -> std::string {
 #undef bam_seqi
 #endif
 
-template <class BidirIt, class OutputIt>
-static inline constexpr OutputIt
-assign_sequence_revcomp(BidirIt first, auto last, OutputIt d_first) {
+template <class bidir_itr_t, class output_itr_t>
+static inline constexpr output_itr_t
+assign_sequence_revcomp(bidir_itr_t first, auto last, output_itr_t d_first) {
+  static constexpr std::span seq_nt16_str = "=ACMGRSVTWYHKDBN";
   constexpr auto complem = [](const auto x) {
     return "TNGNNNCNNNNNNNNNNNNA"[x - 'A'];
   };
-  constexpr auto seq_nt16_str = "=ACMGRSVTWYHKDBN";
   constexpr auto bam_seqi = [](const auto s, const auto i) -> int {
     constexpr auto low_nibble_on = 0xf;
     return s[i >> 1] >> ((~i & 1) << 2) & low_nibble_on;
   };
   for (auto j = last; j != 0; ++d_first)
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
     *d_first = complem(seq_nt16_str[bam_seqi(first, --j)]);
   return d_first;
 }
 
-template <class BidirIt, class OutputIt>
-static inline constexpr OutputIt
-assign_sequence(BidirIt first, auto last, OutputIt d_first) {
-  constexpr auto seq_nt16_str = "=ACMGRSVTWYHKDBN";
+template <class bidir_itr_t, class output_itr_t>
+static inline constexpr output_itr_t
+assign_sequence(bidir_itr_t first, auto last, output_itr_t d_first) {
+  static constexpr std::span seq_nt16_str = "=ACMGRSVTWYHKDBN";
   constexpr auto bam_seqi = [](const auto s, const auto i) -> int {
     constexpr auto low_nibble_on = 0xf;
     return s[i >> 1] >> ((~i & 1) << 2) & low_nibble_on;
   };
   for (auto j = 0U; j != last; ++j)
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
     *d_first++ = seq_nt16_str[bam_seqi(first, j)];
   return d_first;
 }

src/contaminant_set.hpp

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT; Copyright 2026 Andrew D Smith
+
+#ifndef SRC_CONTAMINANT_SET_HPP_
+#define SRC_CONTAMINANT_SET_HPP_
+
+#include <cstdint>
+#include <iterator>
+#include <ranges>  // for std::pair
+#include <string>
+#include <utility>
+#include <vector>
+
+struct contaminant_set {
+  static auto
+  instance(const std::string &filename = std::string{})
+    -> const contaminant_set & {
+    static const contaminant_set s(filename);
+    return s;
+  }
+
+  [[nodiscard]] static auto
+  n_contaminants() -> std::uint64_t {
+    return std::size(instance().contaminants);
+  }
+
+  [[nodiscard]] static auto
+  get_name(std::int64_t idx) -> const std::string &;
+
+  [[nodiscard]] static auto
+  match(const std::string &query) -> std::int64_t;
+
+  // clang-format off
+  contaminant_set(const contaminant_set &) = delete;
+  contaminant_set(contaminant_set &&) = delete;
+  auto operator=(const contaminant_set &) = delete;
+  auto operator=(contaminant_set &&) = delete;
+  ~contaminant_set() = default;
+  // clang-format on
+
+private:
+  std::vector<std::pair<std::string, std::string>> contaminants;
+  explicit contaminant_set(const std::string &filename);
+};  // contaminant_set
+
+#endif  // SRC_CONTAMINANT_SET_HPP_