00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "data-rate.h"
00022 #include "ns3/nstime.h"
00023 #include "ns3/fatal-error.h"
00024
00025
00026 static bool
00027 DoParse (const std::string s, uint64_t *v)
00028 {
00029 std::string::size_type n = s.find_first_not_of("0123456789.");
00030 if (n != std::string::npos)
00031 {
00032 std::istringstream iss;
00033 iss.str (s.substr(0, n));
00034 double r;
00035 iss >> r;
00036 std::string trailer = s.substr(n, std::string::npos);
00037 if (trailer == "bps")
00038 {
00039
00040 *v = (uint64_t)r;
00041 }
00042 else if (trailer == "b/s")
00043 {
00044
00045 *v = (uint64_t)r;
00046 }
00047 else if (trailer == "Bps")
00048 {
00049
00050 *v = (uint64_t)(r * 8);
00051 }
00052 else if (trailer == "B/s")
00053 {
00054
00055 *v = (uint64_t)(r * 8);
00056 }
00057 else if (trailer == "kbps")
00058 {
00059
00060 *v = (uint64_t)(r * 1000);
00061 }
00062 else if (trailer == "kb/s")
00063 {
00064
00065 *v = (uint64_t)(r * 1000);
00066 }
00067 else if (trailer == "Kbps")
00068 {
00069
00070 *v = (uint64_t)(r * 1000);
00071 }
00072 else if (trailer == "Kb/s")
00073 {
00074
00075 *v = (uint64_t)(r * 1000);
00076 }
00077 else if (trailer == "kBps")
00078 {
00079
00080 *v = (uint64_t)(r * 8000);
00081 }
00082 else if (trailer == "kB/s")
00083 {
00084
00085 *v = (uint64_t)(r * 8000);
00086 }
00087 else if (trailer == "KBps")
00088 {
00089
00090 *v = (uint64_t)(r * 8000);
00091 }
00092 else if (trailer == "KB/s")
00093 {
00094
00095 *v = (uint64_t)(r * 8000);
00096 }
00097 else if (trailer == "Kib/s")
00098 {
00099
00100 *v = (uint64_t)(r * 1024);
00101 }
00102 else if (trailer == "KiB/s")
00103 {
00104
00105 *v = (uint64_t)(r * 8192);
00106 }
00107 else if (trailer == "Mbps")
00108 {
00109
00110 *v = (uint64_t)(r * 1000000);
00111 }
00112 else if (trailer == "Mb/s")
00113 {
00114
00115 *v = (uint64_t)(r * 1000000);
00116 }
00117 else if (trailer == "MBps")
00118 {
00119
00120 *v = (uint64_t)(r * 8000000);
00121 }
00122 else if (trailer == "MB/s")
00123 {
00124
00125 *v = (uint64_t)(r * 8000000);
00126 }
00127 else if (trailer == "Mib/s")
00128 {
00129
00130 *v = (uint64_t)(r * 1048576);
00131 }
00132 else if (trailer == "MiB/s")
00133 {
00134
00135 *v = (uint64_t)(r * 1048576 * 8);
00136 }
00137 else if (trailer == "Gbps")
00138 {
00139
00140 *v = (uint64_t)(r * 1000000000);
00141 }
00142 else if (trailer == "Gb/s")
00143 {
00144
00145 *v = (uint64_t)(r * 1000000000);
00146 }
00147 else if (trailer == "GBps")
00148 {
00149
00150 *v = (uint64_t)(r * 8*1000000000);
00151 }
00152 else if (trailer == "GB/s")
00153 {
00154
00155 *v = (uint64_t)(r * 8*1000000000);
00156 }
00157 else if (trailer == "Gib/s")
00158 {
00159
00160 *v = (uint64_t)(r * 1048576 * 1024);
00161 }
00162 else if (trailer == "GiB/s")
00163 {
00164
00165 *v = (uint64_t)(r * 1048576 * 1024 * 8);
00166 }
00167 else
00168 {
00169 return false;
00170 }
00171 return true;
00172 }
00173 std::istringstream iss;
00174 iss.str (s);
00175 iss >> *v;
00176 return true;
00177 }
00178
00179
00180 namespace ns3 {
00181
00182 ATTRIBUTE_HELPER_CPP (DataRate);
00183
00184 DataRate::DataRate ()
00185 : m_bps (0)
00186 {}
00187
00188 DataRate::DataRate(uint64_t bps)
00189 :m_bps(bps)
00190 {}
00191
00192 bool DataRate::operator < (const DataRate& rhs) const
00193 {
00194 return m_bps<rhs.m_bps;
00195 }
00196
00197 bool DataRate::operator <= (const DataRate& rhs) const
00198 {
00199 return m_bps<=rhs.m_bps;
00200 }
00201
00202 bool DataRate::operator > (const DataRate& rhs) const
00203 {
00204 return m_bps>rhs.m_bps;
00205 }
00206
00207 bool DataRate::operator >= (const DataRate& rhs) const
00208 {
00209 return m_bps>=rhs.m_bps;
00210 }
00211
00212 bool DataRate::operator == (const DataRate& rhs) const
00213 {
00214 return m_bps==rhs.m_bps;
00215 }
00216
00217 bool DataRate::operator != (const DataRate& rhs) const
00218 {
00219 return m_bps!=rhs.m_bps;
00220 }
00221
00222 double DataRate::CalculateTxTime(uint32_t bytes) const
00223 {
00224 return static_cast<double>(bytes)*8/m_bps;
00225 }
00226
00227 uint64_t DataRate::GetBitRate() const
00228 {
00229 return m_bps;
00230 }
00231
00232 DataRate::DataRate (std::string rate)
00233 {
00234 bool ok = DoParse (rate, &m_bps);
00235 if (!ok)
00236 {
00237 NS_FATAL_ERROR ("Could not parse rate: "<<rate);
00238 }
00239 }
00240
00241 std::ostream &operator << (std::ostream &os, const DataRate &rate)
00242 {
00243 os << rate.GetBitRate () << "bps";
00244 return os;
00245 }
00246 std::istream &operator >> (std::istream &is, DataRate &rate)
00247 {
00248 std::string value;
00249 is >> value;
00250 uint64_t v;
00251 bool ok = DoParse (value, &v);
00252 if (!ok)
00253 {
00254 is.setstate (std::ios_base::failbit);
00255 }
00256 rate = DataRate (v);
00257 return is;
00258 }
00259
00260
00261
00262 double operator*(const DataRate& lhs, const Time& rhs)
00263 {
00264 return rhs.GetSeconds()*lhs.GetBitRate();
00265 }
00266
00267 double operator*(const Time& lhs, const DataRate& rhs)
00268 {
00269 return lhs.GetSeconds()*rhs.GetBitRate();
00270 }
00271
00272 }