Horizon
vector_pair.hpp
1 #pragma once
2 #include <vector>
3 #include <tuple>
4 
5 namespace horizon {
6 
7 
8 template <typename T1, typename T2> class vector_pair {
9  friend class iterator;
10 
11 private:
12  std::vector<T1> m_first;
13  std::vector<T2> m_second;
14 
15 public:
16  vector_pair() : first(m_first), second(m_second)
17  {
18  }
19 
20  void clear()
21  {
22  m_first.clear();
23  m_second.clear();
24  }
25 
26  void reserve(size_t sz)
27  {
28  m_first.reserve(sz);
29  m_second.reserve(sz);
30  }
31 
32 
33  class iterator {
34  friend class vector_pair;
35 
36  iterator(vector_pair &p, size_t i) : m_parent(p), m_idx(i)
37  {
38  }
39 
40  class vector_pair &m_parent;
41  size_t m_idx = 0;
42 
43  public:
44  void operator++()
45  {
46  m_idx++;
47  }
48 
49  bool operator!=(const iterator &other) const
50  {
51  return m_idx != other.m_idx;
52  }
53 
54  std::pair<T1 &, T2 &> operator*()
55  {
56  return {m_parent.m_first.at(m_idx), m_parent.m_second.at(m_idx)};
57  }
58  };
59 
61  friend class vector_pair;
62 
63  const_iterator(const vector_pair &p, size_t i) : m_parent(p), m_idx(i)
64  {
65  }
66 
67  const class vector_pair &m_parent;
68  size_t m_idx = 0;
69 
70  public:
71  void operator++()
72  {
73  m_idx++;
74  }
75 
76  bool operator!=(const const_iterator &other) const
77  {
78  return m_idx != other.m_idx;
79  }
80 
81  std::pair<const T1 &, const T2 &> operator*()
82  {
83  return {m_parent.m_first.at(m_idx), m_parent.m_second.at(m_idx)};
84  }
85  };
86 
87  auto begin()
88  {
89  return iterator(*this, 0);
90  }
91 
92  auto end()
93  {
94  return iterator(*this, m_first.size());
95  }
96 
97  auto begin() const
98  {
99  return const_iterator(*this, 0);
100  }
101 
102  auto end() const
103  {
104  return const_iterator(*this, m_first.size());
105  }
106 
107 
108  template <typename... Args1, typename... Args2>
109  void emplace_back(std::tuple<Args1...> args1, std::tuple<Args2...> args2)
110  {
111  std::apply([this](auto &&... args) { m_first.emplace_back(args...); }, args1);
112  std::apply([this](auto &&... args) { m_second.emplace_back(args...); }, args2);
113  }
114 
115  std::pair<T1 &, T2 &> atm(size_t idx)
116  {
117  return {m_first.at(idx), m_second.at(idx)};
118  }
119 
120  std::pair<const T1 &, const T2 &> at(size_t idx) const
121  {
122  return {m_first.at(idx), m_second.at(idx)};
123  }
124 
125  size_t size() const
126  {
127  return m_first.size();
128  }
129 
130  void erase(size_t i_first, size_t i_last)
131  {
132  m_first.erase(m_first.begin() + i_first, m_first.begin() + i_last);
133  m_second.erase(m_second.begin() + i_first, m_second.begin() + i_last);
134  }
135 
136  const std::vector<T1> &first;
137  const std::vector<T2> &second;
138 };
139 
140 } // namespace horizon
horizon::vector_pair::iterator
Definition: vector_pair.hpp:33
horizon::vector_pair::const_iterator
Definition: vector_pair.hpp:60
horizon::vector_pair
Definition: vector_pair.hpp:8