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