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