* adding new class in Controler plugin to use CAmSerializer to build up a shadow
* added test to test the new class (unfinished)
${DLT_LIBRARIES})
IF(WITH_TESTS)
-# add_subdirectory (test)
+ add_subdirectory (test)
ENDIF(WITH_TESTS)
#IF(WITH_DOCUMENTATION)
--- /dev/null
+/*
+ * IAmControlReceiverShadow.h
+ *
+ * Created on: Mar 2, 2012
+ * Author: christian
+ */
+
+#ifndef IAMCONTROLRECEIVERSHADOW_H_
+#define IAMCONTROLRECEIVERSHADOW_H_
+
+#include "audiomanagertypes.h"
+#include "shared/CAmSerializer.h"
+
+namespace am
+{
+class IAmControlReceive;
+class CAmSocketHandler;
+
+/**
+ * shadow class that used CAmSerializer to make threadsafe calls to the IAmControlReceive interface.
+ */
+class IAmControlReceiverShadow
+{
+public:
+ IAmControlReceiverShadow(IAmControlReceive* iReceiveInterface, CAmSocketHandler* iSocketHandler);
+ ~IAmControlReceiverShadow();
+ am_Error_e getRoute(bool onlyfree, am_sourceID_t sourceID, am_sinkID_t sinkID, std::vector<am_Route_s>& returnList);
+ am_Error_e connect(am_Handle_s& handle, am_connectionID_t& connectionID, am_ConnectionFormat_e format, am_sourceID_t sourceID, am_sinkID_t sinkID);
+ am_Error_e disconnect(am_Handle_s& handle, am_connectionID_t connectionID);
+ am_Error_e crossfade(am_Handle_s& handle, am_HotSink_e hotSource, am_crossfaderID_t crossfaderID, am_RampType_e rampType, am_time_t rampTime);
+ am_Error_e abortAction(am_Handle_s handle);
+ am_Error_e setSourceState(am_Handle_s& handle, am_sourceID_t sourceID, am_SourceState_e state);
+ am_Error_e setSinkVolume(am_Handle_s& handle, am_sinkID_t sinkID, am_volume_t volume, am_RampType_e ramp, am_time_t time);
+ am_Error_e setSourceVolume(am_Handle_s& handle, am_sourceID_t sourceID, am_volume_t volume, am_RampType_e rampType, am_time_t time);
+ am_Error_e setSinkSoundProperties(am_Handle_s& handle, am_sinkID_t sinkID, std::vector<am_SoundProperty_s>& soundProperty);
+ am_Error_e setSinkSoundProperty(am_Handle_s& handle, am_sinkID_t sinkID, am_SoundProperty_s& soundProperty);
+ am_Error_e setSourceSoundProperties(am_Handle_s& handle, am_sourceID_t sourceID, std::vector<am_SoundProperty_s>& soundProperty);
+ am_Error_e setSourceSoundProperty(am_Handle_s& handle, am_sourceID_t sourceID, am_SoundProperty_s& soundProperty);
+ am_Error_e setDomainState(am_domainID_t domainID, am_DomainState_e domainState);
+ am_Error_e enterDomainDB(am_Domain_s& domainData, am_domainID_t& domainID);
+ am_Error_e enterMainConnectionDB(am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID);
+ am_Error_e enterSinkDB(am_Sink_s& sinkData, am_sinkID_t& sinkID);
+ am_Error_e enterCrossfaderDB(am_Crossfader_s& crossfaderData, am_crossfaderID_t& crossfaderID);
+ am_Error_e enterGatewayDB(am_Gateway_s& gatewayData, am_gatewayID_t& gatewayID);
+ am_Error_e enterSourceDB(am_Source_s& sourceData, am_sourceID_t& sourceID);
+ am_Error_e enterSinkClassDB(am_SinkClass_s& sinkClass, am_sinkClass_t& sinkClassID);
+ am_Error_e enterSourceClassDB(am_sourceClass_t& sourceClassID, am_SourceClass_s& sourceClass);
+ am_Error_e changeSinkClassInfoDB(am_SinkClass_s& sinkClass);
+ am_Error_e changeSourceClassInfoDB(am_SourceClass_s& sourceClass);
+ am_Error_e enterSystemPropertiesListDB(std::vector<am_SystemProperty_s>& listSystemProperties);
+ am_Error_e changeMainConnectionRouteDB(am_mainConnectionID_t mainconnectionID, std::vector<am_connectionID_t>& listConnectionID);
+ am_Error_e changeMainConnectionStateDB(am_mainConnectionID_t mainconnectionID, am_ConnectionState_e connectionState);
+ am_Error_e changeSinkMainVolumeDB(am_mainVolume_t mainVolume, am_sinkID_t sinkID);
+ am_Error_e changeSinkAvailabilityDB(am_Availability_s& availability, am_sinkID_t sinkID);
+ am_Error_e changDomainStateDB(am_DomainState_e domainState, am_domainID_t domainID);
+ am_Error_e changeSinkMuteStateDB(am_MuteState_e muteState, am_sinkID_t sinkID);
+ am_Error_e changeMainSinkSoundPropertyDB(am_MainSoundProperty_s& soundProperty, am_sinkID_t sinkID);
+ am_Error_e changeMainSourceSoundPropertyDB(am_MainSoundProperty_s& soundProperty, am_sourceID_t sourceID);
+ am_Error_e changeSourceAvailabilityDB(am_Availability_s& availability, am_sourceID_t sourceID);
+ am_Error_e changeSystemPropertyDB(am_SystemProperty_s& property);
+ am_Error_e removeMainConnectionDB(am_mainConnectionID_t mainConnectionID);
+ am_Error_e removeSinkDB(am_sinkID_t sinkID);
+ am_Error_e removeSourceDB(am_sourceID_t sourceID);
+ am_Error_e removeGatewayDB(am_gatewayID_t gatewayID);
+ am_Error_e removeCrossfaderDB(am_crossfaderID_t crossfaderID);
+ am_Error_e removeDomainDB(am_domainID_t domainID);
+ am_Error_e removeSinkClassDB(am_sinkClass_t sinkClassID);
+ am_Error_e removeSourceClassDB(am_sourceClass_t sourceClassID);
+ am_Error_e getSourceClassInfoDB(am_sourceID_t sourceID, am_SourceClass_s& classInfo);
+ am_Error_e getSinkClassInfoDB(am_sinkID_t sinkID, am_SinkClass_s& sinkClass);
+ am_Error_e getSinkInfoDB(am_sinkID_t sinkID, am_Sink_s& sinkData);
+ am_Error_e getSourceInfoDB(am_sourceID_t sourceID, am_Source_s& sourceData);
+ am_Error_e getGatewayInfoDB(am_gatewayID_t gatewayID, am_Gateway_s& gatewayData);
+ am_Error_e getCrossfaderInfoDB(am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData);
+ am_Error_e getMainConnectionInfoDB(am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData);
+ am_Error_e getListSinksOfDomain(am_domainID_t domainID, std::vector<am_sinkID_t>& listSinkID);
+ am_Error_e getListSourcesOfDomain(am_domainID_t domainID, std::vector<am_sourceID_t>& listSourceID);
+ am_Error_e getListCrossfadersOfDomain(am_domainID_t domainID, std::vector<am_crossfaderID_t>& listCrossfadersID);
+ am_Error_e getListGatewaysOfDomain(am_domainID_t domainID, std::vector<am_gatewayID_t>& listGatewaysID);
+ am_Error_e getListMainConnections(std::vector<am_MainConnection_s>& listMainConnections);
+ am_Error_e getListDomains(std::vector<am_Domain_s>& listDomains);
+ am_Error_e getListConnections(std::vector<am_Connection_s>& listConnections);
+ am_Error_e getListSinks(std::vector<am_Sink_s>& listSinks);
+ am_Error_e getListSources(std::vector<am_Source_s>& listSources);
+ am_Error_e getListSourceClasses(std::vector<am_SourceClass_s>& listSourceClasses);
+ am_Error_e getListHandles(std::vector<am_Handle_s>& listHandles);
+ am_Error_e getListCrossfaders(std::vector<am_Crossfader_s>& listCrossfaders);
+ am_Error_e getListGateways(std::vector<am_Gateway_s>& listGateways);
+ am_Error_e getListSinkClasses(std::vector<am_SinkClass_s>& listSinkClasses);
+ am_Error_e getListSystemProperties(std::vector<am_SystemProperty_s>& listSystemProperties);
+ void setCommandReady();
+ void setCommandRundown();
+ void setRoutingReady();
+ void setRoutingRundown();
+ void confirmControllerReady();
+ void confirmControllerRundown();
+ am_Error_e getSocketHandler(CAmSocketHandler*& socketHandler);
+private:
+ IAmControlReceive *mpIAmControlReceiver;
+ CAmSerializer mCAmSerializer;
+
+};
+
+} /* namespace am */
+#endif /* IAMCONTROLRECEIVERSHADOW_H_ */
--- /dev/null
+/*
+ * IAmControlReceiverShadow.cpp
+ *
+ * Created on: Mar 2, 2012
+ * Author: christian
+ */
+
+#include "IAmControlReceiverShadow.h"
+#include "control/IAmControlReceive.h"
+
+namespace am
+{
+
+IAmControlReceiverShadow::IAmControlReceiverShadow(IAmControlReceive *iReceiveInterface, CAmSocketHandler *iSocketHandler) :
+ mpIAmControlReceiver(iReceiveInterface), //
+ mCAmSerializer(iSocketHandler)
+{
+}
+
+IAmControlReceiverShadow::~IAmControlReceiverShadow()
+{
+
+}
+
+am_Error_e IAmControlReceiverShadow::getRoute(bool onlyfree, am_sourceID_t sourceID, am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const bool, const am_sourceID_t, const am_sinkID_t, std::vector<am_Route_s> &, bool, am_sourceID_t, am_sinkID_t, std::vector<am_Route_s> >(mpIAmControlReceiver, &IAmControlReceive::getRoute, error, onlyfree, sourceID, sinkID, returnList);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::connect(am_Handle_s & handle, am_connectionID_t & connectionID, am_ConnectionFormat_e format, am_sourceID_t sourceID, am_sinkID_t sinkID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s &, am_connectionID_t &, const am_ConnectionFormat_e, const am_sourceID_t, const am_sinkID_t, am_Handle_s, am_connectionID_t, am_ConnectionFormat_e, am_sourceID_t, am_sinkID_t>(mpIAmControlReceiver, &IAmControlReceive::connect, error, handle, connectionID, format, sourceID, sinkID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::disconnect(am_Handle_s & handle, am_connectionID_t connectionID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s &, const am_connectionID_t, am_Handle_s, am_connectionID_t>(mpIAmControlReceiver, &IAmControlReceive::disconnect, error, handle, connectionID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::crossfade(am_Handle_s & handle, am_HotSink_e hotSource, am_crossfaderID_t crossfaderID, am_RampType_e rampType, am_time_t rampTime)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s &, const am_HotSink_e, const am_crossfaderID_t, const am_RampType_e, const am_time_t, am_Handle_s, am_HotSink_e, am_crossfaderID_t, am_RampType_e, am_time_t>(mpIAmControlReceiver, &IAmControlReceive::crossfade, error, handle, hotSource, crossfaderID, rampType, rampTime);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::abortAction(am_Handle_s handle)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_Handle_s, am_Handle_s>(mpIAmControlReceiver, &IAmControlReceive::abortAction, error, handle);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::setSourceState(am_Handle_s & handle, am_sourceID_t sourceID, am_SourceState_e state)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s&, const am_sourceID_t, const am_SourceState_e, am_Handle_s, am_sourceID_t, am_SourceState_e>(mpIAmControlReceiver, &IAmControlReceive::setSourceState, error, handle, sourceID, state);
+ return (error);
+
+}
+
+am_Error_e IAmControlReceiverShadow::setSinkVolume(am_Handle_s & handle, am_sinkID_t sinkID, am_volume_t volume, am_RampType_e ramp, am_time_t time)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s&, const am_sinkID_t, const am_volume_t, const am_RampType_e, const am_time_t, am_Handle_s, am_sinkID_t, am_volume_t, am_RampType_e, am_time_t>(mpIAmControlReceiver, &IAmControlReceive::setSinkVolume, error, handle, sinkID, volume, ramp, time);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::setSourceVolume(am_Handle_s & handle, am_sourceID_t sourceID, am_volume_t volume, am_RampType_e rampType, am_time_t time)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s&, const am_sourceID_t, const am_volume_t, const am_RampType_e, const am_time_t, am_Handle_s, am_sourceID_t, am_volume_t, am_RampType_e, am_time_t>(mpIAmControlReceiver, &IAmControlReceive::setSourceVolume, error, handle, sourceID, volume, rampType, time);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::setSinkSoundProperties(am_Handle_s & handle, am_sinkID_t sinkID, std::vector<am_SoundProperty_s> & soundProperty)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s &, const am_sinkID_t, const std::vector<am_SoundProperty_s> &, am_Handle_s, am_sinkID_t, std::vector<am_SoundProperty_s> >(mpIAmControlReceiver, &IAmControlReceive::setSinkSoundProperties, error, handle, sinkID, soundProperty);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::setSinkSoundProperty(am_Handle_s & handle, am_sinkID_t sinkID, am_SoundProperty_s & soundProperty)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s &, const am_sinkID_t, const am_SoundProperty_s &, am_Handle_s, am_sinkID_t, am_SoundProperty_s>(mpIAmControlReceiver, &IAmControlReceive::setSinkSoundProperty, error, handle, sinkID, soundProperty);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::setSourceSoundProperties(am_Handle_s & handle, am_sourceID_t sourceID, std::vector<am_SoundProperty_s> & soundProperty)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s &, const am_sourceID_t, const std::vector<am_SoundProperty_s> &, am_Handle_s, am_sourceID_t, std::vector<am_SoundProperty_s> >(mpIAmControlReceiver, &IAmControlReceive::setSourceSoundProperties, error, handle, sourceID, soundProperty);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::setSourceSoundProperty(am_Handle_s & handle, am_sourceID_t sourceID, am_SoundProperty_s & soundProperty)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_Handle_s &, const am_sourceID_t, const am_SoundProperty_s &, am_Handle_s, am_sourceID_t, am_SoundProperty_s>(mpIAmControlReceiver, &IAmControlReceive::setSourceSoundProperty, error, handle, sourceID, soundProperty);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::setDomainState(am_domainID_t domainID, am_DomainState_e domainState)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_domainID_t, const am_DomainState_e, am_domainID_t, am_DomainState_e>(mpIAmControlReceiver, &IAmControlReceive::setDomainState, error, domainID, domainState);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterDomainDB(am_Domain_s & domainData, am_domainID_t & domainID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_Domain_s&, am_domainID_t &, am_Domain_s, am_domainID_t>(mpIAmControlReceiver, &IAmControlReceive::enterDomainDB, error, domainData, domainID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterMainConnectionDB(am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_MainConnection_s &, am_mainConnectionID_t&, am_MainConnection_s, am_mainConnectionID_t>(mpIAmControlReceiver, &IAmControlReceive::enterMainConnectionDB, error, mainConnectionData, connectionID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterSinkDB(am_Sink_s & sinkData, am_sinkID_t & sinkID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_Sink_s &, am_sinkID_t&, am_Sink_s, am_sinkID_t>(mpIAmControlReceiver, &IAmControlReceive::enterSinkDB, error, sinkData, sinkID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterCrossfaderDB(am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_Crossfader_s &, am_crossfaderID_t &, am_Crossfader_s, am_crossfaderID_t>(mpIAmControlReceiver, &IAmControlReceive::enterCrossfaderDB, error, crossfaderData, crossfaderID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterGatewayDB(am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_Gateway_s &, am_gatewayID_t &, am_Gateway_s, am_gatewayID_t>(mpIAmControlReceiver, &IAmControlReceive::enterGatewayDB, error, gatewayData, gatewayID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterSourceDB(am_Source_s & sourceData, am_sourceID_t & sourceID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_Source_s &, am_sourceID_t &, am_Source_s, am_sourceID_t>(mpIAmControlReceiver, &IAmControlReceive::enterSourceDB, error, sourceData, sourceID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterSinkClassDB(am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_SinkClass_s &, am_sinkClass_t &, am_SinkClass_s, am_sinkClass_t>(mpIAmControlReceiver, &IAmControlReceive::enterSinkClassDB, error, sinkClass, sinkClassID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterSourceClassDB(am_sourceClass_t & sourceClassID, am_SourceClass_s & sourceClass)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_sourceClass_t &, const am_SourceClass_s &, am_sourceClass_t, am_SourceClass_s>(mpIAmControlReceiver, &IAmControlReceive::enterSourceClassDB, error, sourceClassID, sourceClass);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeSinkClassInfoDB(am_SinkClass_s & sinkClass)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_SinkClass_s &, am_SinkClass_s>(mpIAmControlReceiver, &IAmControlReceive::changeSinkClassInfoDB, error, sinkClass);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeSourceClassInfoDB(am_SourceClass_s & sourceClass)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_SourceClass_s &, am_SourceClass_s>(mpIAmControlReceiver, &IAmControlReceive::changeSourceClassInfoDB, error, sourceClass);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::enterSystemPropertiesListDB(std::vector<am_SystemProperty_s> & listSystemProperties)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const std::vector<am_SystemProperty_s> &, std::vector<am_SystemProperty_s> >(mpIAmControlReceiver, &IAmControlReceive::enterSystemPropertiesListDB, error, listSystemProperties);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeMainConnectionRouteDB(am_mainConnectionID_t mainconnectionID, std::vector<am_connectionID_t> & listConnectionID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_mainConnectionID_t, const std::vector<am_connectionID_t> &, am_mainConnectionID_t, std::vector<am_connectionID_t> >(mpIAmControlReceiver, &IAmControlReceive::changeMainConnectionRouteDB, error, mainconnectionID, listConnectionID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeMainConnectionStateDB(am_mainConnectionID_t mainconnectionID, am_ConnectionState_e connectionState)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_mainConnectionID_t, const am_ConnectionState_e, am_mainConnectionID_t, am_ConnectionState_e>(mpIAmControlReceiver, &IAmControlReceive::changeMainConnectionStateDB, error, mainconnectionID, connectionState);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeSinkMainVolumeDB(am_mainVolume_t mainVolume, am_sinkID_t sinkID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_mainVolume_t, const am_sinkID_t, am_mainVolume_t, am_sinkID_t>(mpIAmControlReceiver, &IAmControlReceive::changeSinkMainVolumeDB, error, mainVolume, sinkID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_MainConnection_s> &, std::vector<am_MainConnection_s> >(mpIAmControlReceiver, &IAmControlReceive::getListMainConnections, error, listMainConnections);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListDomains(std::vector<am_Domain_s> & listDomains)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_Domain_s> &, std::vector<am_Domain_s> >(mpIAmControlReceiver, &IAmControlReceive::getListDomains, error, listDomains);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListConnections(std::vector<am_Connection_s> & listConnections)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_Connection_s>&, std::vector<am_Connection_s> >(mpIAmControlReceiver, &IAmControlReceive::getListConnections, error, listConnections);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListSinks(std::vector<am_Sink_s> & listSinks)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_Sink_s> &, std::vector<am_Sink_s> >(mpIAmControlReceiver, &IAmControlReceive::getListSinks, error, listSinks);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListSources(std::vector<am_Source_s> & listSources)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_Source_s> &, std::vector<am_Source_s> >(mpIAmControlReceiver, &IAmControlReceive::getListSources, error, listSources);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_SourceClass_s> &, std::vector<am_SourceClass_s> >(mpIAmControlReceiver, &IAmControlReceive::getListSourceClasses, error, listSourceClasses);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListHandles(std::vector<am_Handle_s> & listHandles)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_Handle_s> &, std::vector<am_Handle_s> >(mpIAmControlReceiver, &IAmControlReceive::getListHandles, error, listHandles);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_Crossfader_s> &, std::vector<am_Crossfader_s> >(mpIAmControlReceiver, &IAmControlReceive::getListCrossfaders, error, listCrossfaders);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListGateways(std::vector<am_Gateway_s> & listGateways)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_Gateway_s>&, std::vector<am_Gateway_s> >(mpIAmControlReceiver, &IAmControlReceive::getListGateways, error, listGateways);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_SinkClass_s> &, std::vector<am_SinkClass_s> >(mpIAmControlReceiver, &IAmControlReceive::getListSinkClasses, error, listSinkClasses);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, std::vector<am_SystemProperty_s> &, std::vector<am_SystemProperty_s> >(mpIAmControlReceiver, &IAmControlReceive::getListSystemProperties, error, listSystemProperties);
+ return (error);
+}
+
+void IAmControlReceiverShadow::setCommandReady()
+{
+ mCAmSerializer.asyncCall<IAmControlReceive>(mpIAmControlReceiver, &IAmControlReceive::setCommandReady);
+}
+
+void IAmControlReceiverShadow::setCommandRundown()
+{
+ mCAmSerializer.asyncCall<IAmControlReceive>(mpIAmControlReceiver, &IAmControlReceive::setCommandRundown);
+}
+
+void IAmControlReceiverShadow::setRoutingReady()
+{
+ mCAmSerializer.asyncCall<IAmControlReceive>(mpIAmControlReceiver, &IAmControlReceive::setRoutingReady);
+}
+
+void IAmControlReceiverShadow::setRoutingRundown()
+{
+ mCAmSerializer.asyncCall<IAmControlReceive>(mpIAmControlReceiver, &IAmControlReceive::setRoutingRundown);
+}
+
+void IAmControlReceiverShadow::confirmControllerReady()
+{
+ mCAmSerializer.asyncCall<IAmControlReceive>(mpIAmControlReceiver, &IAmControlReceive::confirmControllerReady);
+}
+
+void IAmControlReceiverShadow::confirmControllerRundown()
+{
+ mCAmSerializer.asyncCall<IAmControlReceive>(mpIAmControlReceiver, &IAmControlReceive::confirmControllerRundown);
+}
+
+am_Error_e IAmControlReceiverShadow::getSocketHandler(CAmSocketHandler *& socketHandler)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, CAmSocketHandler*&, CAmSocketHandler*>(mpIAmControlReceiver, &IAmControlReceive::getSocketHandler, error, socketHandler);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeSinkAvailabilityDB(am_Availability_s& availability, am_sinkID_t sinkID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_Availability_s&, const am_sinkID_t, am_Availability_s, am_sinkID_t>(mpIAmControlReceiver, &IAmControlReceive::changeSinkAvailabilityDB, error, availability, sinkID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changDomainStateDB(am_DomainState_e domainState, am_domainID_t domainID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_DomainState_e, const am_domainID_t, am_DomainState_e, am_domainID_t>(mpIAmControlReceiver, &IAmControlReceive::changDomainStateDB, error, domainState, domainID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeSinkMuteStateDB(am_MuteState_e muteState, am_sinkID_t sinkID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, am_MuteState_e, const am_sinkID_t, am_MuteState_e, am_sinkID_t>(mpIAmControlReceiver, &IAmControlReceive::changeSinkMuteStateDB, error, muteState, sinkID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeMainSinkSoundPropertyDB(am_MainSoundProperty_s& soundProperty, am_sinkID_t sinkID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_MainSoundProperty_s&, const am_sinkID_t, am_MainSoundProperty_s, am_sinkID_t>(mpIAmControlReceiver, &IAmControlReceive::changeMainSinkSoundPropertyDB, error, soundProperty, sinkID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeMainSourceSoundPropertyDB(am_MainSoundProperty_s& soundProperty, am_sourceID_t sourceID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_MainSoundProperty_s&, const am_sourceID_t, am_MainSoundProperty_s, am_sourceID_t>(mpIAmControlReceiver, &IAmControlReceive::changeMainSourceSoundPropertyDB, error, soundProperty, sourceID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeSourceAvailabilityDB(am_Availability_s& availability, am_sourceID_t sourceID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_Availability_s&, const am_sourceID_t, am_Availability_s, am_sourceID_t>(mpIAmControlReceiver, &IAmControlReceive::changeSourceAvailabilityDB, error, availability, sourceID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::changeSystemPropertyDB(am_SystemProperty_s& property)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_SystemProperty_s&, am_SystemProperty_s>(mpIAmControlReceiver, &IAmControlReceive::changeSystemPropertyDB, error, property);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::removeMainConnectionDB(am_mainConnectionID_t mainConnectionID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_mainConnectionID_t, am_mainConnectionID_t>(mpIAmControlReceiver, &IAmControlReceive::removeMainConnectionDB, error, mainConnectionID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::removeSinkDB(am_sinkID_t sinkID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_sinkID_t, am_sinkID_t>(mpIAmControlReceiver, &IAmControlReceive::removeSinkDB, error, sinkID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::removeSourceDB(am_sourceID_t sourceID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_sourceID_t, am_sourceID_t>(mpIAmControlReceiver, &IAmControlReceive::removeSourceDB, error, sourceID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::removeGatewayDB(am_gatewayID_t gatewayID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_gatewayID_t, am_gatewayID_t>(mpIAmControlReceiver, &IAmControlReceive::removeGatewayDB, error, gatewayID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::removeCrossfaderDB(am_crossfaderID_t crossfaderID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_crossfaderID_t, am_crossfaderID_t>(mpIAmControlReceiver, &IAmControlReceive::removeCrossfaderDB, error, crossfaderID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::removeDomainDB(am_domainID_t domainID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_domainID_t, am_domainID_t>(mpIAmControlReceiver, &IAmControlReceive::removeDomainDB, error, domainID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::removeSinkClassDB(am_sinkClass_t sinkClassID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_sinkClass_t, am_sinkClass_t>(mpIAmControlReceiver, &IAmControlReceive::removeSinkClassDB, error, sinkClassID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::removeSourceClassDB(am_sourceClass_t sourceClassID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_sourceClass_t, am_sourceClass_t>(mpIAmControlReceiver, &IAmControlReceive::removeSourceClassDB, error, sourceClassID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getSourceClassInfoDB(am_sourceID_t sourceID, am_SourceClass_s& classInfo)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_sourceID_t, am_SourceClass_s&, am_sourceID_t, am_SourceClass_s>(mpIAmControlReceiver, &IAmControlReceive::getSourceClassInfoDB, error, sourceID, classInfo);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getSinkClassInfoDB(am_sinkID_t sinkID, am_SinkClass_s& sinkClass)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_sinkID_t, am_SinkClass_s&, am_sinkID_t, am_SinkClass_s>(mpIAmControlReceiver, &IAmControlReceive::getSinkClassInfoDB, error, sinkID, sinkClass);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getSinkInfoDB(am_sinkID_t sinkID, am_Sink_s& sinkData)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_sinkID_t, am_Sink_s&, am_sinkID_t, am_Sink_s>(mpIAmControlReceiver, &IAmControlReceive::getSinkInfoDB, error, sinkID, sinkData);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getSourceInfoDB(am_sourceID_t sourceID, am_Source_s& sourceData)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_sourceID_t, am_Source_s&, am_sourceID_t, am_Source_s>(mpIAmControlReceiver, &IAmControlReceive::getSourceInfoDB, error, sourceID, sourceData);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getGatewayInfoDB(am_gatewayID_t gatewayID, am_Gateway_s& gatewayData)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_gatewayID_t, am_Gateway_s&, am_gatewayID_t, am_Gateway_s>(mpIAmControlReceiver, &IAmControlReceive::getGatewayInfoDB, error, gatewayID, gatewayData);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getCrossfaderInfoDB(am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_crossfaderID_t, am_Crossfader_s&, am_crossfaderID_t, am_Crossfader_s>(mpIAmControlReceiver, &IAmControlReceive::getCrossfaderInfoDB, error, crossfaderID, crossfaderData);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getMainConnectionInfoDB(am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_mainConnectionID_t, am_MainConnection_s&, am_mainConnectionID_t, am_MainConnection_s>(mpIAmControlReceiver, &IAmControlReceive::getMainConnectionInfoDB, error, mainConnectionID, mainConnectionData);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListSinksOfDomain(am_domainID_t domainID, std::vector<am_sinkID_t>& listSinkID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_domainID_t, std::vector<am_sinkID_t>&, am_domainID_t, std::vector<am_sinkID_t> >(mpIAmControlReceiver, &IAmControlReceive::getListSinksOfDomain, error, domainID, listSinkID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListSourcesOfDomain(am_domainID_t domainID, std::vector<am_sourceID_t>& listSourceID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_domainID_t, std::vector<am_sourceID_t>&, am_domainID_t, std::vector<am_sourceID_t> >(mpIAmControlReceiver, &IAmControlReceive::getListSourcesOfDomain, error, domainID, listSourceID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListCrossfadersOfDomain(am_domainID_t domainID, std::vector<am_crossfaderID_t>& listCrossfadersID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_domainID_t, std::vector<am_crossfaderID_t>&, am_domainID_t, std::vector<am_crossfaderID_t> >(mpIAmControlReceiver, &IAmControlReceive::getListCrossfadersOfDomain, error, domainID, listCrossfadersID);
+ return (error);
+}
+
+am_Error_e IAmControlReceiverShadow::getListGatewaysOfDomain(am_domainID_t domainID, std::vector<am_gatewayID_t>& listGatewaysID)
+{
+ am_Error_e error;
+ mCAmSerializer.syncCall<IAmControlReceive, am_Error_e, const am_domainID_t, std::vector<am_gatewayID_t>&, am_domainID_t, std::vector<am_gatewayID_t> >(mpIAmControlReceiver, &IAmControlReceive::getListGatewaysOfDomain, error, domainID, listGatewaysID);
+ return (error);
+}
+
+} /* namespace am */
--- /dev/null
+/*
+ * CAmControlReceiverShadowTest.cpp
+ *
+ * Created on: Mar 2, 2012
+ * Author: christian
+ */
+
+#include "CAmControlReceiverShadowTest.h"
+
+using namespace testing;
+using namespace am;
+
+CAmControlReceiverShadowTest::CAmControlReceiverShadowTest() :
+ psocketHandler(), //
+ pMockReceive(), //
+ pShadow(&pMockReceive, &psocketHandler), //
+ ptimerCallback(this, &CAmControlReceiverShadowTest::timerCallback)
+{
+ DefaultValue<am_Error_e>::Set(E_OK); // Sets the default value to be returned.
+}
+
+CAmControlReceiverShadowTest::~CAmControlReceiverShadowTest()
+{
+}
+
+void CAmControlReceiverShadowTest::SetUp()
+{
+ timespec t;
+ t.tv_nsec = 10000;
+ t.tv_sec = 0;
+
+ sh_timerHandle_t handle;
+
+ CAmShTimerCallBack *buf = &ptimerCallback;
+ //lets use a timeout so the test will finish
+ psocketHandler.addTimer(t, buf, handle, (void*) NULL);
+}
+
+void CAmControlReceiverShadowTest::timerCallback(sh_timerHandle_t handle, void* userData)
+{
+ (void)handle;
+ (void)userData;
+ psocketHandler.stop_listening();
+}
+
+void CAmControlReceiverShadowTest::TearDown()
+{
+}
+
+void* run_the_loop(void* socketHandlerPtr)
+{
+ CAmSocketHandler* socketHandler = static_cast<CAmSocketHandler*>(socketHandlerPtr);
+ socketHandler->start_listenting();
+ return (NULL);
+}
+
+TEST_F(CAmControlReceiverShadowTest,getRoute)
+{
+ pthread_t ptestThread;
+ bool onlyfree(true);
+ am_sourceID_t sourceID(1);
+ am_sinkID_t sinkID(2);
+ am_Route_s route;
+ am_RoutingElement_s routingElement;
+ std::vector<am_RoutingElement_s> route_;
+ std::vector<am_Route_s> returnList, List;
+ routingElement.sinkID = 1;
+ routingElement.sourceID = 2;
+ routingElement.domainID = 3;
+ routingElement.connectionFormat = CF_GENIVI_ANALOG;
+ route_.push_back(routingElement);
+ route.sinkID = 1;
+ route.sourceID = 2;
+ route.route = route_;
+ returnList.push_back(route);
+ EXPECT_CALL(pMockReceive,getRoute(onlyfree,sourceID,sinkID,_)).WillOnce(DoAll(SetArgReferee<3>(returnList),Return(E_OK)));
+ pthread_create(&ptestThread, NULL, run_the_loop, (void*) &psocketHandler);
+ ASSERT_EQ(E_OK, pShadow.getRoute(onlyfree, sourceID, sinkID, List));
+ pthread_join(ptestThread, NULL);
+}
+
+TEST_F(CAmControlReceiverShadowTest,connect)
+{
+ pthread_t ptestThread;
+ am_Handle_s handle, handleReturn;
+ handle.handle = 1;
+ handle.handleType = H_CONNECT;
+ am_connectionID_t connectionID(3), connectionIDReturn;
+ am_ConnectionFormat_e connectionFormat(CF_GENIVI_ANALOG);
+ am_sourceID_t sourceID(1);
+ am_sinkID_t sinkID(2);
+
+ EXPECT_CALL(pMockReceive, connect(_,_, connectionFormat, sourceID, sinkID)).WillOnce(DoAll(SetArgReferee<0>(handle),SetArgReferee<1>(connectionID),Return(E_OK)));
+ pthread_create(&ptestThread, NULL, run_the_loop, (void*) &psocketHandler);
+ ASSERT_EQ(E_OK,pShadow.connect(handleReturn,connectionIDReturn, connectionFormat, sourceID, sinkID));
+ ASSERT_EQ(handleReturn.handle,handle.handle);
+ ASSERT_EQ(handleReturn.handleType,handle.handleType);
+ ASSERT_EQ(connectionIDReturn,connectionID);
+ pthread_join(ptestThread, NULL);
+}
+
+TEST_F(CAmControlReceiverShadowTest,disconnect)
+{
+ pthread_t ptestThread;
+ am_Handle_s handle, handleReturn;
+ handle.handle = 1;
+ handle.handleType = H_CONNECT;
+ am_connectionID_t connectionID(3);
+
+ EXPECT_CALL(pMockReceive, disconnect(_,connectionID)).WillOnce(DoAll(SetArgReferee<0>(handle),Return(E_OK)));
+ pthread_create(&ptestThread, NULL, run_the_loop, (void*) &psocketHandler);
+ ASSERT_EQ(E_OK,pShadow.disconnect(handleReturn,connectionID));
+ ASSERT_EQ(handleReturn.handle,handle.handle);
+ ASSERT_EQ(handleReturn.handleType,handle.handleType);
+ pthread_join(ptestThread, NULL);
+}
+
+int main(int argc, char **argv)
+{
+ ::testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
+
--- /dev/null
+/*
+ * CAmControlReceiverShadowTest.h
+ *
+ * Created on: Mar 2, 2012
+ * Author: christian
+ */
+
+#ifndef CAMCONTROLRECEIVERSHADOWTEST_H_
+#define CAMCONTROLRECEIVERSHADOWTEST_H_
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "MockIAmControlReceive.h"
+#include "shared/CAmSocketHandler.h"
+#include "shared/CAmSerializer.h"
+#include "../include/IAmControlReceiverShadow.h"
+
+namespace am
+{
+
+class CAmControlReceiverShadowTest: public ::testing::Test
+{
+public:
+ CAmSocketHandler psocketHandler;
+ MockIAmControlReceive pMockReceive;
+ IAmControlReceiverShadow pShadow;
+ void timerCallback(sh_timerHandle_t handle, void* userData);
+ TAmShTimerCallBack<CAmControlReceiverShadowTest> ptimerCallback;
+ CAmControlReceiverShadowTest();
+ ~CAmControlReceiverShadowTest();
+ void SetUp();
+ void TearDown();
+};
+
+} /* namespace am */
+#endif /* CAMCONTROLRECEIVERSHADOWTEST_H_ */
--- /dev/null
+cmake_minimum_required(VERSION 2.6)
+
+PROJECT(AmControlReceiverShadowTest)
+
+set(EXECUTABLE_OUTPUT_PATH ${TEST_EXECUTABLE_OUTPUT_PATH})
+FIND_PACKAGE(GTest REQUIRED)
+
+find_package (Threads)
+FIND_PACKAGE(PkgConfig)
+pkg_check_modules(DLT REQUIRED automotive-dlt)
+
+INCLUDE_DIRECTORIES(
+ ${STD_INCLUDE_DIRS}
+ ${CMAKE_SOURCE_DIR}
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${AUDIO_include_FOLDER}
+ ${CMAKE_SOURCE_DIR}
+ ${DLT_INCLUDE_DIRS}
+ ${include_FOLDER}
+ ${GTEST_INCLUDE_DIR}
+ ${DBUS_INCLUDE_DIR}
+ ${DBUS_ARCH_INCLUDE_DIR}
+ "../../AudioManagerDaemon/include"
+ "../include"
+)
+
+file(GLOB CONTROL_RECEIVER_PLUGIN_INTERFACE_SRCS_CXX
+ "../../AudioManagerDaemon/src/CAmSocketHandler.cpp"
+ "../../AudioManagerDaemon/src/CAmDltWrapper.cpp"
+ "../src/IAmControlReceiverShadow.cpp"
+ "CAmControlReceiverShadowTest.cpp"
+)
+
+
+ADD_EXECUTABLE(AmControlReceiverShadowTest ${CONTROL_RECEIVER_PLUGIN_INTERFACE_SRCS_CXX})
+
+
+TARGET_LINK_LIBRARIES(AmControlReceiverShadowTest
+ ${DLT_LIBRARIES}
+ ${CMAKE_DL_LIBS}
+ ${CMAKE_THREAD_LIBS_INIT}
+ ${GTEST_LIBRARIES}
+ ${DBUS_LIBRARY}
+ ${SQLITE_LIBRARIES}
+ gmock
+)
+
+INSTALL(TARGETS AmControlReceiverShadowTest
+ DESTINATION "~/AudioManagerTest/"
+ PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
+ COMPONENT tests
+)
+
+SET(ADD_DEPEND "audiomanager-bin" "dlt" "libdbus-1-3(>=1.2.16)" "libgtest-dev(>=1.6.0-1)" "google-mock" "libpthread-stubs0")
+set_property(GLOBAL APPEND PROPERTY tests_prop "${ADD_DEPEND}")
+
--- /dev/null
+#ifndef MOCKCONTROLINTERFACE_H_
+#define MOCKCONTROLINTERFACE_H_
+
+#include "control/IAmControlReceive.h"
+
+
+namespace am {
+
+class MockIAmControlReceive : public IAmControlReceive {
+ public:
+ MOCK_METHOD4(getRoute,
+ am_Error_e(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList));
+ MOCK_METHOD5(connect,
+ am_Error_e(am_Handle_s& handle, am_connectionID_t& connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID));
+ MOCK_METHOD2(disconnect,
+ am_Error_e(am_Handle_s& handle, const am_connectionID_t connectionID));
+ MOCK_METHOD5(crossfade,
+ am_Error_e(am_Handle_s& handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_RampType_e rampType, const am_time_t rampTime));
+ MOCK_METHOD1(abortAction,
+ am_Error_e(const am_Handle_s handle));
+ MOCK_METHOD3(setSourceState,
+ am_Error_e(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SourceState_e state));
+ MOCK_METHOD5(setSinkVolume,
+ am_Error_e(am_Handle_s& handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time));
+ MOCK_METHOD5(setSourceVolume,
+ am_Error_e(am_Handle_s& handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e rampType, const am_time_t time));
+ MOCK_METHOD3(setSinkSoundProperties,
+ am_Error_e(am_Handle_s& handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s>& soundProperty));
+ MOCK_METHOD3(setSinkSoundProperty,
+ am_Error_e(am_Handle_s& handle, const am_sinkID_t sinkID, const am_SoundProperty_s& soundProperty));
+ MOCK_METHOD3(setSourceSoundProperties,
+ am_Error_e(am_Handle_s& handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s>& soundProperty));
+ MOCK_METHOD3(setSourceSoundProperty,
+ am_Error_e(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SoundProperty_s& soundProperty));
+ MOCK_METHOD2(setDomainState,
+ am_Error_e(const am_domainID_t domainID, const am_DomainState_e domainState));
+ MOCK_METHOD2(enterDomainDB,
+ am_Error_e(const am_Domain_s& domainData, am_domainID_t& domainID));
+ MOCK_METHOD2(enterMainConnectionDB,
+ am_Error_e(const am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID));
+ MOCK_METHOD2(enterSinkDB,
+ am_Error_e(const am_Sink_s& sinkData, am_sinkID_t& sinkID));
+ MOCK_METHOD2(enterCrossfaderDB,
+ am_Error_e(const am_Crossfader_s& crossfaderData, am_crossfaderID_t& crossfaderID));
+ MOCK_METHOD2(enterGatewayDB,
+ am_Error_e(const am_Gateway_s& gatewayData, am_gatewayID_t& gatewayID));
+ MOCK_METHOD2(enterSourceDB,
+ am_Error_e(const am_Source_s& sourceData, am_sourceID_t& sourceID));
+ MOCK_METHOD2(enterSinkClassDB,
+ am_Error_e(const am_SinkClass_s& sinkClass, am_sinkClass_t& sinkClassID));
+ MOCK_METHOD2(enterSourceClassDB,
+ am_Error_e(am_sourceClass_t& sourceClassID, const am_SourceClass_s& sourceClass));
+ MOCK_METHOD1(changeSinkClassInfoDB,
+ am_Error_e(const am_SinkClass_s& sinkClass));
+ MOCK_METHOD1(changeSourceClassInfoDB,
+ am_Error_e(const am_SourceClass_s& sourceClass));
+ MOCK_METHOD1(enterSystemPropertiesListDB,
+ am_Error_e(const std::vector<am_SystemProperty_s>& listSystemProperties));
+ MOCK_METHOD2(changeMainConnectionRouteDB,
+ am_Error_e(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID));
+ MOCK_METHOD2(changeMainConnectionStateDB,
+ am_Error_e(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState));
+ MOCK_METHOD2(changeSinkMainVolumeDB,
+ am_Error_e(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID));
+ MOCK_METHOD2(changeSinkAvailabilityDB,
+ am_Error_e(const am_Availability_s& availability, const am_sinkID_t sinkID));
+ MOCK_METHOD2(changDomainStateDB,
+ am_Error_e(const am_DomainState_e domainState, const am_domainID_t domainID));
+ MOCK_METHOD2(changeSinkMuteStateDB,
+ am_Error_e(const am_MuteState_e muteState, const am_sinkID_t sinkID));
+ MOCK_METHOD2(changeMainSinkSoundPropertyDB,
+ am_Error_e(const am_MainSoundProperty_s& soundProperty, const am_sinkID_t sinkID));
+ MOCK_METHOD2(changeMainSourceSoundPropertyDB,
+ am_Error_e(const am_MainSoundProperty_s& soundProperty, const am_sourceID_t sourceID));
+ MOCK_METHOD2(changeSourceAvailabilityDB,
+ am_Error_e(const am_Availability_s& availability, const am_sourceID_t sourceID));
+ MOCK_METHOD1(changeSystemPropertyDB,
+ am_Error_e(const am_SystemProperty_s& property));
+ MOCK_METHOD1(removeMainConnectionDB,
+ am_Error_e(const am_mainConnectionID_t mainConnectionID));
+ MOCK_METHOD1(removeSinkDB,
+ am_Error_e(const am_sinkID_t sinkID));
+ MOCK_METHOD1(removeSourceDB,
+ am_Error_e(const am_sourceID_t sourceID));
+ MOCK_METHOD1(removeGatewayDB,
+ am_Error_e(const am_gatewayID_t gatewayID));
+ MOCK_METHOD1(removeCrossfaderDB,
+ am_Error_e(const am_crossfaderID_t crossfaderID));
+ MOCK_METHOD1(removeDomainDB,
+ am_Error_e(const am_domainID_t domainID));
+ MOCK_METHOD1(removeSinkClassDB,
+ am_Error_e(const am_sinkClass_t sinkClassID));
+ MOCK_METHOD1(removeSourceClassDB,
+ am_Error_e(const am_sourceClass_t sourceClassID));
+ MOCK_CONST_METHOD2(getSourceClassInfoDB,
+ am_Error_e(const am_sourceID_t sourceID, am_SourceClass_s& classInfo));
+ MOCK_CONST_METHOD2(getSinkClassInfoDB,
+ am_Error_e(const am_sinkID_t sinkID, am_SinkClass_s& sinkClass));
+ MOCK_CONST_METHOD2(getSinkInfoDB,
+ am_Error_e(const am_sinkID_t sinkID, am_Sink_s& sinkData));
+ MOCK_CONST_METHOD2(getSourceInfoDB,
+ am_Error_e(const am_sourceID_t sourceID, am_Source_s& sourceData));
+ MOCK_CONST_METHOD2(getGatewayInfoDB,
+ am_Error_e(const am_gatewayID_t gatewayID, am_Gateway_s& gatewayData));
+ MOCK_CONST_METHOD2(getCrossfaderInfoDB,
+ am_Error_e(const am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData));
+ MOCK_CONST_METHOD2(getMainConnectionInfoDB,
+ am_Error_e(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData));
+ MOCK_CONST_METHOD2(getListSinksOfDomain,
+ am_Error_e(const am_domainID_t domainID, std::vector<am_sinkID_t>& listSinkID));
+ MOCK_CONST_METHOD2(getListSourcesOfDomain,
+ am_Error_e(const am_domainID_t domainID, std::vector<am_sourceID_t>& listSourceID));
+ MOCK_CONST_METHOD2(getListCrossfadersOfDomain,
+ am_Error_e(const am_domainID_t domainID, std::vector<am_crossfaderID_t>& listCrossfadersID));
+ MOCK_CONST_METHOD2(getListGatewaysOfDomain,
+ am_Error_e(const am_domainID_t domainID, std::vector<am_gatewayID_t>& listGatewaysID));
+ MOCK_CONST_METHOD1(getListMainConnections,
+ am_Error_e(std::vector<am_MainConnection_s>& listMainConnections));
+ MOCK_CONST_METHOD1(getListDomains,
+ am_Error_e(std::vector<am_Domain_s>& listDomains));
+ MOCK_CONST_METHOD1(getListConnections,
+ am_Error_e(std::vector<am_Connection_s>& listConnections));
+ MOCK_CONST_METHOD1(getListSinks,
+ am_Error_e(std::vector<am_Sink_s>& listSinks));
+ MOCK_CONST_METHOD1(getListSources,
+ am_Error_e(std::vector<am_Source_s>& listSources));
+ MOCK_CONST_METHOD1(getListSourceClasses,
+ am_Error_e(std::vector<am_SourceClass_s>& listSourceClasses));
+ MOCK_CONST_METHOD1(getListHandles,
+ am_Error_e(std::vector<am_Handle_s>& listHandles));
+ MOCK_CONST_METHOD1(getListCrossfaders,
+ am_Error_e(std::vector<am_Crossfader_s>& listCrossfaders));
+ MOCK_CONST_METHOD1(getListGateways,
+ am_Error_e(std::vector<am_Gateway_s>& listGateways));
+ MOCK_CONST_METHOD1(getListSinkClasses,
+ am_Error_e(std::vector<am_SinkClass_s>& listSinkClasses));
+ MOCK_CONST_METHOD1(getListSystemProperties,
+ am_Error_e(std::vector<am_SystemProperty_s>& listSystemProperties));
+ MOCK_METHOD0(setCommandReady,
+ void());
+ MOCK_METHOD0(setCommandRundown,
+ void());
+ MOCK_METHOD0(setRoutingReady,
+ void());
+ MOCK_METHOD0(setRoutingRundown,
+ void());
+ MOCK_METHOD0(confirmControllerReady,
+ void());
+ MOCK_METHOD0(confirmControllerRundown,
+ void());
+ MOCK_METHOD1(getSocketHandler,
+ am_Error_e(CAmSocketHandler*& socketHandler));
+ MOCK_CONST_METHOD1(getInterfaceVersion,
+ void(std::string& version));
+};
+
+} // namespace am
+#endif
#define ROUTINGRECEIVERASYNCSHADOW_H_
#include "routing/IAmRoutingReceive.h"
-#include <pthread.h>
-#include <queue>
#include "shared/CAmSerializer.h"
#include "shared/CAmSocketHandler.h"
#include <errno.h>
#include <string>
#include "shared/CAmDltWrapper.h"
+#include "shared/CAmSerializer.h"
using namespace am;
#include "TAmPluginTemplate.h"
#include "MockIAmRoutingReceive.h"
#include "shared/CAmDltWrapper.h"
+#include "routing/IAmRoutingSend.h"
using namespace am;
using namespace testing;
#include "MockIAmRoutingReceive.h"
#include "shared/CAmSocketHandler.h"
#include "shared/CAmSerializer.h"
-#include "../../AudioManagerDaemon/include/CAmRoutingSender.h"
#define UNIT_TEST 1
PROJECT(AmRoutingReceiverAsync)
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -DUNIT_TEST=1 -DDLT_CONTEXT=AudioManager")
-
set(EXECUTABLE_OUTPUT_PATH ${TEST_EXECUTABLE_OUTPUT_PATH})
FIND_PACKAGE(GTest REQUIRED)
class CAmDelegate
{
public:
- virtual ~CAmDelegate(){};
+ virtual ~CAmDelegate()
+ {};
virtual bool call(int* pipe)=0;
};
void (TClass::*mFunction)();
public:
- CAmNoArgDelegate(TClass* instance, void(TClass::*function)()) :
+ CAmNoArgDelegate(TClass* instance, void (TClass::*function)()) :
mInstance(instance), //
- mFunction(function){};
+ mFunction(function)
+ {};
bool call(int* pipe)
{
- (void)pipe;
+ (void) pipe;
(*mInstance.*mFunction)();
return true;
};
Targ mArgument;
public:
- CAmOneArgDelegate(TClass* instance, void(TClass::*function)(Targ), Targ argument) :
+ CAmOneArgDelegate(TClass* instance, void (TClass::*function)(Targ), Targ argument) :
mInstance(instance), //
mFunction(function), //
- mArgument(argument) { };
+ mArgument(argument)
+ {};
bool call(int* pipe)
{
- (void)pipe;
+ (void) pipe;
(*mInstance.*mFunction)(mArgument);
return true;
};
{
private:
TClass* mInstance;
- void (TClass::*mFunction)(Targ argument,Targ1 argument1);
+ void (TClass::*mFunction)(Targ argument, Targ1 argument1);
Targ mArgument;
Targ1 mArgument1;
public:
- CAmTwoArgDelegate(TClass* instance, void(TClass::*function)(Targ argument,Targ1 argument1), Targ argument, Targ1 argument1) :
+ CAmTwoArgDelegate(TClass* instance, void (TClass::*function)(Targ argument, Targ1 argument1), Targ argument, Targ1 argument1) :
mInstance(instance), //
mFunction(function), //
mArgument(argument), //
- mArgument1(argument1){};
+ mArgument1(argument1)
+ {};
bool call(int* pipe)
{
- (void)pipe;
- (*mInstance.*mFunction)(mArgument,mArgument1);
+ (void) pipe;
+ (*mInstance.*mFunction)(mArgument, mArgument1);
return true;
};
};
{
private:
TClass* mInstance;
- void (TClass::*mFunction)(Targ argument,Targ1 argument1,Targ2 argument2);
+ void (TClass::*mFunction)(Targ argument, Targ1 argument1, Targ2 argument2);
Targ mArgument;
Targ1 mArgument1;
Targ2 mArgument2;
public:
- CAmThreeArgDelegate(TClass* instance, void(TClass::*function)(Targ argument,Targ1 argument1,Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2) :
+ CAmThreeArgDelegate(TClass* instance, void (TClass::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2) :
mInstance(instance), //
mFunction(function), //
mArgument(argument), //
mArgument1(argument1), //
- mArgument2(argument2){};
+ mArgument2(argument2)
+ {
+ }
+ ;
bool call(int* pipe)
{
- (void)pipe;
- (*mInstance.*mFunction)(mArgument,mArgument1,mArgument2);
+ (void) pipe;
+ (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2);
return true;
- };
+ }
+ ;
};
/**
Targ3 mArgument3;
public:
- CAmFourArgDelegate(TClass* instance, void(TClass::*function)(Targ argument,Targ1 argument1,Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) :
+ CAmFourArgDelegate(TClass* instance, void (TClass::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) :
mInstance(instance), //
mFunction(function), //
mArgument(argument), //
mArgument1(argument1), //
mArgument2(argument2), //
- mArgument3(argument3){};
+ mArgument3(argument3)
+ {
+ }
+ ;
bool call(int* pipe)
{
- (void)pipe;
- (*mInstance.*mFunction)(mArgument,mArgument1,mArgument2,mArgument3);
+ (void) pipe;
+ (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3);
return true;
- };
+ }
+ ;
};
/**
template<class TClass, typename TretVal> class CAmSyncNoArgDelegate: public CAmDelegate
{
private:
- TClass* mInstance;
- TretVal (TClass::*mFunction)();
- TretVal mRetval;
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)();
+ TretVal mRetval;
public:
- friend class CAmSerializer;
- CAmSyncNoArgDelegate(TClass* instance, TretVal(TClass::*function)()) :
- mInstance(instance), //
- mFunction(function), //
- mRetval(){};
-
- bool call(int* pipe)
- {
- mRetval = (*mInstance.*mFunction)();
- write(pipe[1], this, sizeof(this));
- return false;
- };
-
- TretVal returnResults()
- {
- return mRetval;
- }
+ friend class CAmSerializer;
+ CAmSyncNoArgDelegate(TClass* instance, TretVal (TClass::*function)()) :
+ mInstance(instance), //
+ mFunction(function), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)();
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults()
+ {
+ return mRetval;
+ }
};
/**
* template for synchronous calls with one argument
*/
- template<class TClass, typename TretVal, typename Targ> class CAmSyncOneArgDelegate: public CAmDelegate
+ template<class TClass, typename TretVal, typename TargCall, typename Targ> class CAmSyncOneArgDelegate: public CAmDelegate
+ {
+ private:
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)(TargCall argument);
+ Targ mArgument;
+ TretVal mRetval;
+
+ public:
+ friend class CAmSerializer;
+ CAmSyncOneArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCall argument), Targ argument) :
+ mInstance(instance), //
+ mFunction(function), //
+ mArgument(argument), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)(mArgument);
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults(Targ& argument)
+ {
+ argument = mArgument;
+ return mRetval;
+ }
+ };
+
+ template<class TClass, typename TretVal, typename TargCall, typename Targ> class CAmSyncOneArgConstDelegate: public CAmDelegate
{
private:
- TClass* mInstance;
- TretVal (TClass::*mFunction)(Targ argument);
- Targ mArgument;
- TretVal mRetval;
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)(TargCall argument) const;
+ Targ mArgument;
+ TretVal mRetval;
public:
- friend class CAmSerializer;
- CAmSyncOneArgDelegate(TClass* instance, TretVal(TClass::*function)(Targ argument), Targ argument) :
- mInstance(instance), //
- mFunction(function), //
- mArgument(argument), //
- mRetval(){};
-
- bool call(int* pipe)
- {
- mRetval = (*mInstance.*mFunction)(mArgument);
- write(pipe[1], this, sizeof(this));
- return false;
- };
-
- TretVal returnResults(Targ& argument)
- {
- argument=mArgument;
- return mRetval;
- }
+ friend class CAmSerializer;
+ CAmSyncOneArgConstDelegate(TClass* instance, TretVal (TClass::*function)(TargCall argument) const, Targ argument) :
+ mInstance(instance), //
+ mFunction(function), //
+ mArgument(argument), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)(mArgument);
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults(Targ& argument)
+ {
+ argument = mArgument;
+ return mRetval;
+ }
};
/**
template<class TClass, typename TretVal, typename TargCall, typename TargCall1, typename Targ, typename Targ1> class CAmSyncTwoArgDelegate: public CAmDelegate
{
private:
- TClass* mInstance;
- TretVal (TClass::*mFunction)(TargCall,TargCall1);
- Targ mArgument;
- Targ1 mArgument1;
- TretVal mRetval;
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)(TargCall, TargCall1);
+ Targ mArgument;
+ Targ1 mArgument1;
+ TretVal mRetval;
public:
- friend class CAmSerializer;
- CAmSyncTwoArgDelegate(TClass* instance, TretVal(TClass::*function)(TargCall, TargCall1), Targ& argument, Targ1& argument1) :
- mInstance(instance), //
- mFunction(function), //
- mArgument(argument), //
- mArgument1(argument1), //
- mRetval(){};
-
- bool call(int* pipe)
- {
- mRetval = (*mInstance.*mFunction)(mArgument, mArgument1);
- write(pipe[1], this, sizeof(this));
- return false;
- };
-
- TretVal returnResults(Targ& argument, Targ1& argument1)
- {
- argument=mArgument;
- argument1=mArgument1;
- return mRetval;
- }
+ friend class CAmSerializer;
+ CAmSyncTwoArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCall, TargCall1), Targ& argument, Targ1& argument1) :
+ mInstance(instance), //
+ mFunction(function), //
+ mArgument(argument), //
+ mArgument1(argument1), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)(mArgument, mArgument1);
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults(Targ& argument, Targ1& argument1)
+ {
+ argument = mArgument;
+ argument1 = mArgument1;
+ return mRetval;
+ }
+ };
+
+ template<class TClass, typename TretVal, typename TargCall, typename TargCall1, typename Targ, typename Targ1> class CAmSyncTwoArgConstDelegate: public CAmDelegate
+ {
+ private:
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)(TargCall, TargCall1) const;
+ Targ mArgument;
+ Targ1 mArgument1;
+ TretVal mRetval;
+
+ public:
+ friend class CAmSerializer;
+ CAmSyncTwoArgConstDelegate(TClass* instance, TretVal (TClass::*function)(TargCall, TargCall1) const, Targ& argument, Targ1& argument1) :
+ mInstance(instance), //
+ mFunction(function), //
+ mArgument(argument), //
+ mArgument1(argument1), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)(mArgument, mArgument1);
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults(Targ& argument, Targ1& argument1)
+ {
+ argument = mArgument;
+ argument1 = mArgument1;
+ return mRetval;
+ }
};
/**
* template for synchronous calls with three arguments
*/
- template<class TClass, typename TretVal, typename Targ, typename Targ1, typename Targ2> class CAmSyncThreeArgDelegate: public CAmDelegate
+ template<class TClass, typename TretVal, typename TargCall, typename TargCall1, typename TargCall2, typename Targ, typename Targ1, typename Targ2> class CAmSyncThreeArgDelegate: public CAmDelegate
{
private:
- TClass* mInstance;
- TretVal (TClass::*mFunction)(Targ argument, Targ1 argument1, Targ2 argument2);
- Targ mArgument;
- Targ1 mArgument1;
- Targ2 mArgument2;
- TretVal mRetval;
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)(TargCall argument, TargCall1 argument1, TargCall2 argument2);
+ Targ mArgument;
+ Targ1 mArgument1;
+ Targ2 mArgument2;
+ TretVal mRetval;
public:
- CAmSyncThreeArgDelegate(TClass* instance, TretVal(TClass::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1,Targ2 argument2) :
- mInstance(instance), //
- mFunction(function), //
- mArgument(argument), //
- mArgument1(argument1), //
- mArgument2(argument2), //
- mRetval(){};
-
- bool call(int* pipe)
- {
- mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2);
- write(pipe[1], this, sizeof(this));
- return false;
- };
-
- TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2)
- {
- argument=mArgument;
- argument1=mArgument1;
- argument2=mArgument2;
- return mRetval;
- }
+ CAmSyncThreeArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCall argument, TargCall1 argument1, TargCall2 argument2), Targ argument, Targ1 argument1, Targ2 argument2) :
+ mInstance(instance), //
+ mFunction(function), //
+ mArgument(argument), //
+ mArgument1(argument1), //
+ mArgument2(argument2), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2);
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2)
+ {
+ argument = mArgument;
+ argument1 = mArgument1;
+ argument2 = mArgument2;
+ return mRetval;
+ }
};
/**
* template for synchronous calls with four arguments
*/
- template<class TClass, typename TretVal, typename Targ, typename Targ1, typename Targ2, typename Targ3> class CAmSyncFourArgDelegate: public CAmDelegate
+ template<class TClass, typename TretVal, typename TargCAll, typename TargCall1, typename TargCall2, typename TargCall3, typename Targ, typename Targ1, typename Targ2, typename Targ3> class CAmSyncFourArgDelegate: public CAmDelegate
+ {
+ private:
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3);
+ Targ mArgument;
+ Targ1 mArgument1;
+ Targ2 mArgument2;
+ Targ3 mArgument3;
+ TretVal mRetval;
+ public:
+ CAmSyncFourArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) :
+ mInstance(instance), //
+ mFunction(function), //
+ mArgument(argument), //
+ mArgument1(argument1), //
+ mArgument2(argument2), //
+ mArgument3(argument3), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3);
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3)
+ {
+ argument = mArgument;
+ argument1 = mArgument1;
+ argument2 = mArgument2;
+ argument3 = mArgument3;
+ return mRetval;
+ }
+ };
+
+ template<class TClass, typename TretVal, typename TargCAll, typename TargCall1, typename TargCall2, typename TargCall3, typename TargCall4, typename Targ, typename Targ1, typename Targ2, typename Targ3, typename Targ4> class CAmSyncFiveArgDelegate: public CAmDelegate
{
private:
- TClass* mInstance;
- TretVal (TClass::*mFunction)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3);
- Targ mArgument;
- Targ1 mArgument1;
- Targ2 mArgument2;
- Targ3 mArgument3;
- TretVal mRetval;
-
- CAmSyncFourArgDelegate(TClass* instance, TretVal(TClass::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) :
- mInstance(instance), //
- mFunction(function), //
- mArgument(argument), //
- mArgument1(argument1), //
- mArgument2(argument2), //
- mArgument3(argument3), //
- mRetval(){};
-
- bool call(int* pipe)
- {
- mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3);
- write(pipe[1], this, sizeof(this));
- return false;
- };
-
- TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3)
- {
- argument=mArgument;
- argument1=mArgument1;
- argument2=mArgument2;
- argument3=mArgument3;
- return mRetval;
- }
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3, TargCall4);
+ Targ mArgument;
+ Targ1 mArgument1;
+ Targ2 mArgument2;
+ Targ3 mArgument3;
+ Targ4 mArgument4;
+ TretVal mRetval;
+ public:
+
+ CAmSyncFiveArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3, TargCall4 argument4), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3, Targ4 argument4) :
+ mInstance(instance), //
+ mFunction(function), //
+ mArgument(argument), //
+ mArgument1(argument1), //
+ mArgument2(argument2), //
+ mArgument3(argument3), //
+ mArgument4(argument4), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3, mArgument4);
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4)
+ {
+ argument = mArgument;
+ argument1 = mArgument1;
+ argument2 = mArgument2;
+ argument3 = mArgument3;
+ argument4 = mArgument4;
+ return mRetval;
+ }
+ };
+
+ template<class TClass, typename TretVal, typename TargCAll, typename TargCall1, typename TargCall2, typename TargCall3, typename TargCall4, typename TargCall5, typename Targ, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5> class CAmSyncSixArgDelegate: public CAmDelegate
+ {
+ private:
+ TClass* mInstance;
+ TretVal (TClass::*mFunction)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3, TargCall4, TargCall5);
+ Targ mArgument;
+ Targ1 mArgument1;
+ Targ2 mArgument2;
+ Targ3 mArgument3;
+ Targ4 mArgument4;
+ Targ5 mArgument5;
+ TretVal mRetval;
+
+ CAmSyncSixArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCAll, TargCall1, TargCall2, TargCall3, TargCall4, TargCall5), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3, Targ4 argument4, Targ5 argument5) :
+ mInstance(instance), //
+ mFunction(function), //
+ mArgument(argument), //
+ mArgument1(argument1), //
+ mArgument2(argument2), //
+ mArgument3(argument3), //
+ mArgument4(argument4), //
+ mArgument5(argument5), //
+ mRetval()
+ {
+ }
+ ;
+
+ bool call(int* pipe)
+ {
+ mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3, mArgument4, mArgument5);
+ write(pipe[1], this, sizeof(this));
+ return false;
+ }
+ ;
+
+ TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4, Targ5& argument5)
+ {
+ argument = mArgument;
+ argument1 = mArgument1;
+ argument2 = mArgument2;
+ argument3 = mArgument3;
+ argument4 = mArgument4;
+ argument5 = mArgument5;
+ return mRetval;
+ }
};
/**
* @endcode
*/
template<class TClass>
- void asyncCall(TClass* instance, void(TClass::*function)())
+ void asyncCall(TClass* instance, void (TClass::*function)())
{
CAmDelegagePtr p(new CAmNoArgDelegate<TClass>(instance, function));
send(p);
* @endcode
*/
template<class TClass1, class Targ>
- void asyncCall(TClass1* instance, void(TClass1::*function)(Targ), Targ argument)
+ void asyncCall(TClass1* instance, void (TClass1::*function)(Targ), Targ argument)
{
CAmDelegagePtr p(new CAmOneArgDelegate<TClass1, Targ>(instance, function, argument));
send(p);
* @param argument1
*/
template<class TClass1, class Targ, class Targ1>
- void asyncCall(TClass1* instance, void(TClass1::*function)(Targ argument,Targ1 argument1), Targ argument, Targ1 argument1)
+ void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1), Targ argument, Targ1 argument1)
{
- CAmDelegagePtr p(new CAmTwoArgDelegate<TClass1, Targ, Targ1>(instance, function, argument,argument1));
+ CAmDelegagePtr p(new CAmTwoArgDelegate<TClass1, Targ, Targ1>(instance, function, argument, argument1));
send(p);
}
* @param function
* @param argument
* @param argument1 template<class TClass1, class TretVal, class Targ, class Targ1>
- void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ,Targ1), TretVal& retVal, Targ& argument, Targ1& argument1)
- {
- CAmSyncTwoArgDelegate<TClass1, TretVal, Targ, Targ1>* p(new CAmSyncTwoArgDelegate<TClass1, TretVal, Targ, Targ1>(instance, function, argument, argument1));
- send(static_cast<CAmDelegagePtr>(p));
- int numReads;
- CAmDelegagePtr ptr;
- if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1)
- {
- logError("CAmSerializer::receiverCallback could not read pipe!");
- throw std::runtime_error("CAmSerializer Could not read pipe!");
- }
- //working with friend class here is not the finest of all programming stiles but it works...
- retVal=p->returnResults(argument,argument1);
- }
+ void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ,Targ1), TretVal& retVal, Targ& argument, Targ1& argument1)
+ {
+ CAmSyncTwoArgDelegate<TClass1, TretVal, Targ, Targ1>* p(new CAmSyncTwoArgDelegate<TClass1, TretVal, Targ, Targ1>(instance, function, argument, argument1));
+ send(static_cast<CAmDelegagePtr>(p));
+ int numReads;
+ CAmDelegagePtr ptr;
+ if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1)
+ {
+ logError("CAmSerializer::receiverCallback could not read pipe!");
+ throw std::runtime_error("CAmSerializer Could not read pipe!");
+ }
+ //working with friend class here is not the finest of all programming stiles but it works...
+ retVal=p->returnResults(argument,argument1);
+ }
* @param argument2
*/
template<class TClass1, class Targ, class Targ1, class Targ2>
- void asyncCall(TClass1* instance, void(TClass1::*function)(Targ argument,Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2)
+ void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2)
{
- CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ, Targ1, Targ2>(instance, function, argument,argument1, argument2));
+ CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ, Targ1, Targ2>(instance, function, argument, argument1, argument2));
send(p);
}
* @param argument3
*/
template<class TClass1, class Targ, class Targ1, class Targ2, class Targ3>
- void asyncCall(TClass1* instance, void(TClass1::*function)(Targ argument,Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3)
+ void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3)
{
- CAmDelegagePtr p(new CAmFourArgDelegate<TClass1, Targ, Targ1, Targ2, Targ3>(instance, function, argument,argument1, argument2, argument3));
+ CAmDelegagePtr p(new CAmFourArgDelegate<TClass1, Targ, Targ1, Targ2, Targ3>(instance, function, argument, argument1, argument2, argument3));
send(p);
}
*
*/
template<class TClass1, class TretVal>
- void syncCall(TClass1* instance, TretVal(TClass1::*function)(), TretVal& retVal)
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(), TretVal& retVal)
{
CAmSyncNoArgDelegate<TClass1, TretVal>* p(new CAmSyncNoArgDelegate<TClass1, TretVal>(instance, function));
send(static_cast<CAmDelegagePtr>(p));
int numReads;
CAmDelegagePtr ptr;
- if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1)
+ if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1)
{
logError("CAmSerializer::receiverCallback could not read pipe!");
throw std::runtime_error("CAmSerializer Could not read pipe!");
}
//working with friend class here is not the finest of all programming stiles but it works...
- retVal=p->returnResults();
+ retVal = p->returnResults();
delete p;
}
* @endcode
* All arguments given to synchronous functions must be non-const since the results of the operations will be written back to the arguments.
*/
- template<class TClass1, class TretVal, class Targ>
- void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ), TretVal& retVal,Targ& argument)
+ template<class TClass1, class TretVal, class TargCall, class Targ>
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall), TretVal& retVal, Targ& argument)
{
- CAmSyncOneArgDelegate<TClass1, TretVal, Targ>* p(new CAmSyncOneArgDelegate<TClass1, TretVal, Targ>(instance, function, argument));
+ CAmSyncOneArgDelegate<TClass1, TretVal, TargCall, Targ>* p(new CAmSyncOneArgDelegate<TClass1, TretVal, TargCall, Targ>(instance, function, argument));
send(static_cast<CAmDelegagePtr>(p));
int numReads;
CAmDelegagePtr ptr;
- if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1)
+ if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1)
{
logError("CAmSerializer::receiverCallback could not read pipe!");
throw std::runtime_error("CAmSerializer Could not read pipe!");
}
//working with friend class here is not the finest of all programming stiles but it works...
- retVal=p->returnResults(argument);
+ retVal = p->returnResults(argument);
+ delete p;
+ }
+
+ template<class TClass1, class TretVal, class TargCall, class Targ>
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall) const, TretVal& retVal, Targ& argument)
+ {
+ CAmSyncOneArgConstDelegate<TClass1, TretVal, TargCall, Targ>* p(new CAmSyncOneArgConstDelegate<TClass1, TretVal, TargCall, Targ>(instance, function, argument));
+ send(static_cast<CAmDelegagePtr>(p));
+ int numReads;
+ CAmDelegagePtr ptr;
+ if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1)
+ {
+ logError("CAmSerializer::receiverCallback could not read pipe!");
+ throw std::runtime_error("CAmSerializer Could not read pipe!");
+ }
+ //working with friend class here is not the finest of all programming stiles but it works...
+ retVal = p->returnResults(argument);
delete p;
}
* @param argument
* @param argument1
*/
- template<class TClass1, class TretVal, class TargCall, class Targ1Call,class Targ, class Targ1>
- void syncCall(TClass1* instance, TretVal(TClass1::*function)(TargCall,Targ1Call), TretVal& retVal, Targ& argument, Targ1& argument1)
+ template<class TClass1, class TretVal, class TargCall, class Targ1Call, class Targ, class Targ1>
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, Targ1Call), TretVal& retVal, Targ& argument, Targ1& argument1)
{
- CAmSyncTwoArgDelegate<TClass1, TretVal,TargCall,Targ1Call, Targ, Targ1>* p(new CAmSyncTwoArgDelegate<TClass1, TretVal,TargCall,Targ1Call, Targ, Targ1>(instance, function, argument, argument1));
+ CAmSyncTwoArgDelegate<TClass1, TretVal, TargCall, Targ1Call, Targ, Targ1>* p(new CAmSyncTwoArgDelegate<TClass1, TretVal, TargCall, Targ1Call, Targ, Targ1>(instance, function, argument, argument1));
send(dynamic_cast<CAmDelegagePtr>(p));
CAmDelegagePtr ptr;
- if (read(mReturnPipe[0],&ptr, sizeof(ptr)) == -1)
+ if (read(mReturnPipe[0], &ptr, sizeof(ptr)) == -1)
{
logError("CAmSerializer::receiverCallback could not read pipe!");
throw std::runtime_error("CAmSerializer Could not read pipe!");
}
- retVal=p->returnResults(argument,argument1);
+ retVal = p->returnResults(argument, argument1);
+ delete p;
+ }
+
+ template<class TClass1, class TretVal, class TargCall, class Targ1Call, class Targ, class Targ1>
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, Targ1Call) const, TretVal& retVal, Targ& argument, Targ1& argument1)
+ {
+ CAmSyncTwoArgConstDelegate<TClass1, TretVal, TargCall, Targ1Call, Targ, Targ1>* p(new CAmSyncTwoArgConstDelegate<TClass1, TretVal, TargCall, Targ1Call, Targ, Targ1>(instance, function, argument, argument1));
+ send(dynamic_cast<CAmDelegagePtr>(p));
+
+ CAmDelegagePtr ptr;
+ if (read(mReturnPipe[0], &ptr, sizeof(ptr)) == -1)
+ {
+ logError("CAmSerializer::receiverCallback could not read pipe!");
+ throw std::runtime_error("CAmSerializer Could not read pipe!");
+ }
+ retVal = p->returnResults(argument, argument1);
delete p;
}
* @param argument1
* @param argument2
*/
- template<class TClass1, class TretVal, class Targ, class Targ1, class Targ2>
- void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ,Targ1,Targ2), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2)
+ template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class Targ, class Targ1, class Targ2>
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2)
{
- CAmSyncThreeArgDelegate<TClass1, TretVal, Targ, Targ1, Targ2>* p(new CAmSyncThreeArgDelegate<TClass1, TretVal, Targ, Targ1, Targ2>(instance, function, argument, argument1, argument2));
+ CAmSyncThreeArgDelegate<TClass1, TretVal, TargCall, TargCall1, TargCall2, Targ, Targ1, Targ2>* p(new CAmSyncThreeArgDelegate<TClass1, TretVal, TargCall, TargCall1, TargCall2, Targ, Targ1, Targ2>(instance, function, argument, argument1, argument2));
send(static_cast<CAmDelegagePtr>(p));
int numReads;
CAmDelegagePtr ptr;
- if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1)
+ if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1)
{
logError("CAmSerializer::receiverCallback could not read pipe!");
throw std::runtime_error("CAmSerializer Could not read pipe!");
}
//working with friend class here is not the finest of all programming stiles but it works...
- retVal=p->returnResults(argument, argument1, argument2);
+ retVal = p->returnResults(argument, argument1, argument2);
delete p;
}
* @param argument2
* @param argument3
*/
- template<class TClass1, class TretVal, class Targ, class Targ1, class Targ2, class Targ3>
- void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ,Targ1,Targ2,Targ3), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3)
+ template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class TargCall3, class Targ, class Targ1, class Targ2, class Targ3>
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3)
+ {
+ CAmSyncFourArgDelegate<TClass1, TretVal, TargCall, TargCall1, TargCall2, TargCall3, Targ, Targ1, Targ2, Targ3>* p(new CAmSyncFourArgDelegate<TClass1, TretVal, TargCall, TargCall1, TargCall2, TargCall3, Targ, Targ1, Targ2, Targ3>(instance, function, argument, argument1, argument2, argument3));
+ send(static_cast<CAmDelegagePtr>(p));
+ int numReads;
+ CAmDelegagePtr ptr;
+ if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1)
+ {
+ logError("CAmSerializer::receiverCallback could not read pipe!");
+ throw std::runtime_error("CAmSerializer Could not read pipe!");
+ }
+ //working with friend class here is not the finest of all programming stiles but it works...
+ retVal = p->returnResults(argument, argument1, argument2, argument3);
+ delete p;
+ }
+
+ template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class TargCall3, class TargCall4, class Targ, class Targ1, class Targ2, class Targ3, class Targ4>
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3, TargCall4), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4)
{
- CAmSyncFourArgDelegate<TClass1, TretVal, Targ, Targ1, Targ2, Targ3>* p(new CAmSyncFourArgDelegate<TClass1, TretVal, Targ, Targ1, Targ2, Targ3>(instance, function, argument, argument1, argument2, argument3));
+ CAmSyncFiveArgDelegate<TClass1, TretVal, TargCall, TargCall1, TargCall2, TargCall3, TargCall4, Targ, Targ1, Targ2, Targ3, Targ4>* p(new CAmSyncFiveArgDelegate<TClass1, TretVal, TargCall, TargCall1, TargCall2, TargCall3, TargCall4, Targ, Targ1, Targ2, Targ3, Targ4>(instance, function, argument, argument1, argument2, argument3, argument4));
send(static_cast<CAmDelegagePtr>(p));
int numReads;
CAmDelegagePtr ptr;
- if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1)
+ if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1)
{
logError("CAmSerializer::receiverCallback could not read pipe!");
throw std::runtime_error("CAmSerializer Could not read pipe!");
}
//working with friend class here is not the finest of all programming stiles but it works...
- retVal=p->returnResults(argument, argument1, argument2, argument3);
+ retVal = p->returnResults(argument, argument1, argument2, argument3, argument4);
delete p;
}
+ template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class TargCall3, class TargCall4, class TargCall5, class Targ, class Targ1, class Targ2, class Targ3, class Targ4, class Targ5>
+ void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3, TargCall4, TargCall5), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4, Targ5& argument5)
+ {
+ CAmSyncSixArgDelegate<TClass1, TretVal, TargCall, TargCall1, TargCall2, TargCall3, TargCall4, TargCall5, Targ, Targ1, Targ2, Targ3, Targ4, Targ5>* p(new CAmSyncSixArgDelegate<TClass1, TretVal, TargCall, TargCall1, TargCall2, TargCall3, TargCall4, TargCall5, Targ, Targ1, Targ2, Targ3, Targ4, Targ5>(instance, function, argument, argument1, argument2, argument3, argument4, argument5));
+ send(static_cast<CAmDelegagePtr>(p));
+ int numReads;
+ CAmDelegagePtr ptr;
+ if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1)
+ {
+ logError("CAmSerializer::receiverCallback could not read pipe!");
+ throw std::runtime_error("CAmSerializer Could not read pipe!");
+ }
+ //working with friend class here is not the finest of all programming stiles but it works...
+ retVal = p->returnResults(argument, argument1, argument2, argument3, argument4, argument5);
+ delete p;
+ }
void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void* userData)
{
(void) userData;
int numReads;
CAmDelegagePtr listPointers[3];
- if ((numReads=read(pollfd.fd,&listPointers, sizeof(listPointers))) == -1)
+ if ((numReads = read(pollfd.fd, &listPointers, sizeof(listPointers))) == -1)
{
logError("CAmSerializer::receiverCallback could not read pipe!");
throw std::runtime_error("CAmSerializer Could not read pipe!");
}
- mListDelegatePoiters.assign(listPointers, listPointers+(numReads/sizeof(CAmDelegagePtr)));
+ mListDelegatePoiters.assign(listPointers, listPointers + (numReads / sizeof(CAmDelegagePtr)));
}
bool checkerCallback(const sh_pollHandle_t handle, void* userData)
(void) userData;
CAmDelegagePtr delegatePoiter = mListDelegatePoiters.front();
mListDelegatePoiters.pop_front();
- if(delegatePoiter->call(mReturnPipe))
+ if (delegatePoiter->call(mReturnPipe))
delete delegatePoiter;
if (mListDelegatePoiters.empty())
return false;
iSocketHandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, NULL, &dispatcherCallbackT, NULL, handle);
}
- ~CAmSerializer(){}
+ ~CAmSerializer()
+ {
+ }
};
} /* namespace am */
#endif /* CAMSERIALIZER_H_ */
projects / profile / ivi / genivi / genivi-audio-manager.git / commitdiff