Rev 1322 | Go to most recent revision | Details | Last modification | View Log | SVN | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 1314 | runge | 1 | /* |
| 2 | * convert.cpp |
||
| 3 | * |
||
| 4 | * Created on: Aug 04, 2009 |
||
| 5 | * Author: Mattias Runge |
||
| 6 | */ |
||
| 7 | |||
| 8 | #include "convert.h" |
||
| 9 | |||
| 10 | namespace atom { |
||
| 11 | namespace convert { |
||
| 12 | |||
| 13 | bool string2bool(const string s) |
||
| 14 | { |
||
| 15 | return (s == "true" || s == "1" || s == "yes"); |
||
| 16 | } |
||
| 17 | |||
| 18 | int string2int(const string s) |
||
| 19 | { |
||
| 20 | istringstream in(s); |
||
| 21 | int i; |
||
| 22 | in >> i; |
||
| 23 | return i; |
||
| 24 | } |
||
| 25 | |||
| 26 | string int2string(int i) |
||
| 27 | { |
||
| 28 | ostringstream out; |
||
| 29 | out << i; |
||
| 30 | return out.str(); |
||
| 31 | } |
||
| 32 | |||
| 33 | unsigned int string2uint(const string s) |
||
| 34 | { |
||
| 35 | istringstream in(s); |
||
| 36 | unsigned int i; |
||
| 37 | in >> i; |
||
| 38 | return i; |
||
| 39 | } |
||
| 40 | |||
| 41 | string uint2string(unsigned int i) |
||
| 42 | { |
||
| 43 | ostringstream out; |
||
| 44 | out << i; |
||
| 45 | return out.str(); |
||
| 46 | } |
||
| 47 | |||
| 48 | float string2float(const string s) |
||
| 49 | { |
||
| 50 | istringstream in(s); |
||
| 51 | float f; |
||
| 52 | in >> f; |
||
| 53 | return f; |
||
| 54 | } |
||
| 55 | |||
| 56 | string float2string(float f) |
||
| 57 | { |
||
| 58 | ostringstream out; |
||
| 59 | out << f; |
||
| 60 | return out.str(); |
||
| 61 | } |
||
| 62 | |||
| 63 | string bytes2string(byte_list bytes) |
||
| 64 | { |
||
| 65 | string str = ""; |
||
| 66 | |||
| 67 | for (unsigned int n = 0; n < bytes.size(); n++) |
||
| 68 | { |
||
| 69 | str += bytes[n]; |
||
| 70 | } |
||
| 71 | |||
| 72 | return str; |
||
| 73 | } |
||
| 74 | |||
| 75 | unsigned int hex2uint(string hex) |
||
| 76 | { |
||
| 77 | return bin2uint(hex2bin(hex)); |
||
| 78 | } |
||
| 79 | |||
| 80 | unsigned int bin2uint(string bin) |
||
| 81 | { |
||
| 82 | unsigned int num = 0; |
||
| 83 | |||
| 84 | for (int n = bin.length() - 1; n >= 0; n--) |
||
| 85 | { |
||
| 86 | if (bin[n] == '1') num += (unsigned int)pow(2.0f, (int)(bin.length() |
||
| 87 | - 1 - n)); |
||
| 88 | } |
||
| 89 | |||
| 90 | return num; |
||
| 91 | } |
||
| 92 | |||
| 93 | |||
| 94 | float bin2float(string bin) |
||
| 95 | { |
||
| 96 | float num = 0; |
||
| 97 | |||
| 98 | if (bin.length() == 0) return 0.0f; |
||
| 99 | |||
| 100 | bool isNegative = false; |
||
| 101 | ; |
||
| 102 | |||
| 103 | if (bin[0] == '1') |
||
| 104 | { |
||
| 105 | bin = bin_invert(bin); |
||
| 106 | isNegative = true; |
||
| 107 | } |
||
| 108 | |||
| 109 | for (int n = bin.length() - 1; n > 0; n--) |
||
| 110 | { |
||
| 111 | if (bin[n] == '1') num += pow(2.0f, (int)(bin.length() - 1 - n)); |
||
| 112 | } |
||
| 113 | |||
| 114 | num /= 64.0f; |
||
| 115 | |||
| 116 | if (isNegative) num = -num; |
||
| 117 | |||
| 118 | return num; |
||
| 119 | } |
||
| 120 | |||
| 121 | string bin2hex(string bin) |
||
| 122 | { |
||
| 123 | string hex; |
||
| 124 | |||
| 125 | while (bin.size() > 0) |
||
| 126 | { |
||
| 127 | string part; |
||
| 128 | |||
| 129 | try |
||
| 130 | { |
||
| 131 | part = bin.substr(0, 4); |
||
| 132 | } |
||
| 133 | catch (std::out_of_range& e) |
||
| 134 | { |
||
| 135 | //cout << "DEBUG: bin2hex exception: " << e.what() << "\n"; |
||
| 136 | //cout << "DEBUG: A bin=" << bin << endl; |
||
| 137 | continue; |
||
| 138 | } |
||
| 139 | |||
| 140 | bin.erase(0, part.size()); |
||
| 141 | |||
| 142 | while (part.size() < 4) |
||
| 143 | part = "0" + part; |
||
| 144 | |||
| 145 | if (part == "0000") |
||
| 146 | hex += '0'; |
||
| 147 | else if (part == "0001") |
||
| 148 | hex += '1'; |
||
| 149 | else if (part == "0010") |
||
| 150 | hex += '2'; |
||
| 151 | else if (part == "0011") |
||
| 152 | hex += '3'; |
||
| 153 | else if (part == "0100") |
||
| 154 | hex += '4'; |
||
| 155 | else if (part == "0101") |
||
| 156 | hex += '5'; |
||
| 157 | else if (part == "0110") |
||
| 158 | hex += '6'; |
||
| 159 | else if (part == "0111") |
||
| 160 | hex += '7'; |
||
| 161 | else if (part == "1000") |
||
| 162 | hex += '8'; |
||
| 163 | else if (part == "1001") |
||
| 164 | hex += '9'; |
||
| 165 | else if (part == "1010") |
||
| 166 | hex += 'a'; |
||
| 167 | else if (part == "1011") |
||
| 168 | hex += 'b'; |
||
| 169 | else if (part == "1100") |
||
| 170 | hex += 'c'; |
||
| 171 | else if (part == "1101") |
||
| 172 | hex += 'd'; |
||
| 173 | else if (part == "1110") |
||
| 174 | hex += 'e'; |
||
| 175 | else if (part == "1111") hex += 'f'; |
||
| 176 | } |
||
| 177 | |||
| 178 | return hex; |
||
| 179 | } |
||
| 180 | |||
| 181 | string float2bin(float num, unsigned int length) |
||
| 182 | { |
||
| 183 | string bin; |
||
| 184 | |||
| 185 | ///FIXME |
||
| 186 | |||
| 187 | while (bin.size() < length) |
||
| 188 | bin = "0" + bin; |
||
| 189 | |||
| 190 | return bin; |
||
| 191 | } |
||
| 192 | |||
| 193 | string hex2bin(string hex) |
||
| 194 | { |
||
| 195 | to_lower(hex); |
||
| 196 | |||
| 197 | string bin; |
||
| 198 | |||
| 199 | for (unsigned int n = 0; n < hex.length(); n++) |
||
| 200 | { |
||
| 201 | switch (hex[n]) |
||
| 202 | { |
||
| 203 | case '0': |
||
| 204 | bin += "0000"; |
||
| 205 | break; |
||
| 206 | case '1': |
||
| 207 | bin += "0001"; |
||
| 208 | break; |
||
| 209 | case '2': |
||
| 210 | bin += "0010"; |
||
| 211 | break; |
||
| 212 | case '3': |
||
| 213 | bin += "0011"; |
||
| 214 | break; |
||
| 215 | case '4': |
||
| 216 | bin += "0100"; |
||
| 217 | break; |
||
| 218 | case '5': |
||
| 219 | bin += "0101"; |
||
| 220 | break; |
||
| 221 | case '6': |
||
| 222 | bin += "0110"; |
||
| 223 | break; |
||
| 224 | case '7': |
||
| 225 | bin += "0111"; |
||
| 226 | break; |
||
| 227 | case '8': |
||
| 228 | bin += "1000"; |
||
| 229 | break; |
||
| 230 | case '9': |
||
| 231 | bin += "1001"; |
||
| 232 | break; |
||
| 233 | case 'a': |
||
| 234 | bin += "1010"; |
||
| 235 | break; |
||
| 236 | case 'b': |
||
| 237 | bin += "1011"; |
||
| 238 | break; |
||
| 239 | case 'c': |
||
| 240 | bin += "1100"; |
||
| 241 | break; |
||
| 242 | case 'd': |
||
| 243 | bin += "1101"; |
||
| 244 | break; |
||
| 245 | case 'e': |
||
| 246 | bin += "1110"; |
||
| 247 | break; |
||
| 248 | case 'f': |
||
| 249 | bin += "1111"; |
||
| 250 | break; |
||
| 251 | } |
||
| 252 | } |
||
| 253 | |||
| 254 | return bin; |
||
| 255 | } |
||
| 256 | |||
| 257 | string uint2bin(unsigned int num, unsigned int length) |
||
| 258 | { |
||
| 259 | string bin; |
||
| 260 | |||
| 261 | while (num) |
||
| 262 | { |
||
| 263 | bin = char((num & 1) + '0') + bin; |
||
| 264 | num >>= 1; |
||
| 265 | } |
||
| 266 | |||
| 267 | while (bin.size() < length) |
||
| 268 | bin = "0" + bin; |
||
| 269 | |||
| 270 | return bin; |
||
| 271 | } |
||
| 272 | |||
| 273 | string uint2hex(unsigned int num, unsigned int length) |
||
| 274 | { |
||
| 275 | return bin2hex(uint2bin(num, length)); |
||
| 276 | } |
||
| 277 | |||
| 278 | |||
| 279 | string bin_invert(string bin) |
||
| 280 | { |
||
| 281 | string inverted; |
||
| 282 | |||
| 283 | for (unsigned int n = 0; n < bin.length(); n++) |
||
| 284 | inverted += (bin[n] == '1' ? '0' : '1'); |
||
| 285 | |||
| 286 | return inverted; |
||
| 287 | } |
||
| 288 | |||
| 289 | } |
||
| 290 | } |