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         };
 294
 295 #define PROPERTYTYPE1(property, propertyType, baseClass, valueType) \
 296         class propertyType : public baseClass { \
 297         public: propertyType(): baseClass(#property) {} \
 298         propertyType(valueType val) : baseClass(#property, val) {} \
 299         };
 300
 301 #define PROPERTYTYPEBASIC(property, valueType) \
 302         class property ## Type : public BasicPropertyType<valueType> { \
 303         public: property ## Type(): BasicPropertyType(property) {} \
 304         property ## Type(valueType val) : BasicPropertyType(property, val) {} \
 305         };
 306
 307 #define PROPERTYTYPEBASIC1(property, valueType) \
 308         class property ## Type : public BasicPropertyType<valueType> { \
 309         public: property ## Type(): BasicPropertyType( #property) {} \
 310         property ## Type(valueType val) : BasicPropertyType(#property, val) {} \
 311         };
 312
 313 #define PROPERTYTYPENOVAL(property, propertyType, baseClass) \
 314         class propertyType : public baseClass { \
 315         public: propertyType(): baseClass(property) {} \
 316         };
 317
 318 class VehicleProperty;
 319
 320
 321 typedef std::vector<std::string> PropertyList;
 322 typedef std::set<std::string> PropertySet;
 323
 324 class VehicleProperty
 325 {
 326
 327 public:
 328
 329
 330         /*!
 331          * \brief factory constructs a static instance of VehicleProperty.  This should be called once before VehicleProperty is used in the app
 332          */
 333         static void factory();
 334
 335         /*!
 336          *
 337          * \brief destroys static instance of VehicleProperty. This should be called at application shutdown
 338          */
 339         static void shutdown();
 340
 341         typedef std::string Property;
 342
 343         /*!
 344          * \brief PropertyTypeFactoryCallback callback used to construct a AbstractPropertyType for a property
 345          * \see registerProperty
 346          */
 347         typedef std::function<AbstractPropertyType* (void)> PropertyTypeFactoryCallback;
 348
 349         /// Various property types:
 350
 351         static const Property NoValue;
 352
 353         /**< Vehicle Velocity in km/h */
 354         static const Property VehicleSpeed;
 355         PROPERTYTYPE(VehicleSpeed, VehicleSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 356         //typedef BasicPropertyType<uint16_t> VehicleSpeedType;
 357
 358         /**< Engine Speed in rotations per minute */
 359         static const Property EngineSpeed;
 360         PROPERTYTYPE(EngineSpeed, EngineSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 361         //typedef BasicPropertyType<uint16_t> EngineSpeedType;
 362
 363          /**< Transmission Shift Position
 364          * 0 = Neutral
 365          * 1 = 1st
 366          * 2 = 2nd
 367          * ...
 368          * 96 = Drive
 369          * 128 = Reverse
 370          * 255 = Park
 371          */
 372         static const Property TransmissionShiftPosition;
 373         PROPERTYTYPE(TransmissionShiftPosition, TransmissionShiftPositionType,
 374                                  BasicPropertyType<Transmission::TransmissionPositions>, Transmission::TransmissionPositions )
 375         //typedef BasicPropertyType<Transmission::TransmissionPositions> TransmissionShiftPositionType;
 376
 377         /**< Transmission Gear Position
 378         * 0 = Neutral
 379         * 1 = 1st
 380         * 2 = 2nd
 381         * ...
 382         * 64 = CVT
 383         * 128 = Reverse
 384         */
 385         static const Property TransmissionGearPosition;
 386         PROPERTYTYPE(TransmissionGearPosition, TransmissionGearPositionType,
 387                                  BasicPropertyType<Transmission::TransmissionPositions>, Transmission::TransmissionPositions)
 388         //typedef BasicPropertyType<Transmission::TransmissionPositions> TransmissionGearPositionType;
 389
 390         /// TODO: deprecate in 0.13.  Replaced by Drive::Mode
 391         static const Property TransmissionMode;
 392         PROPERTYTYPE(TransmissionMode, TransmissionModeType,
 393                                  BasicPropertyType<Transmission::Mode>, Transmission::Mode)
 394         //typedef BasicPropertyType<Transmission::Mode> TransmissionModeType;
 395
 396         /**< TransmissionModeW3C
 397          * see Transmission::W3C::Park, Transmission::W3C::Drive, etc
 398          */
 399         static const Property TransmissionModeW3C;
 400         PROPERTYTYPE(TransmissionModeW3C, TransmissionModeW3CType, StringPropertyType, std::string)
 401
 402         /**< Throttle position 0-100% */
 403         static const Property ThrottlePosition;
 404         PROPERTYTYPE(ThrottlePosition, ThrottlePositionType, BasicPropertyType<uint16_t> , uint16_t)
 405         //typedef BasicPropertyType<uint16_t> ThrottlePositionType;
 406
 407         /**< Wheel brake position.  Engaged = true, Idle = false */
 408         static const Property WheelBrake;
 409         PROPERTYTYPE(WheelBrake, WheelBrakeType, BasicPropertyType<bool>, bool)
 410         //typedef BasicPropertyType<bool> WheelBrakeType;
 411
 412         static const Property WheelBrakePressure;
 413         PROPERTYTYPE(WheelBrakePressure, WheelBrakePressureType, BasicPropertyType<uint16_t>, uint16_t)
 414         //typedef BasicPropertyType<uint16_t> WheelBrakePressureType;
 415
 416         /**< Steering wheel angle (0-359)
 417          * TODO: Deprecate in 0.13.  Replace with SteeringWheelAngleW3C
 418         */
 419         static const Property SteeringWheelAngle;
 420         PROPERTYTYPE(SteeringWheelAngle, SteeringWheelAngleType, BasicPropertyType<uint16_t>, uint16_t)
 421         //typedef BasicPropertyType<uint16_t> SteeringWheelAngleType;
 422
 423         /// TODO: Rename to "SteeringWheel" in 0.13
 424         static const Property SteeringWheelAngleW3C;
 425         PROPERTYTYPE(SteeringWheelAngleW3C, SteeringWheelAngleW3CType, BasicPropertyType<int16_t>, int16_t)
 426
 427         /**< 0=off, 1=right, 2=left, 3=hazard */
 428         static const Property TurnSignal;
 429         PROPERTYTYPE(TurnSignal, TurnSignalType, BasicPropertyType<TurnSignals::TurnSignalType> ,TurnSignals::TurnSignalType)
 430         //typedef BasicPropertyType<TurnSignals::TurnSignalType> TurnSignalType;
 431
 432         /**< Clutch pedal status 0=off, 1=on */
 433         static const Property ClutchStatus;
 434         PROPERTYTYPE(ClutchStatus, ClutchStatusType,BasicPropertyType<bool>,bool)
 435         //typedef BasicPropertyType<bool> ClutchStatusType;
 436
 437          /**< Oil pressure TODO: units */
 438         static const Property EngineOilPressure;
 439         PROPERTYTYPE(EngineOilPressure, EngineOilPressureType,BasicPropertyType<uint16_t>, uint16_t)
 440         //typedef BasicPropertyType<uint16_t> EngineOilPressureType;
 441
 442         /**< Engine coolant temperature in degrees celcius **/
 443         static const Property EngineCoolantTemperature;
 444         PROPERTYTYPE(EngineCoolantTemperature, EngineCoolantTemperatureType, BasicPropertyType<uint>, uint)
 445         //typedef BasicPropertyType<int> EngineCoolantTemperatureType;
 446
 447         static const Property EngineCoolantLevel;
 448         PROPERTYTYPE(EngineCoolantLevel, EngineCoolantLevelType, BasicPropertyType<uint>, uint)
 449
 450         /**< 0=off, 1=on */
 451         static const Property MachineGunTurretStatus;
 452         PROPERTYTYPE(MachineGunTurretStatus, MachineGunTurretStatusType, BasicPropertyType<bool>, bool)
 453         //typedef BasicPropertyType<bool> MachineGunTurretStatusType;
 454
 455         /**< Acceleration on the 'x' axis in 1/1000 gravitational acceleration "g-force" */
 456         static const Property AccelerationX;
 457         PROPERTYTYPE(AccelerationX, AccelerationXType, BasicPropertyType<uint16_t>, uint16_t)
 458         //typedef BasicPropertyType<uint16_t> AccelerationType;
 459
 460         /**< Acceleration on the 'y' axis in 1/1000 gravitational acceleration "g-force" */
 461         static const Property AccelerationY;
 462         PROPERTYTYPE(AccelerationY, AccelerationYType, BasicPropertyType<uint16_t>, uint16_t)
 463
 464         /**< Acceleration on the 'z' axis in 1/1000 gravitational acceleration "g-force" */
 465         static const Property AccelerationZ;
 466         PROPERTYTYPE(AccelerationZ, AccelerationZType, BasicPropertyType<uint16_t>, uint16_t)
 467
 468         /**< Mass Air Flow.  grams/sec */
 469         static const Property MassAirFlow;
 470         PROPERTYTYPE(MassAirFlow, MassAirFlowType, BasicPropertyType<uint16_t>, uint16_t)
 471         //typedef BasicPropertyType<uint16_t> MassAirFlowType;
 472
 473         /**< Button Event @see ButtonEvents::ButtonEventType */
 474         static const Property ButtonEvent;
 475         PROPERTYTYPE(ButtonEvent, ButtonEventType, BasicPropertyType<ButtonEvents::ButtonEventType>, ButtonEvents::ButtonEventType)
 476         //typedef BasicPropertyType<ButtonEvents::ButtonEventType> ButtonEventType;
 477
 478         /**< Air intake temperature in degrees celcius */
 479         static const Property AirIntakeTemperature;
 480         PROPERTYTYPE(AirIntakeTemperature, AirIntakeTemperatureType, BasicPropertyType<int>, int)
 481         //typedef BasicPropertyType<int> AirIntakeTemperatureType;
 482
 483         /**< Battery voltage in volts */
 484         static const Property BatteryVoltage;
 485         PROPERTYTYPE(BatteryVoltage, BatteryVoltageType, BasicPropertyType<double>, double)
 486         //typedef BasicPropertyType<double> BatteryVoltageType;
 487
 488         static const Property BatteryCurrent;
 489         PROPERTYTYPE(BatteryCurrent, BatteryCurrentType, BasicPropertyType<double>, double)
 490         //typedef BasicPropertyType<double> BatteryCurrentType;
 491
 492         static const Property BatteryChargeLevel;
 493         PROPERTYTYPEBASIC(BatteryChargeLevel, uint16_t)
 494
 495         /**< Interior Air Temperature in degrees celcius */
 496         static const Property InteriorTemperature;
 497         PROPERTYTYPE(InteriorTemperature, InteriorTemperatureType, BasicPropertyType<int>, int)
 498         //typedef BasicPropertyType<int> InteriorTemperatureType;
 499
 500         static const Property ExteriorTemperature;
 501         PROPERTYTYPE(ExteriorTemperature, ExteriorTemperatureType, BasicPropertyType<int>, int)
 502         //typedef BasicPropertyType<int> ExteriorTemperatureType;
 503
 504         /**< Engine Oil Temperature in degrees celcius */
 505         static const Property EngineOilTemperature;
 506         PROPERTYTYPE(EngineOilTemperature, EngineOilTemperatureType, BasicPropertyType<int>, int)
 507         //typedef BasicPropertyType<int> EngineOilTemperatureType;
 508
 509         static const Property EngineOilRemaining;
 510         PROPERTYTYPE(EngineOilRemaining, EngineOilRemainingType,BasicPropertyType<uint16_t>, uint16_t)
 511         //typedef BasicPropertyType<uint16_t> EngineOilRemainingType;
 512
 513         /**< Vehicle Identification Number (ISO 3779) 17 chars**/
 514         static const Property VIN;
 515         PROPERTYTYPE(VIN, VINType, StringPropertyType, std::string)
 516         //class VINType: public StringPropertyType { public: VINType(std::string val):StringPropertyType(VIN,val){} };
 517
 518         /**< World Manufacturer Identifier (SAE) 3 characters. */
 519         static const Property WMI;
 520         PROPERTYTYPE(WMI, WMIType, StringPropertyType, std::string)
 521         //class WMIType: public StringPropertyType { public: WMIType(std::string val):StringPropertyType(WMI,val){} };
 522
 523         /**< Tire pressure in kPa */
 524         static const Property TirePressure;
 525         PROPERTYTYPEBASIC(TirePressure, uint16_t)
 526
 527         /**< Tire pressure low */
 528         static const Property TirePressureLow;
 529         PROPERTYTYPEBASIC(TirePressureLow, bool)
 530
 531         /**< Tire temperature in degrees C */
 532         static const Property TireTemperature;
 533         PROPERTYTYPEBASIC(TireTemperature, int16_t)
 534
 535         /**< Vehicle Power Mode.
 536          *@see Power::PowerModes
 537          */
 538         static const Property VehiclePowerMode;
 539         PROPERTYTYPE(VehiclePowerMode, VehiclePowerModeType, BasicPropertyType<Power::PowerModes> ,Power::PowerModes)
 540         //typedef BasicPropertyType<Power::PowerModes> VehiclePowerModeType;
 541
 542         static const Property TripMeters;
 543         PROPERTYTYPE(TripMeters, TripMetersType, ListPropertyType<BasicPropertyType<uint16_t> >, AbstractPropertyType*)
 544         //typedef ListPropertyType<BasicPropertyType<uint16_t> > TripMetersType;
 545
 546         static const Property CruiseControlActive;
 547         PROPERTYTYPE(CruiseControlActive, CruiseControlActiveType, BasicPropertyType<bool>, bool)
 548         //typedef BasicPropertyType<bool> CruiseControlActiveType;
 549
 550         static const Property CruiseControlSpeed;
 551         PROPERTYTYPE(CruiseControlSpeed, CruiseControlSpeedType, BasicPropertyType<uint16_t>, uint16_t)
 552         //typedef BasicPropertyType<uint16_t> CruiseControlSpeedType;
 553
 554         static const Property LightHead;
 555         PROPERTYTYPE(LightHead, LightHeadType, BasicPropertyType<bool>, bool)
 556         static const Property LightRightTurn;
 557         PROPERTYTYPE(LightRightTurn, LightRightTurnType, BasicPropertyType<bool>, bool)
 558         static const Property LightLeftTurn;
 559         PROPERTYTYPE(LightLeftTurn, LightLeftTurnType, BasicPropertyType<bool>, bool)
 560         static const Property LightBrake;
 561         PROPERTYTYPE(LightBrake, LightBrakeType, BasicPropertyType<bool>, bool)
 562         static const Property LightFog;
 563         PROPERTYTYPE(LightFog, LightFogType, BasicPropertyType<bool>, bool)
 564         static const Property LightHazard;
 565         PROPERTYTYPE(LightHazard, LightHazardType, BasicPropertyType<bool>, bool)
 566         static const Property LightParking;
 567         PROPERTYTYPE(LightParking, LightParkingType, BasicPropertyType<bool>, bool)
 568         static const Property LightHighBeam;
 569         PROPERTYTYPE(LightHighBeam, LightHighBeamType, BasicPropertyType<bool>, bool)
 570         static const Property LightAutomatic;
 571         PROPERTYTYPEBASIC(LightAutomatic, bool)
 572         static const Property LightDynamicHighBeam;
 573         PROPERTYTYPEBASIC(LightDynamicHighBeam, bool)
 574
 575
 576         static const Property InteriorLightDriver;
 577         PROPERTYTYPE(InteriorLightDriver, InteriorLightDriverType, BasicPropertyType<bool>, bool)
 578         static const Property InteriorLightCenter;
 579         PROPERTYTYPE(InteriorLightCenter, InteriorLightCenterType, BasicPropertyType<bool>, bool)
 580         static const Property InteriorLightPassenger;
 581         PROPERTYTYPE(InteriorLightPassenger, InteriorLightPassengerType, BasicPropertyType<bool>, bool)
 582
 583         static const Property EngineLoad;
 584         PROPERTYTYPE(EngineLoad, EngineLoadType, BasicPropertyType<uint16_t>, uint16_t)
 585
 586         static const Property Horn;
 587         PROPERTYTYPE(Horn, HornType, BasicPropertyType<bool>, bool)
 588
 589         static const Property FuelLevel;
 590         PROPERTYTYPE(FuelLevel, FuelLevelType, BasicPropertyType<uint16_t>, uint16_t)
 591
 592         static const Property FuelRange;
 593         PROPERTYTYPE(FuelRange, FuelRangeType, BasicPropertyType<uint16_t> , uint16_t)
 594
 595         static const Property FuelConsumption;
 596         PROPERTYTYPE(FuelConsumption, FuelConsumptionType, BasicPropertyType<uint>, uint)
 597
 598         static const Property FuelEconomy;
 599         PROPERTYTYPE(FuelEconomy, FuelEconomyType, BasicPropertyType<uint16_t>, uint16_t)
 600
 601         static const Property FuelAverageEconomy;
 602         PROPERTYTYPE(FuelAverageEconomy, FuelAverageEconomyType, BasicPropertyType<uint16_t> , uint16_t)
 603
 604         static const Property FuelAverageConsumption;
 605         PROPERTYTYPEBASIC(FuelAverageConsumption, uint)
 606
 607         static const Property FuelTimeSinceRestart;
 608         PROPERTYTYPEBASIC(FuelTimeSinceRestart, uint)
 609
 610         static const Property FuelConsumptionSinceRestart;
 611         PROPERTYTYPEBASIC(FuelConsumptionSinceRestart, uint)
 612
 613         static const Property FuelType;
 614         PROPERTYTYPE(FuelType, FuelTypeType, BasicPropertyType<Fuel::Type>, Fuel::Type)
 615
 616         static const Property FuelPositionSide;
 617         PROPERTYTYPE(FuelPositionSide, FuelPositionSideType, BasicPropertyType<Fuel::RefuelPosition>, Fuel::RefuelPosition)
 618
 619         static const Property ExteriorBrightness;
 620         PROPERTYTYPE(ExteriorBrightness, ExteriorBrightnessType, BasicPropertyType<uint16_t>, uint16_t)
 621
 622         static const Property Latitude;
 623         PROPERTYTYPE(Latitude, LatitudeType, BasicPropertyType<double>, double)
 624
 625         static const Property Longitude;
 626         PROPERTYTYPE(Longitude, LongitudeType, BasicPropertyType<double>, double)
 627
 628         static const Property Altitude;
 629         PROPERTYTYPE(Altitude, AltitudeType, BasicPropertyType<double> , double)
 630
 631         static const Property Direction;
 632         PROPERTYTYPE(Direction, DirectionType, BasicPropertyType<uint16_t>, uint16_t)
 633
 634         static const Property VehicleWidth;
 635         PROPERTYTYPE(VehicleWidth, VehicleWidthType, BasicPropertyType<uint>, uint)
 636         static const Property VehicleHeight;
 637         PROPERTYTYPE(VehicleHeight, VehicleHeightType, BasicPropertyType<uint>, uint)
 638         static const Property VehicleLength;
 639         PROPERTYTYPE(VehicleLength, VehicleLengthType, BasicPropertyType<uint>, uint)
 640         //typedef BasicPropertyType<uint> VehicleSizeType;
 641
 642         static const Property VehicleType;
 643         PROPERTYTYPE(VehicleType, VehicleTypeType, BasicPropertyType<Vehicle::Type>, Vehicle::Type)
 644         //typedef BasicPropertyType<Vehicle::Type> VehicleTypeType;
 645
 646         static const Property DoorsPerRow;
 647         PROPERTYTYPE(DoorsPerRow, DoorsPerRowType, ListPropertyType<BasicPropertyType<uint16_t> >, AbstractPropertyType*)
 648         //typedef ListPropertyType<BasicPropertyType<uint16_t> > DoorsPerRowType;
 649
 650         static const Property TransmissionGearType;
 651         PROPERTYTYPE(TransmissionGearType, TransmissionGearTypeType, BasicPropertyType<Transmission::Type>, Transmission::Type)
 652         //typedef BasicPropertyType<Transmission::Type> TransmissionGearTypeType;
 653
 654         static const Property FrontWheelRadius;
 655         PROPERTYTYPE(FrontWheelRadius, FrontWheelRadiusType, BasicPropertyType<uint16_t>, uint16_t)
 656         static const Property RearWheelRadius;
 657         PROPERTYTYPE(RearWheelRadius, RearWheelRadiusType, BasicPropertyType<uint16_t>, uint16_t)
 658 //      /typedef BasicPropertyType<uint16_t> WheelRadiusType;
 659
 660         static const Property WheelTrack;
 661         PROPERTYTYPE(WheelTrack, WheelTrackType, BasicPropertyType<uint>, uint)
 662 //      typedef BasicPropertyType<uint> WheelTrackType;
 663
 664         static const Property BrakePressure;
 665         PROPERTYTYPEBASIC(BrakePressure, uint16_t)
 666         //typedef BasicPropertyType<uint16_t> BrakePressureType;
 667
 668         /// TODO: deprecated.  remove in 0.13.  Use DistanceTotal
 669         static const Property Odometer;
 670         PROPERTYTYPEBASIC(Odometer, uint)
 671
 672         static const Property DistanceTotal;
 673         PROPERTYTYPEBASIC(DistanceTotal, uint)
 674
 675         static const Property DistanceSinceStart;
 676         PROPERTYTYPEBASIC(DistanceSinceStart, uint)
 677
 678         /**< Transmission Fluid Level 0-100%.
 679          **/
 680         static const Property TransmissionFluidLevel;
 681         PROPERTYTYPEBASIC(TransmissionFluidLevel, uint16_t)
 682         //typedef BasicPropertyType<uint16_t> TransmissionFluidLevelType;
 683
 684         /**< Brake Fluid Level 0-100%.
 685          **/
 686         static const Property BrakeFluidLevel;
 687         PROPERTYTYPEBASIC(BrakeFluidLevel, uint16_t)
 688         //typedef BasicPropertyType<uint16_t> BrakeFluidLevelType;
 689
 690         /**< Washer Fluid Level 0-100%.
 691          **/
 692         static const Property WasherFluidLevel;
 693         PROPERTYTYPEBASIC(WasherFluidLevel, uint16_t)
 694         //typedef BasicPropertyType<uint16_t> WasherFluidLevelType;
 695
 696         /**< Securty Alert Status
 697          * status of security alert
 698          * @see Security::Status
 699          */
 700         static const Property SecurityAlertStatus;
 701         PROPERTYTYPEBASIC(SecurityAlertStatus, Security::Status)
 702         //typedef BasicPropertyType<Security::Status> SecurityAlertStatusType;
 703
 704         /**< Parking Brake Status
 705          * status of parking break active (true) or inactive (false)
 706          */
 707         static const Property ParkingBrakeStatus;
 708         PROPERTYTYPEBASIC(ParkingBrakeStatus, bool)
 709         //typedef BasicPropertyType<bool> ParkingBrakeStatusType;
 710
 711         /**< Parking Light Status
 712          * status of parking lights active (true) or inactive (false)
 713          */
 714         static const Property ParkingLightStatus;
 715         PROPERTYTYPEBASIC(ParkingLightStatus,bool)
 716         //typedef BasicPropertyType<bool> ParkingLightStatusType;
 717
 718         /**< Hazard Lights Status
 719          * status of parking lights active (true) or inactive (false)
 720          */
 721         static const Property HazardLightStatus;
 722         PROPERTYTYPEBASIC(HazardLightStatus, bool)
 723         //typedef BasicPropertyType<bool> HazardLightStatusType;
 724
 725         static const Property AntilockBrakingSystem;
 726         PROPERTYTYPEBASIC(AntilockBrakingSystem, bool)
 727         //typedef BasicPropertyType<bool> AntilockBrakingSystemType;
 728
 729         static const Property TractionControlSystem;
 730         PROPERTYTYPEBASIC(TractionControlSystem, bool)
 731         //typedef BasicPropertyType<bool> TractionControlSystemType;
 732
 733         static const Property VehicleTopSpeedLimit;
 734         PROPERTYTYPEBASIC(VehicleTopSpeedLimit,uint16_t)
 735         //typedef BasicPropertyType<uint16_t> VehicleTopSpeedLimitType;
 736
 737         static const Property AirbagStatus;
 738         PROPERTYTYPEBASIC(AirbagStatus, Airbag::Status)
 739
 740         /// TODO: deprecate in 0.13.  Use DoorStatusW3C
 741         static const Property DoorStatus;
 742         PROPERTYTYPEBASIC(DoorStatus, Door::Status)
 743
 744         /** use with Door::W3C::*
 745          */
 746         static const Property DoorStatusW3C;
 747         PROPERTYTYPE(DoorStatusW3C, DoorStatusW3CType, StringPropertyType, std::string)
 748
 749         static const Property DoorLockStatus;
 750         PROPERTYTYPEBASIC(DoorLockStatus, bool)
 751
 752         static const Property ChildLockStatus;
 753         PROPERTYTYPEBASIC(ChildLockStatus, bool)
 754
 755         static const Property SeatBeltStatus;
 756         PROPERTYTYPEBASIC(SeatBeltStatus, bool)
 757
 758         static const Property WindowLockStatus;
 759         PROPERTYTYPEBASIC(WindowLockStatus, bool)
 760
 761         static const Property OccupantStatus;
 762         PROPERTYTYPEBASIC(OccupantStatus, Seat::Occupant)
 763
 764         static const Property ObstacleDistance;
 765         PROPERTYTYPEBASIC(ObstacleDistance, double)
 766
 767         static const Property RainSensor;
 768         PROPERTYTYPEBASIC(RainSensor, uint16_t)
 769         //typedef BasicPropertyType<uint16_t> RainSensorType;
 770
 771         static const Property WindshieldWiper;
 772         PROPERTYTYPEBASIC(WindshieldWiper,Window::WiperSpeed)
 773         //typedef BasicPropertyType<Window::WiperSpeed> WindshieldWiperType;
 774
 775         /// TODO: Deprecated.  Remove in 0.13
 776         static const Property AirflowDirection;
 777         PROPERTYTYPEBASIC(AirflowDirection,HVAC::AirflowDirection)
 778
 779         static const Property AirflowDirectionW3C;
 780         PROPERTYTYPE(AirflowDirectionW3C, AirflowDirectionW3CType, StringPropertyType, std::string)
 781
 782         static const Property FanSpeed;
 783         PROPERTYTYPEBASIC(FanSpeed, uint16_t)
 784
 785         static const Property TargetTemperature;
 786         PROPERTYTYPEBASIC(TargetTemperature, int)
 787
 788         static const Property AirConditioning;
 789         PROPERTYTYPEBASIC(AirConditioning,bool)
 790
 791         static const Property AirRecirculation;
 792         PROPERTYTYPEBASIC(AirRecirculation,bool)
 793
 794         static const Property Heater;
 795         PROPERTYTYPEBASIC(Heater, bool)
 796
 797         /// TODO: deprecated. remove in 0.13
 798         static const Property Defrost;
 799         PROPERTYTYPEBASIC(Defrost, bool )
 800
 801         static const Property DefrostWindow;
 802         PROPERTYTYPEBASIC(DefrostWindow, bool )
 803
 804         static const Property DefrostMirror;
 805         PROPERTYTYPEBASIC(DefrostMirror, bool )
 806
 807         static const Property SteeringWheelHeater;
 808         PROPERTYTYPEBASIC(SteeringWheelHeater,bool)
 809         //typedef BasicPropertyType<bool> SteeringWheelHeaterType;
 810
 811         static const Property SeatHeater;
 812         PROPERTYTYPEBASIC(SeatHeater,int)
 813         //typedef BasicPropertyType<bool> SeatHeaterType;
 814
 815         static const Property SeatCooler;
 816         PROPERTYTYPEBASIC(SeatCooler,bool)
 817 //      /typedef BasicPropertyType<bool> SeatCoolerType;
 818
 819         static const Property WindowStatus;
 820         PROPERTYTYPEBASIC(WindowStatus, uint16_t)
 821
 822         static const Property Sunroof;
 823         PROPERTYTYPEBASIC(Sunroof, uint16_t)
 824         //typedef BasicPropertyType<uint16_t> SunroofType;
 825
 826         static const Property SunroofTilt;
 827         PROPERTYTYPEBASIC(SunroofTilt,uint16_t)
 828         //typedef BasicPropertyType<uint16_t> SunroofTiltType;
 829
 830         static const Property ConvertibleRoof;
 831         PROPERTYTYPEBASIC(ConvertibleRoof, bool)
 832         //typedef BasicPropertyType<bool> ConvertibleRoofType;
 833
 834         static const Property NightMode;
 835         PROPERTYTYPEBASIC(NightMode, bool)
 836
 837         static const Property DrivingMode;
 838         PROPERTYTYPEBASIC(DrivingMode, Driving::Mode)
 839
 840         static const Property DrivingModeW3C;
 841         PROPERTYTYPEBASIC(DrivingModeW3C, bool)
 842
 843         static const Property KeyId;
 844         PROPERTYTYPE(KeyId, KeyIdType, StringPropertyType, std::string)
 845
 846         static const Property Language;
 847         PROPERTYTYPE(Language, LanguageType, StringPropertyType, std::string)
 848
 849         static const Property MeasurementSystem;
 850         PROPERTYTYPEBASIC(MeasurementSystem, Measurement::Type)
 851
 852         static const Property MirrorSettingPan;
 853         static const Property MirrorSettingTilt;
 854
 855         PROPERTYTYPEBASIC(MirrorSettingPan, uint16_t)
 856         PROPERTYTYPEBASIC(MirrorSettingTilt, uint16_t)
 857
 858         static const Property SteeringWheelPositionSlide;
 859         static const Property SteeringWheelPositionTilt;
 860
 861         PROPERTYTYPEBASIC(SteeringWheelPositionSlide, uint16_t)
 862         PROPERTYTYPEBASIC(SteeringWheelPositionTilt, uint16_t)
 863
 864         static const Property SeatPositionRecline;
 865         static const Property SeatPositionSlide;
 866         static const Property SeatPositionCushionHeight;
 867         static const Property SeatPositionHeadrest;
 868         static const Property SeatPositionBackCushion;
 869         static const Property SeatPositionSideCushion;
 870
 871         PROPERTYTYPEBASIC(SeatPositionRecline, uint16_t)
 872         PROPERTYTYPEBASIC(SeatPositionSlide, uint16_t)
 873         PROPERTYTYPEBASIC(SeatPositionCushionHeight, uint16_t)
 874         PROPERTYTYPEBASIC(SeatPositionHeadrest, uint16_t)
 875         PROPERTYTYPEBASIC(SeatPositionBackCushion, uint16_t)
 876         PROPERTYTYPEBASIC(SeatPositionSideCushion, uint16_t)
 877
 878         static const Property DashboardIllumination;
 879         PROPERTYTYPEBASIC(DashboardIllumination, uint16_t)
 880
 881         static const Property GeneratedVehicleSoundMode;
 882         PROPERTYTYPEBASIC(GeneratedVehicleSoundMode, Vehicle::SoundMode)
 883
 884         static const Property DriverId;
 885         PROPERTYTYPE(DriverId, DriverIdType, StringPropertyType, std::string)
 886
 887
 888         /** END PROPERTIES **/
 889
 890
 891         /*!
 892          * \brief capabilities
 893          * \return returns list of all registered properties
 894          * \see VehicleProperty::registerProperty
 895          */
 896         static PropertyList capabilities();
 897
 898         /*!
 899          * \brief customProperties
 900          * \return returns list of custom properties defined by plugins using VehicleProperty::registerProperty
 901          */
 902         static PropertyList customProperties();
 903
 904         /*! \brief getPropertyTypeForPropertyNameValue returns an AbstractPropertyType* for the property name
 905           * with the value specified by 'value'.  Ownership of the returned AbstractPropertyType* is
 906           * transfered to the caller.
 907           */
 908         static AbstractPropertyType* getPropertyTypeForPropertyNameValue(Property name, std::string value="");
 909
 910         /*! \brief registerProperty registers properties with the Vehicle Property system.  Returns true if property
 911          *  has been registered successfully.
 912          *  \param name - name of property.  Name cannot match any existing property or it will be rejected and
 913          *  this method will return false.
 914          *  \param factor - callback function that returns an AbstractPropertyType representation of the value.
 915          *  custom properties will need to return a custom AbstractPropertyType based object.
 916          *  \example :
 917          *
 918          *  #include <vehicleproperty.h>
 919          *  #include <abstractpropertytype.h>
 920          *
 921          *  //Somewhere in a source plugin:
 922          *  ...
 923          *  Property VehicleJetEngineStatus = "VehicleJetEngineStatus";
 924          *  VehicleProperty::registerProperty(VehicleJetEngineStatus, [](){return new BasicPropertyType<bool>(VehicleJetEngineStatus, false);});
 925          *  ...
 926          *  //other initialization
 927          */
 928         static bool registerProperty(Property name, PropertyTypeFactoryCallback factory);
 929
 930
 931
 932 private:
 933
 934         VehicleProperty();
 935
 936         static VehicleProperty* thereCanOnlyBeOne;
 937
 938         static bool registerPropertyPriv(Property name, PropertyTypeFactoryCallback factory);
 939
 940         static std::map<Property, PropertyTypeFactoryCallback> registeredPropertyFactoryMap;
 941         static PropertyList mCapabilities;
 942         static PropertyList mCustomProperties;
 943 };
 944
 945 #endif // VEHICLEPROPERTY_H
 946