[misc] simplify bio::ranges::dictionary

Author: h-2

include/bio/ranges/container/dictionary.hpp

@@ -45,7 +45,6 @@ namespace bio::ranges
  * \ingroup container
  * \tparam key_t   The key type; must be convertible to std::string_view (e.g. also std::string).
  * \tparam mapped_t The mapped type; must be an object type.
- * \tparam mapped_t_is_context_aware See below.
  *
  * This container behaves like a mixture of std::vector and std::unordered_map.
  *
@@ -76,18 +75,13 @@ namespace bio::ranges
  *
  * \include test/snippet/ranges/container/dictionary.cpp
  *
- * ### Context-aware mapped value types
+ * ### Static string element access
  *
- * If the template parameter `mapped_t_is_context_aware` is set to true, the #reference type of the dictionary
- * becomes `bio::meta::tuple<key_t const &, mapped_t const &>`, i.e. the mapped value in dictionary elements cannot be
- * changed via regular element access.
- *
- * Additionally, given an object `o` of type `mapped_t`, if `get<"foo">(o)` is valid,
+ * Given an object `o` of type `mapped_t`, if `get<"foo">(o)` is valid,
  * this container provides a special interface:
  *
  *   * A `get<"foo">(dict)` friend function that calls `get<"foo">(dict.at("foo"))`.
  *   * The `.at("foo"_vtag)` and `operator["foo"_vtag]` member functions with identical semantics.
- *   * These functions may or may not expose mutable references to the mapped value (or one of its members).
  *
  * In combination with element types that are derived from std::variant (and additionally provide the aforementioned
  * string-based get-interface), this can be used to create heterogeneous dictionaries, i.e. transparent access
@@ -96,7 +90,7 @@ namespace bio::ranges
  * \include test/snippet/ranges/container/dictionary_het.cpp
  *
  */
-template <typename key_t, typename mapped_t, bool mapped_t_is_context_aware = false>
+template <typename key_t, typename mapped_t>
 class dictionary
 {
 public:
@@ -108,17 +102,13 @@ class dictionary
     /*!\name Associated types
      * \{
      */
-    using mapped_ref_t =
-      std::conditional_t<mapped_t_is_context_aware, mapped_t const &, mapped_t &>; //!< Usually `mapped_t &`.
-    using value_type      = meta::tuple<key_t, mapped_t>;                          //!< The value_type type.
-    using reference       = meta::tuple<key_t const &, mapped_ref_t>;              //!< The reference type.
-    using const_reference = meta::tuple<key_t const &, mapped_t const &>;          //!< The const_reference type.
-    using difference_type = ptrdiff_t;                                             //!< The difference_type type.
-    using size_type       = size_t;                                                //!< The size_type type.
-    using const_iterator  = detail::random_access_iterator<dictionary const>;      //!< The const_iterator type.
-    using iterator        = std::conditional_t<mapped_t_is_context_aware,
-                                        const_iterator,
-                                        detail::random_access_iterator<dictionary>>; //!< The iterator type.
+    using value_type      = meta::tuple<key_t, mapped_t>;                     //!< The value_type type.
+    using reference       = meta::tuple<key_t const &, mapped_t &>;           //!< The reference type.
+    using const_reference = meta::tuple<key_t const &, mapped_t const &>;     //!< The const_reference type.
+    using difference_type = ptrdiff_t;                                        //!< The difference_type type.
+    using size_type       = size_t;                                           //!< The size_type type.
+    using iterator        = detail::random_access_iterator<dictionary>;       //!< The iterator type.
+    using const_iterator  = detail::random_access_iterator<dictionary const>; //!< The const_iterator type.
     //!\}
 
     //!\cond
@@ -536,7 +526,7 @@ class dictionary
      *
      * Basic exception guarantee.
      */
-    mapped_ref_t at(het_key_t key)
+    mapped_t & at(het_key_t key)
     {
         auto it = key_to_index.find(key);
         if (it == key_to_index.end())
@@ -570,7 +560,7 @@ class dictionary
      *
      * Basic exception guarantee.
      */
-    mapped_ref_t operator[](het_key_t key) { return at(key); }
+    mapped_t & operator[](het_key_t key) { return at(key); }
 
     //!\copydoc operator[](het_key_t key)
     mapped_t const & operator[](het_key_t key) const { return at(key); }
@@ -601,7 +591,7 @@ class dictionary
      */
     template <small_string key>
     friend decltype(auto) get(meta::decays_to<dictionary> auto && dict)
-        requires(mapped_t_is_context_aware && requires { get<key>(get<1>(dict.storage[0])); })
+        requires(requires { get<key>(get<1>(dict.storage[0])); })
     {
 #ifdef __cpp_lib_generic_unordered_lookup
         auto it = dict.key_to_index.find(key);

test/snippet/ranges/container/dictionary.cpp

@@ -11,18 +11,18 @@ int main()
     employee_status.emplace_back("Maria", "promoted");
 
     /* Access by position in dictionary; same as insert-order */
-    auto && first = employee_status[0];         // a tuple of key and mapped_value
-    fmt::print("{}\n", first);                  // prints '("Bob", "hired")'
-    //get<0>(first) = "Rob";                    // key cannot be changed
-    get<1>(first) = "tired";                    // mapped_value can be changed
-    fmt::print("{}\n", employee_status[0]);     // prints '("Bob", "tired")'
+    auto && first = employee_status[0];             // a tuple of key and mapped_value
+    fmt::print("{}\n", first);                      // prints '("Bob", "hired")'
+    //get<0>(first) = "Rob";                        // key cannot be changed
+    get<1>(first) = "tired";                        // mapped_value can be changed
+    fmt::print("{}\n", employee_status[0]);         // prints '("Bob", "tired")'
 
     /* Access by key */
-    auto && jane = employee_status["Jane"];     // the mapped_value belonging to Jane
-    fmt::print("{}\n", jane);                   // prints 'hired'
-    jane = "wired";                             // can be changed
-    fmt::print("{}\n", employee_status["Jane"]);// prints 'wired'
+    auto && janes_status = employee_status["Jane"]; // the mapped_value belonging to Jane
+    fmt::print("{}\n", janes_status);               // prints 'hired'
+    janes_status = "wired";                         // can be changed
+    fmt::print("{}\n", employee_status["Jane"]);    // prints 'wired'
 
     /* No implicit inserts like std::unordered_map */
-    //employee_status["Shane"] = "hired";       // DOES NOT WORK.
+    //employee_status["Shane"] = "hired";           // DOES NOT WORK.
 }

test/snippet/ranges/container/dictionary_het.cpp

@@ -20,6 +20,10 @@ using namespace bio::meta::literals;
  */
 struct sam_optional_field : std::variant<std::string, int32_t>
 {
+    sam_optional_field() = default;
+    using base_t = std::variant<std::string, int32_t>;
+    using base_t::base_t; // inherit constructors from variant
+
     /* Declare the get<"foo">(obj) interface; overloads for cv-qualified versions omitted here. */
     template <bio::ranges::small_string tag>
     friend decltype(auto) get(sam_optional_field const & me)
@@ -51,19 +55,24 @@ struct sam_optional_field : std::variant<std::string, int32_t>
 
 int main()
 {
-    bio::ranges::dictionary<std::string, sam_optional_field, true> sam_optional_fields;
+    bio::ranges::dictionary<std::string, sam_optional_field> sam_optional_fields;
 
     /* You can easily insert elements of different types, but you need to make sure they match the predefined IDs! */
     sam_optional_fields.emplace_back("CO", "This is a comment.");
     sam_optional_fields.emplace_back("AS", 42);                    // Alignment score 42
     sam_optional_fields.emplace_back("NM", 23);                    // Edit distance 23
     sam_optional_fields.emplace_back("OA", "23M3I11M");            // Original cigar
 
-    // std::string s = sam_optional_fields["CO"];   // ["CO"] returns sam_optional_field
-    std::string s = sam_optional_fields["CO"_vtag]; // ["CO"_vtag] returns std::string (type "inside variant")
-    fmt::print("{}\n", s);                          // prints "This is a comment."
+    // sam_optional_field s = sam_optional_fields["CO"];    // ["CO"] returns sam_optional_field
+    std::string s = sam_optional_fields["CO"_vtag];         // ["CO"_vtag] returns std::string (type "inside variant")
+    fmt::print("{}\n", s);                                  // prints "This is a comment."
+
+    // sam_optional_field i = sam_optional_fields["AS"];    // ["AS"] returns sam_optional_field
+    int32_t i = sam_optional_fields["AS"_vtag];             // ["AS"_vtag] returns int (type "inside variant")
+    fmt::print("{}\n", i);                                  // prints "42"
 
-    // int32_t i = sam_optional_fields["AS"];       // ["AS"] returns sam_optional_field
-    int32_t i = sam_optional_fields["AS"_vtag];     // ["AS"_vtag] returns int (type "inside variant")
-    fmt::print("{}\n", i);                          // prints "42"
+    /* Do not do the following: */
+    sam_optional_fields["CO"] = 3;                          // element type changed to int
+    //std::string s2 = sam_optional_fields["CO"_vtag];      // ["CO"_vtag] still returns std::string!
+                                                            // (this throws std::bad_variant_access)
 }

test/unit/ranges/container/dictionary_test.cpp

@@ -455,20 +455,11 @@ TEST(het_dictionary_test, elem_t_test)
     EXPECT_SAME_TYPE(decltype(get<"int">(elem2)), int &);
 }
 
-inline bio::ranges::dictionary<std::string, elem_t, true> dict{
+inline bio::ranges::dictionary<std::string, elem_t> dict{
   bio::meta::tuple{"string"s, elem1},
   bio::meta::tuple{   "int"s, elem2}
 };
-inline bio::ranges::dictionary<std::string, elem_t, true> const & cdict = dict;
-
-TEST(het_dictionary_test, associated_types)
-{
-    EXPECT_SAME_TYPE((bio::meta::tuple<std::string const &, elem_t const &>), decltype(dict[0]));
-    EXPECT_SAME_TYPE(elem_t const &, decltype(dict["foo"]));
-
-    EXPECT_SAME_TYPE(decltype(dict)::reference, decltype(dict)::const_reference);
-    EXPECT_SAME_TYPE(decltype(dict)::iterator, decltype(dict)::const_iterator);
-}
+inline bio::ranges::dictionary<std::string, elem_t> const & cdict = dict;
 
 TEST(het_dictionary_test, get)
 {