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