A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://timsong-cpp.github.io/cppwp/n4659/container.node.overview below:

[container.node.overview]

26 Containers library [containers] 26.2 Container requirements [container.requirements] 26.2.4 Node handles [container.node] 26.2.4.1 node_­handle overview [container.node.overview]

A node handle is an object that accepts ownership of a single element from an associative container or an unordered associative container. It may be used to transfer that ownership to another container with compatible nodes. Containers with compatible nodes have the same node handle type. Elements may be transferred in either direction between container types in the same row of Table 89.

Table

89

— Container types with compatible nodes


map<K, T, C1, A> map<K, T, C2, A> map<K, T, C1, A> multimap<K, T, C2, A> set<K, C1, A> set<K, C2, A> set<K, C1, A> multiset<K, C2, A> unordered_­map<K, T, H1, E1, A> unordered_­map<K, T, H2, E2, A> unordered_­map<K, T, H1, E1, A> unordered_­multimap<K, T, H2, E2, A> unordered_­set<K, H1, E1, A> unordered_­set<K, H2, E2, A> unordered_­set<K, H1, E1, A> unordered_­multiset<K, H2, E2, A>

If a node handle is not empty, then it contains an allocator that is equal to the allocator of the container when the element was extracted. If a node handle is empty, it contains no allocator.

Class node_­handle is for exposition only. An implementation is permitted to provide equivalent functionality without providing a class with this name.

If a user-defined specialization of pair exists for pair<const Key, T> or pair<Key, T>, where Key is the container's key_­type and T is the container's mapped_­type, the behavior of operations involving node handles is undefined.

template<unspecified>
  class node_handle {
  public:
        using value_type     = see below;       using key_type       = see below;       using mapped_type    = see below;       using allocator_type = see below;

  private:
    using container_node_type = unspecified;
    using ator_traits = allocator_traits<allocator_type>;

    typename ator_traits::rebind_traits<container_node_type>::pointer ptr_;
    optional<allocator_type> alloc_;

  public:
    constexpr node_handle() noexcept : ptr_(), alloc_() {}
    ~node_handle();
    node_handle(node_handle&&) noexcept;
    node_handle& operator=(node_handle&&);

    value_type& value() const;              key_type& key() const;                  mapped_type& mapped() const;        
    allocator_type get_allocator() const;
    explicit operator bool() const noexcept;
    bool empty() const noexcept;

    void swap(node_handle&)
      noexcept(ator_traits::propagate_on_container_swap::value ||
               ator_traits::is_always_equal::value);

    friend void swap(node_handle& x, node_handle& y) noexcept(noexcept(x.swap(y))) {
      x.swap(y);
    }
};

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4