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