00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef TIME_H
00021 #define TIME_H
00022
00023 #include "ns3/assert.h"
00024 #include "ns3/attribute.h"
00025 #include "ns3/attribute-helper.h"
00026 #include <stdint.h>
00027 #include <math.h>
00028 #include <ostream>
00029 #include "high-precision.h"
00030 #include "cairo-wideint-private.h"
00031
00032 namespace ns3 {
00033
00034 namespace TimeStepPrecision {
00035
00036 enum precision_t {
00037 S = 0,
00038 MS = 3,
00039 US = 6,
00040 NS = 9,
00041 PS = 12,
00042 FS = 15
00043 };
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053 void Set (precision_t precision);
00054
00055
00056
00057 precision_t Get (void);
00058
00059 }
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112 template <int N>
00113 class TimeUnit
00114 {
00115 public:
00116 TimeUnit ();
00117 TimeUnit (TimeUnit const &o);
00118 TimeUnit operator = (TimeUnit const &o);
00119 TimeUnit (HighPrecision data);
00120
00121
00122
00123
00124 bool IsZero (void) const;
00125
00126
00127
00128 bool IsNegative (void) const;
00129
00130
00131
00132 bool IsPositive (void) const;
00133
00134
00135
00136 bool IsStrictlyNegative (void) const;
00137
00138
00139
00140 bool IsStrictlyPositive (void) const;
00141
00142
00143
00144
00145
00146
00147
00148
00149 HighPrecision const &GetHighPrecision (void) const;
00150 HighPrecision *PeekHighPrecision (void);
00151
00152 private:
00153 HighPrecision m_data;
00154 };
00155
00156 template <int N>
00157 TimeUnit<N>::TimeUnit ()
00158 : m_data ()
00159 {}
00160 template <int N>
00161 TimeUnit<N>::TimeUnit (TimeUnit const &o)
00162 : m_data (o.m_data)
00163 {}
00164 template <int N>
00165 TimeUnit<N>
00166 TimeUnit<N>::operator = (TimeUnit const &o)
00167 {
00168 m_data = o.m_data;
00169 return *this;
00170 }
00171 template <int N>
00172 TimeUnit<N>::TimeUnit (HighPrecision data)
00173 : m_data (data)
00174 {}
00175
00176 template <int N>
00177 HighPrecision const &
00178 TimeUnit<N>::GetHighPrecision (void) const
00179 {
00180 return m_data;
00181 }
00182 template <int N>
00183 HighPrecision *
00184 TimeUnit<N>::PeekHighPrecision (void)
00185 {
00186 return &m_data;
00187 }
00188 template <int N>
00189 bool
00190 TimeUnit<N>::IsZero (void) const
00191 {
00192 return m_data.Compare (HighPrecision::Zero ()) == 0;
00193 }
00194 template <int N>
00195 bool
00196 TimeUnit<N>::IsNegative (void) const
00197 {
00198 return m_data.Compare (HighPrecision::Zero ()) <= 0;
00199 }
00200 template <int N>
00201 bool
00202 TimeUnit<N>::IsPositive (void) const
00203 {
00204 return m_data.Compare (HighPrecision::Zero ()) >= 0;
00205 }
00206 template <int N>
00207 bool
00208 TimeUnit<N>::IsStrictlyNegative (void) const
00209 {
00210 return m_data.Compare (HighPrecision::Zero ()) < 0;
00211 }
00212 template <int N>
00213 bool
00214 TimeUnit<N>::IsStrictlyPositive (void) const
00215 {
00216 return m_data.Compare (HighPrecision::Zero ()) > 0;
00217 }
00218
00219 template <int N>
00220 bool
00221 operator == (TimeUnit<N> const &lhs, TimeUnit<N> const &rhs)
00222 {
00223 return lhs.GetHighPrecision ().Compare (rhs.GetHighPrecision ()) == 0;
00224 }
00225 template <int N>
00226 bool
00227 operator != (TimeUnit<N> const &lhs, TimeUnit<N> const &rhs)
00228 {
00229 return lhs.GetHighPrecision ().Compare (rhs.GetHighPrecision ()) != 0;
00230 }
00231 template <int N>
00232 bool
00233 operator <= (TimeUnit<N> const &lhs, TimeUnit<N> const &rhs)
00234 {
00235 return lhs.GetHighPrecision ().Compare (rhs.GetHighPrecision ()) <= 0;
00236 }
00237 template <int N>
00238 bool
00239 operator >= (TimeUnit<N> const &lhs, TimeUnit<N> const &rhs)
00240 {
00241 return lhs.GetHighPrecision ().Compare (rhs.GetHighPrecision ()) >= 0;
00242 }
00243 template <int N>
00244 bool
00245 operator < (TimeUnit<N> const &lhs, TimeUnit<N> const &rhs)
00246 {
00247 return lhs.GetHighPrecision ().Compare (rhs.GetHighPrecision ()) < 0;
00248 }
00249 template <int N>
00250 bool
00251 operator > (TimeUnit<N> const &lhs, TimeUnit<N> const &rhs)
00252 {
00253 return lhs.GetHighPrecision ().Compare (rhs.GetHighPrecision ()) > 0;
00254 }
00255 template <int N>
00256 TimeUnit<N> operator + (TimeUnit<N> const &lhs, TimeUnit<N> const &rhs)
00257 {
00258 HighPrecision retval = lhs.GetHighPrecision ();
00259 retval.Add (rhs.GetHighPrecision ());
00260 return TimeUnit<N> (retval);
00261 }
00262 template <int N>
00263 TimeUnit<N> operator - (TimeUnit<N> const &lhs, TimeUnit<N> const &rhs)
00264 {
00265 HighPrecision retval = lhs.GetHighPrecision ();
00266 retval.Sub (rhs.GetHighPrecision ());
00267 return TimeUnit<N> (retval);
00268 }
00269 template <int N1, int N2>
00270 TimeUnit<N1+N2> operator * (TimeUnit<N1> const &lhs, TimeUnit<N2> const &rhs)
00271 {
00272 HighPrecision retval = lhs.GetHighPrecision ();
00273 retval.Mul (rhs.GetHighPrecision ());
00274
00275
00276
00277 return TimeUnit<N1+N2> (retval);
00278 }
00279 template <int N1, int N2>
00280 TimeUnit<N1-N2> operator / (TimeUnit<N1> const &lhs, TimeUnit<N2> const &rhs)
00281 {
00282 NS_ASSERT (rhs.GetHighPrecision ().GetDouble () != 0);
00283 HighPrecision retval = lhs.GetHighPrecision ();
00284 retval.Div (rhs.GetHighPrecision ());
00285 return TimeUnit<N1-N2> (retval);
00286 }
00287 template <int N>
00288 TimeUnit<N> &operator += (TimeUnit<N> &lhs, TimeUnit<N> const &rhs) {
00289 HighPrecision *lhsv = lhs.PeekHighPrecision ();
00290 lhsv->Add (rhs.GetHighPrecision ());
00291 return lhs;
00292 }
00293 template <int N>
00294 TimeUnit<N> &operator -= (TimeUnit<N> &lhs, TimeUnit<N> const &rhs) {
00295 HighPrecision *lhsv = lhs.PeekHighPrecision ();
00296 lhsv->Sub (rhs.GetHighPrecision ());
00297 return lhs;
00298 }
00299
00300
00301
00302
00303
00304
00305
00306
00307 template <int N>
00308 TimeUnit<N> Abs (TimeUnit<N> const &time)
00309 {
00310 return TimeUnit<N> (Abs (time.GetHighPrecision ()));
00311 }
00312
00313
00314
00315
00316
00317
00318
00319 template <int N>
00320 TimeUnit<N> Max (TimeUnit<N> const &ta, TimeUnit<N> const &tb)
00321 {
00322 HighPrecision a = ta.GetHighPrecision ();
00323 HighPrecision b = tb.GetHighPrecision ();
00324 return TimeUnit<N> (Max (a, b));
00325 }
00326
00327
00328
00329
00330
00331
00332
00333 template <int N>
00334 TimeUnit<N> Min (TimeUnit<N> const &ta, TimeUnit<N> const &tb)
00335 {
00336 HighPrecision a = ta.GetHighPrecision ();
00337 HighPrecision b = tb.GetHighPrecision ();
00338 return TimeUnit<N> (Max (a, b));
00339 }
00340
00341
00342
00343
00344
00345 class TimeValue;
00346
00347 template <>
00348 class TimeUnit<1>
00349 {
00350
00351 public:
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369 TimeUnit<1>(const std::string& s);
00370
00371
00372
00373
00374 double GetSeconds (void) const;
00375
00376
00377
00378
00379
00380 int64_t GetMilliSeconds (void) const;
00381
00382
00383
00384
00385 int64_t GetMicroSeconds (void) const;
00386
00387
00388
00389
00390 int64_t GetNanoSeconds (void) const;
00391
00392
00393
00394
00395 int64_t GetPicoSeconds (void) const;
00396
00397
00398
00399
00400 int64_t GetFemtoSeconds (void) const;
00401
00402
00403
00404
00405 int64_t GetTimeStep (void) const;
00406
00407
00408 public:
00409 TimeUnit ()
00410 : m_data ()
00411 {}
00412 TimeUnit (TimeUnit const &o)
00413 : m_data (o.m_data) {}
00414 TimeUnit operator = (TimeUnit const &o) {
00415 m_data = o.m_data;
00416 return *this;
00417 }
00418 TimeUnit (HighPrecision data)
00419 : m_data (data) {}
00420 bool IsZero (void) const {
00421 return m_data.Compare (HighPrecision::Zero ()) == 0;
00422 }
00423 bool IsNegative (void) const {
00424 return m_data.Compare (HighPrecision::Zero ()) <= 0;
00425 }
00426 bool IsPositive (void) const {
00427 return m_data.Compare (HighPrecision::Zero ()) >= 0;
00428 }
00429 bool IsStrictlyNegative (void) const {
00430 return m_data.Compare (HighPrecision::Zero ()) < 0;
00431 }
00432 bool IsStrictlyPositive (void) const {
00433 return m_data.Compare (HighPrecision::Zero ()) > 0;
00434 }
00435 HighPrecision const &GetHighPrecision (void) const {
00436 return m_data;
00437 }
00438 HighPrecision *PeekHighPrecision (void) {
00439 return &m_data;
00440 }
00441
00442 static uint64_t UnitsToTimestep (uint64_t unitValue,
00443 uint64_t unitFactor);
00444
00445 private:
00446 HighPrecision m_data;
00447
00448
00449
00450
00451
00452
00453 int64_t ConvertToUnits (int64_t timeValue, uint64_t unitFactor) const;
00454 };
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524 typedef TimeUnit<1> Time;
00525
00526
00527 std::ostream& operator<< (std::ostream& os, const Time & time);
00528 std::istream& operator>> (std::istream& is, Time & time);
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539 Time Seconds (double seconds);
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550 Time MilliSeconds (uint64_t ms);
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560 Time MicroSeconds (uint64_t us);
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570 Time NanoSeconds (uint64_t ns);
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580 Time PicoSeconds (uint64_t ps);
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590 Time FemtoSeconds (uint64_t fs);
00591
00592
00593 Time TimeStep (uint64_t ts);
00594
00595
00596
00597 template <>
00598 class TimeUnit<0>
00599 {
00600
00601 public:
00602 double GetDouble (void) const;
00603 TimeUnit<0> (double scalar);
00604
00605
00606 public:
00607 TimeUnit ()
00608 : m_data ()
00609 {};
00610 TimeUnit (TimeUnit const &o)
00611 : m_data (o.m_data) {}
00612 TimeUnit operator = (TimeUnit const &o) {
00613 m_data = o.m_data;
00614 return *this;
00615 }
00616 TimeUnit (HighPrecision data)
00617 : m_data (data) {}
00618 bool IsZero (void) const {
00619 return m_data.Compare (HighPrecision::Zero ()) == 0;
00620 }
00621 bool IsNegative (void) const {
00622 return m_data.Compare (HighPrecision::Zero ()) <= 0;
00623 }
00624 bool IsPositive (void) const {
00625 return m_data.Compare (HighPrecision::Zero ()) >= 0;
00626 }
00627 bool IsStrictlyNegative (void) const {
00628 return m_data.Compare (HighPrecision::Zero ()) < 0;
00629 }
00630 bool IsStrictlyPositive (void) const {
00631 return m_data.Compare (HighPrecision::Zero ()) > 0;
00632 }
00633 HighPrecision const &GetHighPrecision (void) const {
00634 return m_data;
00635 }
00636 HighPrecision *PeekHighPrecision (void) {
00637 return &m_data;
00638 }
00639
00640 private:
00641 HighPrecision m_data;
00642 };
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671 typedef TimeUnit<0> Scalar;
00672
00673 typedef TimeUnit<-1> TimeInvert;
00674 typedef TimeUnit<2> TimeSquare;
00675
00676
00677
00678
00679
00680
00681
00682 ATTRIBUTE_ACCESSOR_DEFINE (Time);
00683 ATTRIBUTE_VALUE_DEFINE (Time);
00684 ATTRIBUTE_CHECKER_DEFINE (Time);
00685
00686 }
00687
00688 #endif