PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp

   1 /*
   2 * This file was generated by the CommonAPI Generators.
   3 * Used org.genivi.commonapi.core 2.1.1.201309251246.
   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 *
  19 * For further information see http://www.genivi.org/.
  20 */
  21 /**
  22  * @author Christian Linke
  23  */
  24 #include "am.h"
  25
  26
  27 namespace org {
  28 namespace genivi {
  29 namespace am {
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84 am_Route_s::am_Route_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_RoutingElement_L& routeValue):
  85         sourceID(sourceIDValue),
  86         sinkID(sinkIDValue),
  87         route(routeValue)
  88 {
  89 }
  90
  91
  92 bool operator==(const am_Route_s& lhs, const am_Route_s& rhs) {
  93     if (&lhs == &rhs)
  94         return true;
  95
  96     return
  97         lhs.sourceID == rhs.sourceID &&
  98         lhs.sinkID == rhs.sinkID &&
  99         lhs.route == rhs.route
 100     ;
 101 }
 102
 103 void am_Route_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 104     inputStream >> sourceID;
 105     inputStream >> sinkID;
 106     inputStream >> route;
 107 }
 108
 109 void am_Route_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 110     outputStream << sourceID;
 111     outputStream << sinkID;
 112     outputStream << route;
 113 }
 114
 115 am_Availability_s::am_Availability_s(const am_Availability_e& availabilityValue, const am_AvailabilityReason_pe& availabilityReasonValue):
 116         availability(availabilityValue),
 117         availabilityReason(availabilityReasonValue)
 118 {
 119 }
 120
 121
 122 bool operator==(const am_Availability_s& lhs, const am_Availability_s& rhs) {
 123     if (&lhs == &rhs)
 124         return true;
 125
 126     return
 127         lhs.availability == rhs.availability &&
 128         lhs.availabilityReason == rhs.availabilityReason
 129     ;
 130 }
 131
 132 void am_Availability_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 133     inputStream >> availability;
 134     inputStream >> availabilityReason;
 135 }
 136
 137 void am_Availability_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 138     outputStream << availability;
 139     outputStream << availabilityReason;
 140 }
 141
 142 am_ClassProperty_s::am_ClassProperty_s(const am_ClassProperty_pe& classPropertyValue, const int16_t& valueValue):
 143         classProperty(classPropertyValue),
 144         value(valueValue)
 145 {
 146 }
 147
 148
 149 bool operator==(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs) {
 150     if (&lhs == &rhs)
 151         return true;
 152
 153     return
 154         lhs.classProperty == rhs.classProperty &&
 155         lhs.value == rhs.value
 156     ;
 157 }
 158
 159 void am_ClassProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 160     inputStream >> classProperty;
 161     inputStream >> value;
 162 }
 163
 164 void am_ClassProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 165     outputStream << classProperty;
 166     outputStream << value;
 167 }
 168
 169 am_Crossfader_s::am_Crossfader_s(const am_crossfaderID_t& crossfaderIDValue, const std::string& nameValue, const am_sinkID_t& sinkID_AValue, const am_sinkID_t& sinkID_BValue, const am_sourceID_t& sourceIDValue, const am_HotSink_e& hotSinkValue):
 170         crossfaderID(crossfaderIDValue),
 171         name(nameValue),
 172         sinkID_A(sinkID_AValue),
 173         sinkID_B(sinkID_BValue),
 174         sourceID(sourceIDValue),
 175         hotSink(hotSinkValue)
 176 {
 177 }
 178
 179
 180 bool operator==(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs) {
 181     if (&lhs == &rhs)
 182         return true;
 183
 184     return
 185         lhs.crossfaderID == rhs.crossfaderID &&
 186         lhs.name == rhs.name &&
 187         lhs.sinkID_A == rhs.sinkID_A &&
 188         lhs.sinkID_B == rhs.sinkID_B &&
 189         lhs.sourceID == rhs.sourceID &&
 190         lhs.hotSink == rhs.hotSink
 191     ;
 192 }
 193
 194 void am_Crossfader_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 195     inputStream >> crossfaderID;
 196     inputStream >> name;
 197     inputStream >> sinkID_A;
 198     inputStream >> sinkID_B;
 199     inputStream >> sourceID;
 200     inputStream >> hotSink;
 201 }
 202
 203 void am_Crossfader_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 204     outputStream << crossfaderID;
 205     outputStream << name;
 206     outputStream << sinkID_A;
 207     outputStream << sinkID_B;
 208     outputStream << sourceID;
 209     outputStream << hotSink;
 210 }
 211
 212 am_Gateway_s::am_Gateway_s(const am_gatewayID_t& gatewayIDValue, const std::string& nameValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_domainID_t& domainSinkIDValue, const am_domainID_t& domainSourceIDValue, const am_domainID_t& controlDomainIDValue, const am_ConnectionFormat_L& listSourceFormatsValue, const am_ConnectionFormat_L& listSinkFormatsValue, const am_Convertion_L& convertionMatrixValue):
 213         gatewayID(gatewayIDValue),
 214         name(nameValue),
 215         sinkID(sinkIDValue),
 216         sourceID(sourceIDValue),
 217         domainSinkID(domainSinkIDValue),
 218         domainSourceID(domainSourceIDValue),
 219         controlDomainID(controlDomainIDValue),
 220         listSourceFormats(listSourceFormatsValue),
 221         listSinkFormats(listSinkFormatsValue),
 222         convertionMatrix(convertionMatrixValue)
 223 {
 224 }
 225
 226
 227 bool operator==(const am_Gateway_s& lhs, const am_Gateway_s& rhs) {
 228     if (&lhs == &rhs)
 229         return true;
 230
 231     return
 232         lhs.gatewayID == rhs.gatewayID &&
 233         lhs.name == rhs.name &&
 234         lhs.sinkID == rhs.sinkID &&
 235         lhs.sourceID == rhs.sourceID &&
 236         lhs.domainSinkID == rhs.domainSinkID &&
 237         lhs.domainSourceID == rhs.domainSourceID &&
 238         lhs.controlDomainID == rhs.controlDomainID &&
 239         lhs.listSourceFormats == rhs.listSourceFormats &&
 240         lhs.listSinkFormats == rhs.listSinkFormats &&
 241         lhs.convertionMatrix == rhs.convertionMatrix
 242     ;
 243 }
 244
 245 void am_Gateway_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 246     inputStream >> gatewayID;
 247     inputStream >> name;
 248     inputStream >> sinkID;
 249     inputStream >> sourceID;
 250     inputStream >> domainSinkID;
 251     inputStream >> domainSourceID;
 252     inputStream >> controlDomainID;
 253     inputStream >> listSourceFormats;
 254     inputStream >> listSinkFormats;
 255     inputStream >> convertionMatrix;
 256 }
 257
 258 void am_Gateway_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 259     outputStream << gatewayID;
 260     outputStream << name;
 261     outputStream << sinkID;
 262     outputStream << sourceID;
 263     outputStream << domainSinkID;
 264     outputStream << domainSourceID;
 265     outputStream << controlDomainID;
 266     outputStream << listSourceFormats;
 267     outputStream << listSinkFormats;
 268     outputStream << convertionMatrix;
 269 }
 270
 271 am_RoutingElement_s::am_RoutingElement_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_domainID_t& domainIDValue, const am_ConnectionFormat_pe& connectionFormatValue):
 272         sourceID(sourceIDValue),
 273         sinkID(sinkIDValue),
 274         domainID(domainIDValue),
 275         connectionFormat(connectionFormatValue)
 276 {
 277 }
 278
 279
 280 bool operator==(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs) {
 281     if (&lhs == &rhs)
 282         return true;
 283
 284     return
 285         lhs.sourceID == rhs.sourceID &&
 286         lhs.sinkID == rhs.sinkID &&
 287         lhs.domainID == rhs.domainID &&
 288         lhs.connectionFormat == rhs.connectionFormat
 289     ;
 290 }
 291
 292 void am_RoutingElement_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 293     inputStream >> sourceID;
 294     inputStream >> sinkID;
 295     inputStream >> domainID;
 296     inputStream >> connectionFormat;
 297 }
 298
 299 void am_RoutingElement_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 300     outputStream << sourceID;
 301     outputStream << sinkID;
 302     outputStream << domainID;
 303     outputStream << connectionFormat;
 304 }
 305
 306 am_SoundProperty_s::am_SoundProperty_s(const am_SoundPropertyType_pe& typeValue, const int16_t& valueValue):
 307         type(typeValue),
 308         value(valueValue)
 309 {
 310 }
 311
 312
 313 bool operator==(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs) {
 314     if (&lhs == &rhs)
 315         return true;
 316
 317     return
 318         lhs.type == rhs.type &&
 319         lhs.value == rhs.value
 320     ;
 321 }
 322
 323 void am_SoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 324     inputStream >> type;
 325     inputStream >> value;
 326 }
 327
 328 void am_SoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 329     outputStream << type;
 330     outputStream << value;
 331 }
 332
 333 am_SystemProperty_s::am_SystemProperty_s(const am_SystemPropertyType_pe& typeValue, const int16_t& valueValue):
 334         type(typeValue),
 335         value(valueValue)
 336 {
 337 }
 338
 339
 340 bool operator==(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs) {
 341     if (&lhs == &rhs)
 342         return true;
 343
 344     return
 345         lhs.type == rhs.type &&
 346         lhs.value == rhs.value
 347     ;
 348 }
 349
 350 void am_SystemProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 351     inputStream >> type;
 352     inputStream >> value;
 353 }
 354
 355 void am_SystemProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 356     outputStream << type;
 357     outputStream << value;
 358 }
 359
 360 am_SinkClass_s::am_SinkClass_s(const am_sinkClass_t& sinkClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue):
 361         sinkClassID(sinkClassIDValue),
 362         name(nameValue),
 363         listClassProperties(listClassPropertiesValue)
 364 {
 365 }
 366
 367
 368 bool operator==(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs) {
 369     if (&lhs == &rhs)
 370         return true;
 371
 372     return
 373         lhs.sinkClassID == rhs.sinkClassID &&
 374         lhs.name == rhs.name &&
 375         lhs.listClassProperties == rhs.listClassProperties
 376     ;
 377 }
 378
 379 void am_SinkClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 380     inputStream >> sinkClassID;
 381     inputStream >> name;
 382     inputStream >> listClassProperties;
 383 }
 384
 385 void am_SinkClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 386     outputStream << sinkClassID;
 387     outputStream << name;
 388     outputStream << listClassProperties;
 389 }
 390
 391 am_SourceClass_s::am_SourceClass_s(const am_sourceClass_t& sourceClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue):
 392         sourceClassID(sourceClassIDValue),
 393         name(nameValue),
 394         listClassProperties(listClassPropertiesValue)
 395 {
 396 }
 397
 398
 399 bool operator==(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs) {
 400     if (&lhs == &rhs)
 401         return true;
 402
 403     return
 404         lhs.sourceClassID == rhs.sourceClassID &&
 405         lhs.name == rhs.name &&
 406         lhs.listClassProperties == rhs.listClassProperties
 407     ;
 408 }
 409
 410 void am_SourceClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 411     inputStream >> sourceClassID;
 412     inputStream >> name;
 413     inputStream >> listClassProperties;
 414 }
 415
 416 void am_SourceClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 417     outputStream << sourceClassID;
 418     outputStream << name;
 419     outputStream << listClassProperties;
 420 }
 421
 422 am_SourceType_s::am_SourceType_s(const am_sourceID_t& sourceIDValue, const std::string& nameValue, const am_Availability_s& availabilityValue, const am_sourceClass_t& sourceClassIDValue):
 423         sourceID(sourceIDValue),
 424         name(nameValue),
 425         availability(availabilityValue),
 426         sourceClassID(sourceClassIDValue)
 427 {
 428 }
 429
 430
 431 bool operator==(const am_SourceType_s& lhs, const am_SourceType_s& rhs) {
 432     if (&lhs == &rhs)
 433         return true;
 434
 435     return
 436         lhs.sourceID == rhs.sourceID &&
 437         lhs.name == rhs.name &&
 438         lhs.availability == rhs.availability &&
 439         lhs.sourceClassID == rhs.sourceClassID
 440     ;
 441 }
 442
 443 void am_SourceType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 444     inputStream >> sourceID;
 445     inputStream >> name;
 446     inputStream >> availability;
 447     inputStream >> sourceClassID;
 448 }
 449
 450 void am_SourceType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 451     outputStream << sourceID;
 452     outputStream << name;
 453     outputStream << availability;
 454     outputStream << sourceClassID;
 455 }
 456
 457 am_SinkType_s::am_SinkType_s(const am_sinkID_t& sinkIDValue, const std::string& nameValue, const am_Availability_s& availabilityValue, const am_mainVolume_t& volumeValue, const am_MuteState_e& muteStateValue, const am_sinkClass_t& sinkClassIDValue):
 458         sinkID(sinkIDValue),
 459         name(nameValue),
 460         availability(availabilityValue),
 461         volume(volumeValue),
 462         muteState(muteStateValue),
 463         sinkClassID(sinkClassIDValue)
 464 {
 465 }
 466
 467
 468 bool operator==(const am_SinkType_s& lhs, const am_SinkType_s& rhs) {
 469     if (&lhs == &rhs)
 470         return true;
 471
 472     return
 473         lhs.sinkID == rhs.sinkID &&
 474         lhs.name == rhs.name &&
 475         lhs.availability == rhs.availability &&
 476         lhs.volume == rhs.volume &&
 477         lhs.muteState == rhs.muteState &&
 478         lhs.sinkClassID == rhs.sinkClassID
 479     ;
 480 }
 481
 482 void am_SinkType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 483     inputStream >> sinkID;
 484     inputStream >> name;
 485     inputStream >> availability;
 486     inputStream >> volume;
 487     inputStream >> muteState;
 488     inputStream >> sinkClassID;
 489 }
 490
 491 void am_SinkType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 492     outputStream << sinkID;
 493     outputStream << name;
 494     outputStream << availability;
 495     outputStream << volume;
 496     outputStream << muteState;
 497     outputStream << sinkClassID;
 498 }
 499
 500 am_Handle_s::am_Handle_s(const am_Handle_e& handleTypeValue, const uint16_t& handleValue):
 501         handleType(handleTypeValue),
 502         handle(handleValue)
 503 {
 504 }
 505
 506
 507 bool operator==(const am_Handle_s& lhs, const am_Handle_s& rhs) {
 508     if (&lhs == &rhs)
 509         return true;
 510
 511     return
 512         lhs.handleType == rhs.handleType &&
 513         lhs.handle == rhs.handle
 514     ;
 515 }
 516
 517 void am_Handle_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 518     inputStream >> handleType;
 519     inputStream >> handle;
 520 }
 521
 522 void am_Handle_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 523     outputStream << handleType;
 524     outputStream << handle;
 525 }
 526
 527 am_MainSoundProperty_s::am_MainSoundProperty_s(const am_MainSoundPropertyType_pe& typeValue, const int16_t& valueValue):
 528         type(typeValue),
 529         value(valueValue)
 530 {
 531 }
 532
 533
 534 bool operator==(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs) {
 535     if (&lhs == &rhs)
 536         return true;
 537
 538     return
 539         lhs.type == rhs.type &&
 540         lhs.value == rhs.value
 541     ;
 542 }
 543
 544 void am_MainSoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 545     inputStream >> type;
 546     inputStream >> value;
 547 }
 548
 549 void am_MainSoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 550     outputStream << type;
 551     outputStream << value;
 552 }
 553
 554 am_MainConnectionType_s::am_MainConnectionType_s(const am_mainConnectionID_t& mainConnectionIDValue, const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_timeSync_t& delayValue, const am_ConnectionState_e& connectionStateValue):
 555         mainConnectionID(mainConnectionIDValue),
 556         sourceID(sourceIDValue),
 557         sinkID(sinkIDValue),
 558         delay(delayValue),
 559         connectionState(connectionStateValue)
 560 {
 561 }
 562
 563
 564 bool operator==(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs) {
 565     if (&lhs == &rhs)
 566         return true;
 567
 568     return
 569         lhs.mainConnectionID == rhs.mainConnectionID &&
 570         lhs.sourceID == rhs.sourceID &&
 571         lhs.sinkID == rhs.sinkID &&
 572         lhs.delay == rhs.delay &&
 573         lhs.connectionState == rhs.connectionState
 574     ;
 575 }
 576
 577 void am_MainConnectionType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 578     inputStream >> mainConnectionID;
 579     inputStream >> sourceID;
 580     inputStream >> sinkID;
 581     inputStream >> delay;
 582     inputStream >> connectionState;
 583 }
 584
 585 void am_MainConnectionType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 586     outputStream << mainConnectionID;
 587     outputStream << sourceID;
 588     outputStream << sinkID;
 589     outputStream << delay;
 590     outputStream << connectionState;
 591 }
 592
 593 am_MainConnection_s::am_MainConnection_s(const am_mainConnectionID_t& mainConnectionIDValue, const am_ConnectionState_e& connectionStateValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_timeSync_t& delayValue, const am_ConnectionID_L& listConnectionIDValue):
 594         mainConnectionID(mainConnectionIDValue),
 595         connectionState(connectionStateValue),
 596         sinkID(sinkIDValue),
 597         sourceID(sourceIDValue),
 598         delay(delayValue),
 599         listConnectionID(listConnectionIDValue)
 600 {
 601 }
 602
 603
 604 bool operator==(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs) {
 605     if (&lhs == &rhs)
 606         return true;
 607
 608     return
 609         lhs.mainConnectionID == rhs.mainConnectionID &&
 610         lhs.connectionState == rhs.connectionState &&
 611         lhs.sinkID == rhs.sinkID &&
 612         lhs.sourceID == rhs.sourceID &&
 613         lhs.delay == rhs.delay &&
 614         lhs.listConnectionID == rhs.listConnectionID
 615     ;
 616 }
 617
 618 void am_MainConnection_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 619     inputStream >> mainConnectionID;
 620     inputStream >> connectionState;
 621     inputStream >> sinkID;
 622     inputStream >> sourceID;
 623     inputStream >> delay;
 624     inputStream >> listConnectionID;
 625 }
 626
 627 void am_MainConnection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 628     outputStream << mainConnectionID;
 629     outputStream << connectionState;
 630     outputStream << sinkID;
 631     outputStream << sourceID;
 632     outputStream << delay;
 633     outputStream << listConnectionID;
 634 }
 635
 636 am_NotificationPayload_s::am_NotificationPayload_s(const am_NotificationType_pe& typeValue, const int16_t& valueValue):
 637         type(typeValue),
 638         value(valueValue)
 639 {
 640 }
 641
 642
 643 bool operator==(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs) {
 644     if (&lhs == &rhs)
 645         return true;
 646
 647     return
 648         lhs.type == rhs.type &&
 649         lhs.value == rhs.value
 650     ;
 651 }
 652
 653 void am_NotificationPayload_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 654     inputStream >> type;
 655     inputStream >> value;
 656 }
 657
 658 void am_NotificationPayload_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 659     outputStream << type;
 660     outputStream << value;
 661 }
 662
 663 am_NotificationConfiguration_s::am_NotificationConfiguration_s(const am_NotificationType_pe& typeValue, const am_NotificationStatus_e& statusValue, const int16_t& parameterValue):
 664         type(typeValue),
 665         status(statusValue),
 666         parameter(parameterValue)
 667 {
 668 }
 669
 670
 671 bool operator==(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs) {
 672     if (&lhs == &rhs)
 673         return true;
 674
 675     return
 676         lhs.type == rhs.type &&
 677         lhs.status == rhs.status &&
 678         lhs.parameter == rhs.parameter
 679     ;
 680 }
 681
 682 void am_NotificationConfiguration_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 683     inputStream >> type;
 684     inputStream >> status;
 685     inputStream >> parameter;
 686 }
 687
 688 void am_NotificationConfiguration_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 689     outputStream << type;
 690     outputStream << status;
 691     outputStream << parameter;
 692 }
 693
 694 am_Sink_s::am_Sink_s(const am_sinkID_t& sinkIDValue, const std::string& nameValue, const am_domainID_t& domainIDValue, const am_sinkClass_t& sinkClassIDValue, const am_volume_t& volumeValue, const bool& visibleValue, const am_Availability_s& availableValue, const am_MuteState_e& muteStateValue, const am_mainVolume_t& mainVolumeValue, const am_SoundProperty_L& listSoundPropertiesValue, const am_ConnectionFormat_L& listConnectionFormatsValue, const am_MainSoundProperty_L& listMainSoundPropertiesValue, const am_NotificationConfiguration_L& listMainNotificationConfigurationsValue, const am_NotificationConfiguration_L& listNotificationConfigurationsValue):
 695         sinkID(sinkIDValue),
 696         name(nameValue),
 697         domainID(domainIDValue),
 698         sinkClassID(sinkClassIDValue),
 699         volume(volumeValue),
 700         visible(visibleValue),
 701         available(availableValue),
 702         muteState(muteStateValue),
 703         mainVolume(mainVolumeValue),
 704         listSoundProperties(listSoundPropertiesValue),
 705         listConnectionFormats(listConnectionFormatsValue),
 706         listMainSoundProperties(listMainSoundPropertiesValue),
 707         listMainNotificationConfigurations(listMainNotificationConfigurationsValue),
 708         listNotificationConfigurations(listNotificationConfigurationsValue)
 709 {
 710 }
 711
 712
 713 bool operator==(const am_Sink_s& lhs, const am_Sink_s& rhs) {
 714     if (&lhs == &rhs)
 715         return true;
 716
 717     return
 718         lhs.sinkID == rhs.sinkID &&
 719         lhs.name == rhs.name &&
 720         lhs.domainID == rhs.domainID &&
 721         lhs.sinkClassID == rhs.sinkClassID &&
 722         lhs.volume == rhs.volume &&
 723         lhs.visible == rhs.visible &&
 724         lhs.available == rhs.available &&
 725         lhs.muteState == rhs.muteState &&
 726         lhs.mainVolume == rhs.mainVolume &&
 727         lhs.listSoundProperties == rhs.listSoundProperties &&
 728         lhs.listConnectionFormats == rhs.listConnectionFormats &&
 729         lhs.listMainSoundProperties == rhs.listMainSoundProperties &&
 730         lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations &&
 731         lhs.listNotificationConfigurations == rhs.listNotificationConfigurations
 732     ;
 733 }
 734
 735 void am_Sink_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 736     inputStream >> sinkID;
 737     inputStream >> name;
 738     inputStream >> domainID;
 739     inputStream >> sinkClassID;
 740     inputStream >> volume;
 741     inputStream >> visible;
 742     inputStream >> available;
 743     inputStream >> muteState;
 744     inputStream >> mainVolume;
 745     inputStream >> listSoundProperties;
 746     inputStream >> listConnectionFormats;
 747     inputStream >> listMainSoundProperties;
 748     inputStream >> listMainNotificationConfigurations;
 749     inputStream >> listNotificationConfigurations;
 750 }
 751
 752 void am_Sink_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 753     outputStream << sinkID;
 754     outputStream << name;
 755     outputStream << domainID;
 756     outputStream << sinkClassID;
 757     outputStream << volume;
 758     outputStream << visible;
 759     outputStream << available;
 760     outputStream << muteState;
 761     outputStream << mainVolume;
 762     outputStream << listSoundProperties;
 763     outputStream << listConnectionFormats;
 764     outputStream << listMainSoundProperties;
 765     outputStream << listMainNotificationConfigurations;
 766     outputStream << listNotificationConfigurations;
 767 }
 768
 769 am_Source_s::am_Source_s(const am_sourceID_t& sourceIDValue, const am_domainID_t& domainIDValue, const std::string& nameValue, const am_sourceClass_t& sourceClassIDValue, const am_SourceState_e& sourceStateValue, const am_volume_t& volumeValue, const bool& visibleValue, const am_Availability_s& availableValue, const am_InterruptState_e& interruptStateValue, const am_SoundProperty_L& listSoundPropertiesValue, const am_ConnectionFormat_L& listConnectionFormatsValue, const am_MainSoundProperty_L& listMainSoundPropertiesValue, const am_NotificationConfiguration_L& listMainNotificationConfigurationsValue, const am_NotificationConfiguration_L& listNotificationConfigurationsValue):
 770         sourceID(sourceIDValue),
 771         domainID(domainIDValue),
 772         name(nameValue),
 773         sourceClassID(sourceClassIDValue),
 774         sourceState(sourceStateValue),
 775         volume(volumeValue),
 776         visible(visibleValue),
 777         available(availableValue),
 778         interruptState(interruptStateValue),
 779         listSoundProperties(listSoundPropertiesValue),
 780         listConnectionFormats(listConnectionFormatsValue),
 781         listMainSoundProperties(listMainSoundPropertiesValue),
 782         listMainNotificationConfigurations(listMainNotificationConfigurationsValue),
 783         listNotificationConfigurations(listNotificationConfigurationsValue)
 784 {
 785 }
 786
 787
 788 bool operator==(const am_Source_s& lhs, const am_Source_s& rhs) {
 789     if (&lhs == &rhs)
 790         return true;
 791
 792     return
 793         lhs.sourceID == rhs.sourceID &&
 794         lhs.domainID == rhs.domainID &&
 795         lhs.name == rhs.name &&
 796         lhs.sourceClassID == rhs.sourceClassID &&
 797         lhs.sourceState == rhs.sourceState &&
 798         lhs.volume == rhs.volume &&
 799         lhs.visible == rhs.visible &&
 800         lhs.available == rhs.available &&
 801         lhs.interruptState == rhs.interruptState &&
 802         lhs.listSoundProperties == rhs.listSoundProperties &&
 803         lhs.listConnectionFormats == rhs.listConnectionFormats &&
 804         lhs.listMainSoundProperties == rhs.listMainSoundProperties &&
 805         lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations &&
 806         lhs.listNotificationConfigurations == rhs.listNotificationConfigurations
 807     ;
 808 }
 809
 810 void am_Source_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 811     inputStream >> sourceID;
 812     inputStream >> domainID;
 813     inputStream >> name;
 814     inputStream >> sourceClassID;
 815     inputStream >> sourceState;
 816     inputStream >> volume;
 817     inputStream >> visible;
 818     inputStream >> available;
 819     inputStream >> interruptState;
 820     inputStream >> listSoundProperties;
 821     inputStream >> listConnectionFormats;
 822     inputStream >> listMainSoundProperties;
 823     inputStream >> listMainNotificationConfigurations;
 824     inputStream >> listNotificationConfigurations;
 825 }
 826
 827 void am_Source_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 828     outputStream << sourceID;
 829     outputStream << domainID;
 830     outputStream << name;
 831     outputStream << sourceClassID;
 832     outputStream << sourceState;
 833     outputStream << volume;
 834     outputStream << visible;
 835     outputStream << available;
 836     outputStream << interruptState;
 837     outputStream << listSoundProperties;
 838     outputStream << listConnectionFormats;
 839     outputStream << listMainSoundProperties;
 840     outputStream << listMainNotificationConfigurations;
 841     outputStream << listNotificationConfigurations;
 842 }
 843
 844 am_Domain_s::am_Domain_s(const am_domainID_t& domainIDValue, const std::string& nameValue, const std::string& busnameValue, const std::string& nodenameValue, const bool& earlyValue, const bool& completeValue, const am_DomainState_e& stateValue):
 845         domainID(domainIDValue),
 846         name(nameValue),
 847         busname(busnameValue),
 848         nodename(nodenameValue),
 849         early(earlyValue),
 850         complete(completeValue),
 851         state(stateValue)
 852 {
 853 }
 854
 855
 856 bool operator==(const am_Domain_s& lhs, const am_Domain_s& rhs) {
 857     if (&lhs == &rhs)
 858         return true;
 859
 860     return
 861         lhs.domainID == rhs.domainID &&
 862         lhs.name == rhs.name &&
 863         lhs.busname == rhs.busname &&
 864         lhs.nodename == rhs.nodename &&
 865         lhs.early == rhs.early &&
 866         lhs.complete == rhs.complete &&
 867         lhs.state == rhs.state
 868     ;
 869 }
 870
 871 void am_Domain_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 872     inputStream >> domainID;
 873     inputStream >> name;
 874     inputStream >> busname;
 875     inputStream >> nodename;
 876     inputStream >> early;
 877     inputStream >> complete;
 878     inputStream >> state;
 879 }
 880
 881 void am_Domain_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 882     outputStream << domainID;
 883     outputStream << name;
 884     outputStream << busname;
 885     outputStream << nodename;
 886     outputStream << early;
 887     outputStream << complete;
 888     outputStream << state;
 889 }
 890
 891 am_EarlyData_s::am_EarlyData_s(const am_EarlyDataType_e& typeValue, const am_DataType_u& sinksourceValue, const am_EarlyData_u& dataValue):
 892         type(typeValue),
 893         sinksource(sinksourceValue),
 894         data(dataValue)
 895 {
 896 }
 897
 898
 899 bool operator==(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs) {
 900     if (&lhs == &rhs)
 901         return true;
 902
 903     return
 904         lhs.type == rhs.type &&
 905         lhs.sinksource == rhs.sinksource &&
 906         lhs.data == rhs.data
 907     ;
 908 }
 909
 910 void am_EarlyData_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 911     inputStream >> type;
 912     inputStream >> sinksource;
 913     inputStream >> data;
 914 }
 915
 916 void am_EarlyData_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 917     outputStream << type;
 918     outputStream << sinksource;
 919     outputStream << data;
 920 }
 921
 922 am_Connection_s::am_Connection_s(const am_connectionID_t& connectionIDValue, const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_timeSync_t& delayValue, const am_ConnectionFormat_pe& connectionFormatValue):
 923         connectionID(connectionIDValue),
 924         sourceID(sourceIDValue),
 925         sinkID(sinkIDValue),
 926         delay(delayValue),
 927         connectionFormat(connectionFormatValue)
 928 {
 929 }
 930
 931
 932 bool operator==(const am_Connection_s& lhs, const am_Connection_s& rhs) {
 933     if (&lhs == &rhs)
 934         return true;
 935
 936     return
 937         lhs.connectionID == rhs.connectionID &&
 938         lhs.sourceID == rhs.sourceID &&
 939         lhs.sinkID == rhs.sinkID &&
 940         lhs.delay == rhs.delay &&
 941         lhs.connectionFormat == rhs.connectionFormat
 942     ;
 943 }
 944
 945 void am_Connection_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 946     inputStream >> connectionID;
 947     inputStream >> sourceID;
 948     inputStream >> sinkID;
 949     inputStream >> delay;
 950     inputStream >> connectionFormat;
 951 }
 952
 953 void am_Connection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 954     outputStream << connectionID;
 955     outputStream << sourceID;
 956     outputStream << sinkID;
 957     outputStream << delay;
 958     outputStream << connectionFormat;
 959 }
 960
 961 am_Volumes_s::am_Volumes_s(const am_VolumeType_e& volumeTypeValue, const am_DataType_u& volumeIDValue, const am_volume_t& volumeValue, const am_RampType_pe& rampValue, const am_time_t& timeValue):
 962         volumeType(volumeTypeValue),
 963         volumeID(volumeIDValue),
 964         volume(volumeValue),
 965         ramp(rampValue),
 966         time(timeValue)
 967 {
 968 }
 969
 970
 971 bool operator==(const am_Volumes_s& lhs, const am_Volumes_s& rhs) {
 972     if (&lhs == &rhs)
 973         return true;
 974
 975     return
 976         lhs.volumeType == rhs.volumeType &&
 977         lhs.volumeID == rhs.volumeID &&
 978         lhs.volume == rhs.volume &&
 979         lhs.ramp == rhs.ramp &&
 980         lhs.time == rhs.time
 981     ;
 982 }
 983
 984 void am_Volumes_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
 985     inputStream >> volumeType;
 986     inputStream >> volumeID;
 987     inputStream >> volume;
 988     inputStream >> ramp;
 989     inputStream >> time;
 990 }
 991
 992 void am_Volumes_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 993     outputStream << volumeType;
 994     outputStream << volumeID;
 995     outputStream << volume;
 996     outputStream << ramp;
 997     outputStream << time;
 998 }
 999
1000
1001
1002 } // namespace am
1003 } // namespace genivi
1004 } // namespace org