qxLib
generic_span.h
Go to the documentation of this file.
1 /**
2 
3  @file generic_span.h
4  @author Khrapov
5  @date 20.11.2022
6  @copyright (c) Nick Khrapov, 2022. All right reserved.
7 
8 **/
9 #pragma once
10 
11 #include <qx/meta/qualifiers.h>
12 
13 #include <functional>
14 #include <memory>
15 
16 namespace qx
17 {
18 
20 {
21  template<class... args_t>
22  using function_type = std::function<args_t...>;
23 };
24 
25 /**
26 
27  @class generic_span
28  @brief Same as std::span, but may be used with any container with forward iterators
29  @details The class can be used to use any container to iterate over its elements
30  Useful when used in virtual methods
31  Does not own the container
32  The container should not be changed until the end of the iteration
33  May be much slower then std::span when the size of sbo of std::function
34  is smaller then sizeof 2 iterators of this container
35  (libcpp: 16, ligcxx: 16, MSVC: 56)
36  @tparam T - container value type
37  @author Khrapov
38  @date 20.11.2022
39 
40 **/
41 template<class T, class traits_t = default_generic_span_traits>
43 {
44  template<class container_t>
45  using container_value = std::remove_reference_t<decltype(*std::declval<container_t>().begin())>;
46 
47  template<class target_t>
48  using qualified_type = copy_qualifiers_t<std::remove_reference_t<std::remove_pointer_t<T>>, target_t>;
49 
50 public:
51  using traits = traits_t;
52  template<class... args_t>
53  using function_type = typename traits_t::template function_type<args_t...>;
54  using generator_type = function_type<T*()>;
55 
56  using element_type = T;
57  using value_type = std::remove_cv_t<T>;
58  using pointer = T*;
59  using reference = T&;
60 
61  class iterator
62  {
63  public:
64  using value_type = T;
65  using pointer = T*;
66  using reference = T&;
67  using difference_type = std::ptrdiff_t;
68  using size_type = size_t;
69  using iterator_category = std::forward_iterator_tag;
70  using iterator_concept = std::forward_iterator_tag;
71 
72  public:
73  iterator() noexcept = default;
74  iterator(const iterator&) noexcept = default;
75  iterator(generator_type generator, size_type nIndex) noexcept;
76  [[nodiscard]] reference operator*() const noexcept;
77  [[nodiscard]] pointer operator->() const noexcept;
78  iterator& operator++() noexcept;
79  [[nodiscard]] iterator operator++(int) noexcept;
80  bool operator!=(const iterator& r) const noexcept;
81  bool operator==(const iterator& r) const noexcept;
82  operator void*() const noexcept;
83  operator bool() const noexcept;
84 
85  private:
86  generator_type m_Generator;
87  size_type m_nIndex = 0;
88  };
89 
90 public:
91  generic_span() noexcept = default;
92  generic_span(generic_span&&) noexcept = default;
93  generic_span(const generic_span&) noexcept = default;
94 
95  /**
96  @brief generic_span object constructor
97  @tparam container_t - any container, which adapter satisfies forward iterator concept
98  @param container - container instance. container must not be edited until adapter death
99  **/
100  template<class container_t>
101  generic_span(container_t& container) noexcept;
102 
103  /**
104  @brief generic_span object constructor
105  @tparam container_t - any container, which adapter satisfies forward iterator concept
106  @param container - container instance. container must not be edited until adapter death
107  @param valueAdapter - function which transforms Container::value_type to T*
108  **/
109  template<class container_t>
110  generic_span(
111  container_t& container,
112  function_type<reference(qualified_type<container_value<container_t>>&)> valueAdapter) noexcept;
113 
114  /**
115  @brief operator=
116  @tparam container_t - any container, which adapter satisfies forward iterator concept
117  @param container - container instance. container must not be edited until adapter death
118  @return - this object reference
119  **/
120  template<class container_t>
121  generic_span& operator=(container_t& container) noexcept;
122 
123  generic_span& operator=(generic_span&&) noexcept = default;
124  generic_span& operator=(const generic_span&) noexcept = default;
125 
126  /**
127  @brief Check if span is empty
128  @return - true if empty
129  **/
130  bool empty() const noexcept;
131 
132  /**
133  @brief Return iterator to beginning
134  @return - iterator to beginning
135  **/
136  iterator begin() const noexcept;
137 
138  /**
139  @brief Return iterator to end
140  @return - iterator to end
141  **/
142  iterator end() const noexcept;
143 
144  /**
145  @brief Return const iterator to beginning
146  @return - const iterator to beginning
147  **/
148  iterator cbegin() const noexcept;
149 
150  /**
151  @brief Return const iterator to end
152  @return - const iterator to end
153  **/
154  iterator cend() const noexcept;
155 
156 private:
157  /**
158  @brief Create initial generator
159  @tparam container_t - any container, which adapter satisfies forward iterator concept
160  @tparam adapter_t - adapter callable type
161  @param container - container instance. container must not be edited until adapter death
162  @param adapter - function which transforms Container::value_type to T*
163  @return - values generator
164  **/
165  template<class container_t, class adapter_t>
166  static generator_type create_initial_generator(container_t&& container, adapter_t adapter) noexcept;
167 
168 private:
169  generator_type m_InitialGenerator;
170 };
171 
172 } // namespace qx
173 
174 #include <qx/patterns/generic_span.inl>
Same as std::span, but may be used with any container with forward iterators.
Definition: generic_span.h:43
iterator begin() const noexcept
Return iterator to beginning.