Debian Codegraph @

src/mpt/base/alloc.hpp

raw
1 /* SPDX-License-Identifier: BSL-1.0 OR BSD-3-Clause */
2
3 #ifndef MPT_BASE_ALLOC_HPP
4 #define MPT_BASE_ALLOC_HPP
5
6
7
8 #include "mpt/base/namespace.hpp"
9
10 #include "mpt/base/memory.hpp"
11 #include "mpt/base/span.hpp"
12
13 #include <iterator>
14 #include <memory>
15 #include <string>
16 #include <type_traits>
17 #include <utility>
18 #include <vector>
19
20
21
22 namespace mpt {
23 inline namespace MPT_INLINE_NS {
24
25
26
27 template <typename T>
28 inline mpt::span<T> as_span(std::vector<T> & cont) {
29 return mpt::span<T>(cont.data(), cont.data() + cont.size());
30 }
31
32 template <typename T>
33 inline mpt::span<const T> as_span(const std::vector<T> & cont) {
34 return mpt::span<const T>(cont.data(), cont.data() + cont.size());
35 }
36
37 template <typename T>
38 inline span<T> as_span(std::basic_string<T> & str) {
39 return span<T>(str.data(), str.size());
40 }
41
42 template <typename T>
43 inline span<const T> as_span(const std::basic_string<T> & str) {
44 return span<const T>(str.data(), str.size());
45 }
46
47
48
49 template <typename T>
50 inline std::vector<typename std::remove_const<T>::type> make_vector(T * beg, T * end) {
51 return std::vector<typename std::remove_const<T>::type>(beg, end);
52 }
53
54 template <typename T>
55 inline std::vector<typename std::remove_const<T>::type> make_vector(T * data, std::size_t size) {
56 return std::vector<typename std::remove_const<T>::type>(data, data + size);
57 }
58
59 template <typename T>
60 inline std::vector<typename std::remove_const<T>::type> make_vector(mpt::span<T> data) {
61 return std::vector<typename std::remove_const<T>::type>(data.data(), data.data() + data.size());
62 }
63
64 template <typename T, std::size_t N>
65 inline std::vector<typename std::remove_const<T>::type> make_vector(T (&arr)[N]) {
66 return std::vector<typename std::remove_const<T>::type>(std::begin(arr), std::end(arr));
67 }
68
69 template <typename T>
70 inline std::vector<typename std::remove_const<T>::type> make_vector(const std::basic_string<T> & str) {
71 return std::vector<typename std::remove_const<T>::type>(str.begin(), str.end());
72 }
73
74
75
76 template <typename T>
77 inline std::basic_string<typename std::remove_const<T>::type> make_basic_string(T * beg, T * end) {
78 return std::basic_string<typename std::remove_const<T>::type>(beg, end);
79 }
80
81 template <typename T>
82 inline std::basic_string<typename std::remove_const<T>::type> make_basic_string(T * data, std::size_t size) {
83 return std::basic_string<typename std::remove_const<T>::type>(data, data + size);
84 }
85
86 template <typename T>
87 inline std::basic_string<typename std::remove_const<T>::type> make_basic_string(mpt::span<T> data) {
88 return std::basic_string<typename std::remove_const<T>::type>(data.data(), data.data() + data.size());
89 }
90
91 template <typename T, std::size_t N>
92 inline std::basic_string<typename std::remove_const<T>::type> make_basic_string(T (&arr)[N]) {
93 return std::basic_string<typename std::remove_const<T>::type>(std::begin(arr), std::end(arr));
94 }
95
96 template <typename T>
97 inline std::basic_string<typename std::remove_const<T>::type> make_basic_string(const std::vector<T> & str) {
98 return std::vector<typename std::remove_const<T>::type>(str.begin(), str.end());
99 }
100
101
102
103 template <typename Tcont2, typename Tcont1>
104 inline Tcont1 & append(Tcont1 & cont1, const Tcont2 & cont2) {
105 cont1.insert(cont1.end(), cont2.begin(), cont2.end());
106 return cont1;
107 }
108
109 template <typename Tit2, typename Tcont1>
110 inline Tcont1 & append(Tcont1 & cont1, Tit2 beg, Tit2 end) {
111 cont1.insert(cont1.end(), beg, end);
112 return cont1;
113 }
114
115
116
117 template <typename Tdst, typename Tsrc>
118 struct buffer_cast_impl {
119 inline Tdst operator()(const Tsrc & src) const {
120 return Tdst(mpt::byte_cast<const typename Tdst::value_type *>(src.data()), mpt::byte_cast<const typename Tdst::value_type *>(src.data()) + src.size());
121 }
122 };
123
124 // casts between vector<->string of byte-castable types
125 template <typename Tdst, typename Tsrc>
126 inline Tdst buffer_cast(const Tsrc & src) {
127 return buffer_cast_impl<Tdst, Tsrc>()(src);
128 }
129
130
131
132 template <typename T>
133 struct as_raw_memory_impl<std::vector<T>> {
134 inline mpt::const_byte_span operator()(const std::vector<T> & v) const {
135 static_assert(mpt::is_binary_safe<typename std::remove_const<T>::type>::value);
136 return mpt::as_span(reinterpret_cast<const std::byte *>(v.data()), v.size() * sizeof(T));
137 }
138 inline mpt::byte_span operator()(std::vector<T> & v) const {
139 static_assert(mpt::is_binary_safe<typename std::remove_const<T>::type>::value);
140 return mpt::as_span(reinterpret_cast<std::byte *>(v.data()), v.size() * sizeof(T));
141 }
142 };
143
144 template <typename T>
145 struct as_raw_memory_impl<const std::vector<T>> {
146 inline mpt::const_byte_span operator()(const std::vector<T> & v) const {
147 static_assert(mpt::is_binary_safe<typename std::remove_const<T>::type>::value);
148 return mpt::as_span(reinterpret_cast<const std::byte *>(v.data()), v.size() * sizeof(T));
149 }
150 };
151
152
153
154 template <typename T>
155 class heap_value {
156 private:
157 std::unique_ptr<T> m_value{};
158
159 public:
160 template <typename... Targs>
161 heap_value(Targs &&... args)
162 : m_value(std::make_unique<T>(std::forward<Targs>(args)...)) {
163 return;
164 }
165 const T & operator*() const {
166 return *m_value;
167 }
168 T & operator*() {
169 return *m_value;
170 }
171 const T * operator->() const {
172 return m_value.get();
173 }
174 T * operator->() {
175 return m_value.get();
176 }
177 const T * get() const {
178 return m_value.get();
179 }
180 T * get() {
181 return m_value.get();
182 }
183 };
184
185
186
187 } // namespace MPT_INLINE_NS
188 } // namespace mpt
189
190
191
192 #endif // MPT_BASE_ALLOC_HPP