[misc] various things I would rather have in SeqAn

Author: h-2

include/bio/detail/range.hpp

@@ -13,8 +13,10 @@
 
 #pragma once
 
+#include <ranges>
+#include <span>
+
 #include <seqan3/alphabet/concept.hpp>
-#include <seqan3/utility/concept/container.hpp>
 
 #include <bio/platform.hpp>
 
@@ -25,6 +27,57 @@ namespace bio::detail
  * \{
  */
 
+// ----------------------------------------------------------------------------
+// concepts
+// ----------------------------------------------------------------------------
+
+/*!\interface bio::detail::back_insertable_with <>
+ * \extends std::ranges::output_range
+ * \tparam rng_t The container type.
+ * \tparam val_t The type to append to the container.
+ * \brief Describes range types that can grow in amortised constant time by appending an element of type val_t.
+ */
+//!\cond
+template <typename rng_t, typename val_t>
+concept back_insertable_with = std::ranges::output_range<rng_t, val_t> && requires(rng_t & v)
+{
+    v.push_back(std::declval<val_t>());
+};
+//!\endcond
+
+/*!\interface bio::detail::back_insertable <>
+ * \extends std::ranges::output_range
+ * \extends std::ranges::input_range
+ * \tparam rng_t The container type.
+ * \brief Describes range types that can grow in amortised constant time by appending an element.
+ */
+//!\cond
+template <typename rng_t>
+concept back_insertable =
+  std::ranges::input_range<rng_t> && back_insertable_with<rng_t, std::ranges::range_reference_t<rng_t>>;
+//!\endcond
+
+//!\brief A seqan3::alphabet that is **not** a character or number (any std::integral).
+template <typename t>
+concept deliberate_alphabet = seqan3::alphabet<t> && !std::integral<std::remove_cvref_t<t>>;
+
+//!\brief A range whose value type is `char`.
+template <typename t>
+concept char_range = std::ranges::range<t> && std::same_as<char, std::remove_cvref_t<std::ranges::range_value_t<t>>>;
+
+//!\brief A range whose value type is an integral type other than `char`.
+template <typename t>
+concept int_range = std::ranges::range<t> && std::integral<std::remove_cvref_t<std::ranges::range_value_t<t>>> &&
+  !std::same_as<char, std::remove_cvref_t<std::ranges::range_value_t<t>>>;
+
+//!\brief A type that is not std::span<std::byte const>.
+template <typename t>
+concept not_a_byte_span = !std::same_as<t, std::span<std::byte const>>;
+
+// ----------------------------------------------------------------------------
+// copy functions
+// ----------------------------------------------------------------------------
+
 /*!\brief Copy elements from the first range into the second range.
  * \param[in] in The range to copy from.
  * \param[out] out The range to copy to.
@@ -36,8 +89,8 @@ namespace bio::detail
  * If the input range is sized and the target range offers a `.resize()` member, this function uses
  * resize and assignment instead of back-insertion.
  */
-void sized_range_copy(std::ranges::input_range auto &&                                                   in,
-                      seqan3::back_insertable_with<std::ranges::range_reference_t<decltype(in)>> auto && out)
+void sized_range_copy(std::ranges::input_range auto &&                                           in,
+                      back_insertable_with<std::ranges::range_reference_t<decltype(in)>> auto && out)
 {
     using in_t  = decltype(in);
     using out_t = decltype(out);
@@ -64,23 +117,6 @@ void string_copy(std::string_view const in, auto & out)
         sized_range_copy(in, out);
 }
 
-//!\brief A seqan3::alphabet that is **not** a character or number (any std::integral).
-template <typename t>
-concept deliberate_alphabet = seqan3::alphabet<t> && !std::integral<std::remove_cvref_t<t>>;
-
-//!\brief A range whose value type is `char`.
-template <typename t>
-concept char_range = std::ranges::range<t> && std::same_as<char, std::remove_cvref_t<std::ranges::range_value_t<t>>>;
-
-//!\brief A range whose value type is an integral type other than `char`.
-template <typename t>
-concept int_range = std::ranges::range<t> && std::integral<std::remove_cvref_t<std::ranges::range_value_t<t>>> &&
-  !std::same_as<char, std::remove_cvref_t<std::ranges::range_value_t<t>>>;
-
-//!\brief A type that is not std::span<std::byte const>.
-template <typename t>
-concept not_a_byte_span = !std::same_as<t, std::span<std::byte const>>;
-
 //!\}
 
 } // namespace bio::detail

include/bio/format/fasta_input_handler.hpp

@@ -100,7 +100,7 @@ class format_input_handler<fasta> : public format_input_handler_base<format_inpu
      * \{
      */
     //!\brief The fields that this format supports [the base class accesses this type].
-    using format_fields     = seqan3::vtag_t<field::id, field::seq>;
+    using format_fields     = vtag_t<field::id, field::seq>;
     //!\brief Type of the raw record.
     using raw_record_type   = record<format_fields, std::string_view, std::string_view>;
     //!\brief Type of the low-level iterator.
@@ -180,13 +180,10 @@ class format_input_handler<fasta> : public format_input_handler_base<format_inpu
      * \{
      */
     //!\brief We can prevent another copy if the user wants a string.
-    void parse_field(seqan3::vtag_t<field::id> const & /**/, std::string & parsed_field)
-    {
-        std::swap(id_buffer, parsed_field);
-    }
+    void parse_field(vtag_t<field::id> const & /**/, std::string & parsed_field) { std::swap(id_buffer, parsed_field); }
 
     //!\brief We can prevent another copy if the user wants a string.
-    void parse_field(seqan3::vtag_t<field::seq> const & /**/, std::string & parsed_field)
+    void parse_field(vtag_t<field::seq> const & /**/, std::string & parsed_field)
     {
         std::swap(seq_buffer, parsed_field);
     }

include/bio/format/format_input_handler.hpp

@@ -18,7 +18,6 @@
 #include <vector>
 
 #include <seqan3/alphabet/views/char_to.hpp> // TODO replace with char_strictly_to
-#include <seqan3/utility/concept/container.hpp>
 
 #include <bio/detail/charconv.hpp>
 #include <bio/detail/range.hpp>
@@ -105,15 +104,15 @@ class format_input_handler_base
     }
 
     //!\brief Parse into string-like types.
-    template <seqan3::back_insertable parsed_field_t>
+    template <detail::back_insertable parsed_field_t>
         requires detail::char_range<parsed_field_t>
     static void parse_field_aux(std::string_view const in, parsed_field_t & parsed_field)
     {
         detail::sized_range_copy(in, parsed_field);
     }
 
     //!\brief Parse into containers of alphabets.
-    template <seqan3::back_insertable parsed_field_t>
+    template <detail::back_insertable parsed_field_t>
         requires detail::deliberate_alphabet<std::ranges::range_reference_t<parsed_field_t>>
     static void parse_field_aux(std::string_view const in, parsed_field_t & parsed_field)
     {
@@ -146,7 +145,7 @@ class format_input_handler_base
 
     //!\brief Various target types have sane default implementations.
     template <field field_id, typename parsed_field_t>
-    void parse_field(seqan3::vtag_t<field_id> const & /**/, parsed_field_t & parsed_field) requires(requires {
+    void parse_field(vtag_t<field_id> const & /**/, parsed_field_t & parsed_field) requires(requires {
         derived_t::parse_field_aux(get<field_id>(to_derived()->raw_record), parsed_field);
     })
     {
@@ -160,21 +159,21 @@ class format_input_handler_base
      */
     //!\brief Only act on those fields that are present in the record and also provided by the format.
     template <field field_id, typename parsed_record_t>
-    void parse_record_impl(seqan3::vtag_t<field_id> const & /**/, parsed_record_t & parsed_record)
+    void parse_record_impl(vtag_t<field_id> const & /**/, parsed_record_t & parsed_record)
     {
         if constexpr (parsed_record_t::field_ids::contains(field_id))
         {
             auto & parsed_field = get<field_id>(parsed_record);
-            to_derived()->parse_field(seqan3::vtag<field_id>, parsed_field);
+            to_derived()->parse_field(vtag<field_id>, parsed_field);
         }
         // fields that are not in format or not in target record are simply ignored
     }
 
     //!\brief Splits the record into individual fields.
     template <field... field_ids, typename parsed_record_t>
-    void parse_record(seqan3::vtag_t<field_ids...> const & /**/, parsed_record_t & parsed_record)
+    void parse_record(vtag_t<field_ids...> const & /**/, parsed_record_t & parsed_record)
     {
-        (to_derived()->parse_record_impl(seqan3::vtag<field_ids>, parsed_record), ...);
+        (to_derived()->parse_record_impl(vtag<field_ids>, parsed_record), ...);
     }
     //!\}
 

include/bio/misc.hpp

@@ -8,6 +8,11 @@
 
 #pragma once
 
+#include <concepts>
+#include <tuple>
+
+#include <seqan3/utility/type_list/type_list.hpp>
+
 #include <bio/platform.hpp>
 
 /*!\file
@@ -18,17 +23,121 @@
 namespace bio
 {
 
+//-----------------------------------------------------------------------------
+// ownership
+//-----------------------------------------------------------------------------
+
 /*!\brief An enum used as an argument for templates that switch between owning and non-owning behaviour.
+ * \ingroup bio
  * \details
  *
  * Typically used to configure a class template to have members that are vectors/strings VS members that are views.
  * The "shallow" version of such a class is typically cheap to copy (no dynamic memory) while the "deep" version
- * is exppensive to copy (holds dynamic memory).
+ * is expensive to copy (holds dynamic memory).
  */
 enum class ownership
 {
-    shallow, //< Cheap to copy.
-    deep     //< Expensive to copy.
+    shallow, //!< Cheap to copy.
+    deep     //!< Expensive to copy.
+};
+
+//-----------------------------------------------------------------------------
+// vtag
+//-----------------------------------------------------------------------------
+
+/*!\brief The type of bio::vtag. [Default "specialisation" for 0 arguments.]
+ * \tparam more_vs Any number of values [only 0 arguments pick this specialisation].
+ * \ingroup bio
+ * \see bio::vtag
+ */
+template <auto... more_vs>
+struct vtag_t
+{
+    //!\brief The number of values stored in the tag.
+    static constexpr size_t size = 0;
+
+    //!\brief The tag converted to a tuple.
+    static constexpr auto as_tuple = std::tuple{};
+
+    //!\brief A function that checks if a value is contained in the tag.
+    static constexpr bool contains(auto &&) { return false; }
+
+    //!\brief A function that returns the index of a value or ((size_t)-1) if the value is not found.
+    static constexpr size_t index_of(auto &&) { return static_cast<size_t>(-1ULL); }
+};
+
+/*!\brief The type of bio::vtag. [Specialisation for 1 or more arguments]
+ * \tparam v       First value.
+ * \tparam more_vs More values.
+ * \ingroup bio
+ * \see bio::vtag
+ */
+template <auto v, auto... more_vs>
+struct vtag_t<v, more_vs...>
+{
+    //!\brief The first value in the tag.
+    static constexpr auto first_value = v;
+
+    //!\copybrief bio::vtag_t::size
+    static constexpr size_t size = sizeof...(more_vs) + 1;
+
+    //!\copybrief bio::vtag_t::as_tuple
+    static constexpr auto as_tuple = std::tuple{v, more_vs...};
+
+    //!\brief Whether all values in the tag are unique.
+    static constexpr bool unique_values = ((v != more_vs) && ...);
+
+    //!\copybrief bio::vtag_t::contains
+    static constexpr bool contains(auto && s) requires std::equality_comparable_with<decltype(s), decltype(v)> &&
+      (std::equality_comparable_with<decltype(s), decltype(more_vs)> &&...)
+    {
+        return s == v || ((s == more_vs) || ...);
+    }
+
+    //!\copybrief bio::vtag_t::index_of
+    static constexpr size_t index_of(auto && s) requires std::equality_comparable_with<decltype(s), decltype(v)> &&
+      (std::equality_comparable_with<decltype(s), decltype(more_vs)> &&...)
+    {
+        size_t c = 0;
+        ((v != s && ++c) && ((more_vs != s && ++c) && ...));
+        return c >= size ? static_cast<size_t>(-1ULL) : c;
+    }
 };
 
+/*!\brief A value-tag template.
+ * \tparam vs The values to store in the tag.
+ * \ingroup bio
+ * \details
+ *
+ * Using this template, you can easily turn a value, e.g. a literal value, into a compile-time constant with a unique
+ * type.
+ *
+ * ### Example
+ *
+ * \snippet test/snippet/snippet_tag.cpp vtag
+ */
+template <auto... vs>
+inline constexpr vtag_t<vs...> vtag{};
+
+//-----------------------------------------------------------------------------
+// ttag
+//-----------------------------------------------------------------------------
+
+/*!\brief A type-tag template.
+ * \tparam type The first type to store.
+ * \tparam more_types More types to store (optional).
+ * \ingroup bio
+ * \see seqan3::type_list
+ *
+ * \details
+ *
+ * Using this template, you can easily turn a type into a compile-time constant (value).
+ *
+ * ### Example
+ *
+ * \snippet test/snippet/snippet_tag.cpp ttag
+ */
+template <typename type, typename... more_types>
+inline constexpr seqan3::type_list<type, more_types...> ttag{};
+
 } // namespace bio

include/bio/record.hpp

@@ -18,9 +18,10 @@
 #include <bio/platform.hpp>
 
 #include <seqan3/core/detail/template_inspection.hpp>
-#include <seqan3/utility/tag.hpp>
 #include <seqan3/utility/type_list/type_list.hpp>
 
+#include <bio/misc.hpp>
+
 namespace bio
 {
 
@@ -89,7 +90,7 @@ enum class field : uint64_t
  * \implements seqan3::tuple_like
  * \ingroup bio
  * \tparam field_types The types of the fields in this record as a seqan3::type_list.
- * \tparam field_ids   A seqan3::vtag_t type with bio::field IDs corresponding to field_types.
+ * \tparam field_ids   A vtag_t type with bio::field IDs corresponding to field_types.
  * \details
  *
  * This class template behaves just like an std::tuple, with the exception that it provides an additional
@@ -346,8 +347,8 @@ auto const && get(record<field_ids, field_types...> const && r)
  * TODO
  */
 template <auto... field_ids, typename... field_type_ts>
-constexpr auto make_record(seqan3::vtag_t<field_ids...>, field_type_ts &... fields)
-  -> record<seqan3::vtag_t<field_ids...>, field_type_ts...>
+constexpr auto make_record(vtag_t<field_ids...>, field_type_ts &... fields)
+  -> record<vtag_t<field_ids...>, field_type_ts...>
 {
     return {fields...};
 }
@@ -364,8 +365,8 @@ constexpr auto make_record(seqan3::vtag_t<field_ids...>, field_type_ts &... fiel
  * TODO
  */
 template <auto... field_ids, typename... field_type_ts>
-constexpr auto tie_record(seqan3::vtag_t<field_ids...>, field_type_ts &... fields)
-  -> record<seqan3::vtag_t<field_ids...>, field_type_ts &...>
+constexpr auto tie_record(vtag_t<field_ids...>, field_type_ts &... fields)
+  -> record<vtag_t<field_ids...>, field_type_ts &...>
 {
     return {fields...};
 }

include/bio/seq_io/misc.hpp

@@ -13,7 +13,7 @@
 
 #pragma once
 
-#include <seqan3/utility/tag.hpp>
+#include <bio/misc.hpp>
 
 #include <bio/record.hpp>
 
@@ -22,6 +22,6 @@ namespace bio::seq_io
 
 //!\brief Default fields for seqan3::seq_io::reader_options.
 //!\ingroup seq_io
-inline constexpr auto default_field_ids = seqan3::vtag<field::id, field::seq, field::qual>;
+inline constexpr auto default_field_ids = vtag<field::id, field::seq, field::qual>;
 
 } // namespace bio::seq_io