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