sg/mapiterator.hpp at master · user1095108/sg · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#ifndef SG_MAPITERATOR_HPP
# define SG_MAPITERATOR_HPP
# pragma once

#include <iterator>

#include <type_traits>

namespace sg
{

template <typename T>
class mapiterator
{
  using iterator_t = mapiterator<std::remove_const_t<T>>;
  friend mapiterator<T const>;

  T* n_;
  T* const* r_;

public:
  using iterator_category = std::bidirectional_iterator_tag;
  using difference_type = detail::difference_type;
  using value_type = std::conditional_t<
      std::is_const_v<T>,
      typename T::value_type const,
      typename T::value_type
    >;

  using pointer = value_type*;
  using reference = value_type&;

public:
  mapiterator() = default;

  mapiterator(T* const* const r, T* const n = {}) noexcept:
    n_(n),
    r_(r)
  {
  }

  mapiterator(mapiterator const&) = default;
  mapiterator(mapiterator&&) = default;

  mapiterator(iterator_t const& o) noexcept requires(std::is_const_v<T>):
    n_(o.n_),
    r_(o.r_)
  {
  }

  //
  mapiterator& operator=(mapiterator const&) = default;
  mapiterator& operator=(mapiterator&&) = default;

  mapiterator& operator=(iterator_t const& o) noexcept
    requires(std::is_const_v<T>)
  {
    n_ = o.n_; r_ = o.r_; return *this;
  }

  bool operator==(mapiterator const& o) const noexcept { return n_ == o.n_; }

  // increment, decrement
  auto& operator++() noexcept
  {
    n_ = detail::next_node(*r_, n_); return *this;
  }

  auto& operator--() noexcept
  {
    n_ = n_ ? detail::prev_node(*r_, n_) : detail::last_node(*r_);

    return *this;
  }

  mapiterator operator++(int) noexcept
  {
    auto const n(n_); n_ = detail::next_node(*r_, n_); return {n, r_};
  }

  mapiterator operator--(int) noexcept
  {
    auto const n(n_);

    n_ = n_ ? detail::prev_node(*r_, n_) : detail::last_node(*r_);

    return {n, r_};
  }

  // member access
  auto operator->() const noexcept { return &n_->kv_; }
  auto& operator*() const noexcept { return n_->kv_; }

  //
  explicit operator bool() const noexcept { return n_; }
};

}

#endif // SG_MAPITERATOR_HPP