src/components/policy/src/policy/policy_table/table_struct/enums.cc

   1 // This file is generated, do not edit
   2 #include "./enums.h"
   3
   4 namespace rpc {
   5 namespace policy_table_interface_base {
   6 bool IsValidEnum(Priority val) {
   7   switch (val) {
   8     case P_EMERGENCY: return true;
   9     case P_NAVIGATION: return true;
  10     case P_VOICECOM: return true;
  11     case P_COMMUNICATION: return true;
  12     case P_NORMAL: return true;
  13     case P_NONE: return true;
  14     default: return false;
  15   }
  16 }
  17 const char* EnumToJsonString(Priority val) {
  18   switch (val) {
  19     case P_EMERGENCY: return "EMERGENCY";
  20     case P_NAVIGATION: return "NAVIGATION";
  21     case P_VOICECOM: return "VOICECOM";
  22     case P_COMMUNICATION: return "COMMUNICATION";
  23     case P_NORMAL: return "NORMAL";
  24     case P_NONE: return "NONE";
  25     default: return "";
  26   }
  27 }
  28 bool EnumFromJsonString(const std::string& literal, Priority* result) {
  29   if ("EMERGENCY" == literal) {
  30     *result = P_EMERGENCY;
  31     return true;
  32   } else if ("NAVIGATION" == literal) {
  33     *result = P_NAVIGATION;
  34     return true;
  35   } else if ("VOICECOM" == literal) {
  36     *result = P_VOICECOM;
  37     return true;
  38   } else if ("COMMUNICATION" == literal) {
  39     *result = P_COMMUNICATION;
  40     return true;
  41   } else if ("NORMAL" == literal) {
  42     *result = P_NORMAL;
  43     return true;
  44   } else if ("NONE" == literal) {
  45     *result = P_NONE;
  46     return true;
  47   } else {
  48     return false;
  49   }
  50 }
  51
  52 bool IsValidEnum(HmiLevel val) {
  53   switch (val) {
  54     case HL_BACKGROUND: return true;
  55     case HL_FULL: return true;
  56     case HL_LIMITED: return true;
  57     case HL_NONE: return true;
  58     default: return false;
  59   }
  60 }
  61 const char* EnumToJsonString(HmiLevel val) {
  62   switch (val) {
  63     case HL_BACKGROUND: return "BACKGROUND";
  64     case HL_FULL: return "FULL";
  65     case HL_LIMITED: return "LIMITED";
  66     case HL_NONE: return "NONE";
  67     default: return "";
  68   }
  69 }
  70 bool EnumFromJsonString(const std::string& literal, HmiLevel* result) {
  71   if ("BACKGROUND" == literal) {
  72     *result = HL_BACKGROUND;
  73     return true;
  74   } else if ("FULL" == literal) {
  75     *result = HL_FULL;
  76     return true;
  77   } else if ("LIMITED" == literal) {
  78     *result = HL_LIMITED;
  79     return true;
  80   } else if ("NONE" == literal) {
  81     *result = HL_NONE;
  82     return true;
  83   } else {
  84     return false;
  85   }
  86 }
  87
  88 bool IsValidEnum(Parameter val) {
  89   switch (val) {
  90     case P_GPS: return true;
  91     case P_SPEED: return true;
  92     case P_ENGINETORQUE: return true;
  93     case P_EXTERNALTEMPERATURE: return true;
  94     case P_FUELLEVEL: return true;
  95     case P_FUELLEVEL_STATE: return true;
  96     case P_HEADLAMPSTATUS: return true;
  97     case P_INSTANTFUELCONSUMPTION: return true;
  98     case P_ODOMETER: return true;
  99     case P_TIREPRESSURE: return true;
 100     case P_WIPERSTATUS: return true;
 101     case P_VIN: return true;
 102     case P_ACCPEDALPOSITION: return true;
 103     case P_BELTSTATUS: return true;
 104     case P_DRIVERBRAKING: return true;
 105     case P_PRNDL: return true;
 106     case P_RPM: return true;
 107     case P_STEERINGWHEELANGLE: return true;
 108     case P_MYKEY: return true;
 109     case P_AIRBAGSTATUS: return true;
 110     case P_BODYINFORMATION: return true;
 111     case P_CLUSTERMODESTATUS: return true;
 112     case P_DEVICESTATUS: return true;
 113     case P_EMERGENCYEVENT: return true;
 114     case P_ECALLINFO: return true;
 115     default: return false;
 116   }
 117 }
 118 const char* EnumToJsonString(Parameter val) {
 119   switch (val) {
 120     case P_GPS: return "gps";
 121     case P_SPEED: return "speed";
 122     case P_ENGINETORQUE: return "engineTorque";
 123     case P_EXTERNALTEMPERATURE: return "externalTemperature";
 124     case P_FUELLEVEL: return "fuelLevel";
 125     case P_FUELLEVEL_STATE: return "fuelLevel_State";
 126     case P_HEADLAMPSTATUS: return "headLampStatus";
 127     case P_INSTANTFUELCONSUMPTION: return "instantFuelConsumption";
 128     case P_ODOMETER: return "odometer";
 129     case P_TIREPRESSURE: return "tirePressure";
 130     case P_WIPERSTATUS: return "wiperStatus";
 131     case P_VIN: return "vin";
 132     case P_ACCPEDALPOSITION: return "accPedalPosition";
 133     case P_BELTSTATUS: return "beltStatus";
 134     case P_DRIVERBRAKING: return "driverBraking";
 135     case P_PRNDL: return "prndl";
 136     case P_RPM: return "rpm";
 137     case P_STEERINGWHEELANGLE: return "steeringWheelAngle";
 138     case P_MYKEY: return "myKey";
 139     case P_AIRBAGSTATUS: return "airbagStatus";
 140     case P_BODYINFORMATION: return "bodyInformation";
 141     case P_CLUSTERMODESTATUS: return "clusterModeStatus";
 142     case P_DEVICESTATUS: return "deviceStatus";
 143     case P_EMERGENCYEVENT: return "emergencyEvent";
 144     case P_ECALLINFO: return "eCallInfo";
 145     default: return "";
 146   }
 147 }
 148 bool EnumFromJsonString(const std::string& literal, Parameter* result) {
 149   if ("gps" == literal) {
 150     *result = P_GPS;
 151     return true;
 152   } else if ("speed" == literal) {
 153     *result = P_SPEED;
 154     return true;
 155   } else if ("engineTorque" == literal) {
 156     *result = P_ENGINETORQUE;
 157     return true;
 158   } else if ("externalTemperature" == literal) {
 159     *result = P_EXTERNALTEMPERATURE;
 160     return true;
 161   } else if ("fuelLevel" == literal) {
 162     *result = P_FUELLEVEL;
 163     return true;
 164   } else if ("fuelLevel_State" == literal) {
 165     *result = P_FUELLEVEL_STATE;
 166     return true;
 167   } else if ("headLampStatus" == literal) {
 168     *result = P_HEADLAMPSTATUS;
 169     return true;
 170   } else if ("instantFuelConsumption" == literal) {
 171     *result = P_INSTANTFUELCONSUMPTION;
 172     return true;
 173   } else if ("odometer" == literal) {
 174     *result = P_ODOMETER;
 175     return true;
 176   } else if ("tirePressure" == literal) {
 177     *result = P_TIREPRESSURE;
 178     return true;
 179   } else if ("wiperStatus" == literal) {
 180     *result = P_WIPERSTATUS;
 181     return true;
 182   } else if ("vin" == literal) {
 183     *result = P_VIN;
 184     return true;
 185   } else if ("accPedalPosition" == literal) {
 186     *result = P_ACCPEDALPOSITION;
 187     return true;
 188   } else if ("beltStatus" == literal) {
 189     *result = P_BELTSTATUS;
 190     return true;
 191   } else if ("driverBraking" == literal) {
 192     *result = P_DRIVERBRAKING;
 193     return true;
 194   } else if ("prndl" == literal) {
 195     *result = P_PRNDL;
 196     return true;
 197   } else if ("rpm" == literal) {
 198     *result = P_RPM;
 199     return true;
 200   } else if ("steeringWheelAngle" == literal) {
 201     *result = P_STEERINGWHEELANGLE;
 202     return true;
 203   } else if ("myKey" == literal) {
 204     *result = P_MYKEY;
 205     return true;
 206   } else if ("airbagStatus" == literal) {
 207     *result = P_AIRBAGSTATUS;
 208     return true;
 209   } else if ("bodyInformation" == literal) {
 210     *result = P_BODYINFORMATION;
 211     return true;
 212   } else if ("clusterModeStatus" == literal) {
 213     *result = P_CLUSTERMODESTATUS;
 214     return true;
 215   } else if ("deviceStatus" == literal) {
 216     *result = P_DEVICESTATUS;
 217     return true;
 218   } else if ("emergencyEvent" == literal) {
 219     *result = P_EMERGENCYEVENT;
 220     return true;
 221   } else if ("eCallInfo" == literal) {
 222     *result = P_ECALLINFO;
 223     return true;
 224   } else {
 225     return false;
 226   }
 227 }
 228
 229 bool IsValidEnum(AppHMIType val) {
 230   switch (val) {
 231     case AHT_DEFAULT: return true;
 232     case AHT_COMMUNICATION: return true;
 233     case AHT_MEDIA: return true;
 234     case AHT_MESSAGING: return true;
 235     case AHT_NAVIGATION: return true;
 236     case AHT_INFORMATION: return true;
 237     case AHT_SOCIAL: return true;
 238     case AHT_BACKGROUND_PROCESS: return true;
 239     case AHT_TESTING: return true;
 240     case AHT_SYSTEM: return true;
 241     default: return false;
 242   }
 243 }
 244 const char* EnumToJsonString(AppHMIType val) {
 245   switch (val) {
 246     case AHT_DEFAULT: return "DEFAULT";
 247     case AHT_COMMUNICATION: return "COMMUNICATION";
 248     case AHT_MEDIA: return "MEDIA";
 249     case AHT_MESSAGING: return "MESSAGING";
 250     case AHT_NAVIGATION: return "NAVIGATION";
 251     case AHT_INFORMATION: return "INFORMATION";
 252     case AHT_SOCIAL: return "SOCIAL";
 253     case AHT_BACKGROUND_PROCESS: return "BACKGROUND_PROCESS";
 254     case AHT_TESTING: return "TESTING";
 255     case AHT_SYSTEM: return "SYSTEM";
 256     default: return "";
 257   }
 258 }
 259 bool EnumFromJsonString(const std::string& literal, AppHMIType* result) {
 260   if ("DEFAULT" == literal) {
 261     *result = AHT_DEFAULT;
 262     return true;
 263   } else if ("COMMUNICATION" == literal) {
 264     *result = AHT_COMMUNICATION;
 265     return true;
 266   } else if ("MEDIA" == literal) {
 267     *result = AHT_MEDIA;
 268     return true;
 269   } else if ("MESSAGING" == literal) {
 270     *result = AHT_MESSAGING;
 271     return true;
 272   } else if ("NAVIGATION" == literal) {
 273     *result = AHT_NAVIGATION;
 274     return true;
 275   } else if ("INFORMATION" == literal) {
 276     *result = AHT_INFORMATION;
 277     return true;
 278   } else if ("SOCIAL" == literal) {
 279     *result = AHT_SOCIAL;
 280     return true;
 281   } else if ("BACKGROUND_PROCESS" == literal) {
 282     *result = AHT_BACKGROUND_PROCESS;
 283     return true;
 284   } else if ("TESTING" == literal) {
 285     *result = AHT_TESTING;
 286     return true;
 287   } else if ("SYSTEM" == literal) {
 288     *result = AHT_SYSTEM;
 289     return true;
 290   } else {
 291     return false;
 292   }
 293 }
 294
 295 const std::string kDefaultApp = "default";
 296 const std::string kPreDataConsentApp = "pre_DataConsent";
 297 const std::string kDeviceApp = "device";
 298
 299 }  // namespace policy_table_interface_base
 300 }  // namespace rpc
 301