22 #include "simulator.h" |
22 #include "simulator.h" |
23 |
23 |
24 namespace ns3 { |
24 namespace ns3 { |
25 |
25 |
26 Time::Time () |
26 Time::Time () |
27 : m_ns (0), |
27 : m_ns (0) |
28 m_isDestroy (true) |
|
29 {} |
28 {} |
30 Time::Time (Time const &o) |
29 Time::Time (Time const &o) |
31 : m_ns (o.m_ns), |
30 : m_ns (o.m_ns) |
32 m_isDestroy (o.m_isDestroy) |
|
33 {} |
31 {} |
34 Time & |
32 Time & |
35 Time::operator = (Time const &o) |
33 Time::operator = (Time const &o) |
36 { |
34 { |
37 m_ns = o.m_ns; |
35 m_ns = o.m_ns; |
38 m_isDestroy = o.m_isDestroy; |
36 return *this; |
39 return *this; |
|
40 } |
37 } |
41 Time::Time (uint64_t ns) |
38 Time::Time (int64_t ns) |
42 : m_ns (ns), |
39 : m_ns (ns) |
43 m_isDestroy (false) |
|
44 {} |
40 {} |
45 |
41 |
46 double |
42 |
47 Time::S (void) const |
43 bool |
|
44 Time::IsNegative (void) const |
48 { |
45 { |
49 double ns = m_ns; |
46 return m_ns <= 0; |
50 ns /= 1000000000; |
|
51 return ns; |
|
52 } |
47 } |
53 uint64_t |
48 |
54 Time::Us (void) const |
49 bool |
|
50 Time::IsPositive (void) const |
55 { |
51 { |
56 uint64_t us = m_ns / 1000; |
52 return m_ns >= 0; |
57 return us; |
|
58 } |
53 } |
59 |
54 |
60 uint64_t |
55 bool |
61 Time::Ns (void) const |
56 Time::IsStrictlyNegative (void) const |
62 { |
57 { |
63 return m_ns; |
58 return m_ns < 0; |
64 } |
59 } |
65 |
60 bool |
66 bool |
61 Time::IsStrictlyPositive (void) const |
67 Time::IsDestroy (void) const |
|
68 { |
62 { |
69 return m_isDestroy; |
63 return m_ns > 0; |
|
64 } |
|
65 bool |
|
66 Time::IsZero (void) const |
|
67 { |
|
68 return m_ns == 0; |
70 } |
69 } |
71 |
70 |
72 Time |
71 Time |
73 Time::AbsS (double s) |
72 Time::operator += (Time const &o) |
74 { |
73 { |
75 int64_t ns = (int64_t)(s * 1000000000.0); |
74 m_ns += o.m_ns; |
76 return Time (ns); |
75 return *this; |
77 } |
76 } |
|
77 |
78 Time |
78 Time |
79 Time::AbsUs (uint64_t us) |
79 Time::operator -= (Time const &o) |
80 { |
80 { |
81 int64_t ns = us * 1000; |
81 m_ns -= o.m_ns; |
82 return Time (ns); |
82 return *this; |
83 } |
|
84 Time |
|
85 Time::AbsNs (uint64_t ns) |
|
86 { |
|
87 return Time (ns); |
|
88 } |
|
89 Time |
|
90 Time::RelS (double s) |
|
91 { |
|
92 int64_t ns = (int64_t)(s * 1000000000.0); |
|
93 return Time (Simulator::Now ().Ns () + ns); |
|
94 } |
|
95 Time |
|
96 Time::RelUs (uint64_t us) |
|
97 { |
|
98 return Time (Simulator::Now ().Ns () + us * 1000); |
|
99 } |
|
100 Time |
|
101 Time::RelNs (uint64_t ns) |
|
102 { |
|
103 return Time (Simulator::Now ().Ns () + ns); |
|
104 } |
83 } |
105 |
84 |
106 Time |
85 double |
107 Time::Now (void) |
86 Time::ApproximateToSeconds (void) const |
108 { |
87 { |
109 return Time (Simulator::Now ().Ns ()); |
88 double s = m_ns; |
|
89 s /= 1000000000; |
|
90 return s; |
110 } |
91 } |
111 Time |
92 uint64_t |
112 Time::Destroy (void) |
93 Time::ApproximateToMilliSeconds (void) const |
113 { |
94 { |
114 return Time (); |
95 uint64_t ms = m_ns; |
|
96 ms /= 1000000; |
|
97 return ms; |
|
98 } |
|
99 uint64_t |
|
100 Time::ApproximateToMicroSeconds (void) const |
|
101 { |
|
102 uint64_t us = m_ns; |
|
103 us /= 1000; |
|
104 return us; |
|
105 } |
|
106 uint64_t |
|
107 Time::ApproximateToNanoSeconds (void) const |
|
108 { |
|
109 return m_ns; |
115 } |
110 } |
116 |
111 |
|
112 |
|
113 /* To decrease the number of keystrokes |
|
114 */ |
|
115 static uint64_t |
|
116 GetNs (Time const &time) |
|
117 { |
|
118 return time.ApproximateToNanoSeconds (); |
|
119 } |
|
120 |
|
121 Time operator + (Time const &lhs, Time const &rhs) |
|
122 { |
|
123 return NanoSeconds (GetNs (lhs) + GetNs (rhs)); |
|
124 } |
|
125 Time operator - (Time const &lhs, Time const &rhs) |
|
126 { |
|
127 return NanoSeconds (GetNs (lhs) - GetNs (rhs)); |
|
128 } |
|
129 bool operator == (Time const &lhs, Time const &rhs) |
|
130 { |
|
131 return GetNs (lhs) == GetNs (rhs); |
|
132 } |
|
133 |
|
134 bool operator != (Time const &lhs, Time const &rhs) |
|
135 { |
|
136 return GetNs (lhs) != GetNs (rhs); |
|
137 } |
|
138 bool operator < (Time const &lhs, Time const &rhs) |
|
139 { |
|
140 return GetNs (lhs) < GetNs (rhs); |
|
141 } |
|
142 bool operator <= (Time const &lhs, Time const &rhs) |
|
143 { |
|
144 return GetNs (lhs) <= GetNs (rhs); |
|
145 } |
|
146 bool operator > (Time const &lhs, Time const &rhs) |
|
147 { |
|
148 return GetNs (lhs) > GetNs (rhs); |
|
149 } |
|
150 bool operator >= (Time const &lhs, Time const &rhs) |
|
151 { |
|
152 return GetNs (lhs) >= GetNs (rhs); |
|
153 } |
|
154 |
|
155 Now::Now () |
|
156 : Time (Simulator::Now ()) |
|
157 {} |
|
158 Seconds::Seconds (double s) |
|
159 : Time ((int64_t)(s * 1000000000)) |
|
160 {} |
|
161 MilliSeconds::MilliSeconds (int32_t ms) |
|
162 : Time ((int64_t)(ms * 1000000)) |
|
163 {} |
|
164 MicroSeconds::MicroSeconds (int32_t us) |
|
165 : Time ((int64_t)(us * 1000)) |
|
166 {} |
|
167 NanoSeconds::NanoSeconds (int64_t ns) |
|
168 : Time (ns) |
|
169 {} |
|
170 |
|
171 |
|
172 |
|
173 |
117 }; // namespace ns3 |
174 }; // namespace ns3 |