src/marnav/nmea/string.cpp

   1 #include "string.hpp"
   2 #include <marnav/utils/mmsi.hpp>
   3
   4 namespace marnav
   5 {
   6 namespace nmea
   7 {
   8 std::string to_string(char data)
   9 {
  10         char buf[sizeof(int)]; // sizeof(int) is for stack anlignment and protection
  11         snprintf(buf, sizeof(buf), "%c", data);
  12         return buf;
  13 }
  14
  15 std::string to_string(uint64_t data)
  16 {
  17         return std::to_string(data);
  18 }
  19
  20 std::string to_string(uint32_t data)
  21 {
  22         return std::to_string(data);
  23 }
  24
  25 std::string to_string(int32_t data)
  26 {
  27         return std::to_string(data);
  28 }
  29
  30 std::string to_string(double data)
  31 {
  32         char buf[32];
  33         snprintf(buf, sizeof(buf), "%g", data);
  34         return buf;
  35 }
  36
  37 std::string to_string(const std::string & data)
  38 {
  39         return data;
  40 }
  41
  42 std::string to_string(side t)
  43 {
  44         switch (t) {
  45                 case side::left:
  46                         return "L";
  47                 case side::right:
  48                         return "R";
  49         }
  50         return ""; // never reached, gcc does not get it, prevents compiler warning
  51 }
  52
  53 std::string to_string(route t)
  54 {
  55         switch (t) {
  56                 case route::complete:
  57                         return "c";
  58                 case route::working:
  59                         return "w";
  60         }
  61         return ""; // never reached, gcc does not get it, prevents compiler warning
  62 }
  63
  64 std::string to_string(selection_mode t)
  65 {
  66         switch (t) {
  67                 case selection_mode::manual:
  68                         return "M";
  69                 case selection_mode::automatic:
  70                         return "A";
  71         }
  72         return ""; // never reached, gcc does not get it, prevents compiler warning
  73 }
  74
  75 std::string to_string(ais_channel t)
  76 {
  77         switch (t) {
  78                 case ais_channel::A:
  79                         return "A";
  80                 case ais_channel::B:
  81                         return "B";
  82         }
  83         return ""; // never reached, gcc does not get it, prevents compiler warning
  84 }
  85
  86 std::string to_string(type_of_point t)
  87 {
  88         switch (t) {
  89                 case type_of_point::collision:
  90                         return "C";
  91                 case type_of_point::turning_point:
  92                         return "T";
  93                 case type_of_point::reference:
  94                         return "R";
  95                 case type_of_point::wheelover:
  96                         return "W";
  97         }
  98         return ""; // never reached, gcc does not get it, prevents compiler warning
  99 }
 100
 101 std::string to_string(direction t)
 102 {
 103         switch (t) {
 104                 case direction::north:
 105                         return "N";
 106                 case direction::south:
 107                         return "S";
 108                 case direction::east:
 109                         return "E";
 110                 case direction::west:
 111                         return "W";
 112                 case direction::none:
 113                         return "none";
 114         }
 115         return ""; // never reached, gcc does not get it, prevents compiler warning
 116 }
 117
 118 std::string to_string(reference t)
 119 {
 120         switch (t) {
 121                 case reference::TRUE:
 122                         return "T";
 123                 case reference::MAGNETIC:
 124                         return "M";
 125                 case reference::RELATIVE:
 126                         return "R";
 127         }
 128         return ""; // never reached, gcc does not get it, prevents compiler warning
 129 }
 130
 131 std::string to_string(mode_indicator t)
 132 {
 133         switch (t) {
 134                 case mode_indicator::invalid:
 135                         return "V";
 136                 case mode_indicator::autonomous:
 137                         return "A";
 138                 case mode_indicator::differential:
 139                         return "D";
 140                 case mode_indicator::estimated:
 141                         return "E";
 142                 case mode_indicator::manual_input:
 143                         return "M";
 144                 case mode_indicator::simulated:
 145                         return "S";
 146                 case mode_indicator::data_not_valid:
 147                         return "N";
 148                 case mode_indicator::precise:
 149                         return "P";
 150         }
 151         return ""; // never reached, gcc does not get it, prevents compiler warning
 152 }
 153
 154 std::string to_string(status t)
 155 {
 156         switch (t) {
 157                 case status::ok:
 158                         return "A";
 159                 case status::warning:
 160                         return "V";
 161         }
 162         return ""; // never reached, gcc does not get it, prevents compiler warning
 163 }
 164
 165 std::string to_string(quality t)
 166 {
 167         switch (t) {
 168                 case quality::invalid:
 169                         return "0";
 170                 case quality::gps_fix:
 171                         return "1";
 172                 case quality::dgps_fix:
 173                         return "2";
 174                 case quality::guess:
 175                         return "6";
 176                 case quality::simulation:
 177                         return "8";
 178         }
 179         return ""; // never reached, gcc does not get it, prevents compiler warning
 180 }
 181
 182 std::string to_string(target_status t)
 183 {
 184         switch (t) {
 185                 case target_status::lost:
 186                         return "L";
 187                 case target_status::query:
 188                         return "Q";
 189                 case target_status::tracking:
 190                         return "T";
 191         }
 192         return ""; // never reached, gcc does not get it, prevents compiler warning
 193 }
 194
 195 std::string to_string(unit::distance t)
 196 {
 197         switch (t) {
 198                 case unit::distance::meter:
 199                         return "M";
 200                 case unit::distance::feet:
 201                         return "f";
 202                 case unit::distance::nm:
 203                         return "N";
 204                 case unit::distance::km:
 205                         return "K";
 206                 case unit::distance::fathom:
 207                         return "F";
 208         }
 209         return ""; // never reached, gcc does not get it, prevents compiler warning
 210 }
 211
 212 std::string to_string(unit::velocity t)
 213 {
 214         switch (t) {
 215                 case unit::velocity::knot:
 216                         return "N";
 217                 case unit::velocity::kmh:
 218                         return "K";
 219                 case unit::velocity::mps:
 220                         return "M";
 221         }
 222         return ""; // never reached, gcc does not get it, prevents compiler warning
 223 }
 224
 225 std::string to_string(unit::temperature t)
 226 {
 227         switch (t) {
 228                 case unit::temperature::celsius:
 229                         return "C";
 230         }
 231         return ""; // never reached, gcc does not get it, prevents compiler warning
 232 }
 233
 234 std::string to_string(unit::pressure t)
 235 {
 236         switch (t) {
 237                 case unit::pressure::bar:
 238                         return "B";
 239                 case unit::pressure::pascal:
 240                         return "P";
 241         }
 242         return ""; // never reached, gcc does not get it, prevents compiler warning
 243 }
 244
 245 std::string to_string(const utils::mmsi & t)
 246 {
 247         char buf[16];
 248         snprintf(buf, sizeof(buf), "%09u", static_cast<uint32_t>(t));
 249         return buf;
 250 }
 251 }
 252 }