PMDK C++ bindings 1.13.0
This is the C++ bindings documentation for PMDK's libpmemobj.
Loading...
Searching...
No Matches
pext.hpp
Go to the documentation of this file.
1// SPDX-License-Identifier: BSD-3-Clause
2/* Copyright 2016-2020, Intel Corporation */
3
9#ifndef LIBPMEMOBJ_CPP_PEXT_HPP
10#define LIBPMEMOBJ_CPP_PEXT_HPP
11
12#include <iostream>
13#include <libpmemobj++/p.hpp>
14#include <limits>
15
16namespace pmem
17{
18
19namespace obj
20{
21
25template <typename T>
26std::ostream &
27operator<<(std::ostream &os, const p<T> &pp)
28{
29 return os << pp.get_ro();
30}
31
35template <typename T>
36std::istream &
37operator>>(std::istream &is, p<T> &pp)
38{
39 is >> pp.get_rw();
40 return is;
41}
42
46template <typename T>
47p<T> &
49{
50 ++(pp.get_rw());
51 return pp;
52}
53
57template <typename T>
58p<T> &
60{
61 --(pp.get_rw());
62 return pp;
63}
64
68template <typename T>
69p<T>
71{
72 p<T> temp = pp;
73 ++pp;
74 return temp;
75}
76
80template <typename T>
81p<T>
83{
84 p<T> temp = pp;
85 --pp;
86 return temp;
87}
88
92template <typename T, typename Y>
93p<T> &
94operator+=(p<T> &lhs, const p<Y> &rhs)
95{
96 lhs.get_rw() += rhs.get_ro();
97 return lhs;
98}
99
103template <typename T, typename Y>
104p<T> &
105operator+=(p<T> &lhs, const Y &rhs)
106{
107 lhs.get_rw() += rhs;
108 return lhs;
109}
110
114template <typename T, typename Y>
115p<T> &
116operator-=(p<T> &lhs, const p<Y> &rhs)
117{
118 lhs.get_rw() -= rhs.get_ro();
119 return lhs;
120}
121
125template <typename T, typename Y>
126p<T> &
127operator-=(p<T> &lhs, const Y &rhs)
128{
129 lhs.get_rw() -= rhs;
130 return lhs;
131}
132
136template <typename T, typename Y>
137p<T> &
138operator*=(p<T> &lhs, const p<Y> &rhs)
139{
140 lhs.get_rw() *= rhs.get_ro();
141 return lhs;
142}
143
147template <typename T, typename Y>
148p<T> &
149operator*=(p<T> &lhs, const Y &rhs)
150{
151 lhs.get_rw() *= rhs;
152 return lhs;
153}
154
158template <typename T, typename Y>
159p<T> &
160operator/=(p<T> &lhs, const p<Y> &rhs)
161{
162 lhs.get_rw() /= rhs.get_ro();
163 return lhs;
164}
165
169template <typename T, typename Y>
170p<T> &
171operator/=(p<T> &lhs, const Y &rhs)
172{
173 lhs.get_rw() /= rhs;
174 return lhs;
175}
176
180template <typename T, typename Y>
181p<T> &
182operator%=(p<T> &lhs, const p<Y> &rhs)
183{
184 lhs.get_rw() %= rhs.get_ro();
185 return lhs;
186}
187
191template <typename T, typename Y>
192p<T> &
193operator%=(p<T> &lhs, const Y &rhs)
194{
195 lhs.get_rw() %= rhs;
196 return lhs;
197}
198
202template <typename T, typename Y>
203p<T> &
204operator&=(p<T> &lhs, const p<Y> &rhs)
205{
206 lhs.get_rw() &= rhs.get_ro();
207 return lhs;
208}
209
213template <typename T, typename Y>
214p<T> &
215operator&=(p<T> &lhs, const Y &rhs)
216{
217 lhs.get_rw() &= rhs;
218 return lhs;
219}
220
224template <typename T, typename Y>
225p<T> &
226operator|=(p<T> &lhs, const p<Y> &rhs)
227{
228 lhs.get_rw() |= rhs.get_ro();
229 return lhs;
230}
231
235template <typename T, typename Y>
236p<T> &
237operator|=(p<T> &lhs, const Y &rhs)
238{
239 lhs.get_rw() |= rhs;
240 return lhs;
241}
242
246template <typename T, typename Y>
247p<T> &
248operator^=(p<T> &lhs, const p<Y> &rhs)
249{
250 lhs.get_rw() ^= rhs.get_ro();
251 return lhs;
252}
253
257template <typename T, typename Y>
258p<T> &
259operator^=(p<T> &lhs, const Y &rhs)
260{
261 lhs.get_rw() ^= rhs;
262 return lhs;
263}
264
268template <typename T, typename Y>
269p<T> &
270operator<<=(p<T> &lhs, const p<Y> &rhs)
271{
272 lhs.get_rw() = lhs.get_ro() << rhs.get_ro();
273 return lhs;
274}
275
279template <typename T, typename Y>
280p<T> &
281operator<<=(p<T> &lhs, const Y &rhs)
282{
283 lhs.get_rw() = lhs.get_ro() << rhs;
284 return lhs;
285}
286
290template <typename T, typename Y>
291p<T> &
292operator>>=(p<T> &lhs, const p<Y> &rhs)
293{
294 lhs.get_rw() = lhs.get_ro() >> rhs.get_ro();
295 return lhs;
296}
297
301template <typename T, typename Y>
302p<T> &
303operator>>=(p<T> &lhs, const Y &rhs)
304{
305 lhs.get_rw() = lhs.get_ro() >> rhs;
306 return lhs;
307}
308
309} /* namespace obj */
310
311} /* namespace pmem */
312
313namespace std
314{
318template <typename T>
319struct numeric_limits<pmem::obj::p<T>> : public numeric_limits<T> {
320
321 static constexpr bool is_specialized = true;
322};
323
327template <typename T>
328struct less<pmem::obj::p<T>> {
329 size_t
330 operator()(const pmem::obj::p<T> &lhs, const pmem::obj::p<T> &rhs) const
331 {
332 return lhs.get_ro() < rhs.get_ro();
333 }
334};
335
336} /* namespace std */
337
338#endif /* LIBPMEMOBJ_CPP_PEXT_HPP */
Resides on pmem class.
Definition: p.hpp:35
T & get_rw()
Retrieves read-write reference of the object.
Definition: p.hpp:113
const T & get_ro() const noexcept
Retrieves read-only const reference of the object.
Definition: p.hpp:128
p< T > & operator--(p< T > &pp)
Prefix decrement operator overload.
Definition: pext.hpp:59
p< T > & operator|=(p< T > &lhs, const p< Y > &rhs)
Bitwise OR assignment operator overload.
Definition: pext.hpp:226
p< T > & operator%=(p< T > &lhs, const p< Y > &rhs)
Modulo assignment operator overload.
Definition: pext.hpp:182
p< T > & operator-=(p< T > &lhs, const p< Y > &rhs)
Subtraction assignment operator overload.
Definition: pext.hpp:116
p< T > & operator/=(p< T > &lhs, const p< Y > &rhs)
Division assignment operator overload.
Definition: pext.hpp:160
p< T > & operator<<=(p< T > &lhs, const p< Y > &rhs)
Bitwise left shift assignment operator overload.
Definition: pext.hpp:270
std::ostream & operator<<(std::ostream &os, persistent_ptr< T > const &pptr)
Ostream operator for the persistent pointer.
Definition: persistent_ptr.hpp:856
p< T > & operator^=(p< T > &lhs, const p< Y > &rhs)
Bitwise XOR assignment operator overload.
Definition: pext.hpp:248
std::istream & operator>>(std::istream &is, p< T > &pp)
Istream operator overload.
Definition: pext.hpp:37
p< T > & operator>>=(p< T > &lhs, const p< Y > &rhs)
Bitwise right shift assignment operator overload.
Definition: pext.hpp:292
p< T > & operator&=(p< T > &lhs, const p< Y > &rhs)
Bitwise AND assignment operator overload.
Definition: pext.hpp:204
p< T > & operator++(p< T > &pp)
Prefix increment operator overload.
Definition: pext.hpp:48
p< T > & operator+=(p< T > &lhs, const p< Y > &rhs)
Addition assignment operator overload.
Definition: pext.hpp:94
p< T > & operator*=(p< T > &lhs, const p< Y > &rhs)
Multiplication assignment operator overload.
Definition: pext.hpp:138
Persistent memory namespace.
Definition: allocation_flag.hpp:15
Resides on pmem property template.