From 54960599eebf199d5237f863df5a2c08e3c25823 Mon Sep 17 00:00:00 2001 From: Andrei Gherzan Date: Wed, 13 May 2015 16:06:11 +0200 Subject: Add CommonAPI sources generated with CommonAPI 2.1.6 generator Signed-off-by: Andrei Gherzan --- .../src-gen/org/genivi/am.cpp | 1043 ++++++++++++++++++++ 1 file changed, 1043 insertions(+) create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp (limited to 'PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp') diff --git a/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp b/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp new file mode 100644 index 0000000..8092420 --- /dev/null +++ b/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp @@ -0,0 +1,1043 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * @author Christian Linke + */ +#include "am.h" + + +namespace org { +namespace genivi { +namespace am { + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +am_Route_s::am_Route_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_RoutingElement_L& routeValue): + sourceID(sourceIDValue), + sinkID(sinkIDValue), + route(routeValue) +{ +} + + +bool operator==(const am_Route_s& lhs, const am_Route_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceID == rhs.sourceID && + lhs.sinkID == rhs.sinkID && + lhs.route == rhs.route + ; +} + +void am_Route_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceID; + inputStream >> sinkID; + inputStream >> route; +} + +void am_Route_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceID; + outputStream << sinkID; + outputStream << route; +} + +am_Availability_s::am_Availability_s(const am_Availability_e& availabilityValue, const am_CustomAvailabilityReason_t& availabilityReasonValue): + availability(availabilityValue), + availabilityReason(availabilityReasonValue) +{ +} + + +bool operator==(const am_Availability_s& lhs, const am_Availability_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.availability == rhs.availability && + lhs.availabilityReason == rhs.availabilityReason + ; +} + +void am_Availability_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> availability; + inputStream >> availabilityReason; +} + +void am_Availability_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << availability; + outputStream << availabilityReason; +} + +am_ClassProperty_s::am_ClassProperty_s(const am_CustomClassProperty_t& classPropertyValue, const int16_t& valueValue): + classProperty(classPropertyValue), + value(valueValue) +{ +} + + +bool operator==(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.classProperty == rhs.classProperty && + lhs.value == rhs.value + ; +} + +void am_ClassProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> classProperty; + inputStream >> value; +} + +void am_ClassProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << classProperty; + outputStream << value; +} + +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): + crossfaderID(crossfaderIDValue), + name(nameValue), + sinkID_A(sinkID_AValue), + sinkID_B(sinkID_BValue), + sourceID(sourceIDValue), + hotSink(hotSinkValue) +{ +} + + +bool operator==(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.crossfaderID == rhs.crossfaderID && + lhs.name == rhs.name && + lhs.sinkID_A == rhs.sinkID_A && + lhs.sinkID_B == rhs.sinkID_B && + lhs.sourceID == rhs.sourceID && + lhs.hotSink == rhs.hotSink + ; +} + +void am_Crossfader_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> crossfaderID; + inputStream >> name; + inputStream >> sinkID_A; + inputStream >> sinkID_B; + inputStream >> sourceID; + inputStream >> hotSink; +} + +void am_Crossfader_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << crossfaderID; + outputStream << name; + outputStream << sinkID_A; + outputStream << sinkID_B; + outputStream << sourceID; + outputStream << hotSink; +} + +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): + gatewayID(gatewayIDValue), + name(nameValue), + sinkID(sinkIDValue), + sourceID(sourceIDValue), + domainSinkID(domainSinkIDValue), + domainSourceID(domainSourceIDValue), + controlDomainID(controlDomainIDValue), + listSourceFormats(listSourceFormatsValue), + listSinkFormats(listSinkFormatsValue), + convertionMatrix(convertionMatrixValue) +{ +} + + +bool operator==(const am_Gateway_s& lhs, const am_Gateway_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.gatewayID == rhs.gatewayID && + lhs.name == rhs.name && + lhs.sinkID == rhs.sinkID && + lhs.sourceID == rhs.sourceID && + lhs.domainSinkID == rhs.domainSinkID && + lhs.domainSourceID == rhs.domainSourceID && + lhs.controlDomainID == rhs.controlDomainID && + lhs.listSourceFormats == rhs.listSourceFormats && + lhs.listSinkFormats == rhs.listSinkFormats && + lhs.convertionMatrix == rhs.convertionMatrix + ; +} + +void am_Gateway_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> gatewayID; + inputStream >> name; + inputStream >> sinkID; + inputStream >> sourceID; + inputStream >> domainSinkID; + inputStream >> domainSourceID; + inputStream >> controlDomainID; + inputStream >> listSourceFormats; + inputStream >> listSinkFormats; + inputStream >> convertionMatrix; +} + +void am_Gateway_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << gatewayID; + outputStream << name; + outputStream << sinkID; + outputStream << sourceID; + outputStream << domainSinkID; + outputStream << domainSourceID; + outputStream << controlDomainID; + outputStream << listSourceFormats; + outputStream << listSinkFormats; + outputStream << convertionMatrix; +} + +am_Converter_s::am_Converter_s(const am_converterID_t& converterIDValue, const std::string& nameValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_domainID_t& domainIDValue, const am_ConnectionFormat_L& listSourceFormatsValue, const am_ConnectionFormat_L& listSinkFormatsValue, const am_Convertion_L& convertionMatrixValue): + converterID(converterIDValue), + name(nameValue), + sinkID(sinkIDValue), + sourceID(sourceIDValue), + domainID(domainIDValue), + listSourceFormats(listSourceFormatsValue), + listSinkFormats(listSinkFormatsValue), + convertionMatrix(convertionMatrixValue) +{ +} + + +bool operator==(const am_Converter_s& lhs, const am_Converter_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.converterID == rhs.converterID && + lhs.name == rhs.name && + lhs.sinkID == rhs.sinkID && + lhs.sourceID == rhs.sourceID && + lhs.domainID == rhs.domainID && + lhs.listSourceFormats == rhs.listSourceFormats && + lhs.listSinkFormats == rhs.listSinkFormats && + lhs.convertionMatrix == rhs.convertionMatrix + ; +} + +void am_Converter_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> converterID; + inputStream >> name; + inputStream >> sinkID; + inputStream >> sourceID; + inputStream >> domainID; + inputStream >> listSourceFormats; + inputStream >> listSinkFormats; + inputStream >> convertionMatrix; +} + +void am_Converter_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << converterID; + outputStream << name; + outputStream << sinkID; + outputStream << sourceID; + outputStream << domainID; + outputStream << listSourceFormats; + outputStream << listSinkFormats; + outputStream << convertionMatrix; +} + +am_RoutingElement_s::am_RoutingElement_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_domainID_t& domainIDValue, const am_CustomConnectionFormat_t& connectionFormatValue): + sourceID(sourceIDValue), + sinkID(sinkIDValue), + domainID(domainIDValue), + connectionFormat(connectionFormatValue) +{ +} + + +bool operator==(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceID == rhs.sourceID && + lhs.sinkID == rhs.sinkID && + lhs.domainID == rhs.domainID && + lhs.connectionFormat == rhs.connectionFormat + ; +} + +void am_RoutingElement_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceID; + inputStream >> sinkID; + inputStream >> domainID; + inputStream >> connectionFormat; +} + +void am_RoutingElement_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceID; + outputStream << sinkID; + outputStream << domainID; + outputStream << connectionFormat; +} + +am_SoundProperty_s::am_SoundProperty_s(const am_CustomSoundPropertyType_t& typeValue, const int16_t& valueValue): + type(typeValue), + value(valueValue) +{ +} + + +bool operator==(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.value == rhs.value + ; +} + +void am_SoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> value; +} + +void am_SoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << value; +} + +am_SystemProperty_s::am_SystemProperty_s(const am_CustomSystemPropertyType_t& typeValue, const int16_t& valueValue): + type(typeValue), + value(valueValue) +{ +} + + +bool operator==(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.value == rhs.value + ; +} + +void am_SystemProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> value; +} + +void am_SystemProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << value; +} + +am_SinkClass_s::am_SinkClass_s(const am_sinkClass_t& sinkClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue): + sinkClassID(sinkClassIDValue), + name(nameValue), + listClassProperties(listClassPropertiesValue) +{ +} + + +bool operator==(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sinkClassID == rhs.sinkClassID && + lhs.name == rhs.name && + lhs.listClassProperties == rhs.listClassProperties + ; +} + +void am_SinkClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sinkClassID; + inputStream >> name; + inputStream >> listClassProperties; +} + +void am_SinkClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sinkClassID; + outputStream << name; + outputStream << listClassProperties; +} + +am_SourceClass_s::am_SourceClass_s(const am_sourceClass_t& sourceClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue): + sourceClassID(sourceClassIDValue), + name(nameValue), + listClassProperties(listClassPropertiesValue) +{ +} + + +bool operator==(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceClassID == rhs.sourceClassID && + lhs.name == rhs.name && + lhs.listClassProperties == rhs.listClassProperties + ; +} + +void am_SourceClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceClassID; + inputStream >> name; + inputStream >> listClassProperties; +} + +void am_SourceClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceClassID; + outputStream << name; + outputStream << listClassProperties; +} + +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): + sourceID(sourceIDValue), + name(nameValue), + availability(availabilityValue), + sourceClassID(sourceClassIDValue) +{ +} + + +bool operator==(const am_SourceType_s& lhs, const am_SourceType_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceID == rhs.sourceID && + lhs.name == rhs.name && + lhs.availability == rhs.availability && + lhs.sourceClassID == rhs.sourceClassID + ; +} + +void am_SourceType_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceID; + inputStream >> name; + inputStream >> availability; + inputStream >> sourceClassID; +} + +void am_SourceType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceID; + outputStream << name; + outputStream << availability; + outputStream << sourceClassID; +} + +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): + sinkID(sinkIDValue), + name(nameValue), + availability(availabilityValue), + volume(volumeValue), + muteState(muteStateValue), + sinkClassID(sinkClassIDValue) +{ +} + + +bool operator==(const am_SinkType_s& lhs, const am_SinkType_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sinkID == rhs.sinkID && + lhs.name == rhs.name && + lhs.availability == rhs.availability && + lhs.volume == rhs.volume && + lhs.muteState == rhs.muteState && + lhs.sinkClassID == rhs.sinkClassID + ; +} + +void am_SinkType_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sinkID; + inputStream >> name; + inputStream >> availability; + inputStream >> volume; + inputStream >> muteState; + inputStream >> sinkClassID; +} + +void am_SinkType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sinkID; + outputStream << name; + outputStream << availability; + outputStream << volume; + outputStream << muteState; + outputStream << sinkClassID; +} + +am_Handle_s::am_Handle_s(const am_Handle_e& handleTypeValue, const uint16_t& handleValue): + handleType(handleTypeValue), + handle(handleValue) +{ +} + + +bool operator==(const am_Handle_s& lhs, const am_Handle_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.handleType == rhs.handleType && + lhs.handle == rhs.handle + ; +} + +void am_Handle_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> handleType; + inputStream >> handle; +} + +void am_Handle_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << handleType; + outputStream << handle; +} + +am_MainSoundProperty_s::am_MainSoundProperty_s(const am_CustomMainSoundPropertyType_t& typeValue, const int16_t& valueValue): + type(typeValue), + value(valueValue) +{ +} + + +bool operator==(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.value == rhs.value + ; +} + +void am_MainSoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> value; +} + +void am_MainSoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << value; +} + +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): + mainConnectionID(mainConnectionIDValue), + sourceID(sourceIDValue), + sinkID(sinkIDValue), + delay(delayValue), + connectionState(connectionStateValue) +{ +} + + +bool operator==(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.mainConnectionID == rhs.mainConnectionID && + lhs.sourceID == rhs.sourceID && + lhs.sinkID == rhs.sinkID && + lhs.delay == rhs.delay && + lhs.connectionState == rhs.connectionState + ; +} + +void am_MainConnectionType_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> mainConnectionID; + inputStream >> sourceID; + inputStream >> sinkID; + inputStream >> delay; + inputStream >> connectionState; +} + +void am_MainConnectionType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << mainConnectionID; + outputStream << sourceID; + outputStream << sinkID; + outputStream << delay; + outputStream << connectionState; +} + +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): + mainConnectionID(mainConnectionIDValue), + connectionState(connectionStateValue), + sinkID(sinkIDValue), + sourceID(sourceIDValue), + delay(delayValue), + listConnectionID(listConnectionIDValue) +{ +} + + +bool operator==(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.mainConnectionID == rhs.mainConnectionID && + lhs.connectionState == rhs.connectionState && + lhs.sinkID == rhs.sinkID && + lhs.sourceID == rhs.sourceID && + lhs.delay == rhs.delay && + lhs.listConnectionID == rhs.listConnectionID + ; +} + +void am_MainConnection_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> mainConnectionID; + inputStream >> connectionState; + inputStream >> sinkID; + inputStream >> sourceID; + inputStream >> delay; + inputStream >> listConnectionID; +} + +void am_MainConnection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << mainConnectionID; + outputStream << connectionState; + outputStream << sinkID; + outputStream << sourceID; + outputStream << delay; + outputStream << listConnectionID; +} + +am_NotificationPayload_s::am_NotificationPayload_s(const am_CustomNotificationType_t& typeValue, const int16_t& valueValue): + type(typeValue), + value(valueValue) +{ +} + + +bool operator==(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.value == rhs.value + ; +} + +void am_NotificationPayload_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> value; +} + +void am_NotificationPayload_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << value; +} + +am_NotificationConfiguration_s::am_NotificationConfiguration_s(const am_CustomNotificationType_t& typeValue, const am_NotificationStatus_e& statusValue, const int16_t& parameterValue): + type(typeValue), + status(statusValue), + parameter(parameterValue) +{ +} + + +bool operator==(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.status == rhs.status && + lhs.parameter == rhs.parameter + ; +} + +void am_NotificationConfiguration_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> status; + inputStream >> parameter; +} + +void am_NotificationConfiguration_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << status; + outputStream << parameter; +} + +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): + sinkID(sinkIDValue), + name(nameValue), + domainID(domainIDValue), + sinkClassID(sinkClassIDValue), + volume(volumeValue), + visible(visibleValue), + available(availableValue), + muteState(muteStateValue), + mainVolume(mainVolumeValue), + listSoundProperties(listSoundPropertiesValue), + listConnectionFormats(listConnectionFormatsValue), + listMainSoundProperties(listMainSoundPropertiesValue), + listMainNotificationConfigurations(listMainNotificationConfigurationsValue), + listNotificationConfigurations(listNotificationConfigurationsValue) +{ +} + + +bool operator==(const am_Sink_s& lhs, const am_Sink_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sinkID == rhs.sinkID && + lhs.name == rhs.name && + lhs.domainID == rhs.domainID && + lhs.sinkClassID == rhs.sinkClassID && + lhs.volume == rhs.volume && + lhs.visible == rhs.visible && + lhs.available == rhs.available && + lhs.muteState == rhs.muteState && + lhs.mainVolume == rhs.mainVolume && + lhs.listSoundProperties == rhs.listSoundProperties && + lhs.listConnectionFormats == rhs.listConnectionFormats && + lhs.listMainSoundProperties == rhs.listMainSoundProperties && + lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations && + lhs.listNotificationConfigurations == rhs.listNotificationConfigurations + ; +} + +void am_Sink_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sinkID; + inputStream >> name; + inputStream >> domainID; + inputStream >> sinkClassID; + inputStream >> volume; + inputStream >> visible; + inputStream >> available; + inputStream >> muteState; + inputStream >> mainVolume; + inputStream >> listSoundProperties; + inputStream >> listConnectionFormats; + inputStream >> listMainSoundProperties; + inputStream >> listMainNotificationConfigurations; + inputStream >> listNotificationConfigurations; +} + +void am_Sink_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sinkID; + outputStream << name; + outputStream << domainID; + outputStream << sinkClassID; + outputStream << volume; + outputStream << visible; + outputStream << available; + outputStream << muteState; + outputStream << mainVolume; + outputStream << listSoundProperties; + outputStream << listConnectionFormats; + outputStream << listMainSoundProperties; + outputStream << listMainNotificationConfigurations; + outputStream << listNotificationConfigurations; +} + +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): + sourceID(sourceIDValue), + domainID(domainIDValue), + name(nameValue), + sourceClassID(sourceClassIDValue), + sourceState(sourceStateValue), + volume(volumeValue), + visible(visibleValue), + available(availableValue), + interruptState(interruptStateValue), + listSoundProperties(listSoundPropertiesValue), + listConnectionFormats(listConnectionFormatsValue), + listMainSoundProperties(listMainSoundPropertiesValue), + listMainNotificationConfigurations(listMainNotificationConfigurationsValue), + listNotificationConfigurations(listNotificationConfigurationsValue) +{ +} + + +bool operator==(const am_Source_s& lhs, const am_Source_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceID == rhs.sourceID && + lhs.domainID == rhs.domainID && + lhs.name == rhs.name && + lhs.sourceClassID == rhs.sourceClassID && + lhs.sourceState == rhs.sourceState && + lhs.volume == rhs.volume && + lhs.visible == rhs.visible && + lhs.available == rhs.available && + lhs.interruptState == rhs.interruptState && + lhs.listSoundProperties == rhs.listSoundProperties && + lhs.listConnectionFormats == rhs.listConnectionFormats && + lhs.listMainSoundProperties == rhs.listMainSoundProperties && + lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations && + lhs.listNotificationConfigurations == rhs.listNotificationConfigurations + ; +} + +void am_Source_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceID; + inputStream >> domainID; + inputStream >> name; + inputStream >> sourceClassID; + inputStream >> sourceState; + inputStream >> volume; + inputStream >> visible; + inputStream >> available; + inputStream >> interruptState; + inputStream >> listSoundProperties; + inputStream >> listConnectionFormats; + inputStream >> listMainSoundProperties; + inputStream >> listMainNotificationConfigurations; + inputStream >> listNotificationConfigurations; +} + +void am_Source_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceID; + outputStream << domainID; + outputStream << name; + outputStream << sourceClassID; + outputStream << sourceState; + outputStream << volume; + outputStream << visible; + outputStream << available; + outputStream << interruptState; + outputStream << listSoundProperties; + outputStream << listConnectionFormats; + outputStream << listMainSoundProperties; + outputStream << listMainNotificationConfigurations; + outputStream << listNotificationConfigurations; +} + +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): + domainID(domainIDValue), + name(nameValue), + busname(busnameValue), + nodename(nodenameValue), + early(earlyValue), + complete(completeValue), + state(stateValue) +{ +} + + +bool operator==(const am_Domain_s& lhs, const am_Domain_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.domainID == rhs.domainID && + lhs.name == rhs.name && + lhs.busname == rhs.busname && + lhs.nodename == rhs.nodename && + lhs.early == rhs.early && + lhs.complete == rhs.complete && + lhs.state == rhs.state + ; +} + +void am_Domain_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> domainID; + inputStream >> name; + inputStream >> busname; + inputStream >> nodename; + inputStream >> early; + inputStream >> complete; + inputStream >> state; +} + +void am_Domain_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << domainID; + outputStream << name; + outputStream << busname; + outputStream << nodename; + outputStream << early; + outputStream << complete; + outputStream << state; +} + +am_EarlyData_s::am_EarlyData_s(const am_EarlyDataType_e& typeValue, const am_DataType_u& sinksourceValue, const am_EarlyData_u& dataValue): + type(typeValue), + sinksource(sinksourceValue), + data(dataValue) +{ +} + + +bool operator==(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.sinksource == rhs.sinksource && + lhs.data == rhs.data + ; +} + +void am_EarlyData_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> sinksource; + inputStream >> data; +} + +void am_EarlyData_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << sinksource; + outputStream << data; +} + +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_CustomConnectionFormat_t& connectionFormatValue): + connectionID(connectionIDValue), + sourceID(sourceIDValue), + sinkID(sinkIDValue), + delay(delayValue), + connectionFormat(connectionFormatValue) +{ +} + + +bool operator==(const am_Connection_s& lhs, const am_Connection_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.connectionID == rhs.connectionID && + lhs.sourceID == rhs.sourceID && + lhs.sinkID == rhs.sinkID && + lhs.delay == rhs.delay && + lhs.connectionFormat == rhs.connectionFormat + ; +} + +void am_Connection_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> connectionID; + inputStream >> sourceID; + inputStream >> sinkID; + inputStream >> delay; + inputStream >> connectionFormat; +} + +void am_Connection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << connectionID; + outputStream << sourceID; + outputStream << sinkID; + outputStream << delay; + outputStream << connectionFormat; +} + +am_Volumes_s::am_Volumes_s(const am_VolumeType_e& volumeTypeValue, const am_DataType_u& volumeIDValue, const am_volume_t& volumeValue, const am_CustomRampType_t& rampValue, const am_time_t& timeValue): + volumeType(volumeTypeValue), + volumeID(volumeIDValue), + volume(volumeValue), + ramp(rampValue), + time(timeValue) +{ +} + + +bool operator==(const am_Volumes_s& lhs, const am_Volumes_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.volumeType == rhs.volumeType && + lhs.volumeID == rhs.volumeID && + lhs.volume == rhs.volume && + lhs.ramp == rhs.ramp && + lhs.time == rhs.time + ; +} + +void am_Volumes_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> volumeType; + inputStream >> volumeID; + inputStream >> volume; + inputStream >> ramp; + inputStream >> time; +} + +void am_Volumes_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << volumeType; + outputStream << volumeID; + outputStream << volume; + outputStream << ramp; + outputStream << time; +} + + + +} // namespace am +} // namespace genivi +} // namespace org -- cgit v1.2.1