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
  53 namespace TurnSignals {
  54 enum TurnSignalType
  55 {
  56         Off=0,
  57         Right=1,
  58         Left=2,
  59         Hazard=3
  60 };
  61 }
  62
  63 namespace Transmission {
  64 enum TransmissionPositions
  65 {
  66         Neutral = 0,
  67         First,
  68         Second,
  69         Third,
  70         Forth,
  71         Fifth,
  72         Sixth,
  73         Seventh,
  74         Eighth,
  75         Ninth,
  76         Tenth,
  77         CVT = 64,
  78         Drive = 96,
  79         Reverse = 128,
  80         Park = 255
  81
  82 };
  83 /** TODO: deprecate in 0.13.  Replaced with Drive::Mode: **/
  84 enum Mode {
  85         Normal=0,
  86         Sports = 1,
  87         Economy = 2,
  88         OEMCustom1 = 3,
  89         OEMCustom2 = 4
  90 };
  91
  92 enum Type {
  93         Unknown = -1,
  94         Auto = 0,
  95         Manual = 1,
  96         CV = 2
  97 };
  98
  99 namespace W3C
 100 {
 101 extern const char* Park;
 102 extern const char* Reverse;
 103 extern const char* Neutral;
 104 extern const char* Low;
 105 extern const char* Drive;
 106 extern const char* Overdrive;
 107 }
 108 }
 109
 110 namespace Power {
 111 /**< Vehicle Power Modes
 112  * Off = Vehicle is off and key is in the "off" position.
 113  * Accessory1 = Vehicle is off and key is in Accessory1 position.
 114  * Accessory2 = Vehicle is off and key is in Accessory2 position.
 115  * Run = Vehichle is running.  Key is in the running position.
 116  */
 117 enum PowerModes
 118 {
 119         Off = 0,
 120         Accessory1 = 1,
 121         Accessory2 = 2,
 122         Run = 3
 123 };
 124 }
 125
 126 namespace Fuel{
 127 enum Type
 128 {
 129         Unknown = -1,
 130         Gasoline = 0,
 131         High_Octane,
 132         Diesel,
 133         Electric,
 134         Hydrogen
 135 };
 136
 137 enum RefuelPosition
 138 {
 139         UnknownPosition = -1,
 140         Left = 0,
 141         Right,
 142         Front,
 143         Rear
 144 };
 145 }
 146
 147 namespace Vehicle {
 148 enum Type
 149 {
 150         Unknown = -1,
 151         Sedan = 0,
 152         Coupe,
 153         Cabriole,
 154         Roadster,
 155         SUV,
 156         Truck
 157 };
 158 enum SoundMode {
 159         Normal = 0,
 160         Quiet = 1,
 161         Sportive = 2
 162 };
 163 }
 164
 165 namespace Security {
 166 enum Status
 167 {
 168         Idle = 0,
 169         Armed,
 170         AlarmDetected
 171 };
 172 }
 173
 174 namespace Airbag {
 175
 176 enum Status
 177 {
 178         Inactive = 0,
 179         Active,
 180         Deployed
 181 };
 182
 183 }
 184
 185 namespace Door
 186 {
 187 enum Status
 188 {
 189         Closed = 0,
 190         Open,
 191         Ajar
 192 };
 193 namespace W3C
 194 {
 195 extern const char * Closed;
 196 extern const char * Open;
 197 extern const char * Ajar;
 198 }
 199 }
 200
 201 namespace Seat
 202 {
 203
 204 enum Occupant
 205 {
 206         Vacant = 0,
 207         Child,
 208         Adult
 209 };
 210 }
 211
 212 namespace Window
 213 {
 214 enum Location
 215 {
 216         Driver = 0,
 217         Passenger,
 218         LeftRear,
 219         RightRear,
 220         Sunroof,
 221         Windshield,
 222         SideMirrorLeft,
 223         SideMirrorRight,
 224         Rear
 225 };
 226
 227 enum WiperSpeed
 228 {
 229         Off = 0,
 230         Slowest = 1,
 231         Fastest = 5,
 232         Auto = 10
 233 };
 234
 235 }
 236
 237 namespace HVAC
 238 {
 239 enum AirflowDirection
 240 {
 241         FrontPanel=0,
 242         FloorDuct = 1,
 243         Front = 1 << 1,
 244         Defroster = 1 << 2
 245
 246 };
 247
 248 namespace W3C
 249 {
 250 extern const char * FloorPanel;
 251 extern const char * FloorDuct;
 252 extern const char * Bilevel;
 253 extern const char * DefrostFloor;
 254 }
 255 }
 256
 257 namespace Driving
 258 {
 259 enum Mode
 260 {
 261         None = 0,
 262         Driving
 263 };
 264 }
 265
 266 namespace Drive
 267 {
 268 enum Mode {
 269         Normal=0,
 270         Sports = 1,
 271         Economy = 2,
 272         OEMCustom1 = 3,
 273         OEMCustom2 = 4
 274 };
 275 }
 276
 277 namespace Measurement
 278 {
 279 enum Type
 280 {
 281         Metric = 0,
 282         ImperialUS = 1,
 283         ImperialUK = 2
 284 };
 285 }
 286
 287 #include <boost/preprocessor/comma.hpp>
 288
 289 #define PROPERTYTYPE(property, propertyType, baseClass, valueType) \
 290         class propertyType : public baseClass { \
 291         public: propertyType(): baseClass(property) {} \
 292         propertyType(valueType val) : baseClass(property, val) {} \
 293         using baseClass::operator=; \
 294         };
 295
 296 #define PROPERTYTYPE1(property, propertyType, baseClass, valueType) \
 297         class propertyType : public baseClass { \
 298         public: propertyType(): baseClass(#property) {} \
 299         propertyType(valueType val) : baseClass(#property, val) {} \
 300         };
 301
 302 #define PROPERTYTYPEBASIC(property, valueType) \
 303         class property ## Type : public BasicPropertyType<valueType> { \
 304         public: property ## Type(): BasicPropertyType(property) {} \
 305         property ## Type(valueType val) : BasicPropertyType(property, val) {} \
 306         using BasicPropertyType<valueType>::operator=; \
 307         };
 308
 309 #define PROPERTYTYPEBASIC1(property, valueType) \
 310         class property ## Type : public BasicPropertyType<valueType> { \
 311         public: property ## Type(): BasicPropertyType( #property) {} \
 312         property ## Type(valueType val) : BasicPropertyType(#property, val) {} \
 313         };
 314
 315 #define PROPERTYTYPENOVAL(property, propertyType, baseClass) \
 316         class propertyType : public baseClass { \
 317         public: propertyType(): baseClass(property) {} \
 318         };
 319
 320 class VehicleProperty;
 321
 322
 323 typedef std::vector<std::string> PropertyList;
 324 typedef std::set<std::string> PropertySet;
 325
 326 class VehicleProperty
 327 {
 328
 329 public:
 330
 331
 332         /*!
 333          * \brief factory constructs a static instance of VehicleProperty.  This should be called once before VehicleProperty is used in the app
 334          */
 335         static void factory();
 336
 337         /*!
 338          *
 339          * \brief destroys static instance of VehicleProperty. This should be called at application shutdown
 340          */
 341         static void shutdown();
 342
 343         typedef std::string Property;
 344
 345         /*!
 346          * \brief PropertyTypeFactoryCallback callback used to construct a AbstractPropertyType for a property
 347          * \see registerProperty
 348          */
 349         typedef std::function<AbstractPropertyType* (void)> PropertyTypeFactoryCallback;
 350
 351         /// Various property types:
 352
 353         static const Property NoValue;
 354
 355         /**< Vehicle Velocity in km/h */
 356         static const Property VehicleSpeed;
 357         PROPERTYTYPE(VehicleSpeed, VehicleSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 358         //typedef BasicPropertyType<uint16_t> VehicleSpeedType;
 359
 360         /**< Engine Speed in rotations per minute */
 361         static const Property EngineSpeed;
 362         PROPERTYTYPE(EngineSpeed, EngineSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 363         //typedef BasicPropertyType<uint16_t> EngineSpeedType;
 364
 365          /**< Transmission Shift Position
 366          * 0 = Neutral
 367          * 1 = 1st
 368          * 2 = 2nd
 369          * ...
 370          * 96 = Drive
 371          * 128 = Reverse
 372          * 255 = Park
 373          */
 374         static const Property TransmissionShiftPosition;
 375         PROPERTYTYPE(TransmissionShiftPosition, TransmissionShiftPositionType,
 376                                  BasicPropertyType<Transmission::TransmissionPositions>, Transmission::TransmissionPositions )
 377         //typedef BasicPropertyType<Transmission::TransmissionPositions> TransmissionShiftPositionType;
 378
 379         /**< Transmission Gear Position
 380         * 0 = Neutral
 381         * 1 = 1st
 382         * 2 = 2nd
 383         * ...
 384         * 64 = CVT
 385         * 128 = Reverse
 386         */
 387         static const Property TransmissionGearPosition;
 388         PROPERTYTYPE(TransmissionGearPosition, TransmissionGearPositionType,
 389                                  BasicPropertyType<Transmission::TransmissionPositions>, Transmission::TransmissionPositions)
 390         //typedef BasicPropertyType<Transmission::TransmissionPositions> TransmissionGearPositionType;
 391
 392         /// TODO: deprecate in 0.13.  Replaced by Drive::Mode
 393         static const Property TransmissionMode;
 394         PROPERTYTYPE(TransmissionMode, TransmissionModeType,
 395                                  BasicPropertyType<Transmission::Mode>, Transmission::Mode)
 396         //typedef BasicPropertyType<Transmission::Mode> TransmissionModeType;
 397
 398         /**< TransmissionModeW3C
 399          * see Transmission::W3C::Park, Transmission::W3C::Drive, etc
 400          */
 401         static const Property TransmissionModeW3C;
 402         PROPERTYTYPE(TransmissionModeW3C, TransmissionModeW3CType, StringPropertyType, std::string)
 403
 404         /**< Throttle position 0-100% */
 405         static const Property ThrottlePosition;
 406         PROPERTYTYPE(ThrottlePosition, ThrottlePositionType, BasicPropertyType<uint16_t> , uint16_t)
 407         //typedef BasicPropertyType<uint16_t> ThrottlePositionType;
 408
 409         /**< Wheel brake position.  Engaged = true, Idle = false */
 410         static const Property WheelBrake;
 411         PROPERTYTYPE(WheelBrake, WheelBrakeType, BasicPropertyType<bool>, bool)
 412         //typedef BasicPropertyType<bool> WheelBrakeType;
 413
 414         static const Property WheelBrakePressure;
 415         PROPERTYTYPE(WheelBrakePressure, WheelBrakePressureType, BasicPropertyType<uint16_t>, uint16_t)
 416         //typedef BasicPropertyType<uint16_t> WheelBrakePressureType;
 417
 418         /**< Steering wheel angle (0-359)
 419          * TODO: Deprecate in 0.13.  Replace with SteeringWheelAngleW3C
 420         */
 421         static const Property SteeringWheelAngle;
 422         PROPERTYTYPE(SteeringWheelAngle, SteeringWheelAngleType, BasicPropertyType<uint16_t>, uint16_t)
 423
 424         /// TODO: Rename to "SteeringWheel" in 0.13
 425         static const Property SteeringWheelAngleW3C;
 426         PROPERTYTYPEBASIC(SteeringWheelAngleW3C, int16_t)
 427
 428         /**< 0=off, 1=right, 2=left, 3=hazard */
 429         static const Property TurnSignal;
 430         PROPERTYTYPEBASIC(TurnSignal, TurnSignals::TurnSignalType)
 431
 432         /**< Clutch pedal status 0=off, 1=on */
 433         static const Property ClutchStatus;
 434         PROPERTYTYPE(ClutchStatus, ClutchStatusType,BasicPropertyType<bool>,bool)
 435
 436          /**< Oil pressure TODO: units */
 437         static const Property EngineOilPressure;
 438         PROPERTYTYPE(EngineOilPressure, EngineOilPressureType, BasicPropertyType<uint16_t>, uint16_t)
 439
 440         /**< Engine coolant temperature in degrees celcius **/
 441         static const Property EngineCoolantTemperature;
 442         PROPERTYTYPE(EngineCoolantTemperature, EngineCoolantTemperatureType, BasicPropertyType<int>, int)
 443
 444         static const Property EngineCoolantLevel;
 445         PROPERTYTYPE(EngineCoolantLevel, EngineCoolantLevelType, BasicPropertyType<uint>, uint)
 446
 447         /**< 0=off, 1=on */
 448         static const Property MachineGunTurretStatus;
 449         PROPERTYTYPEBASIC(MachineGunTurretStatus, bool)
 450
 451         /**< Acceleration on the 'x' axis in 1/1000 gravitational acceleration "g-force" */
 452         static const Property AccelerationX;
 453         PROPERTYTYPE(AccelerationX, AccelerationXType, BasicPropertyType<uint16_t>, uint16_t)
 454
 455         /**< Acceleration on the 'y' axis in 1/1000 gravitational acceleration "g-force" */
 456         static const Property AccelerationY;
 457         PROPERTYTYPE(AccelerationY, AccelerationYType, BasicPropertyType<uint16_t>, uint16_t)
 458
 459         /**< Acceleration on the 'z' axis in 1/1000 gravitational acceleration "g-force" */
 460         static const Property AccelerationZ;
 461         PROPERTYTYPE(AccelerationZ, AccelerationZType, BasicPropertyType<uint16_t>, uint16_t)
 462
 463         /**< Mass Air Flow.  grams/sec */
 464         static const Property MassAirFlow;
 465         PROPERTYTYPE(MassAirFlow, MassAirFlowType, BasicPropertyType<uint16_t>, uint16_t)
 466         //typedef BasicPropertyType<uint16_t> MassAirFlowType;
 467
 468         /**< Button Event @see ButtonEvents::ButtonEventType */
 469         static const Property ButtonEvent;
 470         PROPERTYTYPE(ButtonEvent, ButtonEventType, BasicPropertyType<ButtonEvents::ButtonEventType>, ButtonEvents::ButtonEventType)
 471         //typedef BasicPropertyType<ButtonEvents::ButtonEventType> ButtonEventType;
 472
 473         /**< Air intake temperature in degrees celcius */
 474         static const Property AirIntakeTemperature;
 475         PROPERTYTYPE(AirIntakeTemperature, AirIntakeTemperatureType, BasicPropertyType<int>, int)
 476         //typedef BasicPropertyType<int> AirIntakeTemperatureType;
 477
 478         /**< Battery voltage in volts */
 479         static const Property BatteryVoltage;
 480         PROPERTYTYPE(BatteryVoltage, BatteryVoltageType, BasicPropertyType<double>, double)
 481         //typedef BasicPropertyType<double> BatteryVoltageType;
 482
 483         static const Property BatteryCurrent;
 484         PROPERTYTYPE(BatteryCurrent, BatteryCurrentType, BasicPropertyType<double>, double)
 485         //typedef BasicPropertyType<double> BatteryCurrentType;
 486
 487         static const Property BatteryChargeLevel;
 488         PROPERTYTYPEBASIC(BatteryChargeLevel, uint16_t)
 489
 490         /**< Interior Air Temperature in degrees celcius */
 491         static const Property InteriorTemperature;
 492         PROPERTYTYPE(InteriorTemperature, InteriorTemperatureType, BasicPropertyType<int>, int)
 493         //typedef BasicPropertyType<int> InteriorTemperatureType;
 494
 495         static const Property ExteriorTemperature;
 496         PROPERTYTYPE(ExteriorTemperature, ExteriorTemperatureType, BasicPropertyType<int>, int)
 497         //typedef BasicPropertyType<int> ExteriorTemperatureType;
 498
 499         /**< Engine Oil Temperature in degrees celcius */
 500         static const Property EngineOilTemperature;
 501         PROPERTYTYPE(EngineOilTemperature, EngineOilTemperatureType, BasicPropertyType<int>, int)
 502         //typedef BasicPropertyType<int> EngineOilTemperatureType;
 503
 504         static const Property EngineOilRemaining;
 505         PROPERTYTYPE(EngineOilRemaining, EngineOilRemainingType,BasicPropertyType<uint16_t>, uint16_t)
 506         //typedef BasicPropertyType<uint16_t> EngineOilRemainingType;
 507
 508         /**< Vehicle Identification Number (ISO 3779) 17 chars**/
 509         static const Property VIN;
 510         PROPERTYTYPE(VIN, VINType, StringPropertyType, std::string)
 511         //class VINType: public StringPropertyType { public: VINType(std::string val):StringPropertyType(VIN,val){} };
 512
 513         /**< World Manufacturer Identifier (SAE) 3 characters. */
 514         static const Property WMI;
 515         PROPERTYTYPE(WMI, WMIType, StringPropertyType, std::string)
 516         //class WMIType: public StringPropertyType { public: WMIType(std::string val):StringPropertyType(WMI,val){} };
 517
 518         /**< Tire pressure in kPa */
 519         static const Property TirePressure;
 520         PROPERTYTYPEBASIC(TirePressure, uint16_t)
 521
 522         /**< Tire pressure low */
 523         static const Property TirePressureLow;
 524         PROPERTYTYPEBASIC(TirePressureLow, bool)
 525
 526         /**< Tire temperature in degrees C */
 527         static const Property TireTemperature;
 528         PROPERTYTYPEBASIC(TireTemperature, int16_t)
 529
 530         /**< Vehicle Power Mode.
 531          *@see Power::PowerModes
 532          */
 533         static const Property VehiclePowerMode;
 534         PROPERTYTYPE(VehiclePowerMode, VehiclePowerModeType, BasicPropertyType<Power::PowerModes> ,Power::PowerModes)
 535         //typedef BasicPropertyType<Power::PowerModes> VehiclePowerModeType;
 536
 537         static const Property TripMeters;
 538         PROPERTYTYPE(TripMeters, TripMetersType, ListPropertyType<BasicPropertyType<uint16_t> >, AbstractPropertyType*)
 539         //typedef ListPropertyType<BasicPropertyType<uint16_t> > TripMetersType;
 540
 541         static const Property CruiseControlActive;
 542         PROPERTYTYPE(CruiseControlActive, CruiseControlActiveType, BasicPropertyType<bool>, bool)
 543         //typedef BasicPropertyType<bool> CruiseControlActiveType;
 544
 545         static const Property CruiseControlSpeed;
 546         PROPERTYTYPE(CruiseControlSpeed, CruiseControlSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 547         //typedef BasicPropertyType<uint16_t> CruiseControlSpeedType;
 548
 549         static const Property LightHead;
 550         PROPERTYTYPE(LightHead, LightHeadType, BasicPropertyType<bool>, bool)
 551         static const Property LightRightTurn;
 552         PROPERTYTYPE(LightRightTurn, LightRightTurnType, BasicPropertyType<bool>, bool)
 553         static const Property LightLeftTurn;
 554         PROPERTYTYPE(LightLeftTurn, LightLeftTurnType, BasicPropertyType<bool>, bool)
 555         static const Property LightBrake;
 556         PROPERTYTYPE(LightBrake, LightBrakeType, BasicPropertyType<bool>, bool)
 557         static const Property LightFog;
 558         PROPERTYTYPE(LightFog, LightFogType, BasicPropertyType<bool>, bool)
 559         static const Property LightHazard;
 560         PROPERTYTYPE(LightHazard, LightHazardType, BasicPropertyType<bool>, bool)
 561         static const Property LightParking;
 562         PROPERTYTYPE(LightParking, LightParkingType, BasicPropertyType<bool>, bool)
 563         static const Property LightHighBeam;
 564         PROPERTYTYPE(LightHighBeam, LightHighBeamType, BasicPropertyType<bool>, bool)
 565         static const Property LightAutomatic;
 566         PROPERTYTYPEBASIC(LightAutomatic, bool)
 567         static const Property LightDynamicHighBeam;
 568         PROPERTYTYPEBASIC(LightDynamicHighBeam, bool)
 569
 570
 571         static const Property InteriorLightDriver;
 572         PROPERTYTYPE(InteriorLightDriver, InteriorLightDriverType, BasicPropertyType<bool>, bool)
 573         static const Property InteriorLightCenter;
 574         PROPERTYTYPE(InteriorLightCenter, InteriorLightCenterType, BasicPropertyType<bool>, bool)
 575         static const Property InteriorLightPassenger;
 576         PROPERTYTYPE(InteriorLightPassenger, InteriorLightPassengerType, BasicPropertyType<bool>, bool)
 577
 578         static const Property EngineLoad;
 579         PROPERTYTYPE(EngineLoad, EngineLoadType, BasicPropertyType<uint16_t>, uint16_t)
 580
 581         static const Property Horn;
 582         PROPERTYTYPE(Horn, HornType, BasicPropertyType<bool>, bool)
 583
 584         static const Property FuelLevel;
 585         PROPERTYTYPE(FuelLevel, FuelLevelType, BasicPropertyType<uint16_t>, uint16_t)
 586
 587         static const Property FuelRange;
 588         PROPERTYTYPE(FuelRange, FuelRangeType, BasicPropertyType<uint16_t> , uint16_t)
 589
 590         static const Property FuelConsumption;
 591         PROPERTYTYPE(FuelConsumption, FuelConsumptionType, BasicPropertyType<uint>, uint)
 592
 593         static const Property FuelEconomy;
 594         PROPERTYTYPE(FuelEconomy, FuelEconomyType, BasicPropertyType<uint16_t>, uint16_t)
 595
 596         static const Property FuelAverageEconomy;
 597         PROPERTYTYPE(FuelAverageEconomy, FuelAverageEconomyType, BasicPropertyType<uint16_t> , uint16_t)
 598
 599         static const Property FuelAverageConsumption;
 600         PROPERTYTYPEBASIC(FuelAverageConsumption, uint)
 601
 602         static const Property FuelTimeSinceRestart;
 603         PROPERTYTYPEBASIC(FuelTimeSinceRestart, uint)
 604
 605         static const Property FuelConsumptionSinceRestart;
 606         PROPERTYTYPEBASIC(FuelConsumptionSinceRestart, uint)
 607
 608         static const Property FuelType;
 609         PROPERTYTYPE(FuelType, FuelTypeType, BasicPropertyType<Fuel::Type>, Fuel::Type)
 610
 611         static const Property FuelPositionSide;
 612         PROPERTYTYPE(FuelPositionSide, FuelPositionSideType, BasicPropertyType<Fuel::RefuelPosition>, Fuel::RefuelPosition)
 613
 614         static const Property ExteriorBrightness;
 615         PROPERTYTYPE(ExteriorBrightness, ExteriorBrightnessType, BasicPropertyType<uint16_t>, uint16_t)
 616
 617         static const Property Latitude;
 618         PROPERTYTYPE(Latitude, LatitudeType, BasicPropertyType<double>, double)
 619
 620         static const Property Longitude;
 621         PROPERTYTYPE(Longitude, LongitudeType, BasicPropertyType<double>, double)
 622
 623         static const Property Altitude;
 624         PROPERTYTYPE(Altitude, AltitudeType, BasicPropertyType<double> , double)
 625
 626         static const Property Direction;
 627         PROPERTYTYPE(Direction, DirectionType, BasicPropertyType<uint16_t>, uint16_t)
 628
 629         static const Property VehicleWidth;
 630         PROPERTYTYPE(VehicleWidth, VehicleWidthType, BasicPropertyType<uint>, uint)
 631         static const Property VehicleHeight;
 632         PROPERTYTYPE(VehicleHeight, VehicleHeightType, BasicPropertyType<uint>, uint)
 633         static const Property VehicleLength;
 634         PROPERTYTYPE(VehicleLength, VehicleLengthType, BasicPropertyType<uint>, uint)
 635         //typedef BasicPropertyType<uint> VehicleSizeType;
 636
 637         static const Property VehicleType;
 638         PROPERTYTYPE(VehicleType, VehicleTypeType, BasicPropertyType<Vehicle::Type>, Vehicle::Type)
 639         //typedef BasicPropertyType<Vehicle::Type> VehicleTypeType;
 640
 641         static const Property DoorsPerRow;
 642         PROPERTYTYPE(DoorsPerRow, DoorsPerRowType, ListPropertyType<BasicPropertyType<uint16_t> >, AbstractPropertyType*)
 643         //typedef ListPropertyType<BasicPropertyType<uint16_t> > DoorsPerRowType;
 644
 645         static const Property TransmissionGearType;
 646         PROPERTYTYPE(TransmissionGearType, TransmissionGearTypeType, BasicPropertyType<Transmission::Type>, Transmission::Type)
 647         //typedef BasicPropertyType<Transmission::Type> TransmissionGearTypeType;
 648
 649         static const Property FrontWheelRadius;
 650         PROPERTYTYPE(FrontWheelRadius, FrontWheelRadiusType, BasicPropertyType<uint16_t>, uint16_t)
 651         static const Property RearWheelRadius;
 652         PROPERTYTYPE(RearWheelRadius, RearWheelRadiusType, BasicPropertyType<uint16_t>, uint16_t)
 653 //      /typedef BasicPropertyType<uint16_t> WheelRadiusType;
 654
 655         static const Property WheelTrack;
 656         PROPERTYTYPE(WheelTrack, WheelTrackType, BasicPropertyType<uint>, uint)
 657 //      typedef BasicPropertyType<uint> WheelTrackType;
 658
 659         static const Property BrakePressure;
 660         PROPERTYTYPEBASIC(BrakePressure, uint16_t)
 661         //typedef BasicPropertyType<uint16_t> BrakePressureType;
 662
 663         /// TODO: deprecated.  remove in 0.13.  Use DistanceTotal
 664         static const Property Odometer;
 665         PROPERTYTYPEBASIC(Odometer, uint)
 666
 667         static const Property DistanceTotal;
 668         PROPERTYTYPEBASIC(DistanceTotal, uint)
 669
 670         static const Property DistanceSinceStart;
 671         PROPERTYTYPEBASIC(DistanceSinceStart, uint)
 672
 673         /**< Transmission Fluid Level 0-100%.
 674          **/
 675         static const Property TransmissionFluidLevel;
 676         PROPERTYTYPEBASIC(TransmissionFluidLevel, uint16_t)
 677         //typedef BasicPropertyType<uint16_t> TransmissionFluidLevelType;
 678
 679         /**< Brake Fluid Level 0-100%.
 680          **/
 681         static const Property BrakeFluidLevel;
 682         PROPERTYTYPEBASIC(BrakeFluidLevel, uint16_t)
 683         //typedef BasicPropertyType<uint16_t> BrakeFluidLevelType;
 684
 685         /**< Washer Fluid Level 0-100%.
 686          **/
 687         static const Property WasherFluidLevel;
 688         PROPERTYTYPEBASIC(WasherFluidLevel, uint16_t)
 689         //typedef BasicPropertyType<uint16_t> WasherFluidLevelType;
 690
 691         /**< Securty Alert Status
 692          * status of security alert
 693          * @see Security::Status
 694          */
 695         static const Property SecurityAlertStatus;
 696         PROPERTYTYPEBASIC(SecurityAlertStatus, Security::Status)
 697         //typedef BasicPropertyType<Security::Status> SecurityAlertStatusType;
 698
 699         /**< Parking Brake Status
 700          * status of parking break active (true) or inactive (false)
 701          */
 702         static const Property ParkingBrakeStatus;
 703         PROPERTYTYPEBASIC(ParkingBrakeStatus, bool)
 704         //typedef BasicPropertyType<bool> ParkingBrakeStatusType;
 705
 706         /**< Parking Light Status
 707          * status of parking lights active (true) or inactive (false)
 708          */
 709         static const Property ParkingLightStatus;
 710         PROPERTYTYPEBASIC(ParkingLightStatus,bool)
 711         //typedef BasicPropertyType<bool> ParkingLightStatusType;
 712
 713         /**< Hazard Lights Status
 714          * status of parking lights active (true) or inactive (false)
 715          */
 716         static const Property HazardLightStatus;
 717         PROPERTYTYPEBASIC(HazardLightStatus, bool)
 718         //typedef BasicPropertyType<bool> HazardLightStatusType;
 719
 720         static const Property AntilockBrakingSystem;
 721         PROPERTYTYPEBASIC(AntilockBrakingSystem, bool)
 722         //typedef BasicPropertyType<bool> AntilockBrakingSystemType;
 723
 724         static const Property TractionControlSystem;
 725         PROPERTYTYPEBASIC(TractionControlSystem, bool)
 726         //typedef BasicPropertyType<bool> TractionControlSystemType;
 727
 728         static const Property VehicleTopSpeedLimit;
 729         PROPERTYTYPEBASIC(VehicleTopSpeedLimit,uint16_t)
 730         //typedef BasicPropertyType<uint16_t> VehicleTopSpeedLimitType;
 731
 732         static const Property AirbagStatus;
 733         PROPERTYTYPEBASIC(AirbagStatus, Airbag::Status)
 734
 735         /// TODO: deprecate in 0.13.  Use DoorStatusW3C
 736         static const Property DoorStatus;
 737         PROPERTYTYPEBASIC(DoorStatus, Door::Status)
 738
 739         /** use with Door::W3C::*
 740          */
 741         static const Property DoorStatusW3C;
 742         PROPERTYTYPE(DoorStatusW3C, DoorStatusW3CType, StringPropertyType, std::string)
 743
 744         static const Property DoorLockStatus;
 745         PROPERTYTYPEBASIC(DoorLockStatus, bool)
 746
 747         static const Property ChildLockStatus;
 748         PROPERTYTYPEBASIC(ChildLockStatus, bool)
 749
 750         static const Property SeatBeltStatus;
 751         PROPERTYTYPEBASIC(SeatBeltStatus, bool)
 752
 753         static const Property WindowLockStatus;
 754         PROPERTYTYPEBASIC(WindowLockStatus, bool)
 755
 756         static const Property OccupantStatus;
 757         PROPERTYTYPEBASIC(OccupantStatus, Seat::Occupant)
 758
 759         static const Property ObstacleDistance;
 760         PROPERTYTYPEBASIC(ObstacleDistance, double)
 761
 762         static const Property RainSensor;
 763         PROPERTYTYPEBASIC(RainSensor, uint16_t)
 764         //typedef BasicPropertyType<uint16_t> RainSensorType;
 765
 766         static const Property WindshieldWiper;
 767         PROPERTYTYPEBASIC(WindshieldWiper,Window::WiperSpeed)
 768         //typedef BasicPropertyType<Window::WiperSpeed> WindshieldWiperType;
 769
 770         /// TODO: Deprecated.  Remove in 0.13
 771         static const Property AirflowDirection;
 772         PROPERTYTYPEBASIC(AirflowDirection,HVAC::AirflowDirection)
 773
 774         static const Property AirflowDirectionW3C;
 775         PROPERTYTYPE(AirflowDirectionW3C, AirflowDirectionW3CType, StringPropertyType, std::string)
 776
 777         static const Property FanSpeed;
 778         PROPERTYTYPEBASIC(FanSpeed, uint16_t)
 779
 780         static const Property TargetTemperature;
 781         PROPERTYTYPEBASIC(TargetTemperature, int)
 782
 783         static const Property AirConditioning;
 784         PROPERTYTYPEBASIC(AirConditioning,bool)
 785
 786         static const Property AirRecirculation;
 787         PROPERTYTYPEBASIC(AirRecirculation,bool)
 788
 789         static const Property Heater;
 790         PROPERTYTYPEBASIC(Heater, bool)
 791
 792         /// TODO: deprecated. remove in 0.13
 793         static const Property Defrost;
 794         PROPERTYTYPEBASIC(Defrost, bool )
 795
 796         static const Property DefrostWindow;
 797         PROPERTYTYPEBASIC(DefrostWindow, bool )
 798
 799         static const Property DefrostMirror;
 800         PROPERTYTYPEBASIC(DefrostMirror, bool )
 801
 802         static const Property SteeringWheelHeater;
 803         PROPERTYTYPEBASIC(SteeringWheelHeater,bool)
 804         //typedef BasicPropertyType<bool> SteeringWheelHeaterType;
 805
 806         static const Property SeatHeater;
 807         PROPERTYTYPEBASIC(SeatHeater,int)
 808         //typedef BasicPropertyType<bool> SeatHeaterType;
 809
 810         static const Property SeatCooler;
 811         PROPERTYTYPEBASIC(SeatCooler,bool)
 812 //      /typedef BasicPropertyType<bool> SeatCoolerType;
 813
 814         static const Property WindowStatus;
 815         PROPERTYTYPEBASIC(WindowStatus, uint16_t)
 816
 817         static const Property Sunroof;
 818         PROPERTYTYPEBASIC(Sunroof, uint16_t)
 819         //typedef BasicPropertyType<uint16_t> SunroofType;
 820
 821         static const Property SunroofTilt;
 822         PROPERTYTYPEBASIC(SunroofTilt,uint16_t)
 823         //typedef BasicPropertyType<uint16_t> SunroofTiltType;
 824
 825         static const Property ConvertibleRoof;
 826         PROPERTYTYPEBASIC(ConvertibleRoof, bool)
 827         //typedef BasicPropertyType<bool> ConvertibleRoofType;
 828
 829         static const Property NightMode;
 830         PROPERTYTYPEBASIC(NightMode, bool)
 831
 832         static const Property DrivingMode;
 833         PROPERTYTYPEBASIC(DrivingMode, Driving::Mode)
 834
 835         static const Property DrivingModeW3C;
 836         PROPERTYTYPEBASIC(DrivingModeW3C, bool)
 837
 838         static const Property KeyId;
 839         PROPERTYTYPE(KeyId, KeyIdType, StringPropertyType, std::string)
 840
 841         static const Property Language;
 842         PROPERTYTYPE(Language, LanguageType, StringPropertyType, std::string)
 843
 844         static const Property MeasurementSystem;
 845         PROPERTYTYPEBASIC(MeasurementSystem, Measurement::Type)
 846
 847         static const Property MirrorSettingPan;
 848         static const Property MirrorSettingTilt;
 849
 850         PROPERTYTYPEBASIC(MirrorSettingPan, uint16_t)
 851         PROPERTYTYPEBASIC(MirrorSettingTilt, uint16_t)
 852
 853         static const Property SteeringWheelPositionSlide;
 854         static const Property SteeringWheelPositionTilt;
 855
 856         PROPERTYTYPEBASIC(SteeringWheelPositionSlide, uint16_t)
 857         PROPERTYTYPEBASIC(SteeringWheelPositionTilt, uint16_t)
 858
 859         static const Property SeatPositionRecline;
 860         static const Property SeatPositionSlide;
 861         static const Property SeatPositionCushionHeight;
 862         static const Property SeatPositionHeadrest;
 863         static const Property SeatPositionBackCushion;
 864         static const Property SeatPositionSideCushion;
 865
 866         PROPERTYTYPEBASIC(SeatPositionRecline, uint16_t)
 867         PROPERTYTYPEBASIC(SeatPositionSlide, uint16_t)
 868         PROPERTYTYPEBASIC(SeatPositionCushionHeight, uint16_t)
 869         PROPERTYTYPEBASIC(SeatPositionHeadrest, uint16_t)
 870         PROPERTYTYPEBASIC(SeatPositionBackCushion, uint16_t)
 871         PROPERTYTYPEBASIC(SeatPositionSideCushion, uint16_t)
 872
 873         static const Property DashboardIllumination;
 874         PROPERTYTYPEBASIC(DashboardIllumination, uint16_t)
 875
 876         static const Property GeneratedVehicleSoundMode;
 877         PROPERTYTYPEBASIC(GeneratedVehicleSoundMode, Vehicle::SoundMode)
 878
 879         static const Property DriverId;
 880         PROPERTYTYPE(DriverId, DriverIdType, StringPropertyType, std::string)
 881
 882
 883         /** END PROPERTIES **/
 884
 885
 886         /*!
 887          * \brief capabilities
 888          * \return returns list of all registered properties
 889          * \see VehicleProperty::registerProperty
 890          */
 891         static PropertyList capabilities();
 892
 893         /*!
 894          * \brief customProperties
 895          * \return returns list of custom properties defined by plugins using VehicleProperty::registerProperty
 896          */
 897         static PropertyList customProperties();
 898
 899         /*! \brief getPropertyTypeForPropertyNameValue returns an AbstractPropertyType* for the property name
 900           * with the value specified by 'value'.  Ownership of the returned AbstractPropertyType* is
 901           * transfered to the caller.
 902           */
 903         static AbstractPropertyType* getPropertyTypeForPropertyNameValue(Property name, std::string value="");
 904
 905         /*! \brief registerProperty registers properties with the Vehicle Property system.  Returns true if property
 906          *  has been registered successfully.
 907          *  \param name - name of property.  Name cannot match any existing property or it will be rejected and
 908          *  this method will return false.
 909          *  \param factor - callback function that returns an AbstractPropertyType representation of the value.
 910          *  custom properties will need to return a custom AbstractPropertyType based object.
 911          *  \example :
 912          *
 913          *  #include <vehicleproperty.h>
 914          *  #include <abstractpropertytype.h>
 915          *
 916          *  //Somewhere in a source plugin:
 917          *  ...
 918          *  Property VehicleJetEngineStatus = "VehicleJetEngineStatus";
 919          *  VehicleProperty::registerProperty(VehicleJetEngineStatus, [](){return new BasicPropertyType<bool>(VehicleJetEngineStatus, false);});
 920          *  ...
 921          *  //other initialization
 922          */
 923         static bool registerProperty(Property name, PropertyTypeFactoryCallback factory);
 924
 925
 926
 927 private:
 928
 929         VehicleProperty();
 930
 931         static VehicleProperty* thereCanOnlyBeOne;
 932
 933         static bool registerPropertyPriv(Property name, PropertyTypeFactoryCallback factory);
 934
 935         static std::map<Property, PropertyTypeFactoryCallback> registeredPropertyFactoryMap;
 936         static PropertyList mCapabilities;
 937         static PropertyList mCustomProperties;
 938 };
 939
 940 #endif // VEHICLEPROPERTY_H
 941