blob: 561beec9bb9b4b3a38ad36948b47d1c13cb7952d (
plain)
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
//
// Copyright 2010-2015 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
#ifndef INCLUDED_UHD_UTILS_DIRTY_TRACKED_HPP
#define INCLUDED_UHD_UTILS_DIRTY_TRACKED_HPP
namespace uhd{
/*!
* A class that wraps a data value with a dirty flag
* When the client uses the assignment operator on this object, the object
* automatically dirties itself if the assigned type is not equal the underlying
* data. Data can be cleaned using the mark_clean entry-point.
*
* Requirements for data_t
* - Must have a default constructor
* - Must have a copy constructor
* - Must have an assignment operator (=)
* - Must have an equality operator (==)
*/
template<typename data_t>
class dirty_tracked {
public:
/*!
* Default ctor: Initialize to default value and dirty
*/
dirty_tracked() :
_data(), //data_t must have a default ctor
_dirty(true)
{}
/*!
* Initialize to specified value and dirty
*/
dirty_tracked(const data_t& value) :
_data(value), //data_t must have a copy ctor
_dirty(true)
{}
/*!
* Copy ctor: Assign source to this type
*/
dirty_tracked(const dirty_tracked& source) {
*this = source;
}
/*!
* Get underlying data
*/
UHD_INLINE const data_t& get() const {
return _data;
}
/*!
* Has the underlying data changed since the last
* time it was cleaned?
*/
UHD_INLINE bool is_dirty() const {
return _dirty;
}
/*!
* Mark the underlying data as clean
*/
UHD_INLINE void mark_clean() {
_dirty = false;
}
/*!
* Mark the underlying data as dirty
*/
UHD_INLINE void force_dirty() {
_dirty = true;
}
/*!
* Assignment with data.
* Store the specified value and mark it as dirty
* if it is not equal to the underlying data.
*/
UHD_INLINE dirty_tracked& operator=(const data_t& value)
{
if(!(_data == value)) { //data_t must have an equality operator
_dirty = true;
_data = value; //data_t must have an assignment operator
}
return *this;
}
/*!
* Assignment with dirty tracked type.
* Store the specified value from dirty type and mark it as dirty
* if it is not equal to the underlying data.
* This exists to optimize out an implicit cast from dirty_tracked
* type to data type.
*/
UHD_INLINE dirty_tracked& operator=(const dirty_tracked& source) {
if (!(_data == source._data)) {
_dirty = true;
_data = source._data;
}
return *this;
}
/*!
* Explicit conversion from this type to data_t
*/
UHD_INLINE operator const data_t&() const {
return get();
}
private:
data_t _data;
bool _dirty;
};
} //namespace uhd
#endif /* INCLUDED_UHD_UTILS_DIRTY_TRACKED_HPP */
|
