00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef TRACED_VALUE_H
00021 #define TRACED_VALUE_H
00022
00023 #include "traced-callback.h"
00024 #include "integer.h"
00025 #include "uinteger.h"
00026 #include "boolean.h"
00027 #include "double.h"
00028 #include "enum.h"
00029
00030 #define TRACED_VALUE_DEBUG(x)
00031
00032 namespace ns3 {
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052 template <typename T>
00053 class TracedValue
00054 {
00055 public:
00056 TracedValue ()
00057 : m_v () {}
00058 TracedValue (const TracedValue &o)
00059 : m_v (o.m_v) {}
00060 TracedValue (const T &v)
00061 : m_v (v) {}
00062 operator T () const {
00063 return m_v;
00064 }
00065 TracedValue &operator = (const TracedValue &o) {
00066 TRACED_VALUE_DEBUG ("x=");
00067 Set (o.m_v);
00068 return *this;
00069 }
00070 TracedValue (const IntegerValue &value)
00071 : m_v (value.Get ()) {}
00072 operator IntegerValue () const {
00073 return IntegerValue (m_v);
00074 }
00075 TracedValue (const UintegerValue &value)
00076 : m_v (value.Get ()) {}
00077 operator UintegerValue () const {
00078 return UintegerValue (m_v);
00079 }
00080 TracedValue (const BooleanValue &value)
00081 : m_v (value.Get ()) {}
00082 operator BooleanValue () const {
00083 return BooleanValue (m_v);
00084 }
00085 TracedValue (const EnumValue &value)
00086 : m_v (value.Get ()) {}
00087 operator EnumValue () const {
00088 return EnumValue (m_v);
00089 }
00090 void ConnectWithoutContext (const CallbackBase &cb) {
00091 m_cb.ConnectWithoutContext (cb);
00092 }
00093 void Connect (const CallbackBase &cb, std::string path) {
00094 m_cb.Connect (cb, path);
00095 }
00096 void DisconnectWithoutContext (const CallbackBase &cb) {
00097 m_cb.DisconnectWithoutContext (cb);
00098 }
00099 void Disconnect (const CallbackBase &cb, std::string path) {
00100 m_cb.Disconnect (cb, path);
00101 }
00102 void Set (const T &v) {
00103 if (m_v != v)
00104 {
00105 m_cb (m_v, v);
00106 m_v = v;
00107 }
00108 }
00109 T Get (void) const {
00110 return m_v;
00111 }
00112 TracedValue &operator++ () {
00113 TRACED_VALUE_DEBUG ("++x");
00114 T tmp = Get ();
00115 ++tmp;
00116 Set (tmp);
00117 return *this;
00118 }
00119 TracedValue &operator-- () {
00120 TRACED_VALUE_DEBUG ("--x");
00121 T tmp = Get ();
00122 --tmp;
00123 Set (tmp);
00124 return *this;
00125 }
00126 TracedValue operator++ (int) {
00127 TRACED_VALUE_DEBUG ("x++");
00128 TracedValue old (*this);
00129 T tmp = Get ();
00130 tmp++;
00131 Set (tmp);
00132 return old;
00133 }
00134 TracedValue operator-- (int) {
00135 TRACED_VALUE_DEBUG ("x--");
00136 TracedValue old (*this);
00137 T tmp = Get ();
00138 tmp--;
00139 Set (tmp);
00140 return old;
00141 }
00142 private:
00143 T m_v;
00144 TracedCallback<T,T> m_cb;
00145 };
00146
00147 template <typename T>
00148 std::ostream& operator << (std::ostream& os, const TracedValue<T>& rhs)
00149 {
00150 return os<<rhs.Get();
00151 }
00152
00153 template <typename T, typename U>
00154 bool operator == (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
00155 {
00156 TRACED_VALUE_DEBUG ("x==x");
00157 return lhs.Get () == rhs.Get ();
00158 }
00159 template <typename T, typename U>
00160 bool operator == (const TracedValue<T> &lhs, const U &rhs)
00161 {
00162 TRACED_VALUE_DEBUG ("x==");
00163 return lhs.Get () == rhs;
00164 }
00165 template <typename T, typename U>
00166 bool operator == (const U &lhs, const TracedValue<T> &rhs)
00167 {
00168 TRACED_VALUE_DEBUG ("==x");
00169 return lhs == rhs.Get ();
00170 }
00171
00172 template <typename T, typename U>
00173 bool operator != (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
00174 {
00175 TRACED_VALUE_DEBUG ("x!=x");
00176 return lhs.Get () != rhs.Get ();
00177 }
00178 template <typename T, typename U>
00179 bool operator != (const TracedValue<T> &lhs, const U &rhs)
00180 {
00181 TRACED_VALUE_DEBUG ("x!=");
00182 return lhs.Get () != rhs;
00183 }
00184 template <typename T, typename U>
00185 bool operator != (const U &lhs, const TracedValue<T> &rhs)
00186 {
00187 TRACED_VALUE_DEBUG ("!=x");
00188 return lhs != rhs.Get ();
00189 }
00190
00191 template <typename T, typename U>
00192 bool operator <= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
00193 {
00194 TRACED_VALUE_DEBUG ("x<=x");
00195 return lhs.Get () <= rhs.Get ();
00196 }
00197 template <typename T, typename U>
00198 bool operator <= (const TracedValue<T> &lhs, const U &rhs)
00199 {
00200 TRACED_VALUE_DEBUG ("x<=");
00201 return lhs.Get () <= rhs;
00202 }
00203 template <typename T, typename U>
00204 bool operator <= (const U &lhs, const TracedValue<T> &rhs)
00205 {
00206 TRACED_VALUE_DEBUG ("<=x");
00207 return lhs <= rhs.Get ();
00208 }
00209 template <typename T, typename U>
00210 bool operator >= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
00211 {
00212 TRACED_VALUE_DEBUG ("x>=x");
00213 return lhs.Get () >= rhs.Get ();
00214 }
00215 template <typename T, typename U>
00216 bool operator >= (const TracedValue<T> &lhs, const U &rhs)
00217 {
00218 TRACED_VALUE_DEBUG ("x>=");
00219 return lhs.Get () >= rhs;
00220 }
00221 template <typename T, typename U>
00222 bool operator >= (const U &lhs, const TracedValue<T> &rhs)
00223 {
00224 TRACED_VALUE_DEBUG (">=x");
00225 return lhs >= rhs.Get ();
00226 }
00227
00228 template <typename T, typename U>
00229 bool operator < (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
00230 {
00231 TRACED_VALUE_DEBUG ("x<x");
00232 return lhs.Get () < rhs.Get ();
00233 }
00234 template <typename T, typename U>
00235 bool operator < (const TracedValue<T> &lhs, const U &rhs)
00236 {
00237 TRACED_VALUE_DEBUG ("x<");
00238 return lhs.Get () < rhs;
00239 }
00240 template <typename T, typename U>
00241 bool operator < (const U &lhs, const TracedValue<T> &rhs)
00242 {
00243 TRACED_VALUE_DEBUG ("<x");
00244 return lhs < rhs.Get ();
00245 }
00246 template <typename T, typename U>
00247 bool operator > (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
00248 {
00249 TRACED_VALUE_DEBUG ("x>x");
00250 return lhs.Get () > rhs.Get ();
00251 }
00252 template <typename T, typename U>
00253 bool operator > (const TracedValue<T> &lhs, const U &rhs)
00254 {
00255 TRACED_VALUE_DEBUG ("x>");
00256 return lhs.Get () > rhs;
00257 }
00258 template <typename T, typename U>
00259 bool operator > (const U &lhs, const TracedValue<T> &rhs)
00260 {
00261 TRACED_VALUE_DEBUG (">x");
00262 return lhs > rhs.Get ();
00263 }
00264 template <typename T, typename U>
00265 TracedValue<T> &operator += (TracedValue<T> &lhs, const U &rhs) {
00266 TRACED_VALUE_DEBUG ("x+=");
00267 T tmp = lhs.Get ();
00268 tmp += rhs;
00269 lhs.Set (tmp);
00270 return lhs;
00271 }
00272 template <typename T, typename U>
00273 TracedValue<T> &operator -= (TracedValue<T> &lhs, const U &rhs) {
00274 TRACED_VALUE_DEBUG ("x-=");
00275 T tmp = lhs.Get ();
00276 tmp -= rhs;
00277 lhs.Set (tmp);
00278 return lhs;
00279 }
00280 template <typename T, typename U>
00281 TracedValue<T> &operator *= (TracedValue<T> &lhs, const U &rhs) {
00282 TRACED_VALUE_DEBUG ("x*=");
00283 T tmp = lhs.Get ();
00284 tmp *= rhs;
00285 lhs.Set (tmp);
00286 return lhs;
00287 }
00288 template <typename T, typename U>
00289 TracedValue<T> &operator /= (TracedValue<T> &lhs, const U &rhs) {
00290 TRACED_VALUE_DEBUG ("x/=");
00291 T tmp = lhs.Get ();
00292 tmp /= rhs;
00293 lhs.Set (tmp);
00294 return lhs;
00295 }
00296 template <typename T, typename U>
00297 TracedValue<T> &operator %= (TracedValue<T> &lhs, const U &rhs) {
00298 TRACED_VALUE_DEBUG ("x%=");
00299 T tmp = lhs.Get ();
00300 tmp %= rhs;
00301 lhs.Set (tmp);
00302 return lhs;
00303 }
00304 template <typename T, typename U>
00305 TracedValue<T> &operator <<= (TracedValue<T> &lhs, const U &rhs) {
00306 TRACED_VALUE_DEBUG ("x<<=");
00307 T tmp = lhs.Get ();
00308 tmp <<= rhs;
00309 lhs.Set (tmp);
00310 return lhs;
00311 }
00312 template <typename T, typename U>
00313 TracedValue<T> &operator >>= (TracedValue<T> &lhs, const U &rhs) {
00314 TRACED_VALUE_DEBUG ("x>>=");
00315 T tmp = lhs.Get ();
00316 tmp >>= rhs;
00317 lhs.Set (tmp);
00318 return lhs;
00319 }
00320 template <typename T, typename U>
00321 TracedValue<T> &operator &= (TracedValue<T> &lhs, const U &rhs) {
00322 TRACED_VALUE_DEBUG ("x&=");
00323 T tmp = lhs.Get ();
00324 tmp &= rhs;
00325 lhs.Set (tmp);
00326 return lhs;
00327 }
00328 template <typename T, typename U>
00329 TracedValue<T> &operator |= (TracedValue<T> &lhs, const U &rhs) {
00330 TRACED_VALUE_DEBUG ("x|=");
00331 T tmp = lhs.Get ();
00332 tmp |= rhs;
00333 lhs.Set (tmp);
00334 return lhs;
00335 }
00336 template <typename T, typename U>
00337 TracedValue<T> &operator ^= (TracedValue<T> &lhs, const U &rhs) {
00338 TRACED_VALUE_DEBUG ("x^=");
00339 T tmp = lhs.Get ();
00340 tmp ^= rhs;
00341 lhs.Set (tmp);
00342 return lhs;
00343 }
00344 template <typename T, typename U>
00345 TracedValue<T> operator + (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00346 TRACED_VALUE_DEBUG ("x+x");
00347 return TracedValue<T> (lhs.Get () + rhs.Get ());
00348 }
00349 template <typename T, typename U>
00350 TracedValue<T> operator + (const TracedValue<T> &lhs, const U &rhs) {
00351 TRACED_VALUE_DEBUG ("x+");
00352 return TracedValue<T> (lhs.Get () + rhs);
00353 }
00354 template <typename T, typename U>
00355 TracedValue<T> operator + (const U &lhs, const TracedValue<T> &rhs) {
00356 TRACED_VALUE_DEBUG ("+x");
00357 return TracedValue<T> (lhs + rhs.Get ());
00358 }
00359
00360 template <typename T, typename U>
00361 TracedValue<T> operator - (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00362 TRACED_VALUE_DEBUG ("x-x");
00363 return TracedValue<T> (lhs.Get () - rhs.Get ());
00364 }
00365 template <typename T, typename U>
00366 TracedValue<T> operator - (const TracedValue<T> &lhs, const U &rhs) {
00367 TRACED_VALUE_DEBUG ("x-");
00368 return TracedValue<T> (lhs.Get () - rhs);
00369 }
00370 template <typename T, typename U>
00371 TracedValue<T> operator - (const U &lhs, const TracedValue<T> &rhs) {
00372 TRACED_VALUE_DEBUG ("-x");
00373 return TracedValue<T> (lhs - rhs.Get ());
00374 }
00375
00376 template <typename T, typename U>
00377 TracedValue<T> operator * (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00378 TRACED_VALUE_DEBUG ("x*x");
00379 return TracedValue<T> (lhs.Get () * rhs.Get ());
00380 }
00381 template <typename T, typename U>
00382 TracedValue<T> operator * (const TracedValue<T> &lhs, const U &rhs) {
00383 TRACED_VALUE_DEBUG ("x*");
00384 return TracedValue<T> (lhs.Get () * rhs);
00385 }
00386 template <typename T, typename U>
00387 TracedValue<T> operator * (const U &lhs, const TracedValue<T> &rhs) {
00388 TRACED_VALUE_DEBUG ("*x");
00389 return TracedValue<T> (lhs - rhs.Get ());
00390 }
00391
00392 template <typename T, typename U>
00393 TracedValue<T> operator / (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00394 TRACED_VALUE_DEBUG ("x/x");
00395 return TracedValue<T> (lhs.Get () / rhs.Get ());
00396 }
00397 template <typename T, typename U>
00398 TracedValue<T> operator / (const TracedValue<T> &lhs, const U &rhs) {
00399 TRACED_VALUE_DEBUG ("x/");
00400 return TracedValue<T> (lhs.Get () / rhs);
00401 }
00402 template <typename T, typename U>
00403 TracedValue<T> operator / (const U &lhs, const TracedValue<T> &rhs) {
00404 TRACED_VALUE_DEBUG ("/x");
00405 return TracedValue<T> (lhs / rhs.Get ());
00406 }
00407
00408 template <typename T, typename U>
00409 TracedValue<T> operator % (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00410 TRACED_VALUE_DEBUG ("x%x");
00411 return TracedValue<T> (lhs.Get () % rhs.Get ());
00412 }
00413 template <typename T, typename U>
00414 TracedValue<T> operator % (const TracedValue<T> &lhs, const U &rhs) {
00415 TRACED_VALUE_DEBUG ("x%");
00416 return TracedValue<T> (lhs.Get () % rhs);
00417 }
00418 template <typename T, typename U>
00419 TracedValue<T> operator % (const U &lhs, const TracedValue<T> &rhs) {
00420 TRACED_VALUE_DEBUG ("%x");
00421 return TracedValue<T> (lhs % rhs.Get ());
00422 }
00423
00424 template <typename T, typename U>
00425 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00426 TRACED_VALUE_DEBUG ("x^x");
00427 return TracedValue<T> (lhs.Get () ^ rhs.Get ());
00428 }
00429 template <typename T, typename U>
00430 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const U &rhs) {
00431 TRACED_VALUE_DEBUG ("x^");
00432 return TracedValue<T> (lhs.Get () ^ rhs);
00433 }
00434 template <typename T, typename U>
00435 TracedValue<T> operator ^ (const U &lhs, const TracedValue<T> &rhs) {
00436 TRACED_VALUE_DEBUG ("^x");
00437 return TracedValue<T> (lhs ^ rhs.Get ());
00438 }
00439
00440 template <typename T, typename U>
00441 TracedValue<T> operator | (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00442 TRACED_VALUE_DEBUG ("x|x");
00443 return TracedValue<T> (lhs.Get () | rhs.Get ());
00444 }
00445 template <typename T, typename U>
00446 TracedValue<T> operator | (const TracedValue<T> &lhs, const U &rhs) {
00447 TRACED_VALUE_DEBUG ("x|");
00448 return TracedValue<T> (lhs.Get () | rhs);
00449 }
00450 template <typename T, typename U>
00451 TracedValue<T> operator | (const U &lhs, const TracedValue<T> &rhs) {
00452 TRACED_VALUE_DEBUG ("|x");
00453 return TracedValue<T> (lhs | rhs.Get ());
00454 }
00455
00456 template <typename T, typename U>
00457 TracedValue<T> operator & (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00458 TRACED_VALUE_DEBUG ("x&x");
00459 return TracedValue<T> (lhs.Get () & rhs.Get ());
00460 }
00461 template <typename T, typename U>
00462 TracedValue<T> operator & (const TracedValue<T> &lhs, const U &rhs) {
00463 TRACED_VALUE_DEBUG ("x&");
00464 return TracedValue<T> (lhs.Get () & rhs);
00465 }
00466 template <typename T, typename U>
00467 TracedValue<T> operator & (const U &lhs, const TracedValue<T> &rhs) {
00468 TRACED_VALUE_DEBUG ("&x");
00469 return TracedValue<T> (lhs & rhs.Get ());
00470 }
00471
00472 template <typename T, typename U>
00473 TracedValue<T> operator << (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00474 TRACED_VALUE_DEBUG ("x<<x");
00475 return TracedValue<T> (lhs.Get () << rhs.Get ());
00476 }
00477 template <typename T, typename U>
00478 TracedValue<T> operator << (const TracedValue<T> &lhs, const U &rhs) {
00479 TRACED_VALUE_DEBUG ("x<<");
00480 return TracedValue<T> (lhs.Get () << rhs);
00481 }
00482 template <typename T, typename U>
00483 TracedValue<T> operator << (const U &lhs, const TracedValue<T> &rhs) {
00484 TRACED_VALUE_DEBUG ("<<x");
00485 return TracedValue<T> (lhs << rhs.Get ());
00486 }
00487
00488 template <typename T, typename U>
00489 TracedValue<T> operator >> (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
00490 TRACED_VALUE_DEBUG ("x>>x");
00491 return TracedValue<T> (lhs.Get () >> rhs.Get ());
00492 }
00493 template <typename T, typename U>
00494 TracedValue<T> operator >> (const TracedValue<T> &lhs, const U &rhs) {
00495 TRACED_VALUE_DEBUG ("x>>");
00496 return TracedValue<T> (lhs.Get () >> rhs);
00497 }
00498 template <typename T, typename U>
00499 TracedValue<T> operator >> (const U &lhs, const TracedValue<T> &rhs) {
00500 TRACED_VALUE_DEBUG (">>x");
00501 return TracedValue<T> (lhs >> rhs.Get ());
00502 }
00503
00504
00505 template <typename T>
00506 TracedValue<T> operator + (const TracedValue<T> &lhs) {
00507 TRACED_VALUE_DEBUG ("(+x)");
00508 return TracedValue<T> (+lhs.Get ());
00509 }
00510 template <typename T>
00511 TracedValue<T> operator - (const TracedValue<T> &lhs) {
00512 TRACED_VALUE_DEBUG ("(-x)");
00513 return TracedValue<T> (-lhs.Get ());
00514 }
00515 template <typename T>
00516 TracedValue<T> operator ~ (const TracedValue<T> &lhs) {
00517 TRACED_VALUE_DEBUG ("(~x)");
00518 return TracedValue<T> (~lhs.Get ());
00519 }
00520 template <typename T>
00521 TracedValue<T> operator ! (const TracedValue<T> &lhs) {
00522 TRACED_VALUE_DEBUG ("(!x)");
00523 return TracedValue<T> (!lhs.Get ());
00524 }
00525
00526
00527 }
00528
00529 #endif