lib/vehicleproperty.h

   1 /*
   2         Copyright (C) 2012  Intel Corporation
   3
   4         This library is free software; you can redistribute it and/or
   5         modify it under the terms of the GNU Lesser General Public
   6         License as published by the Free Software Foundation; either
   7         version 2.1 of the License, or (at your option) any later version.
   8
   9         This library is distributed in the hope that it will be useful,
  10         but WITHOUT ANY WARRANTY; without even the implied warranty of
  11         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12         Lesser General Public License for more details.
  13
  14         You should have received a copy of the GNU Lesser General Public
  15         License along with this library; if not, write to the Free Software
  16         Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19
  20 #ifndef VEHICLEPROPERTY_H
  21 #define VEHICLEPROPERTY_H
  22
  23 #include "nullptr.h"
  24 #include <string>
  25 #include <list>
  26 #include <set>
  27 #include <sstream>
  28 #include <map>
  29 #include <functional>
  30 #include "abstractpropertytype.h"
  31 #include "mappropertytype.hpp"
  32
  33 namespace ButtonEvents {
  34 enum ButtonEventType {
  35         NoButton = 0,
  36         PlayButton = 1,
  37         SkipButton = 1 << 1,
  38         PrevButton = 1 << 2,
  39         PauseButton = 1 << 3,
  40         Preset1Button = 1 << 4,
  41         Preset2Button = 1 << 5,
  42         Preset3Button = 1 << 6,
  43         Preset4Button = 1 << 7,
  44         StopButton = 1 << 8,
  45         NavigateUpButton = 1 << 9,
  46         NavigateDownButton = 1 << 10,
  47         NavigateLeftButton = 1 << 11,
  48         NavigateRightButton = 1 << 12
  49 };
  50
  51 namespace W3C
  52 {
  53 extern const char* Home;
  54 extern const char* Back;
  55 extern const char* Search;
  56 extern const char* Call;
  57 extern const char* EndCall;
  58 extern const char* MediaPlay;
  59 extern const char* MediaNext;
  60 extern const char* MediaPrevious;
  61 extern const char* MediaPause;
  62 extern const char* VoiceRecognize;
  63 extern const char* Enter;
  64 extern const char* Left;
  65 extern const char* Right;
  66 extern const char* Up;
  67 extern const char* Down;
  68 }
  69 }
  70
  71 namespace TurnSignals {
  72 enum TurnSignalType
  73 {
  74         Off=0,
  75         Right=1,
  76         Left=2,
  77         Hazard=3
  78 };
  79 }
  80
  81 namespace Transmission {
  82 enum TransmissionPositions
  83 {
  84         Neutral = 0,
  85         First,
  86         Second,
  87         Third,
  88         Forth,
  89         Fifth,
  90         Sixth,
  91         Seventh,
  92         Eighth,
  93         Ninth,
  94         Tenth,
  95         CVT = 64,
  96         Drive = 96,
  97         Reverse = 128,
  98         Park = 255
  99
 100 };
 101 /** TODO: deprecate in 0.14.  Replaced with Drive::Mode: **/
 102 enum Mode {
 103         Normal=0,
 104         Sports = 1,
 105         Economy = 2,
 106         OEMCustom1 = 3,
 107         OEMCustom2 = 4
 108 };
 109
 110 enum Type {
 111         Unknown = -1,
 112         Auto = 0,
 113         Manual = 1,
 114         CV = 2
 115 };
 116
 117 namespace W3C
 118 {
 119 extern const char* Park;
 120 extern const char* Reverse;
 121 extern const char* Neutral;
 122 extern const char* Low;
 123 extern const char* Drive;
 124 extern const char* Overdrive;
 125 }
 126 }
 127
 128 namespace Power {
 129 /**< Vehicle Power Modes
 130  * Off = Vehicle is off and key is in the "off" position.
 131  * Accessory1 = Vehicle is off and key is in Accessory1 position.
 132  * Accessory2 = Vehicle is off and key is in Accessory2 position.
 133  * Run = Vehichle is running.  Key is in the running position.
 134  */
 135 enum Modes
 136 {
 137         Off = 0,
 138         Accessory1 = 1,
 139         Accessory2 = 2,
 140         Run = 3
 141 };
 142 }
 143
 144 namespace Fuel{
 145 enum Type
 146 {
 147         Unknown = -1,
 148         Gasoline = 0,
 149         High_Octane,
 150         Diesel,
 151         Electric,
 152         Hydrogen
 153 };
 154
 155 enum RefuelPosition
 156 {
 157         UnknownPosition = -1,
 158         Left = 0,
 159         Right,
 160         Front,
 161         Rear
 162 };
 163 }
 164
 165 namespace Vehicle {
 166 enum Type
 167 {
 168         Unknown = -1,
 169         Sedan = 0,
 170         Coupe,
 171         Cabriole,
 172         Roadster,
 173         SUV,
 174         Truck
 175 };
 176 enum SoundMode {
 177         Normal = 0,
 178         Quiet = 1,
 179         Sportive = 2
 180 };
 181 }
 182
 183 namespace Security {
 184 enum Status
 185 {
 186         Idle = 0,
 187         Armed,
 188         AlarmDetected
 189 };
 190
 191 namespace W3C
 192 {
 193 extern const char * Disarmed;
 194 extern const char * Prearmed;
 195 extern const char * Armed;
 196 extern const char * Alarmed;
 197 }
 198
 199 }
 200
 201 namespace Airbag {
 202
 203 enum Status
 204 {
 205         Inactive = 0,
 206         Active,
 207         Deployed
 208 };
 209
 210 }
 211
 212 namespace Door
 213 {
 214 enum Status
 215 {
 216         Closed = 0,
 217         Open,
 218         Ajar
 219 };
 220 namespace W3C
 221 {
 222 extern const char * Closed;
 223 extern const char * Open;
 224 extern const char * Ajar;
 225 }
 226 }
 227
 228 namespace Seat
 229 {
 230
 231 enum Occupant
 232 {
 233         Vacant = 0,
 234         Child,
 235         Adult
 236 };
 237 namespace W3C
 238 {
 239 extern const char * Vacant;
 240 extern const char * Child;
 241 extern const char * Adult;
 242
 243 extern const char * Pin;
 244 extern const char * Keyfob;
 245 extern const char * Bluetooth;
 246 extern const char * NFC ;
 247 extern const char * Fingerprint;
 248 extern const char * Camera;
 249 extern const char * Voice;
 250 }
 251
 252
 253 }
 254
 255 namespace Window
 256 {
 257 enum WiperSpeed
 258 {
 259         Off = 0,
 260         Slowest = 1,
 261         Fastest = 5,
 262         Auto = 10
 263 };
 264 }
 265
 266 namespace ConvertibleRoofW3C
 267 {
 268 extern const char * Opened;
 269 extern const char * Opening;
 270 extern const char * Closed;
 271 extern const char * Closing;
 272 }
 273
 274 namespace WiperSpeedSetting
 275 {
 276 namespace W3C
 277 {
 278 extern const char * Off;
 279 extern const char * Once;
 280 extern const char * Slowest;
 281 extern const char * Slow;
 282 extern const char * Middle;
 283 extern const char * Fast;
 284 extern const char * Fastest;
 285 extern const char * Auto;
 286 }
 287 }
 288
 289 namespace HVAC
 290 {
 291 enum AirflowDirection
 292 {
 293         FrontPanel=0,
 294         FloorDuct = 1,
 295         Front = 1 << 1,
 296         Defroster = 1 << 2
 297
 298 };
 299
 300 namespace W3C
 301 {
 302 extern const char * FloorPanel;
 303 extern const char * FloorDuct;
 304 extern const char * Bilevel;
 305 extern const char * DefrostFloor;
 306 }
 307 }
 308
 309 namespace Driving
 310 {
 311 enum Mode
 312 {
 313         None = 0,
 314         Driving
 315 };
 316 }
 317
 318 namespace Drive
 319 {
 320 enum Mode {
 321         Normal=0,
 322         Sports = 1,
 323         Economy = 2,
 324         OEMCustom1 = 3,
 325         OEMCustom2 = 4
 326 };
 327
 328 namespace W3C
 329 {
 330 extern const char* Comfort;
 331 extern const char* Auto;
 332 extern const char* Sport;
 333 extern const char* Eco;
 334 extern const char* Manual;
 335 extern const char* Winter;
 336 }
 337
 338 }
 339
 340 namespace Measurement
 341 {
 342 enum Type
 343 {
 344         Metric = 0,
 345         ImperialUS = 1,
 346         ImperialUK = 2
 347 };
 348 }
 349
 350 namespace LaneDeparture
 351 {
 352 namespace W3C
 353 {
 354 extern const char * Off;
 355 extern const char * Pause;
 356 extern const char * Running;
 357 }
 358 }
 359
 360 namespace ParkingBrake
 361 {
 362 namespace W3C
 363 {
 364 extern const char * Inactive;
 365 extern const char * Active;
 366 extern const char * Error;
 367 }
 368 }
 369
 370 #include <boost/preprocessor/comma.hpp>
 371
 372 #define PROPERTYTYPE(property, propertyType, baseClass, valueType) \
 373         class propertyType : public baseClass { \
 374         public: propertyType(): baseClass(property) {} \
 375         propertyType(valueType val) : baseClass(property, val) {} \
 376         using baseClass::operator=; \
 377         };
 378
 379 #define PROPERTYTYPE1(property, propertyType, baseClass, valueType) \
 380         class propertyType : public baseClass { \
 381         public: propertyType(): baseClass(#property) {} \
 382         propertyType(valueType val) : baseClass(#property, val) {} \
 383         };
 384
 385 #define PROPERTYTYPEBASIC(property, valueType) \
 386         class property ## Type : public BasicPropertyType<valueType> { \
 387         public: property ## Type(): BasicPropertyType(property) {} \
 388         property ## Type(valueType val) : BasicPropertyType(property, val) {} \
 389         using BasicPropertyType<valueType>::operator=; \
 390         };
 391
 392 #define PROPERTYTYPEBASIC1(property, valueType) \
 393         class property ## Type : public BasicPropertyType<valueType> { \
 394         public: property ## Type(): BasicPropertyType( #property) {} \
 395         property ## Type(valueType val) : BasicPropertyType(#property, val) {} \
 396         };
 397
 398 #define PROPERTYTYPENOVAL(property, propertyType, baseClass) \
 399         class propertyType : public baseClass { \
 400         public: propertyType(): baseClass(property) {} \
 401         };
 402
 403 class VehicleProperty;
 404
 405
 406 typedef std::vector<std::string> PropertyList;
 407 typedef std::set<std::string> PropertySet;
 408
 409 class VehicleProperty
 410 {
 411
 412 public:
 413
 414         /*!
 415          * \brief factory constructs a static instance of VehicleProperty.  This should be called once before VehicleProperty is used in the app
 416          */
 417         static void factory();
 418
 419         typedef std::string Property;
 420
 421         /*!
 422          * \brief PropertyTypeFactoryCallback callback used to construct a AbstractPropertyType for a property
 423          * \see registerProperty
 424          */
 425         typedef std::function<AbstractPropertyType* (void)> PropertyTypeFactoryCallback;
 426
 427         /// Various property types:
 428
 429         static const Property NoValue;
 430
 431         /**< Vehicle Velocity in km/h */
 432         static const Property VehicleSpeed;
 433         PROPERTYTYPE(VehicleSpeed, VehicleSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 434         //typedef BasicPropertyType<uint16_t> VehicleSpeedType;
 435
 436         /**< Engine Speed in rotations per minute */
 437         static const Property EngineSpeed;
 438         PROPERTYTYPE(EngineSpeed, EngineSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 439         //typedef BasicPropertyType<uint16_t> EngineSpeedType;
 440
 441          /**< Transmission Shift Position
 442          * 0 = Neutral
 443          * 1 = 1st
 444          * 2 = 2nd
 445          * ...
 446          * 96 = Drive
 447          * 128 = Reverse
 448          * 255 = Park
 449          */
 450         static const Property TransmissionShiftPosition;
 451         PROPERTYTYPE(TransmissionShiftPosition, TransmissionShiftPositionType,
 452                                  BasicPropertyType<Transmission::TransmissionPositions>, Transmission::TransmissionPositions )
 453         //typedef BasicPropertyType<Transmission::TransmissionPositions> TransmissionShiftPositionType;
 454
 455         /**< Transmission Gear Position
 456         * 0 = Neutral
 457         * 1 = 1st
 458         * 2 = 2nd
 459         * ...
 460         * 64 = CVT
 461         * 128 = Reverse
 462         */
 463         static const Property TransmissionGearPosition;
 464         PROPERTYTYPE(TransmissionGearPosition, TransmissionGearPositionType,
 465                                  BasicPropertyType<Transmission::TransmissionPositions>, Transmission::TransmissionPositions)
 466         //typedef BasicPropertyType<Transmission::TransmissionPositions> TransmissionGearPositionType;
 467
 468         /// TODO: deprecate in 0.14.  Replaced by Drive::Mode
 469         static const Property TransmissionMode;
 470         PROPERTYTYPE(TransmissionMode, TransmissionModeType,
 471                                  BasicPropertyType<Transmission::Mode>, Transmission::Mode)
 472         //typedef BasicPropertyType<Transmission::Mode> TransmissionModeType;
 473
 474         /**< TransmissionModeW3C
 475          * see Transmission::W3C::Park, Transmission::W3C::Drive, etc
 476          */
 477         static const Property TransmissionModeW3C;
 478         PROPERTYTYPE(TransmissionModeW3C, TransmissionModeW3CType, StringPropertyType, std::string)
 479
 480         /**< Throttle position 0-100% */
 481         static const Property ThrottlePosition;
 482         PROPERTYTYPE(ThrottlePosition, ThrottlePositionType, BasicPropertyType<uint16_t> , uint16_t)
 483         //typedef BasicPropertyType<uint16_t> ThrottlePositionType;
 484
 485         /**< Wheel brake position.  Engaged = true, Idle = false */
 486         static const Property WheelBrake;
 487         PROPERTYTYPE(WheelBrake, WheelBrakeType, BasicPropertyType<bool>, bool)
 488         //typedef BasicPropertyType<bool> WheelBrakeType;
 489
 490         static const Property WheelBrakePressure;
 491         PROPERTYTYPE(WheelBrakePressure, WheelBrakePressureType, BasicPropertyType<uint16_t>, uint16_t)
 492         //typedef BasicPropertyType<uint16_t> WheelBrakePressureType;
 493
 494         /**< Steering wheel angle (0-359)
 495          * TODO: Deprecate in 0.14.  Replace with SteeringWheelAngleW3C
 496         */
 497         static const Property SteeringWheelAngle;
 498         PROPERTYTYPE(SteeringWheelAngle, SteeringWheelAngleType, BasicPropertyType<uint16_t>, uint16_t)
 499
 500         /// TODO: Rename to "SteeringWheel" in 0.14
 501         static const Property SteeringWheelAngleW3C;
 502         PROPERTYTYPEBASIC(SteeringWheelAngleW3C, int16_t)
 503
 504         /**< 0=off, 1=right, 2=left, 3=hazard */
 505         static const Property TurnSignal;
 506         PROPERTYTYPEBASIC(TurnSignal, TurnSignals::TurnSignalType)
 507
 508         /**< Clutch pedal status 0=off, 1=on */
 509         static const Property ClutchStatus;
 510         PROPERTYTYPE(ClutchStatus, ClutchStatusType,BasicPropertyType<bool>,bool)
 511
 512          /**< Oil pressure TODO: units */
 513         static const Property EngineOilPressure;
 514         PROPERTYTYPE(EngineOilPressure, EngineOilPressureType, BasicPropertyType<uint16_t>, uint16_t)
 515
 516         /**< Engine coolant temperature in degrees celcius **/
 517         static const Property EngineCoolantTemperature;
 518         PROPERTYTYPEBASIC(EngineCoolantTemperature, int16_t)
 519
 520         static const Property EngineCoolantLevel;
 521         PROPERTYTYPE(EngineCoolantLevel, EngineCoolantLevelType, BasicPropertyType<uint>, uint)
 522
 523         /**< 0=off, 1=on */
 524         static const Property MachineGunTurretStatus;
 525         PROPERTYTYPEBASIC(MachineGunTurretStatus, bool)
 526
 527         static const Property AccelerationX;
 528         PROPERTYTYPEBASIC(AccelerationX, int16_t)
 529
 530         static const Property AccelerationY;
 531         PROPERTYTYPEBASIC(AccelerationY, int16_t)
 532
 533         static const Property AccelerationZ;
 534         PROPERTYTYPEBASIC(AccelerationZ, int16_t)
 535
 536         /**< Mass Air Flow.  grams/sec */
 537         static const Property MassAirFlow;
 538         PROPERTYTYPE(MassAirFlow, MassAirFlowType, BasicPropertyType<uint16_t>, uint16_t)
 539         //typedef BasicPropertyType<uint16_t> MassAirFlowType;
 540
 541         /**< Button Event @see ButtonEvents::ButtonEventType */
 542         ///TODO: deprecated.  Use ButtonEventW3C. Remove in 0.14
 543         static const Property ButtonEvent;
 544         PROPERTYTYPE(ButtonEvent, ButtonEventType, BasicPropertyType<ButtonEvents::ButtonEventType>, ButtonEvents::ButtonEventType)
 545
 546         static const Property ButtonEventW3C;
 547         class ButtonEventW3CType: public MapPropertyType<StringPropertyType>
 548         {
 549         public:
 550                 ButtonEventW3CType() : MapPropertyType(ButtonEventW3C) {}
 551         };
 552
 553
 554         /**< Air intake temperature in degrees celcius */
 555         static const Property AirIntakeTemperature;
 556         PROPERTYTYPE(AirIntakeTemperature, AirIntakeTemperatureType, BasicPropertyType<int>, int)
 557         //typedef BasicPropertyType<int> AirIntakeTemperatureType;
 558
 559         /**< Battery voltage in volts */
 560         static const Property BatteryVoltage;
 561         PROPERTYTYPE(BatteryVoltage, BatteryVoltageType, BasicPropertyType<double>, double)
 562         //typedef BasicPropertyType<double> BatteryVoltageType;
 563
 564         static const Property BatteryCurrent;
 565         PROPERTYTYPE(BatteryCurrent, BatteryCurrentType, BasicPropertyType<double>, double)
 566         //typedef BasicPropertyType<double> BatteryCurrentType;
 567
 568         static const Property BatteryChargeLevel;
 569         PROPERTYTYPEBASIC(BatteryChargeLevel, uint16_t)
 570
 571         /**< Interior Air Temperature in degrees celcius */
 572         static const Property InteriorTemperature;
 573         PROPERTYTYPE(InteriorTemperature, InteriorTemperatureType, BasicPropertyType<int>, int)
 574         //typedef BasicPropertyType<int> InteriorTemperatureType;
 575
 576         static const Property ExteriorTemperature;
 577         PROPERTYTYPE(ExteriorTemperature, ExteriorTemperatureType, BasicPropertyType<int>, int)
 578         //typedef BasicPropertyType<int> ExteriorTemperatureType;
 579
 580         static const Property EngineOilTemperature;
 581         PROPERTYTYPEBASIC(EngineOilTemperature, int)
 582
 583         static const Property EngineOilRemaining;
 584         PROPERTYTYPEBASIC(EngineOilRemaining, uint16_t)
 585
 586         static const Property EngineOilLifeRemaining;
 587         PROPERTYTYPEBASIC(EngineOilLifeRemaining, uint16_t)
 588
 589         static const Property EngineOilChangeIndicator;
 590         PROPERTYTYPEBASIC(EngineOilChangeIndicator, bool)
 591
 592         /**< Vehicle Identification Number (ISO 3779) 17 chars**/
 593         static const Property VIN;
 594         PROPERTYTYPE(VIN, VINType, StringPropertyType, std::string)
 595         //class VINType: public StringPropertyType { public: VINType(std::string val):StringPropertyType(VIN,val){} };
 596
 597         /**< World Manufacturer Identifier (SAE) 3 characters. */
 598         static const Property WMI;
 599         PROPERTYTYPE(WMI, WMIType, StringPropertyType, std::string)
 600         //class WMIType: public StringPropertyType { public: WMIType(std::string val):StringPropertyType(WMI,val){} };
 601
 602         /**< Tire pressure in kPa */
 603         static const Property TirePressure;
 604         PROPERTYTYPEBASIC(TirePressure, uint16_t)
 605
 606         /**< Tire pressure low */
 607         static const Property TirePressureLow;
 608         PROPERTYTYPEBASIC(TirePressureLow, bool)
 609
 610         /**< Tire temperature in degrees C */
 611         static const Property TireTemperature;
 612         PROPERTYTYPEBASIC(TireTemperature, int16_t)
 613
 614         /**< Vehicle Power Mode.
 615          *@see Power::Modes
 616          */
 617         static const Property VehiclePowerMode;
 618         PROPERTYTYPE(VehiclePowerMode, VehiclePowerModeType, BasicPropertyType<Power::Modes>, Power::Modes)
 619
 620         static const Property TripMeters;
 621         PROPERTYTYPE(TripMeters, TripMetersType, ListPropertyType<uint16_t>, uint16_t)
 622
 623         static const Property CruiseControlActive;
 624         PROPERTYTYPE(CruiseControlActive, CruiseControlActiveType, BasicPropertyType<bool>, bool)
 625
 626         static const Property CruiseControlSpeed;
 627         PROPERTYTYPE(CruiseControlSpeed, CruiseControlSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 628
 629         static const Property LightHead;
 630         PROPERTYTYPE(LightHead, LightHeadType, BasicPropertyType<bool>, bool)
 631         static const Property LightRightTurn;
 632         PROPERTYTYPE(LightRightTurn, LightRightTurnType, BasicPropertyType<bool>, bool)
 633         static const Property LightLeftTurn;
 634         PROPERTYTYPE(LightLeftTurn, LightLeftTurnType, BasicPropertyType<bool>, bool)
 635         static const Property LightBrake;
 636         PROPERTYTYPE(LightBrake, LightBrakeType, BasicPropertyType<bool>, bool)
 637         static const Property LightFog;
 638         PROPERTYTYPE(LightFog, LightFogType, BasicPropertyType<bool>, bool)
 639         static const Property LightHazard;
 640         PROPERTYTYPE(LightHazard, LightHazardType, BasicPropertyType<bool>, bool)
 641         static const Property LightParking;
 642         PROPERTYTYPE(LightParking, LightParkingType, BasicPropertyType<bool>, bool)
 643         static const Property LightHighBeam;
 644         PROPERTYTYPE(LightHighBeam, LightHighBeamType, BasicPropertyType<bool>, bool)
 645         static const Property LightAutomatic;
 646         PROPERTYTYPEBASIC(LightAutomatic, bool)
 647         static const Property LightDynamicHighBeam;
 648         PROPERTYTYPEBASIC(LightDynamicHighBeam, bool)
 649
 650         ///TODO: deprecated.  Use InteriorLightStatus which is zoned.  Remove in 0.14
 651         static const Property InteriorLightDriver;
 652         PROPERTYTYPE(InteriorLightDriver, InteriorLightDriverType, BasicPropertyType<bool>, bool)
 653         ///TODO: deprecated.  Use InteriorLightStatus which is zoned.  Remove in 0.14
 654         static const Property InteriorLightCenter;
 655         PROPERTYTYPE(InteriorLightCenter, InteriorLightCenterType, BasicPropertyType<bool>, bool)
 656         ///TODO: deprecated.  Use InteriorLightStatus which is zoned.  Remove in 0.14
 657         static const Property InteriorLightPassenger;
 658         PROPERTYTYPE(InteriorLightPassenger, InteriorLightPassengerType, BasicPropertyType<bool>, bool)
 659
 660         static const Property InteriorLightStatus;
 661         PROPERTYTYPEBASIC(InteriorLightStatus, bool)
 662
 663         static const Property EngineLoad;
 664         PROPERTYTYPE(EngineLoad, EngineLoadType, BasicPropertyType<uint16_t>, uint16_t)
 665
 666         static const Property Horn;
 667         PROPERTYTYPE(Horn, HornType, BasicPropertyType<bool>, bool)
 668
 669         static const Property FuelLevel;
 670         PROPERTYTYPE(FuelLevel, FuelLevelType, BasicPropertyType<uint16_t>, uint16_t)
 671
 672         static const Property FuelRange;
 673         PROPERTYTYPE(FuelRange, FuelRangeType, BasicPropertyType<uint16_t> , uint16_t)
 674
 675         static const Property FuelConsumption;
 676         PROPERTYTYPE(FuelConsumption, FuelConsumptionType, BasicPropertyType<uint>, uint)
 677
 678         static const Property FuelEconomy;
 679         PROPERTYTYPE(FuelEconomy, FuelEconomyType, BasicPropertyType<uint16_t>, uint16_t)
 680
 681         static const Property FuelAverageEconomy;
 682         PROPERTYTYPE(FuelAverageEconomy, FuelAverageEconomyType, BasicPropertyType<uint16_t> , uint16_t)
 683
 684         static const Property FuelAverageConsumption;
 685         PROPERTYTYPEBASIC(FuelAverageConsumption, uint)
 686
 687         static const Property FuelTimeSinceRestart;
 688         PROPERTYTYPEBASIC(FuelTimeSinceRestart, uint)
 689
 690         static const Property FuelConsumptionSinceRestart;
 691         PROPERTYTYPEBASIC(FuelConsumptionSinceRestart, uint)
 692
 693         static const Property FuelType;
 694         PROPERTYTYPE(FuelType, FuelTypeType, BasicPropertyType<Fuel::Type>, Fuel::Type)
 695
 696         static const Property FuelPositionSide;
 697         PROPERTYTYPE(FuelPositionSide, FuelPositionSideType, BasicPropertyType<Fuel::RefuelPosition>, Fuel::RefuelPosition)
 698
 699         static const Property ExteriorBrightness;
 700         PROPERTYTYPE(ExteriorBrightness, ExteriorBrightnessType, BasicPropertyType<uint16_t>, uint16_t)
 701
 702         static const Property Latitude;
 703         PROPERTYTYPE(Latitude, LatitudeType, BasicPropertyType<double>, double)
 704
 705         static const Property Longitude;
 706         PROPERTYTYPE(Longitude, LongitudeType, BasicPropertyType<double>, double)
 707
 708         static const Property Altitude;
 709         PROPERTYTYPE(Altitude, AltitudeType, BasicPropertyType<double> , double)
 710
 711         static const Property Direction;
 712         PROPERTYTYPE(Direction, DirectionType, BasicPropertyType<uint16_t>, uint16_t)
 713
 714         static const Property VehicleWidth;
 715         PROPERTYTYPE(VehicleWidth, VehicleWidthType, BasicPropertyType<uint>, uint)
 716         static const Property VehicleHeight;
 717         PROPERTYTYPE(VehicleHeight, VehicleHeightType, BasicPropertyType<uint>, uint)
 718         static const Property VehicleLength;
 719         PROPERTYTYPE(VehicleLength, VehicleLengthType, BasicPropertyType<uint>, uint)
 720
 721         static const Property VehicleType;
 722         PROPERTYTYPE(VehicleType, VehicleTypeType, BasicPropertyType<Vehicle::Type>, Vehicle::Type)
 723
 724         static const Property DoorsPerRow;
 725         PROPERTYTYPE(DoorsPerRow, DoorsPerRowType, ListPropertyType<uint16_t>, uint16_t)
 726
 727         static const Property TransmissionGearType;
 728         PROPERTYTYPE(TransmissionGearType, TransmissionGearTypeType, BasicPropertyType<Transmission::Type>, Transmission::Type)
 729
 730         static const Property FrontWheelRadius;
 731         PROPERTYTYPE(FrontWheelRadius, FrontWheelRadiusType, BasicPropertyType<uint16_t>, uint16_t)
 732         static const Property RearWheelRadius;
 733         PROPERTYTYPE(RearWheelRadius, RearWheelRadiusType, BasicPropertyType<uint16_t>, uint16_t)
 734
 735         static const Property WheelTrack;
 736         PROPERTYTYPE(WheelTrack, WheelTrackType, BasicPropertyType<uint>, uint)
 737
 738         static const Property BrakePressure;
 739         PROPERTYTYPEBASIC(BrakePressure, uint16_t)
 740
 741         /// TODO: deprecated.  remove in 0.14.  Use DistanceTotal
 742         static const Property Odometer;
 743         PROPERTYTYPEBASIC(Odometer, uint)
 744
 745         static const Property DistanceTotal;
 746         PROPERTYTYPEBASIC(DistanceTotal, uint)
 747
 748         static const Property DistanceSinceStart;
 749         PROPERTYTYPEBASIC(DistanceSinceStart, uint)
 750
 751         /**< Transmission Fluid Level 0-100%.
 752          **/
 753         static const Property TransmissionFluidLevel;
 754         PROPERTYTYPEBASIC(TransmissionFluidLevel, uint16_t)
 755
 756         static const Property TransmissionOilWear;
 757         PROPERTYTYPEBASIC(TransmissionOilWear, uint16_t)
 758
 759         static const Property TransmissionOilTemperature;
 760         PROPERTYTYPEBASIC(TransmissionOilTemperature, int16_t)
 761
 762         static const Property TransmissionClutchWear;
 763         PROPERTYTYPEBASIC(TransmissionClutchWear, uint16_t)
 764
 765         /**< Brake Fluid Level 0-100%.
 766          **/
 767         static const Property BrakeFluidLevel;
 768         PROPERTYTYPEBASIC(BrakeFluidLevel, uint16_t)
 769
 770         /**< Washer Fluid Level 0-100%.
 771          **/
 772         static const Property WasherFluidLevel;
 773         PROPERTYTYPEBASIC(WasherFluidLevel, uint16_t)
 774
 775         static const Property WasherFluidLevelLow;
 776         PROPERTYTYPEBASIC(WasherFluidLevelLow, bool)
 777
 778         ///TODO: Depreciated in 0.14.  Use AlarmStatus
 779         static const Property SecurityAlertStatus;
 780         PROPERTYTYPEBASIC(SecurityAlertStatus, Security::Status)
 781
 782         /**< Parking Brake Status
 783          * status of parking break active (true) or inactive (false)
 784          * TODO: Deprecated in 0.14.
 785          */
 786         static const Property ParkingBrakeStatus;
 787         PROPERTYTYPEBASIC(ParkingBrakeStatus, bool)
 788
 789         /*!
 790          * \brief ParkingBrakeStatusW3C use with ParkingBrake::W3C::*
 791          */
 792         static const Property ParkingBrakeStatusW3C;
 793         PROPERTYTYPE(ParkingBrakeStatusW3C, ParkingBrakeStatusW3CType, StringPropertyType, std::string)
 794
 795         /**< Parking Light Status
 796          * status of parking lights active (true) or inactive (false)
 797          */
 798         static const Property ParkingLightStatus;
 799         PROPERTYTYPEBASIC(ParkingLightStatus,bool)
 800
 801         /**< Hazard Lights Status
 802          * status of parking lights active (true) or inactive (false)
 803          */
 804         static const Property HazardLightStatus;
 805         PROPERTYTYPEBASIC(HazardLightStatus, bool)
 806
 807         static const Property AntilockBrakingSystem;
 808         PROPERTYTYPEBASIC(AntilockBrakingSystem, bool)
 809
 810         static const Property AntilockBrakingSystemEnabled;
 811         PROPERTYTYPEBASIC(AntilockBrakingSystemEnabled, bool)
 812
 813         static const Property TractionControlSystem;
 814         PROPERTYTYPEBASIC(TractionControlSystem, bool)
 815
 816         static const Property TractionControlSystemEnabled;
 817         PROPERTYTYPEBASIC(TractionControlSystemEnabled, bool)
 818
 819         static const Property VehicleTopSpeedLimit;
 820         PROPERTYTYPEBASIC(VehicleTopSpeedLimit,uint16_t)
 821
 822         ///TODO: Deprecated in 0.14
 823         static const Property AirbagStatus;
 824         PROPERTYTYPEBASIC(AirbagStatus, Airbag::Status)
 825
 826         static const Property AirbagActivated;
 827         PROPERTYTYPEBASIC(AirbagActivated, bool)
 828
 829         static const Property AirbagDeployed;
 830         PROPERTYTYPEBASIC(AirbagDeployed, bool)
 831
 832         /// TODO: deprecate in 0.14.  Use DoorStatusW3C
 833         static const Property DoorStatus;
 834         PROPERTYTYPEBASIC(DoorStatus, Door::Status)
 835
 836         /*!
 837          * \brief DoorStatusW3C
 838          * use with Door::W3C::*
 839          */
 840         static const Property DoorStatusW3C;
 841         PROPERTYTYPE(DoorStatusW3C, DoorStatusW3CType, StringPropertyType, std::string)
 842
 843         static const Property DoorLockStatus;
 844         PROPERTYTYPEBASIC(DoorLockStatus, bool)
 845
 846         static const Property ChildLockStatus;
 847         PROPERTYTYPEBASIC(ChildLockStatus, bool)
 848
 849         static const Property SeatBeltStatus;
 850         PROPERTYTYPEBASIC(SeatBeltStatus, bool)
 851
 852         static const Property WindowLockStatus;
 853         PROPERTYTYPEBASIC(WindowLockStatus, bool)
 854
 855         ///TODO Deprecated in 0.14
 856         static const Property OccupantStatus;
 857         PROPERTYTYPEBASIC(OccupantStatus, Seat::Occupant)
 858
 859         static const Property OccupantStatusW3C;
 860         PROPERTYTYPE(OccupantStatusW3C, OccupantStatusW3CType, StringPropertyType, std::string)
 861
 862         static const Property ObstacleDistance;
 863         PROPERTYTYPEBASIC(ObstacleDistance, double)
 864
 865         static const Property RainSensor;
 866         PROPERTYTYPEBASIC(RainSensor, uint16_t)
 867
 868         ///TODO Deprecated in 0.14.  Use WinshieldWiperSpeed
 869         static const Property WindshieldWiper;
 870         PROPERTYTYPEBASIC(WindshieldWiper, Window::WiperSpeed)
 871
 872         /*!
 873          * \brief WindshieldWiperSpeed
 874          * Use WiperSpeedSetting::W3C::* for value
 875          */
 876         static const Property WindshieldWiperSpeed;
 877         PROPERTYTYPE(WindshieldWiperSpeed, WindshieldWiperSpeedType, StringPropertyType, std::string)
 878
 879         /*!
 880          * \brief WindshieldWiperSetting
 881          * Use WiperSpeedSetting::W3C::* for value
 882          */
 883         static const Property WindshieldWiperSetting;
 884         PROPERTYTYPE(WindshieldWiperSetting, WindshieldWiperSettingType, StringPropertyType, std::string)
 885
 886         /// TODO: Deprecated.  Remove in 0.14
 887         static const Property AirflowDirection;
 888         PROPERTYTYPEBASIC(AirflowDirection,HVAC::AirflowDirection)
 889
 890         static const Property AirflowDirectionW3C;
 891         PROPERTYTYPE(AirflowDirectionW3C, AirflowDirectionW3CType, StringPropertyType, std::string)
 892
 893         static const Property FanSpeed;
 894         PROPERTYTYPEBASIC(FanSpeed, uint16_t)
 895
 896         static const Property TargetTemperature;
 897         PROPERTYTYPEBASIC(TargetTemperature, int)
 898
 899         static const Property AirConditioning;
 900         PROPERTYTYPEBASIC(AirConditioning,bool)
 901
 902         static const Property AirRecirculation;
 903         PROPERTYTYPEBASIC(AirRecirculation,bool)
 904
 905         static const Property Heater;
 906         PROPERTYTYPEBASIC(Heater, bool)
 907
 908         /// TODO: deprecated. remove in 0.14
 909         static const Property Defrost;
 910         PROPERTYTYPEBASIC(Defrost, bool )
 911
 912         static const Property DefrostWindow;
 913         PROPERTYTYPEBASIC(DefrostWindow, bool )
 914
 915         static const Property DefrostMirror;
 916         PROPERTYTYPEBASIC(DefrostMirror, bool )
 917
 918         static const Property SteeringWheelHeater;
 919         PROPERTYTYPEBASIC(SteeringWheelHeater,bool)
 920         //typedef BasicPropertyType<bool> SteeringWheelHeaterType;
 921
 922         static const Property SeatHeater;
 923         PROPERTYTYPEBASIC(SeatHeater,int)
 924         //typedef BasicPropertyType<bool> SeatHeaterType;
 925
 926         static const Property SeatCooler;
 927         PROPERTYTYPEBASIC(SeatCooler,bool)
 928 //      /typedef BasicPropertyType<bool> SeatCoolerType;
 929
 930         static const Property WindowStatus;
 931         PROPERTYTYPEBASIC(WindowStatus, uint16_t)
 932
 933         static const Property Sunroof;
 934         PROPERTYTYPEBASIC(Sunroof, uint16_t)
 935         //typedef BasicPropertyType<uint16_t> SunroofType;
 936
 937         static const Property SunroofTilt;
 938         PROPERTYTYPEBASIC(SunroofTilt,uint16_t)
 939         //typedef BasicPropertyType<uint16_t> SunroofTiltType;
 940
 941         static const Property ConvertibleRoof;
 942         PROPERTYTYPEBASIC(ConvertibleRoof, bool)
 943
 944         /*!
 945          * \brief ConvertibleRoofStatus use with ConvertibleRoofW3C::*
 946          */
 947         static const Property ConvertibleRoofStatus;
 948         PROPERTYTYPE(ConvertibleRoofStatus, ConvertibleRoofStatusType, StringPropertyType, std::string)
 949
 950         static const Property NightMode;
 951         PROPERTYTYPEBASIC(NightMode, bool)
 952
 953         static const Property DrivingMode;
 954         PROPERTYTYPEBASIC(DrivingMode, Driving::Mode)
 955
 956         static const Property DrivingModeW3C;
 957         PROPERTYTYPEBASIC(DrivingModeW3C, bool)
 958
 959         static const Property KeyId;
 960         PROPERTYTYPE(KeyId, KeyIdType, StringPropertyType, std::string)
 961
 962         static const Property Language;
 963         PROPERTYTYPE(Language, LanguageType, StringPropertyType, std::string)
 964
 965         static const Property MeasurementSystem;
 966         PROPERTYTYPEBASIC(MeasurementSystem, Measurement::Type)
 967
 968         static const Property MirrorSettingPan;
 969         static const Property MirrorSettingTilt;
 970
 971         PROPERTYTYPEBASIC(MirrorSettingPan, uint16_t)
 972         PROPERTYTYPEBASIC(MirrorSettingTilt, uint16_t)
 973
 974         static const Property SteeringWheelPositionSlide;
 975         static const Property SteeringWheelPositionTilt;
 976
 977         PROPERTYTYPEBASIC(SteeringWheelPositionSlide, uint16_t)
 978         PROPERTYTYPEBASIC(SteeringWheelPositionTilt, uint16_t)
 979
 980         static const Property SeatPositionRecline;
 981         static const Property SeatPositionSlide;
 982         static const Property SeatPositionCushionHeight;
 983         static const Property SeatPositionHeadrest;
 984         static const Property SeatPositionBackCushion;
 985         static const Property SeatPositionSideCushion;
 986
 987         PROPERTYTYPEBASIC(SeatPositionRecline, uint16_t)
 988         PROPERTYTYPEBASIC(SeatPositionSlide, uint16_t)
 989         PROPERTYTYPEBASIC(SeatPositionCushionHeight, uint16_t)
 990         PROPERTYTYPEBASIC(SeatPositionHeadrest, uint16_t)
 991         PROPERTYTYPEBASIC(SeatPositionBackCushion, uint16_t)
 992         PROPERTYTYPEBASIC(SeatPositionSideCushion, uint16_t)
 993
 994         static const Property DashboardIllumination;
 995         PROPERTYTYPEBASIC(DashboardIllumination, uint16_t)
 996
 997         static const Property GeneratedVehicleSoundMode;
 998         PROPERTYTYPEBASIC(GeneratedVehicleSoundMode, Vehicle::SoundMode)
 999
1000         static const Property DriverId;
1001         PROPERTYTYPE(DriverId, DriverIdType, StringPropertyType, std::string)
1002
1003         static const Property PowertrainTorque;
1004         PROPERTYTYPEBASIC(PowertrainTorque, uint16_t)
1005
1006         static const Property AcceleratorPedalPosition;
1007         PROPERTYTYPEBASIC(AcceleratorPedalPosition, uint16_t)
1008
1009         static const Property Chime;
1010         PROPERTYTYPEBASIC(Chime, bool)
1011
1012         static const Property WheelTick;
1013         PROPERTYTYPEBASIC(WheelTick, uint)
1014
1015         static const Property IgnitionTimeOn;
1016         PROPERTYTYPEBASIC(IgnitionTimeOn, uint64_t)
1017
1018         static const Property IgnitionTimeOff;
1019         PROPERTYTYPEBASIC(IgnitionTimeOff, uint64_t)
1020
1021         static const Property YawRate;
1022         PROPERTYTYPEBASIC(YawRate, int16_t)
1023
1024         static const Property BrakePadWear;
1025         PROPERTYTYPEBASIC(BrakePadWear, uint16_t)
1026
1027         static const Property BrakeFluidLevelLow;
1028         PROPERTYTYPEBASIC(BrakeFluidLevelLow, bool)
1029
1030         static const Property BrakesWorn;
1031         PROPERTYTYPEBASIC(BrakesWorn, bool)
1032
1033         static const Property MalfunctionIndicatorOn;
1034         PROPERTYTYPEBASIC(MalfunctionIndicatorOn, bool)
1035
1036         static const Property AccumulatedEngineRuntime;
1037         PROPERTYTYPEBASIC(AccumulatedEngineRuntime, uint32_t)
1038
1039         static const Property DistanceSinceCodeCleared;
1040         PROPERTYTYPEBASIC(DistanceSinceCodeCleared, uint32_t)
1041
1042         static const Property DistanceWithMILOn;
1043         PROPERTYTYPEBASIC(DistanceWithMILOn, uint32_t)
1044
1045         static const Property TimeRunMILOn;
1046         PROPERTYTYPEBASIC(TimeRunMILOn, uint32_t)
1047
1048         static const Property TimeTroubleCodeClear;
1049         PROPERTYTYPEBASIC(TimeTroubleCodeClear, uint32_t)
1050
1051         static const Property VehicleDriveMode;
1052         PROPERTYTYPE(VehicleDriveMode, VehicleDriveModeType, StringPropertyType, std::string)
1053
1054         static const Property ActiveNoiseControlMode;
1055         PROPERTYTYPEBASIC(ActiveNoiseControlMode, bool)
1056
1057         static const Property AvailableSounds;
1058         PROPERTYTYPE(AvailableSounds, AvailableSoundsType, ListPropertyType<std::string>, std::string)
1059
1060         static const Property EngineSoundEnhancementMode;
1061         PROPERTYTYPE(EngineSoundEnhancementMode, EngineSoundEnhancementModeType, StringPropertyType, std::string)
1062
1063         static const Property ElectronicStabilityControlEnabled;
1064         PROPERTYTYPEBASIC(ElectronicStabilityControlEnabled, bool)
1065
1066         static const Property ElectronicStabilityControlEngaged;
1067         PROPERTYTYPEBASIC(ElectronicStabilityControlEngaged, bool)
1068
1069         static const Property OccupantIdentificationType;
1070         PROPERTYTYPE(OccupantIdentificationType, OccupantIdentificationTypeType, StringPropertyType, std::string)
1071
1072         static const Property OccupantName;
1073         PROPERTYTYPE(OccupantName, OccupantNameType, StringPropertyType, std::string)
1074
1075         static const Property AtmosphericPressure;
1076         PROPERTYTYPEBASIC(AtmosphericPressure, uint16_t)
1077
1078         static const Property LaneDepartureStatus;
1079         PROPERTYTYPE(LaneDepartureStatus, LaneDepartureStatusType, StringPropertyType, std::string)
1080
1081         /*!
1082          * \brief AlarmStatus.  Use with Security::W3C*
1083          */
1084         static const Property AlarmStatus;
1085         PROPERTYTYPE(AlarmStatus, AlarmStatusType, StringPropertyType, std::string)
1086
1087         //static const Property Lane
1088
1089         /** END PROPERTIES **/
1090
1091         /*!
1092          * \brief capabilities
1093          * \return returns list of all registered properties
1094          * \see VehicleProperty::registerProperty
1095          */
1096         static PropertyList capabilities();
1097
1098         /*!
1099          * \brief customProperties
1100          * \return returns list of custom properties defined by plugins using VehicleProperty::registerProperty
1101          */
1102         static PropertyList customProperties();
1103
1104         /*! \brief getPropertyTypeForPropertyNameValue returns an AbstractPropertyType* for the property name
1105           * with the value specified by 'value'.  Ownership of the returned AbstractPropertyType* is
1106           * transfered to the caller.
1107           */
1108         static AbstractPropertyType* getPropertyTypeForPropertyNameValue(Property name, std::string value="");
1109
1110         /*! \brief registerProperty registers properties with the Vehicle Property system.  Returns true if property
1111          *  has been registered successfully.
1112          *  \param name - name of property.  Name cannot match any existing property or it will be rejected and
1113          *  this method will return false.
1114          *  \param factor - callback function that returns an AbstractPropertyType representation of the value.
1115          *  custom properties will need to return a custom AbstractPropertyType based object.
1116          *  \example :
1117          *
1118          *  #include <vehicleproperty.h>
1119          *  #include <abstractpropertytype.h>
1120          *
1121          *  //Somewhere in a source plugin:
1122          *  ...
1123          *  Property VehicleJetEngineStatus = "VehicleJetEngineStatus";
1124          *  VehicleProperty::registerProperty(VehicleJetEngineStatus, [](){return new BasicPropertyType<bool>(VehicleJetEngineStatus, false);});
1125          *  ...
1126          *  //other initialization
1127          */
1128         static bool registerProperty(Property name, PropertyTypeFactoryCallback factory);
1129
1130
1131
1132 private:
1133
1134         VehicleProperty();
1135
1136         static std::unique_ptr<VehicleProperty> thereCanOnlyBeOne;
1137
1138         static bool registerPropertyPriv(Property name, PropertyTypeFactoryCallback factory);
1139
1140         static std::map<Property, PropertyTypeFactoryCallback> registeredPropertyFactoryMap;
1141         static PropertyList mCapabilities;
1142         static PropertyList mCustomProperties;
1143 };
1144
1145 #endif // VEHICLEPROPERTY_H
1146
1147