PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h

   1 /*
   2 * This file was generated by the CommonAPI Generators.
   3 * Used org.genivi.commonapi.core 2.1.5.201312121915.
   4 * Used org.franca.core 0.8.11.201401091023.
   5 *
   6 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
   7 * If a copy of the MPL was not distributed with this file, You can obtain one at
   8 * http://mozilla.org/MPL/2.0/.
   9 */
  10 /**
  11  * @author Christian Linke
  12  */
  13 #ifndef ORG_GENIVI_am_H_
  14 #define ORG_GENIVI_am_H_
  15
  16
  17
  18 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
  19 #define COMMONAPI_INTERNAL_COMPILATION
  20 #endif
  21
  22 #include <CommonAPI/InputStream.h>
  23 #include <CommonAPI/OutputStream.h>
  24 #include <CommonAPI/SerializableStruct.h>
  25 #include <CommonAPI/SerializableVariant.h>
  26 #include <CommonAPI/types.h>
  27 #include <cstdint>
  28 #include <memory>
  29 #include <string>
  30 #include <vector>
  31
  32 #undef COMMONAPI_INTERNAL_COMPILATION
  33
  34 namespace org {
  35 namespace genivi {
  36
  37 namespace am {
  38     /**
  39      * a source ID
  40      */
  41     /**
  42      * a source ID
  43      */
  44     typedef uint16_t am_sourceID_t;
  45     /**
  46      * a mainConnection ID
  47      */
  48     /**
  49      * a mainConnection ID
  50      */
  51     typedef uint16_t am_mainConnectionID_t;
  52     /**
  53      * offset time that is introduced in milli seconds.
  54      */
  55     /**
  56      * offset time that is introduced in milli seconds.
  57      */
  58     typedef int16_t am_timeSync_t;
  59     /**
  60      * a sink ID
  61      */
  62     /**
  63      * a sink ID
  64      */
  65     typedef uint16_t am_sinkID_t;
  66     /**
  67      * represents the connection state
  68      */
  69     enum class am_ConnectionState_e: int32_t {
  70         CS_UNKNOWN = 0,
  71         /**
  72          * This means the connection is just building up
  73          */
  74         CS_CONNECTING = 1,
  75         /**
  76          * the connection is ready to be used
  77          */
  78         CS_CONNECTED = 2,
  79         /**
  80          * the connection is in the course to be knocked down
  81          */
  82         CS_DISCONNECTING = 3,
  83         /**
  84          * only relevant for connectionStatechanged. Is send after the connection was
  85          *  removed
  86          */
  87         CS_DISCONNECTED = 4,
  88         /**
  89          * this means the connection is still build up but unused at the moment
  90          */
  91         CS_SUSPENDED = 5,
  92         CS_MAX
  93     };
  94
  95     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
  96     struct am_ConnectionState_eComparator;
  97     /**
  98      * this type holds all information of connections relevant to the HMI
  99      */
 100     /**
 101      * this type holds all information of connections relevant to the HMI
 102      */
 103     struct am_MainConnectionType_s: CommonAPI::SerializableStruct {
 104         /**
 105          * the ID of the mainconnection
 106          */
 107          am_mainConnectionID_t mainConnectionID;
 108         /**
 109          * the sourceID where the connection starts
 110          */
 111          am_sourceID_t sourceID;
 112         /**
 113          * the sinkID where the connection ends
 114          */
 115          am_sinkID_t sinkID;
 116         /**
 117          * the delay of the mainconnection
 118          */
 119          am_timeSync_t delay;
 120         /**
 121          * the current connection state
 122          */
 123          am_ConnectionState_e connectionState;
 124
 125         am_MainConnectionType_s() = default;
 126         am_MainConnectionType_s(const am_mainConnectionID_t& mainConnectionID, const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_timeSync_t& delay, const am_ConnectionState_e& connectionState);
 127
 128
 129         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 130         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 131
 132         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 133             typeOutputStream.writeUInt16Type();
 134             typeOutputStream.writeUInt16Type();
 135             typeOutputStream.writeUInt16Type();
 136             typeOutputStream.writeInt16Type();
 137             typeOutputStream.writeInt32Type();
 138         }
 139     };
 140     typedef std::vector<am_MainConnectionType_s> am_MainConnection_L;
 141     /**
 142      * product specific identifier of property
 143      */
 144     /**
 145      * product specific identifier of property
 146      */
 147     typedef uint16_t am_CustomClassProperty_t;
 148     /**
 149      * describes class properties
 150      */
 151     /**
 152      * describes class properties
 153      */
 154     struct am_ClassProperty_s: CommonAPI::SerializableStruct {
 155         /**
 156          * the property as enum
 157          */
 158          am_CustomClassProperty_t classProperty;
 159         /**
 160          * the value of the property
 161          */
 162          int16_t value;
 163
 164         am_ClassProperty_s() = default;
 165         am_ClassProperty_s(const am_CustomClassProperty_t& classProperty, const int16_t& value);
 166
 167
 168         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 169         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 170
 171         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 172             typeOutputStream.writeUInt16Type();
 173             typeOutputStream.writeInt16Type();
 174         }
 175     };
 176     typedef std::vector<am_ClassProperty_s> am_ClassProperty_L;
 177     typedef uint16_t am_sinkClass_t;
 178     /**
 179      * struct describing sinkclasses
 180      */
 181     /**
 182      * struct describing sinkclasses
 183      */
 184     struct am_SinkClass_s: CommonAPI::SerializableStruct {
 185         /**
 186          * the ID of the sinkClass
 187          */
 188          am_sinkClass_t sinkClassID;
 189         /**
 190          * the name of the sinkClass - must be unique in the system
 191          */
 192          std::string name;
 193         /**
 194          * the list of the class properties. These are pairs of  a project specific enum
 195          *  describing the type of the value and an integer holding the real value.
 196          */
 197          am_ClassProperty_L listClassProperties;
 198
 199         am_SinkClass_s() = default;
 200         am_SinkClass_s(const am_sinkClass_t& sinkClassID, const std::string& name, const am_ClassProperty_L& listClassProperties);
 201
 202
 203         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 204         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 205
 206         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 207             typeOutputStream.writeUInt16Type();
 208             typeOutputStream.writeStringType();
 209             typeOutputStream.beginWriteVectorType();
 210             typeOutputStream.beginWriteStructType();
 211             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
 212             typeOutputStream.endWriteStructType();
 213             typeOutputStream.endWriteVectorType();
 214         }
 215     };
 216     typedef std::vector<am_SinkClass_s> am_SinkClass_L;
 217     /**
 218      * This is the volume presented on the command interface. It is in the duty of the
 219      *  Controller to change the volumes given here into meaningful values on the
 220      *  routing interface.
 221     The range of this type is customer specific.
 222      */
 223     /**
 224      * This is the volume presented on the command interface. It is in the duty of the
 225      *  Controller to change the volumes given here into meaningful values on the
 226      *  routing interface.
 227     The range of this type is customer specific.
 228      */
 229     typedef int16_t am_mainVolume_t;
 230     /**
 231      * This  project specific value gives the information about reason for reason for
 232      *  Source/Sink change
 233      */
 234     /**
 235      * This  project specific value gives the information about reason for reason for
 236      *  Source/Sink change
 237      */
 238     typedef uint16_t am_CustomAvailabilityReason_t;
 239     /**
 240      * with the help of this enum, sinks and sources can report their availability
 241      *  state
 242      */
 243     enum class am_Availability_e: int32_t {
 244         /**
 245          * default
 246          */
 247         A_UNKNOWN = 0,
 248         /**
 249          * The source / sink is available
 250          */
 251         A_AVAILABLE = 1,
 252         /**
 253          * the source / sink is not available
 254          */
 255         A_UNAVAILABLE = 2,
 256         A_MAX
 257     };
 258
 259     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
 260     struct am_Availability_eComparator;
 261     enum class am_MuteState_e: int32_t {
 262         /**
 263          * default
 264          */
 265         MS_UNKNOWN = 0,
 266         /**
 267          * the source / sink is muted
 268          */
 269         MS_MUTED = 1,
 270         /**
 271          * the source / sink is unmuted
 272          */
 273         MS_UNMUTED = 2,
 274         MS_MAX
 275     };
 276
 277     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
 278     struct am_MuteState_eComparator;
 279     /**
 280      * this describes the availability of a sink or a source together with the latest
 281      *  change
 282      */
 283     /**
 284      * this describes the availability of a sink or a source together with the latest
 285      *  change
 286      */
 287     struct am_Availability_s: CommonAPI::SerializableStruct {
 288         /**
 289          * the current availability state
 290          */
 291          am_Availability_e availability;
 292         /**
 293          * the reason for the last change. This can be used to trigger events that deal
 294          *  with state changes.
 295          */
 296          am_CustomAvailabilityReason_t availabilityReason;
 297
 298         am_Availability_s() = default;
 299         am_Availability_s(const am_Availability_e& availability, const am_CustomAvailabilityReason_t& availabilityReason);
 300
 301
 302         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 303         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 304
 305         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 306             typeOutputStream.writeInt32Type();
 307             typeOutputStream.writeUInt16Type();
 308         }
 309     };
 310     /**
 311      * this type holds all information of sinks relevant to the HMI
 312      */
 313     /**
 314      * this type holds all information of sinks relevant to the HMI
 315      */
 316     struct am_SinkType_s: CommonAPI::SerializableStruct {
 317         /**
 318          * This is the ID of the sink, it is unique in the system. There are 2 ways, ID
 319          *  can be created: either it is assigned during the registration process (in a
 320          *  dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
 321          *  is a fixed (the project has to ensure the uniqueness of the ID).
 322          */
 323          am_sinkID_t sinkID;
 324         /**
 325          * The name of the sink. Must be unique in the whole system.
 326          */
 327          std::string name;
 328         /**
 329          * This attribute reflects the availability of the sink. There are several reasons
 330          *  why a sink could be not available for the moment: for example the shutdown of
 331          *  a sink because of overtemperature or over- &amp; undervoltage. The
 332          *  availability consists of two pieces of information:
 333
 334             Availablility: the
 335          *  status itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
 336
 337          *  AvailabilityReason: this informs about the last reason for a change in
 338          *  availability. The reasons itself are product specific.
 339          */
 340          am_Availability_s availability;
 341         /**
 342          * This is the representation of the Volume for the commandInterface. It is used
 343          *  by the HMI to set the volume of a sink, the AudioManagerController has to
 344          *  transform this into real source and sink volumes.
 345          */
 346          am_mainVolume_t volume;
 347          am_MuteState_e muteState;
 348         /**
 349          * The sinkClassID references to a sinkClass. With the help of classification,
 350          *  rules can be setup to define the system behaviour.
 351          */
 352          am_sinkClass_t sinkClassID;
 353
 354         am_SinkType_s() = default;
 355         am_SinkType_s(const am_sinkID_t& sinkID, const std::string& name, const am_Availability_s& availability, const am_mainVolume_t& volume, const am_MuteState_e& muteState, const am_sinkClass_t& sinkClassID);
 356
 357
 358         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 359         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 360
 361         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 362             typeOutputStream.writeUInt16Type();
 363             typeOutputStream.writeStringType();
 364             typeOutputStream.beginWriteStructType();
 365             typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
 366             typeOutputStream.endWriteStructType();
 367             typeOutputStream.writeInt16Type();
 368             typeOutputStream.writeInt32Type();
 369             typeOutputStream.writeUInt16Type();
 370         }
 371     };
 372     typedef std::vector<am_SinkType_s> am_SinkType_L;
 373     typedef uint16_t am_sourceClass_t;
 374     /**
 375      * struct describing source classes
 376      */
 377     /**
 378      * struct describing source classes
 379      */
 380     struct am_SourceClass_s: CommonAPI::SerializableStruct {
 381         /**
 382          * the source ID
 383          */
 384          am_sourceClass_t sourceClassID;
 385         /**
 386          * the name of the sourceClass - must be unique in the system
 387          */
 388          std::string name;
 389         /**
 390          * the list of the class properties. These are pairs of  a project specific enum
 391          *  describing the type of the value and an integer holding the real value.
 392          */
 393          am_ClassProperty_L listClassProperties;
 394
 395         am_SourceClass_s() = default;
 396         am_SourceClass_s(const am_sourceClass_t& sourceClassID, const std::string& name, const am_ClassProperty_L& listClassProperties);
 397
 398
 399         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 400         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 401
 402         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 403             typeOutputStream.writeUInt16Type();
 404             typeOutputStream.writeStringType();
 405             typeOutputStream.beginWriteVectorType();
 406             typeOutputStream.beginWriteStructType();
 407             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
 408             typeOutputStream.endWriteStructType();
 409             typeOutputStream.endWriteVectorType();
 410         }
 411     };
 412     typedef std::vector<am_SourceClass_s> am_SourceClass_L;
 413     /**
 414      * this type holds all information of sources relevant to the HMI
 415      */
 416     /**
 417      * this type holds all information of sources relevant to the HMI
 418      */
 419     struct am_SourceType_s: CommonAPI::SerializableStruct {
 420         /**
 421          * This is the ID of the source, it is unique in the system. There are 2 ways, ID
 422          *  can be created: either it is assigned during the registration process (in a
 423          *  dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
 424          *  is a fixed (the project has to ensure the uniqueness of the ID).
 425          */
 426          am_sourceID_t sourceID;
 427         /**
 428          * The name of the source. Must be unique in the whole system.
 429          */
 430          std::string name;
 431         /**
 432          * the availability of the source
 433          */
 434          am_Availability_s availability;
 435         /**
 436          * the sourceClassID, indicates the class the source is in. This information can
 437          *  be used by the Controller to implement different behaviour for different
 438          *  classes.
 439          */
 440          am_sourceClass_t sourceClassID;
 441
 442         am_SourceType_s() = default;
 443         am_SourceType_s(const am_sourceID_t& sourceID, const std::string& name, const am_Availability_s& availability, const am_sourceClass_t& sourceClassID);
 444
 445
 446         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 447         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 448
 449         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 450             typeOutputStream.writeUInt16Type();
 451             typeOutputStream.writeStringType();
 452             typeOutputStream.beginWriteStructType();
 453             typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
 454             typeOutputStream.endWriteStructType();
 455             typeOutputStream.writeUInt16Type();
 456         }
 457     };
 458     typedef std::vector<am_SourceType_s> am_SourceType_L;
 459     /**
 460      * describes the different system properties. Project specific
 461      */
 462     /**
 463      * describes the different system properties. Project specific
 464      */
 465     typedef uint16_t am_CustomSystemPropertyType_t;
 466     /**
 467      * struct describing system properties
 468      */
 469     /**
 470      * struct describing system properties
 471      */
 472     struct am_SystemProperty_s: CommonAPI::SerializableStruct {
 473         /**
 474          * the type that is set
 475          */
 476          am_CustomSystemPropertyType_t type;
 477         /**
 478          * the value
 479          */
 480          int16_t value;
 481
 482         am_SystemProperty_s() = default;
 483         am_SystemProperty_s(const am_CustomSystemPropertyType_t& type, const int16_t& value);
 484
 485
 486         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 487         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 488
 489         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 490             typeOutputStream.writeUInt16Type();
 491             typeOutputStream.writeInt16Type();
 492         }
 493     };
 494     typedef std::vector<am_SystemProperty_s> am_SystemProperty_L;
 495     /**
 496      * a connection ID
 497      */
 498     /**
 499      * a connection ID
 500      */
 501     typedef uint16_t am_connectionID_t;
 502     typedef std::vector<am_connectionID_t> am_ConnectionID_L;
 503     /**
 504      * The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE). The minimum and
 505      *  maximum can be limited by actual project.
 506      */
 507     /**
 508      * The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE). The minimum and
 509      *  maximum can be limited by actual project.
 510      */
 511     typedef int16_t am_volume_t;
 512     /**
 513      * Project specific sound properties.
 514      */
 515     /**
 516      * Project specific sound properties.
 517      */
 518     typedef uint16_t am_CustomSoundPropertyType_t;
 519     /**
 520      * This enum characterizes the data of the EarlyData_t
 521      */
 522     enum class am_EarlyDataType_e: int32_t {
 523         /**
 524          * default
 525          */
 526         ES_UNKNOWN = 0,
 527         /**
 528          * the source volume
 529          */
 530         ED_SOURCE_VOLUME = 1,
 531         /**
 532          * the sink volume
 533          */
 534         ED_SINK_VOLUME = 2,
 535         /**
 536          * a source property
 537          */
 538         ED_SOURCE_PROPERTY = 3,
 539         /**
 540          * a sink property
 541          */
 542         ED_SINK_PROPERTY = 4,
 543         ED_MAX
 544     };
 545
 546     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
 547     struct am_EarlyDataType_eComparator;
 548     /**
 549      * struct describing the sound property
 550      */
 551     /**
 552      * struct describing the sound property
 553      */
 554     struct am_SoundProperty_s: CommonAPI::SerializableStruct {
 555         /**
 556          * the type of the property - a project specific enum
 557          */
 558          am_CustomSoundPropertyType_t type;
 559         /**
 560          * the actual value of the property
 561          */
 562          int16_t value;
 563
 564         am_SoundProperty_s() = default;
 565         am_SoundProperty_s(const am_CustomSoundPropertyType_t& type, const int16_t& value);
 566
 567
 568         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 569         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 570
 571         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 572             typeOutputStream.writeUInt16Type();
 573             typeOutputStream.writeInt16Type();
 574         }
 575     };
 576     /**
 577      * data type depends of am_EarlyDataType_e:
 578     volume_t in case of ED_SOURCE_VOLUME,
 579      *  ED_SINK_VOLUME
 580     soundProperty_t in case of ED_SOURCE_PROPERTY,
 581      *  ED_SINK_PROPERTY
 582      */
 583     /**
 584      * data type depends of am_EarlyDataType_e:
 585     volume_t in case of ED_SOURCE_VOLUME,
 586      *  ED_SINK_VOLUME
 587     soundProperty_t in case of ED_SOURCE_PROPERTY,
 588      *  ED_SINK_PROPERTY
 589      */
 590     typedef CommonAPI::Variant<am_volume_t, am_SoundProperty_s>  am_EarlyData_u;
 591     /**
 592      * data type depends of am_EarlyDataType_e:
 593     sourceID in case of ED_SOURCE_VOLUME,
 594      *  ED_SOURCE_PROPERTY
 595     sinkID in case of ED_SINK_VOLUME, ED_SINK_PROPERTY
 596      */
 597     /**
 598      * data type depends of am_EarlyDataType_e:
 599     sourceID in case of ED_SOURCE_VOLUME,
 600      *  ED_SOURCE_PROPERTY
 601     sinkID in case of ED_SINK_VOLUME, ED_SINK_PROPERTY
 602      */
 603     typedef CommonAPI::Variant<am_sinkID_t, am_sourceID_t>  am_DataType_u;
 604     struct am_EarlyData_s: CommonAPI::SerializableStruct {
 605          am_EarlyDataType_e type;
 606          am_DataType_u sinksource;
 607          am_EarlyData_u data;
 608
 609         am_EarlyData_s() = default;
 610         am_EarlyData_s(const am_EarlyDataType_e& type, const am_DataType_u& sinksource, const am_EarlyData_u& data);
 611
 612
 613         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 614         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 615
 616         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 617             typeOutputStream.writeInt32Type();
 618             typeOutputStream.writeVariantType();
 619             typeOutputStream.writeVariantType();
 620         }
 621     };
 622     typedef std::vector<am_EarlyData_s> am_EarlyData_L;
 623     /**
 624      * Here are all SoundProperties that can be set via the CommandInterface. Product
 625      *  specific
 626      */
 627     /**
 628      * Here are all SoundProperties that can be set via the CommandInterface. Product
 629      *  specific
 630      */
 631     typedef uint16_t am_CustomMainSoundPropertyType_t;
 632     /**
 633      * struct describung mainsound property
 634      */
 635     /**
 636      * struct describung mainsound property
 637      */
 638     struct am_MainSoundProperty_s: CommonAPI::SerializableStruct {
 639         /**
 640          * the type of the property
 641          */
 642          am_CustomMainSoundPropertyType_t type;
 643         /**
 644          * the actual value
 645          */
 646          int16_t value;
 647
 648         am_MainSoundProperty_s() = default;
 649         am_MainSoundProperty_s(const am_CustomMainSoundPropertyType_t& type, const int16_t& value);
 650
 651
 652         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 653         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 654
 655         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 656             typeOutputStream.writeUInt16Type();
 657             typeOutputStream.writeInt16Type();
 658         }
 659     };
 660     typedef std::vector<am_MainSoundProperty_s> am_MainSoundProperty_L;
 661     /**
 662      * gives the type of the Notification.
 663      */
 664     /**
 665      * gives the type of the Notification.
 666      */
 667     typedef uint16_t am_CustomNotificationType_t;
 668     enum class am_NotificationStatus_e: int32_t {
 669         NS_UNKNOWN = 0,
 670         /**
 671          * No notification, the function is turned off
 672          */
 673         NS_OFF = 1,
 674         /**
 675          * Periodic notifications are sent out. The period in ms is given by
 676          *  am_NotificationParameter
 677          */
 678         NS_PERIODIC = 2,
 679         /**
 680          * The notification is sent out when the minimum given by am_NotificationParameter
 681          *  is reached.
 682          */
 683         NS_MINIMUM = 3,
 684         /**
 685          * The notification is sent out when the maximum given by am_NotificationParameter
 686          *  is reached.
 687          */
 688         NS_MAXIMUM = 4,
 689         /**
 690          * The notification is sent out when a change happened. The Resolution of the
 691          *  change is defined by am_NotificationParameter.
 692          */
 693         NS_CHANGE_ = 5,
 694         NS_MAX
 695     };
 696
 697     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
 698     struct am_NotificationStatus_eComparator;
 699     /**
 700      * This struct holds information about the configuration for notifications
 701      */
 702     /**
 703      * This struct holds information about the configuration for notifications
 704      */
 705     struct am_NotificationConfiguration_s: CommonAPI::SerializableStruct {
 706         /**
 707          * The notification type of the notification
 708          */
 709          am_CustomNotificationType_t type;
 710         /**
 711          * The Notification status. This can be periodic, min/max value based or even off
 712          *  for example
 713          */
 714          am_NotificationStatus_e status;
 715         /**
 716          * This gives additional information to the notification status.
 717         Relation
 718          *  between notification status and the value:
 719         NS_PERIODIC - the period in
 720          *  ms
 721         NS_MINIMUM - the minimum value that triggers the notification
 722         NS_MAXIMUM
 723          *  - the maximum value that triggers the notifcation
 724         NS_CHANGE - the resolution
 725          *  of the change value
 726          */
 727          int16_t parameter;
 728
 729         am_NotificationConfiguration_s() = default;
 730         am_NotificationConfiguration_s(const am_CustomNotificationType_t& type, const am_NotificationStatus_e& status, const int16_t& parameter);
 731
 732
 733         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 734         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 735
 736         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 737             typeOutputStream.writeUInt16Type();
 738             typeOutputStream.writeInt32Type();
 739             typeOutputStream.writeInt16Type();
 740         }
 741     };
 742     typedef std::vector<am_NotificationConfiguration_s> am_NotificationConfiguration_L;
 743     /**
 744      * a domain ID
 745      */
 746     /**
 747      * a domain ID
 748      */
 749     typedef uint16_t am_domainID_t;
 750     /**
 751      * This project specific value classifies the format in which data is exchanged
 752      *  within a connection.
 753      */
 754     /**
 755      * This project specific value classifies the format in which data is exchanged
 756      *  within a connection.
 757      */
 758     typedef uint16_t am_CustomConnectionFormat_t;
 759     /**
 760      * This represents one "hopp" in a route
 761      */
 762     /**
 763      * This represents one "hopp" in a route
 764      */
 765     struct am_RoutingElement_s: CommonAPI::SerializableStruct {
 766         /**
 767          * the source ID
 768          */
 769          am_sourceID_t sourceID;
 770         /**
 771          * the sinkID
 772          */
 773          am_sinkID_t sinkID;
 774         /**
 775          * the domainID the routeElement is in
 776          */
 777          am_domainID_t domainID;
 778         /**
 779          * the connectionformat that is used for the route
 780          */
 781          am_CustomConnectionFormat_t connectionFormat;
 782
 783         am_RoutingElement_s() = default;
 784         am_RoutingElement_s(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_domainID_t& domainID, const am_CustomConnectionFormat_t& connectionFormat);
 785
 786
 787         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 788         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 789
 790         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 791             typeOutputStream.writeUInt16Type();
 792             typeOutputStream.writeUInt16Type();
 793             typeOutputStream.writeUInt16Type();
 794             typeOutputStream.writeUInt16Type();
 795         }
 796     };
 797     typedef std::vector<am_RoutingElement_s> am_RoutingElement_L;
 798     typedef std::vector<am_SoundProperty_s> am_SoundProperty_L;
 799     /**
 800      * time in ms!
 801      */
 802     /**
 803      * time in ms!
 804      */
 805     typedef int16_t am_time_t;
 806     /**
 807      * For products, different ramp types can be defined here.
 808     It is in the
 809      *  responsibility of the product to make sure that the routing plugins are aware
 810      *  of the ramp types used.
 811      */
 812     /**
 813      * For products, different ramp types can be defined here.
 814     It is in the
 815      *  responsibility of the product to make sure that the routing plugins are aware
 816      *  of the ramp types used.
 817      */
 818     typedef uint16_t am_CustomRampType_t;
 819     /**
 820      * This datatype determines if a sourceID or a sinkID is used in the union
 821      *  following
 822      */
 823     enum class am_VolumeType_e: int32_t {
 824         VT_UNKNOWN = 0,
 825         /**
 826          * the following type is a sink
 827          */
 828         VT_SINK = 1,
 829         /**
 830          * the following type is a source
 831          */
 832         VT_SOURCE = 2,
 833         VT_MAX
 834     };
 835
 836     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
 837     struct am_VolumeType_eComparator;
 838     /**
 839      * This types describe a mixed description for source and sinks volumes.
 840      */
 841     /**
 842      * This types describe a mixed description for source and sinks volumes.
 843      */
 844     struct am_Volumes_s: CommonAPI::SerializableStruct {
 845         /**
 846          * describes the type of the volume: source or sink.
 847          */
 848          am_VolumeType_e volumeType;
 849         /**
 850          * either sourceID or sinkID
 851          */
 852          am_DataType_u volumeID;
 853         /**
 854          * The volume
 855          */
 856          am_volume_t volume;
 857         /**
 858          * the ramp that shall be driven
 859          */
 860          am_CustomRampType_t ramp;
 861         /**
 862          * the time for the ramp
 863          */
 864          am_time_t time;
 865
 866         am_Volumes_s() = default;
 867         am_Volumes_s(const am_VolumeType_e& volumeType, const am_DataType_u& volumeID, const am_volume_t& volume, const am_CustomRampType_t& ramp, const am_time_t& time);
 868
 869
 870         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
 871         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
 872
 873         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
 874             typeOutputStream.writeInt32Type();
 875             typeOutputStream.writeVariantType();
 876             typeOutputStream.writeInt16Type();
 877             typeOutputStream.writeUInt16Type();
 878             typeOutputStream.writeInt16Type();
 879         }
 880     };
 881     typedef std::vector<am_Volumes_s> am_Volumes_L;
 882     typedef std::vector<am_CustomConnectionFormat_t> am_ConnectionFormat_L;
 883     typedef bool am_bool_t;
 884     typedef std::vector<am_bool_t> am_Convertion_L;
 885     /**
 886      * a gateway ID
 887      */
 888     /**
 889      * a gateway ID
 890      */
 891     typedef uint16_t am_gatewayID_t;
 892     /**
 893      * a crossfader ID
 894      */
 895     /**
 896      * a crossfader ID
 897      */
 898     typedef uint16_t am_crossfaderID_t;
 899     /**
 900      * speed
 901      */
 902     /**
 903      * speed
 904      */
 905     typedef uint16_t am_speed_t;
 906     /**
 907      * describes the active sink of a crossfader.
 908      */
 909     enum class am_HotSink_e: int32_t {
 910         /**
 911          * default
 912          */
 913         HS_UNKNOWN = 0,
 914         /**
 915          * sinkA is active
 916          */
 917         HS_SINKA = 1,
 918         /**
 919          * sinkB is active
 920          */
 921         HS_SINKB = 2,
 922         /**
 923          * the crossfader is in the transition state
 924          */
 925         HS_INTERMEDIATE = 3,
 926         HS_MAX
 927     };
 928
 929     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
 930     struct am_HotSink_eComparator;
 931     enum class am_DomainState_e: int32_t {
 932         /**
 933          * default
 934          */
 935         DS_UNKNOWN = 0,
 936         /**
 937          * the domain is controlled by the daemon
 938          */
 939         DS_CONTROLLED = 1,
 940         /**
 941          * the domain is independent starting up
 942          */
 943         DS_INDEPENDENT_STARTUP = 1,
 944         /**
 945          * the domain is independent running down
 946          */
 947         DS_INDEPENDENT_RUNDOWN = 2,
 948         DS_MAX
 949     };
 950
 951     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
 952     struct am_DomainState_eComparator;
 953     /**
 954      * the errors of the audiomanager. All possible errors are in here. This enum is
 955      *  used widely as return parameter.
 956      */
 957     enum class am_Error_e: int32_t {
 958         /**
 959          * no error - positive reply
 960          */
 961         E_OK = 0,
 962         /**
 963          * default
 964          */
 965         E_UNKNOWN = 1,
 966         /**
 967          * value out of range
 968          */
 969         E_OUT_OF_RANGE = 2,
 970         /**
 971          * not used
 972          */
 973         E_NOT_USED = 3,
 974         /**
 975          * a database error occurred
 976          */
 977         E_DATABASE_ERROR = 4,
 978         /**
 979          * the desired object already exists
 980          */
 981         E_ALREADY_EXISTS = 5,
 982         /**
 983          * there is no change
 984          */
 985         E_NO_CHANGE = 6,
 986         /**
 987          * the desired action is not possible
 988          */
 989         E_NOT_POSSIBLE = 7,
 990         /**
 991          * the desired object is non existent
 992          */
 993         E_NON_EXISTENT = 8,
 994         /**
 995          * the asynchronous action was aborted
 996          */
 997         E_ABORTED = 9,
 998         /**
 999          * This error is returned in case a connect is issued with a connectionFormat that
1000          *  cannot be selected for the connection. This could be either due to the
1001          *  capabilities of a source or a sink or gateway compatibilities for example
1002          */
1003         E_WRONG_FORMAT = 10,
1004         E_MAX
1005     };
1006
1007     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
1008     struct am_Error_eComparator;
1009     enum class am_InterruptState_e: int32_t {
1010         /**
1011          * default
1012          */
1013         IS_UNKNOWN = 0,
1014         /**
1015          * the interrupt state is off - no interrupt
1016          */
1017         IS_OFF = 1,
1018         /**
1019          * the interrupt state is interrupted - the interrupt is active
1020          */
1021         IS_INTERRUPTED = 2,
1022         IS_MAX
1023     };
1024
1025     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
1026     struct am_InterruptState_eComparator;
1027     /**
1028      * This enumeration is used to define the type of the action that is correlated to
1029      *  a handle.
1030      */
1031     enum class am_Handle_e: int32_t {
1032         H_UNKNOWN = 0,
1033         H_CONNECT = 1,
1034         H_DISCONNECT = 2,
1035         H_SETSOURCESTATE = 3,
1036         H_SETSINKVOLUME = 4,
1037         H_SETSOURCEVOLUME = 5,
1038         H_SETSINKSOUNDPROPERTY = 6,
1039         H_SETSOURCESOUNDPROPERTY = 7,
1040         H_SETSINKSOUNDPROPERTIES = 8,
1041         H_SETSOURCESOUNDPROPERTIES = 9,
1042         H_CROSSFADE = 10,
1043         H_SETVOLUMES = 11,
1044         H_SETSINKNOTIFICATION = 12,
1045         H_SETSOURCENOTIFICATION = 13,
1046         H_MAX
1047     };
1048
1049     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
1050     struct am_Handle_eComparator;
1051     /**
1052      * The source state reflects the state of the source
1053      */
1054     enum class am_SourceState_e: int32_t {
1055         SS_UNKNNOWN = 0,
1056         /**
1057          * The source can be activly heared
1058          */
1059         SS_ON = 1,
1060         /**
1061          * The source cannot be heared
1062          */
1063         SS_OFF = 2,
1064         /**
1065          * The source is paused. Meaning it cannot be heared but should be prepared to
1066          *  play again soon.
1067          */
1068         SS_PAUSED = 3,
1069         SS_MAX
1070     };
1071
1072     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
1073     struct am_SourceState_eComparator;
1074     /**
1075      * This enum describes the ready state of the routing part
1076      */
1077     enum class am_RoutingReady_e: int32_t {
1078         RR_UNKNOWN = 0,
1079         RR_READY = 1,
1080         RR_RUNDOWN = 2
1081     };
1082
1083     // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
1084     struct am_RoutingReady_eComparator;
1085     /**
1086      * a list of routing elements that lead from source to sink
1087      */
1088     /**
1089      * a list of routing elements that lead from source to sink
1090      */
1091     struct am_Route_s: CommonAPI::SerializableStruct {
1092         /**
1093          * the sourceID where the route starts
1094          */
1095          am_sourceID_t sourceID;
1096         /**
1097          * the sinkID where the route ends
1098          */
1099          am_sinkID_t sinkID;
1100         /**
1101          * the actual route as list of routing elements
1102          */
1103          am_RoutingElement_L route;
1104
1105         am_Route_s() = default;
1106         am_Route_s(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_RoutingElement_L& route);
1107
1108
1109         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1110         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1111
1112         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1113             typeOutputStream.writeUInt16Type();
1114             typeOutputStream.writeUInt16Type();
1115             typeOutputStream.beginWriteVectorType();
1116             typeOutputStream.beginWriteStructType();
1117             typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();
1118             typeOutputStream.endWriteStructType();
1119             typeOutputStream.endWriteVectorType();
1120         }
1121     };
1122     /**
1123      * This struct describes the attribiutes of a crossfader.
1124      */
1125     /**
1126      * This struct describes the attribiutes of a crossfader.
1127      */
1128     struct am_Crossfader_s: CommonAPI::SerializableStruct {
1129         /**
1130          * This is the ID of the crossfader, it is unique in the system. There are 2 ways,
1131          *  ID can be created: either it is assigned during the registration process (in a
1132          *  dynamic context, uniqueness will be ensured by the AudioManager daemon), or it
1133          *  is a fixed (the project has to ensure the uniqueness of the ID).
1134          */
1135          am_crossfaderID_t crossfaderID;
1136         /**
1137          * The name of the crossfader. Must be unique in the whole system.
1138          */
1139          std::string name;
1140         /**
1141          * The sinkID of the SinkA. Sinks shall be registered before registering the
1142          *  crossfader.
1143          */
1144          am_sinkID_t sinkID_A;
1145         /**
1146          * The sinkID of the SinkB. Sinks shall be registered before registering the
1147          *  crossfader.
1148          */
1149          am_sinkID_t sinkID_B;
1150         /**
1151          * The sourceID of the crossfader source. The source shall be registered before
1152          *  the crossfader.
1153          */
1154          am_sourceID_t sourceID;
1155         /**
1156          * This enum can have 3 states:
1157
1158             HS_SINKA sinkA is the current hot one,
1159          *  sinkB is not audible
1160             HS_SINKB sinkB is the current hot one, sinkB is not
1161          *  audible
1162             HS_INTERMEDIATE the fader is stuck in between a cross-fading
1163          *  action. This could be due to an abort or an error. Before using the
1164          *  crossfader, it must be set to either HS_SINKA or HS_SINKB.
1165          */
1166          am_HotSink_e hotSink;
1167
1168         am_Crossfader_s() = default;
1169         am_Crossfader_s(const am_crossfaderID_t& crossfaderID, const std::string& name, const am_sinkID_t& sinkID_A, const am_sinkID_t& sinkID_B, const am_sourceID_t& sourceID, const am_HotSink_e& hotSink);
1170
1171
1172         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1173         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1174
1175         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1176             typeOutputStream.writeUInt16Type();
1177             typeOutputStream.writeStringType();
1178             typeOutputStream.writeUInt16Type();
1179             typeOutputStream.writeUInt16Type();
1180             typeOutputStream.writeUInt16Type();
1181             typeOutputStream.writeInt32Type();
1182         }
1183     };
1184     /**
1185      * This struct describes the attributes of a gateway.
1186      */
1187     /**
1188      * This struct describes the attributes of a gateway.
1189      */
1190     struct am_Gateway_s: CommonAPI::SerializableStruct {
1191         /**
1192          * This is the ID of the gateway, it is unique in the system. There are 2 ways, ID
1193          *  can be created: either it is assigned during the registration process (in a
1194          *  dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
1195          *  is a fixed (the project has to ensure the uniqueness of the ID).
1196          */
1197          am_gatewayID_t gatewayID;
1198         /**
1199          * The name of the gateway. Must be unique in the whole system.
1200          */
1201          std::string name;
1202         /**
1203          * The sinkID of the gateway sink-end. The sink is a full blown sink with
1204          *  connectionFormats, sinkClassIDs etc... It makes sense to register the sinks of
1205          *  a gateway as non-visible. Care needs to be taken that the connectionsFormats
1206          *  match with the ones in the conversionMatrix. If the sink is located in the
1207          *  controllingDomain, the ID needs to be retrieved by registering the sink before
1208          *  registering the gateway. In case the sink is in a different domain, the ID
1209          *  needs to be retrieved via peeking.
1210          */
1211          am_sinkID_t sinkID;
1212         /**
1213          * The sourceID of the gateway sink-end. The sink is a full blown source with
1214          *  connectionFormats, sinkClassIDs etc... It makes sense to register the sources
1215          *  of a gateway as non-visible. Care needs to be taken that the
1216          *  connectionsFormats match with the ones in the conversionMatrix. If the source
1217          *  is located in the controllingDomain, the ID needs to be retrieved by
1218          *  registering the source before registering the gateway. In case the source is
1219          *  in a different domain, the ID needs to be retrieved via peeking.
1220          */
1221          am_sourceID_t sourceID;
1222         /**
1223          * The ID of the sink. If the domain is the same like the controlling domain, the
1224          *  ID is known due to registration. If the domain is different, the ID needs to
1225          *  be retrieved via peeking.
1226          */
1227          am_domainID_t domainSinkID;
1228         /**
1229          * The ID of the source. If the domain is the same like the controlling domain,
1230          *  the ID is known due to registration. If the domain is different, the ID needs
1231          *  to be retrieved via peeking.
1232          */
1233          am_domainID_t domainSourceID;
1234         /**
1235          * This is the ID of the domain that registers the gateway.
1236          */
1237          am_domainID_t controlDomainID;
1238         /**
1239          * This is the list of available formats on the source side of the gateway. It is
1240          *  not defined during the gateway registration but copied from the source
1241          *  registration.
1242          */
1243          am_ConnectionFormat_L listSourceFormats;
1244         /**
1245          * This is the list of available formats on the sink side of the gateway. It is
1246          *  not defined during the gateway registration but copied from the sink
1247          *  registration.
1248          */
1249          am_ConnectionFormat_L listSinkFormats;
1250         /**
1251          * This is matrix holding information about the conversion capability of the
1252          *  gateway, it's length is defined by the length(listSinkFormats) x
1253          *  length(listSourceFormats).
1254         If a SinkFormat can be converted into a
1255          *  SourceFormat, the vector will hold a 1, if no conversion is possible, a
1256          *  0.
1257         The data is stored row orientated, where the rows are related to the
1258          *  sinksFormats and the columns to the sourceFormats. The first value will hold
1259          *  the conversion information from the first sourceFormat to the first sinkFormat
1260          *  for example and the seventh value the information about the 3rd sinkFormat to
1261          *  the 1st sourceFormat in case we would have 3 sourceFormats.
1262          */
1263          am_Convertion_L convertionMatrix;
1264
1265         am_Gateway_s() = default;
1266         am_Gateway_s(const am_gatewayID_t& gatewayID, const std::string& name, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_domainID_t& domainSinkID, const am_domainID_t& domainSourceID, const am_domainID_t& controlDomainID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix);
1267
1268
1269         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1270         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1271
1272         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1273             typeOutputStream.writeUInt16Type();
1274             typeOutputStream.writeStringType();
1275             typeOutputStream.writeUInt16Type();
1276             typeOutputStream.writeUInt16Type();
1277             typeOutputStream.writeUInt16Type();
1278             typeOutputStream.writeUInt16Type();
1279             typeOutputStream.writeUInt16Type();
1280             typeOutputStream.beginWriteVectorType();
1281             typeOutputStream.writeUInt16Type();
1282             typeOutputStream.endWriteVectorType();
1283             typeOutputStream.beginWriteVectorType();
1284             typeOutputStream.writeUInt16Type();
1285             typeOutputStream.endWriteVectorType();
1286             typeOutputStream.beginWriteVectorType();
1287             typeOutputStream.writeBoolType();
1288             typeOutputStream.endWriteVectorType();
1289         }
1290     };
1291     /**
1292      * a handle is used for asynchronous operations and is uniquely assigned for each
1293      *  of this operations
1294      */
1295     /**
1296      * a handle is used for asynchronous operations and is uniquely assigned for each
1297      *  of this operations
1298      */
1299     struct am_Handle_s: CommonAPI::SerializableStruct {
1300         /**
1301          * the handletype
1302          */
1303          am_Handle_e handleType;
1304         /**
1305          * the handle as value
1306          */
1307          uint16_t handle;
1308
1309         am_Handle_s() = default;
1310         am_Handle_s(const am_Handle_e& handleType, const uint16_t& handle);
1311
1312
1313         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1314         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1315
1316         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1317             typeOutputStream.writeInt32Type();
1318             typeOutputStream.writeUInt16Type();
1319         }
1320     };
1321     /**
1322      * struct that holds attribiutes of a mainconnection
1323      */
1324     /**
1325      * struct that holds attribiutes of a mainconnection
1326      */
1327     struct am_MainConnection_s: CommonAPI::SerializableStruct {
1328         /**
1329          * the assigned ID
1330          */
1331          am_mainConnectionID_t mainConnectionID;
1332         /**
1333          * the current connection state
1334          */
1335          am_ConnectionState_e connectionState;
1336         /**
1337          * the sinkID
1338          */
1339          am_sinkID_t sinkID;
1340         /**
1341          * the sourceID
1342          */
1343          am_sourceID_t sourceID;
1344         /**
1345          * the delay of the connection
1346          */
1347          am_timeSync_t delay;
1348         /**
1349          * the list of sub connection IDs the mainconnection consists of
1350          */
1351          am_ConnectionID_L listConnectionID;
1352
1353         am_MainConnection_s() = default;
1354         am_MainConnection_s(const am_mainConnectionID_t& mainConnectionID, const am_ConnectionState_e& connectionState, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_timeSync_t& delay, const am_ConnectionID_L& listConnectionID);
1355
1356
1357         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1358         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1359
1360         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1361             typeOutputStream.writeUInt16Type();
1362             typeOutputStream.writeInt32Type();
1363             typeOutputStream.writeUInt16Type();
1364             typeOutputStream.writeUInt16Type();
1365             typeOutputStream.writeInt16Type();
1366             typeOutputStream.beginWriteVectorType();
1367             typeOutputStream.writeUInt16Type();
1368             typeOutputStream.endWriteVectorType();
1369         }
1370     };
1371     /**
1372      * This struct holds the payload of a notification.
1373      */
1374     /**
1375      * This struct holds the payload of a notification.
1376      */
1377     struct am_NotificationPayload_s: CommonAPI::SerializableStruct {
1378         /**
1379          * This defines the notification type
1380          */
1381          am_CustomNotificationType_t type;
1382         /**
1383          * This is finally the value of the notification. It's meaning depends on the
1384          *  notificationType
1385          */
1386          int16_t value;
1387
1388         am_NotificationPayload_s() = default;
1389         am_NotificationPayload_s(const am_CustomNotificationType_t& type, const int16_t& value);
1390
1391
1392         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1393         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1394
1395         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1396             typeOutputStream.writeUInt16Type();
1397             typeOutputStream.writeInt16Type();
1398         }
1399     };
1400     /**
1401      * This struct describes the attribiutes of a sink
1402      */
1403     /**
1404      * This struct describes the attribiutes of a sink
1405      */
1406     struct am_Sink_s: CommonAPI::SerializableStruct {
1407         /**
1408          * This is the ID of the sink, it is unique in the system. There are 2 ways, ID
1409          *  can be created: either it is assigned during the registration process (in a
1410          *  dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
1411          *  is a fixed (the project has to ensure the uniqueness of the ID).
1412          */
1413          am_sinkID_t sinkID;
1414         /**
1415          * The name of the sink. Must be unique in the whole system.
1416          */
1417          std::string name;
1418         /**
1419          * The domainID is the domain the sink belongs to. A sink can only be in one
1420          *  domain.
1421          */
1422          am_domainID_t domainID;
1423         /**
1424          * The sinkClassID references to a sinkClass. With the help of classification,
1425          *  rules can be setup to define the system behaviour.
1426          */
1427          am_sinkClass_t sinkClassID;
1428         /**
1429          * This is the volume of the sink. It is set by the AudioManagerController.
1430          */
1431          am_volume_t volume;
1432         /**
1433          * This Boolean flag indicates whether a sink is visible to the commandInterface
1434          *  or not. If the User must have the possibility to choose the source in the HMI,
1435          *  it must be visible. But there are also good reasons for invisible sinks, for
1436          *  example if the sink is part of a crossfader or gateway. HMI relevant changes
1437          *  in visible sinks will be automatically reported by the daemon to the
1438          *  commandInterface.
1439          */
1440          bool visible;
1441         /**
1442          * This attribute reflects the availability of the sink. There are several reasons
1443          *  why a sink could be not available for the moment: for example the shutdown of
1444          *  a sink because of overtemperature or over- &amp; undervoltage. The
1445          *  availability consists of two pieces of information:
1446
1447             Availablility: the
1448          *  status itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
1449
1450          *  AvailabilityReason: this informs about the last reason for a change in
1451          *  availability. The reasons itself are product specific.
1452          */
1453          am_Availability_s available;
1454         /**
1455          * This attribute reflects the muteState of the sink. The information is not the
1456          *  "real" state of the sink, but the HMI representation for he commandInterface
1457          *  controlled by the AudioManagerController.
1458          */
1459          am_MuteState_e muteState;
1460         /**
1461          * This is the representation of the Volume for the commandInterface. It is used
1462          *  by the HMI to set the volume of a sink, the AudioManagerController has to
1463          *  transform this into real source and sink volumes.
1464          */
1465          am_mainVolume_t mainVolume;
1466         /**
1467          * This is the list of soundProperties, that the sink is capable of. The
1468          *  soundProperties itself are project specific. For sinks, a possible
1469          *  soundProperty could be for example settings.
1470          */
1471          am_SoundProperty_L listSoundProperties;
1472         /**
1473          * This list holds information about the formats that the Source is capable of
1474          *  supporting when delivering audio.
1475          */
1476          am_ConnectionFormat_L listConnectionFormats;
1477         /**
1478          * This is the list of the available mainSoundProperties. The principle is the
1479          *  same than with soundProperties, but they are only visible to the
1480          *  CommandInterface.
1481          */
1482          am_MainSoundProperty_L listMainSoundProperties;
1483         /**
1484          * This is the list of the MainNotificationConfigurations. These notifications
1485          *  work on the level of command interface.
1486          */
1487          am_NotificationConfiguration_L listMainNotificationConfigurations;
1488         /**
1489          * This is the list of the NotificationConfigurations. These notifications work on
1490          *  the level of RoutingPlugins.
1491          */
1492          am_NotificationConfiguration_L listNotificationConfigurations;
1493
1494         am_Sink_s() = default;
1495         am_Sink_s(const am_sinkID_t& sinkID, const std::string& name, const am_domainID_t& domainID, const am_sinkClass_t& sinkClassID, const am_volume_t& volume, const bool& visible, const am_Availability_s& available, const am_MuteState_e& muteState, const am_mainVolume_t& mainVolume, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, const am_NotificationConfiguration_L& listMainNotificationConfigurations, const am_NotificationConfiguration_L& listNotificationConfigurations);
1496
1497
1498         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1499         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1500
1501         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1502             typeOutputStream.writeUInt16Type();
1503             typeOutputStream.writeStringType();
1504             typeOutputStream.writeUInt16Type();
1505             typeOutputStream.writeUInt16Type();
1506             typeOutputStream.writeInt16Type();
1507             typeOutputStream.writeBoolType();
1508             typeOutputStream.beginWriteStructType();
1509             typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
1510             typeOutputStream.endWriteStructType();
1511             typeOutputStream.writeInt32Type();
1512             typeOutputStream.writeInt16Type();
1513             typeOutputStream.beginWriteVectorType();
1514             typeOutputStream.beginWriteStructType();
1515             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
1516             typeOutputStream.endWriteStructType();
1517             typeOutputStream.endWriteVectorType();
1518             typeOutputStream.beginWriteVectorType();
1519             typeOutputStream.writeUInt16Type();
1520             typeOutputStream.endWriteVectorType();
1521             typeOutputStream.beginWriteVectorType();
1522             typeOutputStream.beginWriteStructType();
1523             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
1524             typeOutputStream.endWriteStructType();
1525             typeOutputStream.endWriteVectorType();
1526             typeOutputStream.beginWriteVectorType();
1527             typeOutputStream.beginWriteStructType();
1528             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
1529             typeOutputStream.endWriteStructType();
1530             typeOutputStream.endWriteVectorType();
1531             typeOutputStream.beginWriteVectorType();
1532             typeOutputStream.beginWriteStructType();
1533             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
1534             typeOutputStream.endWriteStructType();
1535             typeOutputStream.endWriteVectorType();
1536         }
1537     };
1538     /**
1539      * This struct describes the attribiutes of a source
1540      */
1541     /**
1542      * This struct describes the attribiutes of a source
1543      */
1544     struct am_Source_s: CommonAPI::SerializableStruct {
1545         /**
1546          * This is the ID of the source, it is unique in the system. There are 2 ways, ID
1547          *  can be created: either it is assigned during the registration process (in a
1548          *  dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
1549          *  is a fixed (the project has to ensure the uniqueness of the ID).
1550          */
1551          am_sourceID_t sourceID;
1552         /**
1553          * The domainID is the domain the source belongs to. A source can only be in one
1554          *  domain.
1555          */
1556          am_domainID_t domainID;
1557         /**
1558          * The name of the source. Must be unique in the whole system.
1559          */
1560          std::string name;
1561         /**
1562          * the sourceClassID, indicates the class the source is in. This information can
1563          *  be used by the Controller to implement different behaviour for different
1564          *  classes.
1565          */
1566          am_sourceClass_t sourceClassID;
1567         /**
1568          * The source state is an indication towards the source if it is actively heard or
1569          *  not. The source can use this information to implement features like automatic
1570          *  spin down of CD's in case the CD is not the active source or AF following of a
1571          *  tuner that is not actively heard. The source state is set by the
1572          *  AudioManagerController.There are 3 possible states:
1573
1574             SS_ON: the source
1575          *  is active
1576             SS_OFF: the source is off
1577             SS_PAUSED: the source is paused
1578          *  and not active.
1579          */
1580          am_SourceState_e sourceState;
1581         /**
1582          * This is the volume of the source. It is set by the AudioManagerController. It
1583          *  is used to adopt different audiolevels in a system and mixing of sources (e.g.
1584          *  navigation hints &amp; music).
1585          */
1586          am_volume_t volume;
1587         /**
1588          * This Boolean flag indicates whether a source is visible to the commandInterface
1589          *  or not. If the User must have the possibility to choose the source in the HMI,
1590          *  it must be visible. But there are also good reasons for invisible sources, for
1591          *  example if the source is part of a crossfader or gateway. HMI relevant changes
1592          *  in visible sources will be automatically reported by the daemon to the
1593          *  commandInterface.
1594          */
1595          bool visible;
1596         /**
1597          * This attribute reflects the availability of the source. There are several
1598          *  reasons why a source could be not available for the moment. For example a CD
1599          *  player which has no CD entered in the slot can be unavailable, or a USB player
1600          *  with no or unreadable stick attached. Other scenarios involve the shutdown of
1601          *  a source because of overtemperature or over- &amp; undervoltage. The
1602          *  availability consists of two informations:
1603
1604             Availablility: the status
1605          *  itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
1606
1607          *  AvailabilityReason: this informs about the last reason for a change in
1608          *  availability. The reasons itself are product specific.
1609          */
1610          am_Availability_s available;
1611         /**
1612          * Some special sources can have special behaviors, the are so called "Low Level
1613          *  Interrupts". Here the current status is documented. The information can be
1614          *  used by the AudioManagerController to react to the changes by for example
1615          *  lowering the volume of the mainSources. The two states are
1616
1617             IS_OFF: the
1618          *  interrupt is not active at the moment
1619             IS_INTERRUPTED: the interrupt is
1620          *  playing at the moment.
1621          */
1622          am_InterruptState_e interruptState;
1623         /**
1624          * This is the list of soundProperties, that the source is capable of. The
1625          *  soundProperties itself are project specific. For sources, a possible
1626          *  soundProperty could be navigation volume offset, for example.
1627          */
1628          am_SoundProperty_L listSoundProperties;
1629         /**
1630          * This list holds information about the formats that the Source is capable of
1631          *  supporting when delivering audio.
1632          */
1633          am_ConnectionFormat_L listConnectionFormats;
1634         /**
1635          * This is the list of the available mainSoundProperties. The principle is the
1636          *  same than with soundProperties, but they are only visible to the
1637          *  CommandInterface.
1638          */
1639          am_MainSoundProperty_L listMainSoundProperties;
1640         /**
1641          * The list of MainNotificationConfigurations. These notifications work on the
1642          *  level of CommandInterface.
1643          */
1644          am_NotificationConfiguration_L listMainNotificationConfigurations;
1645         /**
1646          * The list of MainNotificationConfigurations. These notifications work on the
1647          *  level of RoutingInterface.
1648          */
1649          am_NotificationConfiguration_L listNotificationConfigurations;
1650
1651         am_Source_s() = default;
1652         am_Source_s(const am_sourceID_t& sourceID, const am_domainID_t& domainID, const std::string& name, const am_sourceClass_t& sourceClassID, const am_SourceState_e& sourceState, const am_volume_t& volume, const bool& visible, const am_Availability_s& available, const am_InterruptState_e& interruptState, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, const am_NotificationConfiguration_L& listMainNotificationConfigurations, const am_NotificationConfiguration_L& listNotificationConfigurations);
1653
1654
1655         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1656         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1657
1658         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1659             typeOutputStream.writeUInt16Type();
1660             typeOutputStream.writeUInt16Type();
1661             typeOutputStream.writeStringType();
1662             typeOutputStream.writeUInt16Type();
1663             typeOutputStream.writeInt32Type();
1664             typeOutputStream.writeInt16Type();
1665             typeOutputStream.writeBoolType();
1666             typeOutputStream.beginWriteStructType();
1667             typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
1668             typeOutputStream.endWriteStructType();
1669             typeOutputStream.writeInt32Type();
1670             typeOutputStream.beginWriteVectorType();
1671             typeOutputStream.beginWriteStructType();
1672             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
1673             typeOutputStream.endWriteStructType();
1674             typeOutputStream.endWriteVectorType();
1675             typeOutputStream.beginWriteVectorType();
1676             typeOutputStream.writeUInt16Type();
1677             typeOutputStream.endWriteVectorType();
1678             typeOutputStream.beginWriteVectorType();
1679             typeOutputStream.beginWriteStructType();
1680             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
1681             typeOutputStream.endWriteStructType();
1682             typeOutputStream.endWriteVectorType();
1683             typeOutputStream.beginWriteVectorType();
1684             typeOutputStream.beginWriteStructType();
1685             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
1686             typeOutputStream.endWriteStructType();
1687             typeOutputStream.endWriteVectorType();
1688             typeOutputStream.beginWriteVectorType();
1689             typeOutputStream.beginWriteStructType();
1690             typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
1691             typeOutputStream.endWriteStructType();
1692             typeOutputStream.endWriteVectorType();
1693         }
1694     };
1695     /**
1696      * This struct describes the attribiutes of a domain
1697      */
1698     /**
1699      * This struct describes the attribiutes of a domain
1700      */
1701     struct am_Domain_s: CommonAPI::SerializableStruct {
1702         /**
1703          * the domain ID
1704          */
1705          am_domainID_t domainID;
1706         /**
1707          * the name of the domain
1708          */
1709          std::string name;
1710         /**
1711          * the busname. This is equal to a plugin name and is used to dispatch messages to
1712          *  the elements of a plugin
1713          */
1714          std::string busname;
1715         /**
1716          * the name of the node
1717          */
1718          std::string nodename;
1719         /**
1720          * indicated if the domain is independent at startup or not
1721          */
1722          bool early;
1723         /**
1724          * indicates if the domain registration is complete or not
1725          */
1726          bool complete;
1727         /**
1728          * the current domain state
1729          */
1730          am_DomainState_e state;
1731
1732         am_Domain_s() = default;
1733         am_Domain_s(const am_domainID_t& domainID, const std::string& name, const std::string& busname, const std::string& nodename, const bool& early, const bool& complete, const am_DomainState_e& state);
1734
1735
1736         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1737         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1738
1739         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1740             typeOutputStream.writeUInt16Type();
1741             typeOutputStream.writeStringType();
1742             typeOutputStream.writeStringType();
1743             typeOutputStream.writeStringType();
1744             typeOutputStream.writeBoolType();
1745             typeOutputStream.writeBoolType();
1746             typeOutputStream.writeInt32Type();
1747         }
1748     };
1749     /**
1750      * a connection
1751      */
1752     /**
1753      * a connection
1754      */
1755     struct am_Connection_s: CommonAPI::SerializableStruct {
1756         /**
1757          * the assigned ID
1758          */
1759          am_connectionID_t connectionID;
1760         /**
1761          * the source the audio flows from
1762          */
1763          am_sourceID_t sourceID;
1764         /**
1765          * the sink the audio flows to
1766          */
1767          am_sinkID_t sinkID;
1768         /**
1769          * the delay of the conneciton
1770          */
1771          am_timeSync_t delay;
1772         /**
1773          * the used connectionformat
1774          */
1775          am_CustomConnectionFormat_t connectionFormat;
1776
1777         am_Connection_s() = default;
1778         am_Connection_s(const am_connectionID_t& connectionID, const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_timeSync_t& delay, const am_CustomConnectionFormat_t& connectionFormat);
1779
1780
1781         virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
1782         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
1783
1784         static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
1785             typeOutputStream.writeUInt16Type();
1786             typeOutputStream.writeUInt16Type();
1787             typeOutputStream.writeUInt16Type();
1788             typeOutputStream.writeInt16Type();
1789             typeOutputStream.writeUInt16Type();
1790         }
1791     };
1792
1793 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Availability_e& enumValue) {
1794     return inputStream.readEnumValue<int32_t>(enumValue);
1795 }
1796
1797 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Availability_e& enumValue) {
1798     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1799 }
1800
1801 struct am_Availability_eComparator {
1802     inline bool operator()(const am_Availability_e& lhs, const am_Availability_e& rhs) const {
1803         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1804     }
1805 };
1806
1807 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_HotSink_e& enumValue) {
1808     return inputStream.readEnumValue<int32_t>(enumValue);
1809 }
1810
1811 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_HotSink_e& enumValue) {
1812     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1813 }
1814
1815 struct am_HotSink_eComparator {
1816     inline bool operator()(const am_HotSink_e& lhs, const am_HotSink_e& rhs) const {
1817         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1818     }
1819 };
1820
1821 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_ConnectionState_e& enumValue) {
1822     return inputStream.readEnumValue<int32_t>(enumValue);
1823 }
1824
1825 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_ConnectionState_e& enumValue) {
1826     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1827 }
1828
1829 struct am_ConnectionState_eComparator {
1830     inline bool operator()(const am_ConnectionState_e& lhs, const am_ConnectionState_e& rhs) const {
1831         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1832     }
1833 };
1834
1835 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_DomainState_e& enumValue) {
1836     return inputStream.readEnumValue<int32_t>(enumValue);
1837 }
1838
1839 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_DomainState_e& enumValue) {
1840     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1841 }
1842
1843 struct am_DomainState_eComparator {
1844     inline bool operator()(const am_DomainState_e& lhs, const am_DomainState_e& rhs) const {
1845         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1846     }
1847 };
1848
1849 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_EarlyDataType_e& enumValue) {
1850     return inputStream.readEnumValue<int32_t>(enumValue);
1851 }
1852
1853 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_EarlyDataType_e& enumValue) {
1854     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1855 }
1856
1857 struct am_EarlyDataType_eComparator {
1858     inline bool operator()(const am_EarlyDataType_e& lhs, const am_EarlyDataType_e& rhs) const {
1859         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1860     }
1861 };
1862
1863 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Error_e& enumValue) {
1864     return inputStream.readEnumValue<int32_t>(enumValue);
1865 }
1866
1867 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Error_e& enumValue) {
1868     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1869 }
1870
1871 struct am_Error_eComparator {
1872     inline bool operator()(const am_Error_e& lhs, const am_Error_e& rhs) const {
1873         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1874     }
1875 };
1876
1877 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_MuteState_e& enumValue) {
1878     return inputStream.readEnumValue<int32_t>(enumValue);
1879 }
1880
1881 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_MuteState_e& enumValue) {
1882     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1883 }
1884
1885 struct am_MuteState_eComparator {
1886     inline bool operator()(const am_MuteState_e& lhs, const am_MuteState_e& rhs) const {
1887         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1888     }
1889 };
1890
1891 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_InterruptState_e& enumValue) {
1892     return inputStream.readEnumValue<int32_t>(enumValue);
1893 }
1894
1895 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_InterruptState_e& enumValue) {
1896     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1897 }
1898
1899 struct am_InterruptState_eComparator {
1900     inline bool operator()(const am_InterruptState_e& lhs, const am_InterruptState_e& rhs) const {
1901         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1902     }
1903 };
1904
1905 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_VolumeType_e& enumValue) {
1906     return inputStream.readEnumValue<int32_t>(enumValue);
1907 }
1908
1909 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_VolumeType_e& enumValue) {
1910     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1911 }
1912
1913 struct am_VolumeType_eComparator {
1914     inline bool operator()(const am_VolumeType_e& lhs, const am_VolumeType_e& rhs) const {
1915         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1916     }
1917 };
1918
1919 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_NotificationStatus_e& enumValue) {
1920     return inputStream.readEnumValue<int32_t>(enumValue);
1921 }
1922
1923 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_NotificationStatus_e& enumValue) {
1924     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1925 }
1926
1927 struct am_NotificationStatus_eComparator {
1928     inline bool operator()(const am_NotificationStatus_e& lhs, const am_NotificationStatus_e& rhs) const {
1929         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1930     }
1931 };
1932
1933 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Handle_e& enumValue) {
1934     return inputStream.readEnumValue<int32_t>(enumValue);
1935 }
1936
1937 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Handle_e& enumValue) {
1938     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1939 }
1940
1941 struct am_Handle_eComparator {
1942     inline bool operator()(const am_Handle_e& lhs, const am_Handle_e& rhs) const {
1943         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1944     }
1945 };
1946
1947 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_SourceState_e& enumValue) {
1948     return inputStream.readEnumValue<int32_t>(enumValue);
1949 }
1950
1951 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_SourceState_e& enumValue) {
1952     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1953 }
1954
1955 struct am_SourceState_eComparator {
1956     inline bool operator()(const am_SourceState_e& lhs, const am_SourceState_e& rhs) const {
1957         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1958     }
1959 };
1960
1961 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_RoutingReady_e& enumValue) {
1962     return inputStream.readEnumValue<int32_t>(enumValue);
1963 }
1964
1965 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_RoutingReady_e& enumValue) {
1966     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
1967 }
1968
1969 struct am_RoutingReady_eComparator {
1970     inline bool operator()(const am_RoutingReady_e& lhs, const am_RoutingReady_e& rhs) const {
1971         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
1972     }
1973 };
1974
1975 bool operator==(const am_Route_s& lhs, const am_Route_s& rhs);
1976 inline bool operator!=(const am_Route_s& lhs, const am_Route_s& rhs) {
1977     return !(lhs == rhs);
1978 }
1979 bool operator==(const am_Availability_s& lhs, const am_Availability_s& rhs);
1980 inline bool operator!=(const am_Availability_s& lhs, const am_Availability_s& rhs) {
1981     return !(lhs == rhs);
1982 }
1983 bool operator==(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs);
1984 inline bool operator!=(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs) {
1985     return !(lhs == rhs);
1986 }
1987 bool operator==(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs);
1988 inline bool operator!=(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs) {
1989     return !(lhs == rhs);
1990 }
1991 bool operator==(const am_Gateway_s& lhs, const am_Gateway_s& rhs);
1992 inline bool operator!=(const am_Gateway_s& lhs, const am_Gateway_s& rhs) {
1993     return !(lhs == rhs);
1994 }
1995 bool operator==(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs);
1996 inline bool operator!=(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs) {
1997     return !(lhs == rhs);
1998 }
1999 bool operator==(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs);
2000 inline bool operator!=(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs) {
2001     return !(lhs == rhs);
2002 }
2003 bool operator==(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs);
2004 inline bool operator!=(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs) {
2005     return !(lhs == rhs);
2006 }
2007 bool operator==(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs);
2008 inline bool operator!=(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs) {
2009     return !(lhs == rhs);
2010 }
2011 bool operator==(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs);
2012 inline bool operator!=(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs) {
2013     return !(lhs == rhs);
2014 }
2015 bool operator==(const am_SourceType_s& lhs, const am_SourceType_s& rhs);
2016 inline bool operator!=(const am_SourceType_s& lhs, const am_SourceType_s& rhs) {
2017     return !(lhs == rhs);
2018 }
2019 bool operator==(const am_SinkType_s& lhs, const am_SinkType_s& rhs);
2020 inline bool operator!=(const am_SinkType_s& lhs, const am_SinkType_s& rhs) {
2021     return !(lhs == rhs);
2022 }
2023 bool operator==(const am_Handle_s& lhs, const am_Handle_s& rhs);
2024 inline bool operator!=(const am_Handle_s& lhs, const am_Handle_s& rhs) {
2025     return !(lhs == rhs);
2026 }
2027 bool operator==(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs);
2028 inline bool operator!=(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs) {
2029     return !(lhs == rhs);
2030 }
2031 bool operator==(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs);
2032 inline bool operator!=(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs) {
2033     return !(lhs == rhs);
2034 }
2035 bool operator==(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs);
2036 inline bool operator!=(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs) {
2037     return !(lhs == rhs);
2038 }
2039 bool operator==(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs);
2040 inline bool operator!=(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs) {
2041     return !(lhs == rhs);
2042 }
2043 bool operator==(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs);
2044 inline bool operator!=(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs) {
2045     return !(lhs == rhs);
2046 }
2047 bool operator==(const am_Sink_s& lhs, const am_Sink_s& rhs);
2048 inline bool operator!=(const am_Sink_s& lhs, const am_Sink_s& rhs) {
2049     return !(lhs == rhs);
2050 }
2051 bool operator==(const am_Source_s& lhs, const am_Source_s& rhs);
2052 inline bool operator!=(const am_Source_s& lhs, const am_Source_s& rhs) {
2053     return !(lhs == rhs);
2054 }
2055 bool operator==(const am_Domain_s& lhs, const am_Domain_s& rhs);
2056 inline bool operator!=(const am_Domain_s& lhs, const am_Domain_s& rhs) {
2057     return !(lhs == rhs);
2058 }
2059 bool operator==(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs);
2060 inline bool operator!=(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs) {
2061     return !(lhs == rhs);
2062 }
2063 bool operator==(const am_Connection_s& lhs, const am_Connection_s& rhs);
2064 inline bool operator!=(const am_Connection_s& lhs, const am_Connection_s& rhs) {
2065     return !(lhs == rhs);
2066 }
2067 bool operator==(const am_Volumes_s& lhs, const am_Volumes_s& rhs);
2068 inline bool operator!=(const am_Volumes_s& lhs, const am_Volumes_s& rhs) {
2069     return !(lhs == rhs);
2070 }
2071
2072
2073 static inline const char* getTypeCollectionName() {
2074     static const char* typeCollectionName = "org.genivi.am";
2075     return typeCollectionName;
2076 }
2077
2078 inline CommonAPI::Version getTypeCollectionVersion() {
2079     return CommonAPI::Version(1, 0);
2080 }
2081
2082 } // namespace am
2083
2084 } // namespace genivi
2085 } // namespace org
2086
2087 namespace CommonAPI {
2088
2089     template<>
2090     struct BasicTypeWriter<org::genivi::am::am_Availability_e> {
2091         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2092             typeStream.writeInt32EnumType();
2093         }
2094     };
2095
2096     template<>
2097     struct InputStreamVectorHelper<org::genivi::am::am_Availability_e> {
2098         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Availability_e>& vectorValue) {
2099                 (void)vectorValue;
2100             inputStream.beginReadInt32EnumVector();
2101         }
2102     };
2103
2104     template <>
2105     struct OutputStreamVectorHelper<org::genivi::am::am_Availability_e> {
2106         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Availability_e>& vectorValue) {
2107             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2108         }
2109     };
2110     template<>
2111     struct BasicTypeWriter<org::genivi::am::am_HotSink_e> {
2112         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2113             typeStream.writeInt32EnumType();
2114         }
2115     };
2116
2117     template<>
2118     struct InputStreamVectorHelper<org::genivi::am::am_HotSink_e> {
2119         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_HotSink_e>& vectorValue) {
2120                 (void)vectorValue;
2121             inputStream.beginReadInt32EnumVector();
2122         }
2123     };
2124
2125     template <>
2126     struct OutputStreamVectorHelper<org::genivi::am::am_HotSink_e> {
2127         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_HotSink_e>& vectorValue) {
2128             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2129         }
2130     };
2131     template<>
2132     struct BasicTypeWriter<org::genivi::am::am_ConnectionState_e> {
2133         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2134             typeStream.writeInt32EnumType();
2135         }
2136     };
2137
2138     template<>
2139     struct InputStreamVectorHelper<org::genivi::am::am_ConnectionState_e> {
2140         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_ConnectionState_e>& vectorValue) {
2141                 (void)vectorValue;
2142             inputStream.beginReadInt32EnumVector();
2143         }
2144     };
2145
2146     template <>
2147     struct OutputStreamVectorHelper<org::genivi::am::am_ConnectionState_e> {
2148         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_ConnectionState_e>& vectorValue) {
2149             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2150         }
2151     };
2152     template<>
2153     struct BasicTypeWriter<org::genivi::am::am_DomainState_e> {
2154         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2155             typeStream.writeInt32EnumType();
2156         }
2157     };
2158
2159     template<>
2160     struct InputStreamVectorHelper<org::genivi::am::am_DomainState_e> {
2161         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_DomainState_e>& vectorValue) {
2162                 (void)vectorValue;
2163             inputStream.beginReadInt32EnumVector();
2164         }
2165     };
2166
2167     template <>
2168     struct OutputStreamVectorHelper<org::genivi::am::am_DomainState_e> {
2169         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_DomainState_e>& vectorValue) {
2170             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2171         }
2172     };
2173     template<>
2174     struct BasicTypeWriter<org::genivi::am::am_EarlyDataType_e> {
2175         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2176             typeStream.writeInt32EnumType();
2177         }
2178     };
2179
2180     template<>
2181     struct InputStreamVectorHelper<org::genivi::am::am_EarlyDataType_e> {
2182         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_EarlyDataType_e>& vectorValue) {
2183                 (void)vectorValue;
2184             inputStream.beginReadInt32EnumVector();
2185         }
2186     };
2187
2188     template <>
2189     struct OutputStreamVectorHelper<org::genivi::am::am_EarlyDataType_e> {
2190         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_EarlyDataType_e>& vectorValue) {
2191             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2192         }
2193     };
2194     template<>
2195     struct BasicTypeWriter<org::genivi::am::am_Error_e> {
2196         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2197             typeStream.writeInt32EnumType();
2198         }
2199     };
2200
2201     template<>
2202     struct InputStreamVectorHelper<org::genivi::am::am_Error_e> {
2203         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Error_e>& vectorValue) {
2204                 (void)vectorValue;
2205             inputStream.beginReadInt32EnumVector();
2206         }
2207     };
2208
2209     template <>
2210     struct OutputStreamVectorHelper<org::genivi::am::am_Error_e> {
2211         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Error_e>& vectorValue) {
2212             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2213         }
2214     };
2215     template<>
2216     struct BasicTypeWriter<org::genivi::am::am_MuteState_e> {
2217         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2218             typeStream.writeInt32EnumType();
2219         }
2220     };
2221
2222     template<>
2223     struct InputStreamVectorHelper<org::genivi::am::am_MuteState_e> {
2224         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_MuteState_e>& vectorValue) {
2225                 (void)vectorValue;
2226             inputStream.beginReadInt32EnumVector();
2227         }
2228     };
2229
2230     template <>
2231     struct OutputStreamVectorHelper<org::genivi::am::am_MuteState_e> {
2232         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_MuteState_e>& vectorValue) {
2233             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2234         }
2235     };
2236     template<>
2237     struct BasicTypeWriter<org::genivi::am::am_InterruptState_e> {
2238         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2239             typeStream.writeInt32EnumType();
2240         }
2241     };
2242
2243     template<>
2244     struct InputStreamVectorHelper<org::genivi::am::am_InterruptState_e> {
2245         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_InterruptState_e>& vectorValue) {
2246                 (void)vectorValue;
2247             inputStream.beginReadInt32EnumVector();
2248         }
2249     };
2250
2251     template <>
2252     struct OutputStreamVectorHelper<org::genivi::am::am_InterruptState_e> {
2253         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_InterruptState_e>& vectorValue) {
2254             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2255         }
2256     };
2257     template<>
2258     struct BasicTypeWriter<org::genivi::am::am_VolumeType_e> {
2259         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2260             typeStream.writeInt32EnumType();
2261         }
2262     };
2263
2264     template<>
2265     struct InputStreamVectorHelper<org::genivi::am::am_VolumeType_e> {
2266         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_VolumeType_e>& vectorValue) {
2267                 (void)vectorValue;
2268             inputStream.beginReadInt32EnumVector();
2269         }
2270     };
2271
2272     template <>
2273     struct OutputStreamVectorHelper<org::genivi::am::am_VolumeType_e> {
2274         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_VolumeType_e>& vectorValue) {
2275             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2276         }
2277     };
2278     template<>
2279     struct BasicTypeWriter<org::genivi::am::am_NotificationStatus_e> {
2280         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2281             typeStream.writeInt32EnumType();
2282         }
2283     };
2284
2285     template<>
2286     struct InputStreamVectorHelper<org::genivi::am::am_NotificationStatus_e> {
2287         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_NotificationStatus_e>& vectorValue) {
2288                 (void)vectorValue;
2289             inputStream.beginReadInt32EnumVector();
2290         }
2291     };
2292
2293     template <>
2294     struct OutputStreamVectorHelper<org::genivi::am::am_NotificationStatus_e> {
2295         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_NotificationStatus_e>& vectorValue) {
2296             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2297         }
2298     };
2299     template<>
2300     struct BasicTypeWriter<org::genivi::am::am_Handle_e> {
2301         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2302             typeStream.writeInt32EnumType();
2303         }
2304     };
2305
2306     template<>
2307     struct InputStreamVectorHelper<org::genivi::am::am_Handle_e> {
2308         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Handle_e>& vectorValue) {
2309                 (void)vectorValue;
2310             inputStream.beginReadInt32EnumVector();
2311         }
2312     };
2313
2314     template <>
2315     struct OutputStreamVectorHelper<org::genivi::am::am_Handle_e> {
2316         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Handle_e>& vectorValue) {
2317             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2318         }
2319     };
2320     template<>
2321     struct BasicTypeWriter<org::genivi::am::am_SourceState_e> {
2322         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2323             typeStream.writeInt32EnumType();
2324         }
2325     };
2326
2327     template<>
2328     struct InputStreamVectorHelper<org::genivi::am::am_SourceState_e> {
2329         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_SourceState_e>& vectorValue) {
2330                 (void)vectorValue;
2331             inputStream.beginReadInt32EnumVector();
2332         }
2333     };
2334
2335     template <>
2336     struct OutputStreamVectorHelper<org::genivi::am::am_SourceState_e> {
2337         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_SourceState_e>& vectorValue) {
2338             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2339         }
2340     };
2341     template<>
2342     struct BasicTypeWriter<org::genivi::am::am_RoutingReady_e> {
2343         inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
2344             typeStream.writeInt32EnumType();
2345         }
2346     };
2347
2348     template<>
2349     struct InputStreamVectorHelper<org::genivi::am::am_RoutingReady_e> {
2350         static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_RoutingReady_e>& vectorValue) {
2351                 (void)vectorValue;
2352             inputStream.beginReadInt32EnumVector();
2353         }
2354     };
2355
2356     template <>
2357     struct OutputStreamVectorHelper<org::genivi::am::am_RoutingReady_e> {
2358         static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_RoutingReady_e>& vectorValue) {
2359             outputStream.beginWriteInt32EnumVector(vectorValue.size());
2360         }
2361     };
2362
2363 }
2364
2365
2366 namespace std {
2367     //Hash for am_Availability_e
2368     template<>
2369     struct hash<org::genivi::am::am_Availability_e> {
2370         inline size_t operator()(const org::genivi::am::am_Availability_e& am_Availability_e) const {
2371             return static_cast<int32_t>(am_Availability_e);
2372         }
2373     };
2374     //Hash for am_HotSink_e
2375     template<>
2376     struct hash<org::genivi::am::am_HotSink_e> {
2377         inline size_t operator()(const org::genivi::am::am_HotSink_e& am_HotSink_e) const {
2378             return static_cast<int32_t>(am_HotSink_e);
2379         }
2380     };
2381     //Hash for am_ConnectionState_e
2382     template<>
2383     struct hash<org::genivi::am::am_ConnectionState_e> {
2384         inline size_t operator()(const org::genivi::am::am_ConnectionState_e& am_ConnectionState_e) const {
2385             return static_cast<int32_t>(am_ConnectionState_e);
2386         }
2387     };
2388     //Hash for am_DomainState_e
2389     template<>
2390     struct hash<org::genivi::am::am_DomainState_e> {
2391         inline size_t operator()(const org::genivi::am::am_DomainState_e& am_DomainState_e) const {
2392             return static_cast<int32_t>(am_DomainState_e);
2393         }
2394     };
2395     //Hash for am_EarlyDataType_e
2396     template<>
2397     struct hash<org::genivi::am::am_EarlyDataType_e> {
2398         inline size_t operator()(const org::genivi::am::am_EarlyDataType_e& am_EarlyDataType_e) const {
2399             return static_cast<int32_t>(am_EarlyDataType_e);
2400         }
2401     };
2402     //Hash for am_Error_e
2403     template<>
2404     struct hash<org::genivi::am::am_Error_e> {
2405         inline size_t operator()(const org::genivi::am::am_Error_e& am_Error_e) const {
2406             return static_cast<int32_t>(am_Error_e);
2407         }
2408     };
2409     //Hash for am_MuteState_e
2410     template<>
2411     struct hash<org::genivi::am::am_MuteState_e> {
2412         inline size_t operator()(const org::genivi::am::am_MuteState_e& am_MuteState_e) const {
2413             return static_cast<int32_t>(am_MuteState_e);
2414         }
2415     };
2416     //Hash for am_InterruptState_e
2417     template<>
2418     struct hash<org::genivi::am::am_InterruptState_e> {
2419         inline size_t operator()(const org::genivi::am::am_InterruptState_e& am_InterruptState_e) const {
2420             return static_cast<int32_t>(am_InterruptState_e);
2421         }
2422     };
2423     //Hash for am_VolumeType_e
2424     template<>
2425     struct hash<org::genivi::am::am_VolumeType_e> {
2426         inline size_t operator()(const org::genivi::am::am_VolumeType_e& am_VolumeType_e) const {
2427             return static_cast<int32_t>(am_VolumeType_e);
2428         }
2429     };
2430     //Hash for am_NotificationStatus_e
2431     template<>
2432     struct hash<org::genivi::am::am_NotificationStatus_e> {
2433         inline size_t operator()(const org::genivi::am::am_NotificationStatus_e& am_NotificationStatus_e) const {
2434             return static_cast<int32_t>(am_NotificationStatus_e);
2435         }
2436     };
2437     //Hash for am_Handle_e
2438     template<>
2439     struct hash<org::genivi::am::am_Handle_e> {
2440         inline size_t operator()(const org::genivi::am::am_Handle_e& am_Handle_e) const {
2441             return static_cast<int32_t>(am_Handle_e);
2442         }
2443     };
2444     //Hash for am_SourceState_e
2445     template<>
2446     struct hash<org::genivi::am::am_SourceState_e> {
2447         inline size_t operator()(const org::genivi::am::am_SourceState_e& am_SourceState_e) const {
2448             return static_cast<int32_t>(am_SourceState_e);
2449         }
2450     };
2451     //Hash for am_RoutingReady_e
2452     template<>
2453     struct hash<org::genivi::am::am_RoutingReady_e> {
2454         inline size_t operator()(const org::genivi::am::am_RoutingReady_e& am_RoutingReady_e) const {
2455             return static_cast<int32_t>(am_RoutingReady_e);
2456         }
2457     };
2458 }
2459
2460 #endif // ORG_GENIVI_am_H_