A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
traced-value.h
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2005,2006,2007 INRIA
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
19  */
20 #ifndef TRACED_VALUE_H
21 #define TRACED_VALUE_H
22 
23 #include "traced-callback.h"
24 #include "integer.h"
25 #include "uinteger.h"
26 #include "boolean.h"
27 #include "double.h"
28 #include "enum.h"
29 
30 #define TRACED_VALUE_DEBUG(x)
31 
32 namespace ns3 {
33 
54 template <typename T>
56 {
57 public:
59  : m_v () {}
61  : m_v (o.m_v) {}
62  TracedValue (const T &v)
63  : m_v (v) {}
64  operator T () const {
65  return m_v;
66  }
68  TRACED_VALUE_DEBUG ("x=");
69  Set (o.m_v);
70  return *this;
71  }
72  template <typename U>
73  TracedValue (const TracedValue<U> &other)
74  : m_v (other.m_v)
75  {}
76  template <typename U>
77  TracedValue (const U &other)
78  : m_v ((T)other)
79  {}
82  }
83  void Connect (const CallbackBase &cb, std::string path) {
84  m_cb.Connect (cb, path);
85  }
88  }
89  void Disconnect (const CallbackBase &cb, std::string path) {
90  m_cb.Disconnect (cb, path);
91  }
92  void Set (const T &v) {
93  if (m_v != v)
94  {
95  m_cb (m_v, v);
96  m_v = v;
97  }
98  }
99  T Get (void) const {
100  return m_v;
101  }
103  TRACED_VALUE_DEBUG ("++x");
104  T tmp = Get ();
105  ++tmp;
106  Set (tmp);
107  return *this;
108  }
110  TRACED_VALUE_DEBUG ("--x");
111  T tmp = Get ();
112  --tmp;
113  Set (tmp);
114  return *this;
115  }
117  TRACED_VALUE_DEBUG ("x++");
118  TracedValue old (*this);
119  T tmp = Get ();
120  tmp++;
121  Set (tmp);
122  return old;
123  }
125  TRACED_VALUE_DEBUG ("x--");
126  TracedValue old (*this);
127  T tmp = Get ();
128  tmp--;
129  Set (tmp);
130  return old;
131  }
132 private:
133  T m_v;
135 };
136 
137 template <typename T>
138 std::ostream& operator << (std::ostream& os, const TracedValue<T>& rhs)
139 {
140  return os<<rhs.Get ();
141 }
142 
143 template <typename T, typename U>
144 bool operator == (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
145 {
146  TRACED_VALUE_DEBUG ("x==x");
147  return lhs.Get () == rhs.Get ();
148 }
149 template <typename T, typename U>
150 bool operator == (const TracedValue<T> &lhs, const U &rhs)
151 {
152  TRACED_VALUE_DEBUG ("x==");
153  return lhs.Get () == rhs;
154 }
155 template <typename T, typename U>
156 bool operator == (const U &lhs, const TracedValue<T> &rhs)
157 {
158  TRACED_VALUE_DEBUG ("==x");
159  return lhs == rhs.Get ();
160 }
161 
162 template <typename T, typename U>
163 bool operator != (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
164 {
165  TRACED_VALUE_DEBUG ("x!=x");
166  return lhs.Get () != rhs.Get ();
167 }
168 template <typename T, typename U>
169 bool operator != (const TracedValue<T> &lhs, const U &rhs)
170 {
171  TRACED_VALUE_DEBUG ("x!=");
172  return lhs.Get () != rhs;
173 }
174 template <typename T, typename U>
175 bool operator != (const U &lhs, const TracedValue<T> &rhs)
176 {
177  TRACED_VALUE_DEBUG ("!=x");
178  return lhs != rhs.Get ();
179 }
180 
181 template <typename T, typename U>
182 bool operator <= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
183 {
184  TRACED_VALUE_DEBUG ("x<=x");
185  return lhs.Get () <= rhs.Get ();
186 }
187 template <typename T, typename U>
188 bool operator <= (const TracedValue<T> &lhs, const U &rhs)
189 {
190  TRACED_VALUE_DEBUG ("x<=");
191  return lhs.Get () <= rhs;
192 }
193 template <typename T, typename U>
194 bool operator <= (const U &lhs, const TracedValue<T> &rhs)
195 {
196  TRACED_VALUE_DEBUG ("<=x");
197  return lhs <= rhs.Get ();
198 }
199 template <typename T, typename U>
200 bool operator >= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
201 {
202  TRACED_VALUE_DEBUG ("x>=x");
203  return lhs.Get () >= rhs.Get ();
204 }
205 template <typename T, typename U>
206 bool operator >= (const TracedValue<T> &lhs, const U &rhs)
207 {
208  TRACED_VALUE_DEBUG ("x>=");
209  return lhs.Get () >= rhs;
210 }
211 template <typename T, typename U>
212 bool operator >= (const U &lhs, const TracedValue<T> &rhs)
213 {
214  TRACED_VALUE_DEBUG (">=x");
215  return lhs >= rhs.Get ();
216 }
217 
218 template <typename T, typename U>
219 bool operator < (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
220 {
221  TRACED_VALUE_DEBUG ("x<x");
222  return lhs.Get () < rhs.Get ();
223 }
224 template <typename T, typename U>
225 bool operator < (const TracedValue<T> &lhs, const U &rhs)
226 {
227  TRACED_VALUE_DEBUG ("x<");
228  return lhs.Get () < rhs;
229 }
230 template <typename T, typename U>
231 bool operator < (const U &lhs, const TracedValue<T> &rhs)
232 {
233  TRACED_VALUE_DEBUG ("<x");
234  return lhs < rhs.Get ();
235 }
236 template <typename T, typename U>
237 bool operator > (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
238 {
239  TRACED_VALUE_DEBUG ("x>x");
240  return lhs.Get () > rhs.Get ();
241 }
242 template <typename T, typename U>
243 bool operator > (const TracedValue<T> &lhs, const U &rhs)
244 {
245  TRACED_VALUE_DEBUG ("x>");
246  return lhs.Get () > rhs;
247 }
248 template <typename T, typename U>
249 bool operator > (const U &lhs, const TracedValue<T> &rhs)
250 {
251  TRACED_VALUE_DEBUG (">x");
252  return lhs > rhs.Get ();
253 }
254 template <typename T, typename U>
256  TRACED_VALUE_DEBUG ("x+=");
257  T tmp = lhs.Get ();
258  tmp += rhs;
259  lhs.Set (tmp);
260  return lhs;
261 }
262 template <typename T, typename U>
264  TRACED_VALUE_DEBUG ("x-=");
265  T tmp = lhs.Get ();
266  tmp -= rhs;
267  lhs.Set (tmp);
268  return lhs;
269 }
270 template <typename T, typename U>
272  TRACED_VALUE_DEBUG ("x*=");
273  T tmp = lhs.Get ();
274  tmp *= rhs;
275  lhs.Set (tmp);
276  return lhs;
277 }
278 template <typename T, typename U>
280  TRACED_VALUE_DEBUG ("x/=");
281  T tmp = lhs.Get ();
282  tmp /= rhs;
283  lhs.Set (tmp);
284  return lhs;
285 }
286 template <typename T, typename U>
288  TRACED_VALUE_DEBUG ("x%=");
289  T tmp = lhs.Get ();
290  tmp %= rhs;
291  lhs.Set (tmp);
292  return lhs;
293 }
294 template <typename T, typename U>
295 TracedValue<T> &operator <<= (TracedValue<T> &lhs, const U &rhs) {
296  TRACED_VALUE_DEBUG ("x<<=");
297  T tmp = lhs.Get ();
298  tmp <<= rhs;
299  lhs.Set (tmp);
300  return lhs;
301 }
302 template <typename T, typename U>
304  TRACED_VALUE_DEBUG ("x>>=");
305  T tmp = lhs.Get ();
306  tmp >>= rhs;
307  lhs.Set (tmp);
308  return lhs;
309 }
310 template <typename T, typename U>
312  TRACED_VALUE_DEBUG ("x&=");
313  T tmp = lhs.Get ();
314  tmp &= rhs;
315  lhs.Set (tmp);
316  return lhs;
317 }
318 template <typename T, typename U>
320  TRACED_VALUE_DEBUG ("x|=");
321  T tmp = lhs.Get ();
322  tmp |= rhs;
323  lhs.Set (tmp);
324  return lhs;
325 }
326 template <typename T, typename U>
328  TRACED_VALUE_DEBUG ("x^=");
329  T tmp = lhs.Get ();
330  tmp ^= rhs;
331  lhs.Set (tmp);
332  return lhs;
333 }
334 template <typename T, typename U>
336  TRACED_VALUE_DEBUG ("x+x");
337  return TracedValue<T> (lhs.Get () + rhs.Get ());
338 }
339 template <typename T, typename U>
340 TracedValue<T> operator + (const TracedValue<T> &lhs, const U &rhs) {
341  TRACED_VALUE_DEBUG ("x+");
342  return TracedValue<T> (lhs.Get () + rhs);
343 }
344 template <typename T, typename U>
345 TracedValue<T> operator + (const U &lhs, const TracedValue<T> &rhs) {
346  TRACED_VALUE_DEBUG ("+x");
347  return TracedValue<T> (lhs + rhs.Get ());
348 }
349 
350 template <typename T, typename U>
352  TRACED_VALUE_DEBUG ("x-x");
353  return TracedValue<T> (lhs.Get () - rhs.Get ());
354 }
355 template <typename T, typename U>
356 TracedValue<T> operator - (const TracedValue<T> &lhs, const U &rhs) {
357  TRACED_VALUE_DEBUG ("x-");
358  return TracedValue<T> (lhs.Get () - rhs);
359 }
360 template <typename T, typename U>
361 TracedValue<T> operator - (const U &lhs, const TracedValue<T> &rhs) {
362  TRACED_VALUE_DEBUG ("-x");
363  return TracedValue<T> (lhs - rhs.Get ());
364 }
365 
366 template <typename T, typename U>
368  TRACED_VALUE_DEBUG ("x*x");
369  return TracedValue<T> (lhs.Get () * rhs.Get ());
370 }
371 template <typename T, typename U>
372 TracedValue<T> operator * (const TracedValue<T> &lhs, const U &rhs) {
373  TRACED_VALUE_DEBUG ("x*");
374  return TracedValue<T> (lhs.Get () * rhs);
375 }
376 template <typename T, typename U>
377 TracedValue<T> operator * (const U &lhs, const TracedValue<T> &rhs) {
378  TRACED_VALUE_DEBUG ("*x");
379  return TracedValue<T> (lhs * rhs.Get ());
380 }
381 
382 template <typename T, typename U>
384  TRACED_VALUE_DEBUG ("x/x");
385  return TracedValue<T> (lhs.Get () / rhs.Get ());
386 }
387 template <typename T, typename U>
388 TracedValue<T> operator / (const TracedValue<T> &lhs, const U &rhs) {
389  TRACED_VALUE_DEBUG ("x/");
390  return TracedValue<T> (lhs.Get () / rhs);
391 }
392 template <typename T, typename U>
393 TracedValue<T> operator / (const U &lhs, const TracedValue<T> &rhs) {
394  TRACED_VALUE_DEBUG ("/x");
395  return TracedValue<T> (lhs / rhs.Get ());
396 }
397 
398 template <typename T, typename U>
400  TRACED_VALUE_DEBUG ("x%x");
401  return TracedValue<T> (lhs.Get () % rhs.Get ());
402 }
403 template <typename T, typename U>
404 TracedValue<T> operator % (const TracedValue<T> &lhs, const U &rhs) {
405  TRACED_VALUE_DEBUG ("x%");
406  return TracedValue<T> (lhs.Get () % rhs);
407 }
408 template <typename T, typename U>
409 TracedValue<T> operator % (const U &lhs, const TracedValue<T> &rhs) {
410  TRACED_VALUE_DEBUG ("%x");
411  return TracedValue<T> (lhs % rhs.Get ());
412 }
413 
414 template <typename T, typename U>
416  TRACED_VALUE_DEBUG ("x^x");
417  return TracedValue<T> (lhs.Get () ^ rhs.Get ());
418 }
419 template <typename T, typename U>
420 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const U &rhs) {
421  TRACED_VALUE_DEBUG ("x^");
422  return TracedValue<T> (lhs.Get () ^ rhs);
423 }
424 template <typename T, typename U>
425 TracedValue<T> operator ^ (const U &lhs, const TracedValue<T> &rhs) {
426  TRACED_VALUE_DEBUG ("^x");
427  return TracedValue<T> (lhs ^ rhs.Get ());
428 }
429 
430 template <typename T, typename U>
432  TRACED_VALUE_DEBUG ("x|x");
433  return TracedValue<T> (lhs.Get () | rhs.Get ());
434 }
435 template <typename T, typename U>
436 TracedValue<T> operator | (const TracedValue<T> &lhs, const U &rhs) {
437  TRACED_VALUE_DEBUG ("x|");
438  return TracedValue<T> (lhs.Get () | rhs);
439 }
440 template <typename T, typename U>
441 TracedValue<T> operator | (const U &lhs, const TracedValue<T> &rhs) {
442  TRACED_VALUE_DEBUG ("|x");
443  return TracedValue<T> (lhs | rhs.Get ());
444 }
445 
446 template <typename T, typename U>
448  TRACED_VALUE_DEBUG ("x&x");
449  return TracedValue<T> (lhs.Get () & rhs.Get ());
450 }
451 template <typename T, typename U>
452 TracedValue<T> operator & (const TracedValue<T> &lhs, const U &rhs) {
453  TRACED_VALUE_DEBUG ("x&");
454  return TracedValue<T> (lhs.Get () & rhs);
455 }
456 template <typename T, typename U>
457 TracedValue<T> operator & (const U &lhs, const TracedValue<T> &rhs) {
458  TRACED_VALUE_DEBUG ("&x");
459  return TracedValue<T> (lhs & rhs.Get ());
460 }
461 
462 template <typename T, typename U>
463 TracedValue<T> operator << (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
464  TRACED_VALUE_DEBUG ("x<<x");
465  return TracedValue<T> (lhs.Get () << rhs.Get ());
466 }
467 template <typename T, typename U>
468 TracedValue<T> operator << (const TracedValue<T> &lhs, const U &rhs) {
469  TRACED_VALUE_DEBUG ("x<<");
470  return TracedValue<T> (lhs.Get () << rhs);
471 }
472 template <typename T, typename U>
473 TracedValue<T> operator << (const U &lhs, const TracedValue<T> &rhs) {
474  TRACED_VALUE_DEBUG ("<<x");
475  return TracedValue<T> (lhs << rhs.Get ());
476 }
477 
478 template <typename T, typename U>
480  TRACED_VALUE_DEBUG ("x>>x");
481  return TracedValue<T> (lhs.Get () >> rhs.Get ());
482 }
483 template <typename T, typename U>
484 TracedValue<T> operator >> (const TracedValue<T> &lhs, const U &rhs) {
485  TRACED_VALUE_DEBUG ("x>>");
486  return TracedValue<T> (lhs.Get () >> rhs);
487 }
488 template <typename T, typename U>
489 TracedValue<T> operator >> (const U &lhs, const TracedValue<T> &rhs) {
490  TRACED_VALUE_DEBUG (">>x");
491  return TracedValue<T> (lhs >> rhs.Get ());
492 }
493 
494 
495 template <typename T>
497  TRACED_VALUE_DEBUG ("(+x)");
498  return TracedValue<T> (+lhs.Get ());
499 }
500 template <typename T>
502  TRACED_VALUE_DEBUG ("(-x)");
503  return TracedValue<T> (-lhs.Get ());
504 }
505 template <typename T>
507  TRACED_VALUE_DEBUG ("(~x)");
508  return TracedValue<T> (~lhs.Get ());
509 }
510 template <typename T>
512  TRACED_VALUE_DEBUG ("(!x)");
513  return TracedValue<T> (!lhs.Get ());
514 }
515 
516 
517 } // namespace ns3
518 
519 #endif /* TRACED_VALUE_H */
std::istream & operator>>(std::istream &is, Angles &a)
initialize a struct Angles from input
Definition: angles.cc:49
TracedValue< T > & operator%=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:287
int64x64_t operator+(const int64x64_t &lhs)
Unary plus operator.
Definition: int64x64-128.h:381
int64x64_t & operator/=(int64x64_t &lhs, const int64x64_t &rhs)
Compound division operator.
Definition: int64x64-128.h:371
TracedValue & operator=(const TracedValue &o)
Definition: traced-value.h:67
int64x64_t operator-(const int64x64_t &lhs)
Unary negation operator (change sign operator)
Definition: int64x64-128.h:389
TracedValue< T > operator~(const TracedValue< T > &lhs)
Definition: traced-value.h:506
Base class for Callback class.
Definition: callback.h:848
void Disconnect(const CallbackBase &cb, std::string path)
Definition: traced-value.h:89
int64x64_t & operator+=(int64x64_t &lhs, const int64x64_t &rhs)
Compound addition operator.
Definition: int64x64-128.h:344
void Set(const T &v)
Definition: traced-value.h:92
trace classes with value semantics
Definition: traced-value.h:55
T Get(void) const
Definition: traced-value.h:99
bool operator>=(const int64x64_t &lhs, const int64x64_t &rhs)
Greater or equal operator.
Definition: int64x64.h:154
TracedValue(const TracedValue< U > &other)
Definition: traced-value.h:73
TracedValue< T > & operator&=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:311
void ConnectWithoutContext(const CallbackBase &cb)
Definition: traced-value.h:80
int64x64_t operator*(const int64x64_t &lhs, const int64x64_t &rhs)
Multiplication operator.
Definition: int64x64.h:117
void Connect(const CallbackBase &cb, std::string path)
Definition: traced-value.h:83
void DisconnectWithoutContext(const CallbackBase &callback)
TracedValue & operator--()
Definition: traced-value.h:109
TracedValue< T > & operator^=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:327
void Disconnect(const CallbackBase &callback, std::string path)
TracedValue< T > & operator|=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:319
TracedValue(const U &other)
Definition: traced-value.h:77
int64x64_t operator/(const int64x64_t &lhs, const int64x64_t &rhs)
Division operator.
Definition: int64x64.h:128
bool operator!=(Callback< R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > a, Callback< R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > b)
Inequality test.
Definition: callback.h:1217
int64x64_t & operator*=(int64x64_t &lhs, const int64x64_t &rhs)
Compound multiplication operator.
Definition: int64x64-128.h:362
TracedValue< T > & operator>>=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:303
TracedValue(const T &v)
Definition: traced-value.h:62
TracedValue< T > operator&(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:447
void Connect(const CallbackBase &callback, std::string path)
TracedValue(const TracedValue &o)
Definition: traced-value.h:60
void ConnectWithoutContext(const CallbackBase &callback)
bool operator>(const int64x64_t &lhs, const int64x64_t &rhs)
Greater operator.
Definition: int64x64-128.h:335
bool operator==(const EventId &a, const EventId &b)
Definition: event-id.cc:89
TracedValue< T > operator^(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:415
void DisconnectWithoutContext(const CallbackBase &cb)
Definition: traced-value.h:86
#define TRACED_VALUE_DEBUG(x)
Definition: traced-value.h:30
TracedValue< T > operator|(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:431
TracedValue & operator++()
Definition: traced-value.h:102
TracedValue< T > operator%(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:399
TracedCallback< T, T > m_cb
Definition: traced-value.h:134
int64x64_t operator!(const int64x64_t &lhs)
Logical not operator.
Definition: int64x64-128.h:397
int64x64_t & operator-=(int64x64_t &lhs, const int64x64_t &rhs)
Compound subtraction operator.
Definition: int64x64-128.h:353