Line data Source code
1 : //
2 : // Author: Vladimir Migashko <migashko@gmail.com>, (C) 2012
3 : //
4 : // Copyright: See COPYING file that comes with this distribution
5 : //
6 :
7 : #ifndef VSET_VSET_ALLOCATOR_OFFSET_POINTER_HPP
8 : #define VSET_VSET_ALLOCATOR_OFFSET_POINTER_HPP
9 :
10 : #include <iterator>
11 : #include <fas/system/nullptr.hpp>
12 :
13 : namespace vset { namespace memory{
14 :
15 : /**
16 : * @brief Указатель для перемещения в буфере менеджера памяти vset::memory::manager
17 : */
18 : template<typename T, typename M>
19 : class offset_pointer
20 : {
21 : public:
22 : typedef offset_pointer<T, M> self;
23 : typedef M offset_provider;
24 : typedef T value_type;
25 : typedef typename std::iterator_traits<value_type*>::iterator_category iterator_category;
26 : typedef typename std::iterator_traits<value_type*>::difference_type difference_type;
27 : typedef typename std::iterator_traits<value_type*>::pointer pointer;
28 : typedef typename std::iterator_traits<value_type*>::reference reference;
29 :
30 4 : offset_pointer()
31 : : _provider()
32 4 : , _offset(static_cast<size_t>(-1))
33 : {
34 4 : }
35 :
36 61696 : explicit offset_pointer(offset_provider provider, size_t offset = static_cast<size_t>(-1) )
37 : : _provider(provider)
38 61696 : , _offset(offset)
39 : {
40 61696 : }
41 :
42 :
43 10857 : operator value_type* ()
44 : {
45 10857 : return this->get_address();
46 : }
47 :
48 : operator const value_type* () const
49 : {
50 : return this->get_address();
51 : }
52 :
53 :
54 22511 : value_type& operator*()
55 : {
56 22511 : return *(this->get_address());
57 : }
58 :
59 : const value_type& operator*() const
60 : {
61 : return *(this->get_address());
62 : }
63 :
64 2701953 : value_type* operator->()
65 : {
66 2701953 : return this->get_address();
67 : }
68 :
69 4407 : const value_type* operator->() const
70 : {
71 4407 : return this->get_address();
72 : }
73 :
74 :
75 : value_type& get_ref()
76 : {
77 : return *(this->get_address());
78 : }
79 :
80 : const value_type& get_ref() const
81 : {
82 : return *(this->get_address());
83 : }
84 :
85 : const value_type& get_cref() const
86 : {
87 : return *(this->get_address());
88 : }
89 :
90 2749214 : value_type* get_address()
91 : {
92 2749214 : if ( _offset == static_cast<size_t>(-1) )
93 12 : return fas_nullptr;
94 2749202 : return _provider.get(_offset);
95 : }
96 :
97 4407 : const value_type* get_address() const
98 : {
99 4407 : if ( _offset == static_cast<size_t>(-1) )
100 0 : return fas_nullptr;
101 4407 : return _provider.get(_offset);
102 : }
103 :
104 11622 : size_t set_address(value_type* t)
105 : {
106 11622 : _offset = _provider.offset(t);
107 11622 : return _offset;
108 : }
109 :
110 32384 : size_t get_offset() const
111 : {
112 32384 : return _offset;
113 : }
114 :
115 722823 : void set_offset(size_t offset)
116 : {
117 722823 : _offset = offset;
118 722823 : }
119 :
120 : bool is_null() const
121 : {
122 : return _offset == static_cast<size_t>(-1);
123 : }
124 :
125 94050 : self& operator++()
126 : {
127 94050 : _offset = _provider.next(_offset);
128 94050 : return *this;
129 : }
130 :
131 : self operator++(int)
132 : {
133 : self ans = *this;
134 : _offset = _provider.next(_offset);
135 : return ans;
136 : }
137 :
138 12342 : self& operator--()
139 : {
140 12342 : _offset = _provider.pred(_offset);
141 12342 : return *this;
142 : }
143 :
144 : self operator--(int)
145 : {
146 : self ans = *this;
147 : _offset = _provider.pred(_offset);
148 : return ans;
149 : }
150 :
151 116600 : bool operator == (const self& r ) const
152 : {
153 116600 : return _offset == r._offset && _provider==r._provider ;
154 : }
155 :
156 116597 : bool operator != (const self& r ) const
157 : {
158 116597 : return !this->operator == (r);
159 : }
160 :
161 : bool operator < (const self& r ) const
162 : {
163 : return _offset < r._offset;
164 : }
165 :
166 : bool operator > (const self& r ) const
167 : {
168 : return _offset > r._offset;
169 : }
170 :
171 : bool operator <= (const self& r ) const
172 : {
173 : return !this->operator >( r );
174 : }
175 :
176 : bool operator >= (const self& r ) const
177 : {
178 : return !this->operator < ( r );
179 : }
180 :
181 30015 : self& operator += (difference_type n )
182 : {
183 30015 : if ( n >= 0 )
184 20010 : _offset = _provider.next( _offset, static_cast<size_t>(n) );
185 : else
186 10005 : return this->operator -= ( -1 * n );
187 20010 : return *this;
188 : }
189 :
190 20010 : self& operator -= (difference_type n )
191 : {
192 20010 : if ( n >= 0 )
193 10005 : _offset = _provider.pred( _offset, static_cast<size_t>(n) );
194 : else
195 10005 : return this->operator += ( -1 * n );
196 10005 : return *this;
197 : }
198 :
199 : reference operator[] ( difference_type n )
200 : {
201 : return *(_provider.get( _provider.next( _offset, static_cast<size_t>(n) ) ));
202 : /*return *(_provider.get( _offset + sizeof(value_type)*n ));*/
203 : }
204 :
205 : const reference operator[] ( difference_type n ) const
206 : {
207 : return *(_provider.get( _provider.next( _offset, static_cast<size_t>(n) ) ));
208 : /*return *(_provider.get( _offset + sizeof(value_type)*n ));*/
209 : }
210 :
211 : private:
212 : offset_provider _provider;
213 : size_t _offset;
214 : };
215 :
216 :
217 : template<typename T, typename M, typename Dist>
218 : inline offset_pointer<T, M> operator +
219 : (
220 : offset_pointer<T, M> r,
221 : Dist n
222 : )
223 : {
224 : return r+=n;
225 : }
226 :
227 : template<typename T, typename M, typename Dist>
228 : inline offset_pointer<T, M> operator +
229 : (
230 : Dist n,
231 : offset_pointer<T, M> r
232 : )
233 : {
234 : return r+= n;
235 : }
236 :
237 : template<typename T, typename M, typename Dist>
238 : inline offset_pointer<T, M> operator -
239 : (
240 : offset_pointer<T, M> r,
241 : Dist n
242 : )
243 : {
244 : return r-= n;
245 : }
246 :
247 : template<typename T, typename M, typename Dist>
248 : inline offset_pointer<T, M> operator -
249 : (
250 : Dist n,
251 : offset_pointer<T, M> r
252 : )
253 : {
254 : return r -= n;
255 : }
256 :
257 : template<typename T, typename M>
258 20213 : inline typename offset_pointer<T, M>::difference_type operator -
259 : (
260 : offset_pointer<T, M> r1,
261 : offset_pointer<T, M> r2
262 : )
263 : {
264 20213 : typename offset_pointer<T, M>::difference_type dist = 0;
265 20213 : for ( ;r2!=r1; ++r2) ++dist;
266 20213 : return dist;
267 : }
268 :
269 : }}
270 :
271 : #endif
|
