Merge pull request #77 from h-2/rebrand

[misc] shallow records are not copyable

Author: h-2

doc/record_faq.md

@@ -60,7 +60,8 @@ performance** but also in some important limitations:
 * Shallow records cannot be modified (as easily¹).
 * Shallow records cannot be "stored"; they depend on internal caches and buffers of the reader and become invalid
 as soon as the next record is read from the file.
-
+* To prevent the user from accidentally copying the record into a scope where it would be invalid, shallow records
+are not copyable!
 
 If you need to change a record in-place and/or "store" the record for longer than one iteration of the reader, you need to use *deep records* instead.
 You can tell the reader that you want deep records by providing the respective options:

include/bio/io/detail/concept.hpp

@@ -14,6 +14,7 @@
 #pragma once
 
 #include <concepts>
+#include <ranges>
 
 #include <bio/alphabet/concept.hpp>
 #include <bio/meta/overloaded.hpp>
@@ -50,7 +51,6 @@ constexpr bool lazy_concept_checker(auto fun)
     using ret_t = decltype(meta::overloaded{fallback, fun}(1));
     return ret_t::value;
 }
-
 //!\}
 
 } // namespace bio::io::detail

include/bio/io/detail/reader_base.hpp

@@ -137,13 +137,13 @@ class reader_base
      * the file is detected as being compressed.
      * See the section on compression and decompression (TODO) for more information.
      */
-    reader_base(std::filesystem::path const & filename, format_type const & fmt, options_t const & opt = options_t{}) :
-      options{opt}, stream{filename, opt.stream_options}, format{fmt}
+    reader_base(std::filesystem::path const & filename, format_type const & fmt, options_t opt = options_t{}) :
+      stream{filename, opt.stream_options}, options{std::move(opt)}, format{fmt}
     {}
 
     //!\overload
-    explicit reader_base(std::filesystem::path const & filename, options_t const & opt = options_t{}) :
-      options{opt}, stream{filename, opt.stream_options}
+    explicit reader_base(std::filesystem::path const & filename, options_t opt = options_t{}) :
+      stream{filename, opt.stream_options}, options{std::move(opt)}
     {
         // initialise format handler or throw if format is not found
         detail::set_format(format, stream.truncated_filename());
@@ -164,17 +164,17 @@ class reader_base
      * it is detected as being compressed.
      * See the section on compression and decompression (TODO) for more information.
      */
-    reader_base(std::istream & str, format_type const & fmt, options_t const & opt = options_t{}) :
-      options{opt}, stream{str, opt.stream_options}, format{fmt}
+    reader_base(std::istream & str, format_type const & fmt, options_t opt = options_t{}) :
+      stream{str, opt.stream_options}, options{std::move(opt)}, format{fmt}
     {}
 
     //!\overload
     template <movable_istream temporary_stream_t>
         //!\cond REQ
         requires(!std::is_lvalue_reference_v<temporary_stream_t>)
     //!\endcond
-    reader_base(temporary_stream_t && str, format_type const & fmt, options_t const & opt = options_t{}) :
-      options{opt}, stream{std::move(str), opt.stream_options}, format{fmt}
+    reader_base(temporary_stream_t && str, format_type const & fmt, options_t opt = options_t{}) :
+      stream{std::move(str), opt.stream_options}, options{std::move(opt)}, format{fmt}
     {}
     //!\}
 
@@ -252,10 +252,10 @@ class reader_base
     /*!\name State
      * \{
      */
-    //!\brief The object holding the options.
-    options_t           options;
     //!\brief The input stream.
     transparent_istream stream;
+    //!\brief The object holding the options.
+    options_t           options;
     //!\brief Buffer for a single record.
     record_type         record_buffer;
     //!\brief Tracks whether the very first record is buffered when calling begin().

include/bio/io/detail/utility.hpp

@@ -19,6 +19,7 @@
 #include <ranges>
 #include <string>
 
+#include <bio/meta/tuple.hpp>
 #include <bio/meta/type_list/function.hpp>
 #include <bio/meta/type_list/type_list.hpp>
 #include <bio/meta/type_traits/template_inspection.hpp>
@@ -32,6 +33,10 @@ namespace bio::io::detail
  * \{
  */
 
+//=============================================================================
+// move_tracker
+//=============================================================================
+
 //!\brief Can be included as a member to infer whether parent is in moved-from state.
 //!\ingroup io
 struct move_tracker
@@ -55,6 +60,36 @@ struct move_tracker
     bool moved_from = false;
 };
 
+//=============================================================================
+// copy_blocker
+//=============================================================================
+
+//!\brief Can be included as a member to prevent the parent from being copyable/movable.
+//!\ingroup io
+template <bool shallow>
+struct copy_blocker
+{
+    /*!\name Constructors, destructor and assignment
+     * \{
+     */
+    copy_blocker()                            = default; //!<Defaulted.
+    copy_blocker(copy_blocker &&)             = default; //!<Defaulted.
+    copy_blocker & operator=(copy_blocker &&) = default; //!<Defaulted.
+
+    copy_blocker(copy_blocker const &) requires(!shallow) = default; //!<Conditionally defaulted.
+    copy_blocker(copy_blocker const &) requires(shallow)  = delete;  //!<USE DEEP RECORDS IF YOU WANT TO COPY!
+    copy_blocker & operator=(copy_blocker const &) requires(!shallow) = default; //!<Conditionally defaulted.
+    copy_blocker & operator=(copy_blocker const &) requires(shallow) = delete; //!<USE DEEP RECORDS IF YOU WANT TO COPY!
+    //!\}
+
+    //!\brief Comparison operator that always compares as equal.
+    friend auto operator<=>(copy_blocker const & lhs, copy_blocker const & rhs) = default;
+};
+
+//=============================================================================
+// clear()
+//=============================================================================
+
 //!\brief Helper for clearing objects that provide such functionality.
 //!\ingroup io
 void clear(auto && arg) requires(requires { arg.clear(); })
@@ -68,4 +103,30 @@ void clear(auto && arg)
     arg = {};
 }
 
+//=============================================================================
+// is_shallow_v
+//=============================================================================
+
+//!\brief A type that is a an lvalue reference or a copyable view.
+template <typename t>
+inline constexpr bool is_shallow_v = std::is_lvalue_reference_v<t> ||
+                                     (std::ranges::view<t> && std::copy_constructible<t>);
+
+//!\brief A type that is a an lvalue reference or a copyable view. [specialisation for std::tuple]
+template <typename... args_t>
+inline constexpr bool is_shallow_v<std::tuple<args_t...>> = (is_shallow_v<args_t> || ...);
+
+//!\brief A type that is a an lvalue reference or a copyable view. [specialisation for std::pair]
+template <typename... args_t>
+inline constexpr bool is_shallow_v<std::pair<args_t...>> = (is_shallow_v<args_t> || ...);
+
+//!\brief A type that is a an lvalue reference or a copyable view. [specialisation for bio::meta::tuple]
+template <typename... args_t>
+inline constexpr bool is_shallow_v<bio::meta::tuple<args_t...>> = (is_shallow_v<args_t> || ...);
+
+//!\brief A type that is a an lvalue reference or a copyable view. [specialisation for containers]
+template <std::ranges::range container_t>
+    requires(!std::ranges::view<container_t>)
+inline constexpr bool is_shallow_v<container_t> = is_shallow_v<std::ranges::range_value_t<container_t>>;
+
 } // namespace bio::io::detail

include/bio/io/seq/reader.hpp

@@ -139,16 +139,16 @@ class reader : public reader_base<reader<option_args_t...>, reader_options<optio
      * the file is detected as being compressed.
      * See the section on compression and decompression (TODO) for more information.
      */
-    reader(std::filesystem::path const &            filename,
-           format_type const &                      fmt,
-           reader_options<option_args_t...> const & opt = reader_options<option_args_t...>{}) :
-      base_t{filename, fmt, opt}
+    reader(std::filesystem::path const &    filename,
+           format_type const &              fmt,
+           reader_options<option_args_t...> opt = reader_options<option_args_t...>{}) :
+      base_t{filename, fmt, std::move(opt)}
     {}
 
     //!\overload
-    explicit reader(std::filesystem::path const &            filename,
-                    reader_options<option_args_t...> const & opt = reader_options<option_args_t...>{}) :
-      base_t{filename, opt}
+    explicit reader(std::filesystem::path const &    filename,
+                    reader_options<option_args_t...> opt = reader_options<option_args_t...>{}) :
+      base_t{filename, std::move(opt)}
     {}
 
     /*!\brief Construct from an existing stream and with specified format.
@@ -166,21 +166,21 @@ class reader : public reader_base<reader<option_args_t...>, reader_options<optio
      * it is detected as being compressed.
      * See the section on compression and decompression (TODO) for more information.
      */
-    reader(std::istream &                           str,
-           format_type const &                      fmt,
-           reader_options<option_args_t...> const & opt = reader_options<option_args_t...>{}) :
-      base_t{str, fmt, opt}
+    reader(std::istream &                   str,
+           format_type const &              fmt,
+           reader_options<option_args_t...> opt = reader_options<option_args_t...>{}) :
+      base_t{str, fmt, std::move(opt)}
     {}
 
     //!\overload
     template <movable_istream temporary_stream_t>
         //!\cond REQ
         requires(!std::is_lvalue_reference_v<temporary_stream_t>)
     //!\endcond
-    reader(temporary_stream_t &&                    str,
-           format_type const &                      fmt,
-           reader_options<option_args_t...> const & opt = reader_options<option_args_t...>{}) :
-      base_t{std::move(str), fmt, opt}
+    reader(temporary_stream_t &&            str,
+           format_type const &              fmt,
+           reader_options<option_args_t...> opt = reader_options<option_args_t...>{}) :
+      base_t{std::move(str), fmt, std::move(opt)}
     {}
 };
 

include/bio/io/seq/reader_options.hpp

@@ -50,6 +50,9 @@ namespace bio::io::seq
  * Furthermore, different container and view types can be chosen. See bio::io::seq::record
  * for more details.
  *
+ * If you define the options before creating the reader, it is recommended to `std::move()`
+ * them into the constructor of the reader, since some members might not be copyable.
+ *
  * ### Example
  *
  * Options can be easily set via [designated

include/bio/io/seq/record.hpp

@@ -13,7 +13,9 @@
 
 #pragma once
 
+#include <ranges>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 #include <bio/alphabet/aminoacid/aa27.hpp>
@@ -29,6 +31,7 @@
 #include <bio/io/detail/misc.hpp>
 #include <bio/io/detail/range.hpp>
 #include <bio/io/detail/tuple_record.hpp>
+#include <bio/io/detail/utility.hpp>
 #include <bio/io/format/fasta.hpp>
 #include <bio/io/format/fastq.hpp>
 #include <bio/io/misc.hpp>
@@ -163,8 +166,59 @@ struct record
      * The default and all pre-defined aliases satisfy the requirements for reading and writing.
      */
     qual_t qual{};
+
+    //!\brief Defaulted comparison operators.
+    friend auto operator<=>(record const & lhs, record const & rhs) = default;
+
+    //!\privatesection
+    //!\brief Type of the copy_blocker.
+    using _copy_blocker_t =
+      io::detail::copy_blocker<io::detail::is_shallow_v<id_t> || io::detail::is_shallow_v<seq_t> ||
+                               io::detail::is_shallow_v<qual_t>>;
+    //!\brief Empty member that prevents this class from being copyable if it contains views or references.
+    [[no_unique_address]] _copy_blocker_t _shallow_record_not_copyable_use_deep_record_instead{};
+
+    //!\brief Enable structured bindings for this class that ignore the copy_blocker.
+    template <size_t i>
+        requires(i < 3)
+    friend decltype(auto) get(meta::decays_to<record> auto && r)
+    {
+        auto fwd_like_r = []<typename t>(t & mem) -> decltype(auto)
+        { return static_cast<std::conditional_t<std::is_lvalue_reference_v<decltype(r)>, t &, t &&>>(mem); };
+
+        if constexpr (i == 0)
+            return fwd_like_r(r.id);
+        else if constexpr (i == 1)
+            return fwd_like_r(r.seq);
+        else
+            return fwd_like_r(r.qual);
+    }
 };
 
+} // namespace bio::io::seq
+
+//!\cond
+namespace std
+{
+
+template <typename... args>
+struct tuple_size<bio::io::seq::record<args...>> : public std::integral_constant<size_t, 3>
+{};
+
+template <size_t i, typename... args>
+struct tuple_element<i, bio::io::seq::record<args...>> : tuple_element<i, std::tuple<args...>>
+{};
+
+template <size_t i, typename... args>
+struct tuple_element<i, bio::io::seq::record<args...> const> : tuple_element<i, std::tuple<args...> const>
+{};
+
+} // namespace std
+//!\endcond
+
+namespace bio::io::seq
+{
+
 //-----------------------------------------------------------------------------
 // tie_record()
 //-----------------------------------------------------------------------------

include/bio/io/txt/misc.hpp

@@ -36,6 +36,16 @@ namespace bio::io::txt
  */
 struct record
 {
+    /*!\name Constructors, destructor and assignment
+     * \{
+     */
+    record()                           = default; //!< Defaulted.
+    record(record &&)                  = default; //!< Defaulted.
+    record(record const &)             = delete;  //!< Deleted to prevent dangling copies.
+    record & operator=(record &&)      = default; //!< Defaulted.
+    record & operator=(record const &) = delete;  //!< Deleted to prevent dangling copies.
+    //!\}
+
     //!\brief The entire line (exluding EOL characters but including delimiters).
     std::string_view              line;
     //!\brief A range of the individual fields (without delimiters or EOL characters).