Basic associative container requiring unique, Comparable and Hashable keys.
The order of the elements of the map is unspecified. Also, all the keys must be Hashable, and any two keys with equal hashes must be Comparable with each other at compile-time.
hana::map is implementation-defined. In particular, one should not take for granted the order of the template parameters and the presence of any additional constructors or assignment operators than what is documented. The canonical way of creating a hana::map is through hana::make_map.ComparableSearchableLogical. Also note that operator[] can be used instead of at_key. FoldableFoldable Any Foldable of Products can be converted to a hana::map with hana::to<hana::map_tag> or, equivalently, hana::to_map. If the Foldable contains duplicate keys, only the value associated to the first occurence of each key is kept.
Synopsis of associated functions | |
| template<> | |
| constexpr auto | make< map_tag > |
Function object for creating a hana::map. More... | |
| constexpr auto | make_map = make<map_tag> |
Alias to make<map_tag>; provided for convenience. More... | |
| constexpr auto | to_map = to<map_tag> |
Equivalent to to<map_tag>; provided for convenience. More... | |
| constexpr auto | keys |
Returns a Sequence of the keys of the map, in unspecified order. More... | |
| constexpr auto | values |
Returns a Sequence of the values of the map, in unspecified order. More... | |
| constexpr auto | insert |
| Inserts a new key/value pair in a map. More... | |
| constexpr auto | erase_key |
| Removes a key/value pair from a map. More... | |
Friends | |
| template<typename X , typename Y > | |
| constexpr auto | operator== (X &&x, Y &&y) |
Equivalent to hana::equal | |
| template<typename X , typename Y > | |
| constexpr auto | operator!= (X &&x, Y &&y) |
Equivalent to hana::not_equal | |
Public Member Functions | |
| constexpr | map ()=default |
| Default-construct a map. This constructor only exists when all the elements of the map are default-constructible. | |
| constexpr | map (map const &other)=default |
| Copy-construct a map from another map. This constructor only exists when all the elements of the map are copy-constructible. | |
| constexpr | map (map &&other)=default |
| Move-construct a map from another map. This constructor only exists when all the elements of the map are move-constructible. | |
| template<typename Key > | |
| decltype(auto) constexpr | operator[] (Key &&key) |
Equivalent to hana::at_key | |
Function object for creating a hana::map.
Given zero or more Products representing key/value associations, make<map_tag> returns a hana::map associating these keys to these values.
make<map_tag> requires all the keys to be unique and to have different hashes. If you need to create a map with duplicate keys or with keys whose hashes might collide, use hana::to_map or insert (key, value) pairs to an empty map successively. However, be aware that doing so will be much more compile-time intensive than using make<map_tag>, because the uniqueness of keys will have to be enforced.
Alias to make<map_tag>; provided for convenience.
Equivalent to to<map_tag>; provided for convenience.
|
related |
Returns a Sequence of the keys of the map, in unspecified order.
|
related |
Returns a Sequence of the values of the map, in unspecified order.
|
related |
Inserts a new key/value pair in a map.
Given a (key, value) pair, insert inserts this new pair into a map. If the map already contains this key, nothing is done and the map is returned as-is.
| map | The map in which to insert a (key,value) pair. |
| pair | An arbitrary Product representing a (key, value) pair to insert in the map. The key must be compile-time Comparable. |
|
related |
Removes a key/value pair from a map.
Returns a new hana::map containing all the elements of the original, except for the (key, value) pair whose key compares equal to the given key. If the map does not contain such an element, a new map equal to the original is returned.
| map | The map in which to erase a key. |
| key | A key to remove from the map. It must be compile-time Comparable. |