refactor: make more single argument ctors explicit

src/dwarfs/categorizer.cpp

@@ -219,7 +219,7 @@ categorizer_job::categorizer_job(std::unique_ptr<impl> impl)
 template <typename LoggerPolicy>
 class categorizer_manager_ final : public categorizer_manager_private {
  public:
-  categorizer_manager_(logger& lgr)
+  explicit categorizer_manager_(logger& lgr)
       : lgr_{lgr}
       , LOG_PROXY_INIT(lgr) {
     add_category(categorizer::DEFAULT_CATEGORY,

src/dwarfs/categorizer/binary_categorizer.cpp

@@ -55,7 +55,7 @@ class binary_categorizer_base : public random_access_categorizer {
 template <typename LoggerPolicy>
 class binary_categorizer_ final : public binary_categorizer_base {
  public:
-  binary_categorizer_(logger& lgr)
+  explicit binary_categorizer_(logger& lgr)
       : LOG_PROXY_INIT(lgr) {}
 
   inode_fragments

src/dwarfs/categorizer/libmagic_categorizer.cpp

@@ -94,7 +94,7 @@ class magic_wrapper {
 
   class scoped_cookie {
    public:
-    scoped_cookie(magic_wrapper const& w)
+    explicit scoped_cookie(magic_wrapper const& w)
         : cookie_{get_scoped_cookie(w)}
         , w_{w} {}
 

src/dwarfs/categorizer/pcmaudio_categorizer.cpp

@@ -449,7 +449,7 @@ class pcmaudio_categorizer_base : public random_access_categorizer {
 template <typename LoggerPolicy>
 class pcmaudio_categorizer_ final : public pcmaudio_categorizer_base {
  public:
-  pcmaudio_categorizer_(logger& lgr)
+  explicit pcmaudio_categorizer_(logger& lgr)
       : LOG_PROXY_INIT(lgr) {
     waveform_req_.add_set("endianness", &pcmaudio_metadata::sample_endianness,
                           parse_endianness_dyn);

src/dwarfs/compression/flac.cpp

@@ -53,7 +53,7 @@ constexpr size_t const kBlockSize{65536};
 
 class dwarfs_flac_stream_encoder : public FLAC::Encoder::Stream {
  public:
-  dwarfs_flac_stream_encoder(std::vector<uint8_t>& data)
+  explicit dwarfs_flac_stream_encoder(std::vector<uint8_t>& data)
       : data_{data}
       , pos_{data_.size()} {}
 

src/dwarfs/filesystem_writer.cpp

@@ -136,7 +136,7 @@ class fsblock {
 
 class fsblock_merger_policy {
  public:
-  fsblock_merger_policy(size_t worst_case_block_size)
+  explicit fsblock_merger_policy(size_t worst_case_block_size)
       : worst_case_block_size_{worst_case_block_size} {}
 
   size_t block_size(std::unique_ptr<fsblock> const& fsb) const {

src/dwarfs/pcm_sample_transformer.cpp

@@ -196,7 +196,7 @@ class pcm_sample_transformer_generic final
  public:
   using basic_transformer = basic_pcm_sample_transformer<UnpackedType>;
 
-  pcm_sample_transformer_generic(int bits)
+  explicit pcm_sample_transformer_generic(int bits)
       : bits_{bits} {}
 
   void unpack(std::span<UnpackedType> dst,

src/dwarfs/segmenter.cpp

@@ -341,7 +341,7 @@ class ConstantGranularityPolicy : private GranularityPolicyBase {
 
 class VariableGranularityPolicy : private GranularityPolicyBase {
  public:
-  VariableGranularityPolicy(uint32_t granularity) noexcept
+  explicit VariableGranularityPolicy(uint32_t granularity) noexcept
       : granularity_{granularity} {}
 
   template <typename T>

src/dwarfs/similarity_ordering.cpp

@@ -177,7 +177,7 @@ struct basic_cluster_tree_node {
 
   basic_cluster_tree_node()
       : v{std::make_unique<cluster_type>()} {}
-  basic_cluster_tree_node(index_type&& index)
+  explicit basic_cluster_tree_node(index_type&& index)
       : v{std::make_unique<cluster_type>(std::move(index))} {}
 
   children_vector const& children() const {

src/mkdwarfs_main.cpp

@@ -289,7 +289,7 @@ class categorize_optval {
   bool is_explicit{false};
 
   categorize_optval() = default;
-  categorize_optval(std::string const& val, bool expl = false)
+  explicit categorize_optval(std::string const& val, bool expl = false)
       : value{val}
       , is_explicit{expl} {}
 

test/block_merger_test.cpp

@@ -91,7 +91,8 @@ struct sized_block {
 
 class sized_block_merger_policy {
  public:
-  sized_block_merger_policy(std::vector<size_t>&& worst_case_block_size)
+  explicit sized_block_merger_policy(
+      std::vector<size_t>&& worst_case_block_size)
       : worst_case_block_size_{std::move(worst_case_block_size)} {}
 
   static size_t block_size(sized_block const& blk) { return blk.size; }