diff options
author | christian mueller <christian.ei.mueller@bmw.de> | 2012-09-10 17:41:30 +0200 |
---|---|---|
committer | christian linke <christian.linke@bmw.de> | 2012-10-30 13:55:45 +0100 |
commit | 723253be013e9aef003405610c3837f177ea5ff1 (patch) | |
tree | 367dd0d5f0984ad4aebc681db85668571900ffda | |
parent | 8844ea5c3e210d30afbf923a05779626a96aea77 (diff) | |
download | audiomanager-723253be013e9aef003405610c3837f177ea5ff1.tar.gz |
* [GAM-91] make CAmSerializer calls with references safer
Signed-off-by: christian mueller <christian.ei.mueller@bmw.de>
-rw-r--r-- | AudioManagerDaemon/src/CAmDatabaseObserver.cpp | 10 | ||||
-rw-r--r-- | include/shared/CAmSerializer.h | 154 |
2 files changed, 158 insertions, 6 deletions
diff --git a/AudioManagerDaemon/src/CAmDatabaseObserver.cpp b/AudioManagerDaemon/src/CAmDatabaseObserver.cpp index ae81a4e..8d8b78a 100644 --- a/AudioManagerDaemon/src/CAmDatabaseObserver.cpp +++ b/AudioManagerDaemon/src/CAmDatabaseObserver.cpp @@ -164,22 +164,22 @@ void CAmDatabaseObserver::mainConnectionStateChanged(const am_mainConnectionID_t void CAmDatabaseObserver::mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty) { - mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_MainSoundProperty_s&>(mCommandSender, &CAmCommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty); + mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_MainSoundProperty_s>(mCommandSender, &CAmCommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty); } void CAmDatabaseObserver::mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s & SoundProperty) { - mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t, const am_MainSoundProperty_s&>(mCommandSender, &CAmCommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty); + mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t, const am_MainSoundProperty_s>(mCommandSender, &CAmCommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty); } void CAmDatabaseObserver::sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability) { - mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_Availability_s&>(mCommandSender, &CAmCommandSender::cbSinkAvailabilityChanged, sinkID, availability); + mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_Availability_s>(mCommandSender, &CAmCommandSender::cbSinkAvailabilityChanged, sinkID, availability); } void CAmDatabaseObserver::sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability) { - mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t, const am_Availability_s&>(mCommandSender, &CAmCommandSender::cbSourceAvailabilityChanged, sourceID, availability); + mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t, const am_Availability_s>(mCommandSender, &CAmCommandSender::cbSourceAvailabilityChanged, sourceID, availability); } void CAmDatabaseObserver::volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume) @@ -194,7 +194,7 @@ void CAmDatabaseObserver::sinkMuteStateChanged(const am_sinkID_t sinkID, const a void CAmDatabaseObserver::systemPropertyChanged(const am_SystemProperty_s& SystemProperty) { - mSerializer.asyncCall<CAmCommandSender, const am_SystemProperty_s&>(mCommandSender, &CAmCommandSender::cbSystemPropertyChanged, SystemProperty); + mSerializer.asyncCall<CAmCommandSender, const am_SystemProperty_s>(mCommandSender, &CAmCommandSender::cbSystemPropertyChanged, SystemProperty); } void CAmDatabaseObserver::timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time) diff --git a/include/shared/CAmSerializer.h b/include/shared/CAmSerializer.h index a88c0ad..5c3b2eb 100644 --- a/include/shared/CAmSerializer.h +++ b/include/shared/CAmSerializer.h @@ -139,6 +139,7 @@ private: }; }; + /** * delegate template for three arguments */ @@ -646,6 +647,33 @@ public: } /** + * calls a function with one argument called by reference asynchronously threadsafe + * @param instance the instance of the class that shall be called + * @param function the function that shall be called as memberfunction pointer. + * @param argument the argument + * @tparam TClass1 the type of the Class to be called + * @tparam Targ the type of the argument to be called + * \section ex Example: + * @code + * class myClass + * { + * public: + * void myfunction(int k); + * } + * CAmSerializer serial(&Sockethandler); + * myClass instanceMyClass; + * serial<CommandSender,int>(&instanceMyClass,&myClass::myfunction,k); + * @endcode + * + */ + template<class TClass1, class Targ> + void asyncCall(TClass1* instance, void (TClass1::*function)(Targ&), Targ& argument) + { + CAmDelegagePtr p(new CAmOneArgDelegate<TClass1, Targ&>(instance, function, argument)); + send(p); + } + + /** * calls a function with two arguments asynchronously threadsafe. for more see asyncCall with one argument * @param instance pointer to the instance of the class * @param function memberfunction poitner @@ -658,11 +686,64 @@ public: template<class TClass1, class Targ, class Targ1> void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1), Targ argument, Targ1 argument1) { + logInfo("took without ref"); CAmDelegagePtr p(new CAmTwoArgDelegate<TClass1, Targ, Targ1>(instance, function, argument, argument1)); send(p); } /** + * calls a function with two arguments asynchronously threadsafe, first argument is a reference. for more see asyncCall with one argument + * @param instance pointer to the instance of the class + * @param function memberfunction poitner + * @param argument the first argument + * @param argument1 the second argument + * @tparam TClass1 the type of the Class to be called + * @tparam Targ the type of the argument to be called + * @tparam Targ1 the type of the first argument to be called + */ + template<class TClass1, class Targ, class Targ1> + 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)); + send(p); + } + + /** + * calls a function with two arguments asynchronously threadsafe, second argument is a reference. for more see asyncCall with one argument + * @param instance pointer to the instance of the class + * @param function memberfunction poitner + * @param argument the first argument + * @param argument1 the second argument + * @tparam TClass1 the type of the Class to be called + * @tparam Targ the type of the argument to be called + * @tparam Targ1 the type of the first argument to be called + */ + template<class TClass1, class Targ, class Targ1> + void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1& argument1), Targ argument, Targ1& argument1) + { + logInfo("took ref"); + CAmDelegagePtr p(new CAmTwoArgDelegate<TClass1, Targ, Targ1&>(instance, function, argument, argument1)); + send(p); + } + + /** + * calls a function with two arguments asynchronously threadsafe, both arguments are references. for more see asyncCall with one argument + * @param instance pointer to the instance of the class + * @param function memberfunction poitner + * @param argument the first argument + * @param argument1 the second argument + * @tparam TClass1 the type of the Class to be called + * @tparam Targ the type of the argument to be called + * @tparam Targ1 the type of the first argument to be called + */ + template<class TClass1, class Targ, class Targ1> + 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)); + send(p); + } + + /** * calls a function with three arguments asynchronously threadsafe. for more see other asycCall */ template<class TClass1, class Targ, class Targ1, class Targ2> @@ -673,6 +754,77 @@ public: } /** + * calls a function with three arguments asynchronously threadsafe. for more see other asycCall + */ + 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) + { + CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ&, Targ1, Targ2>(instance, function, argument, argument1, argument2)); + send(p); + } + + + /** + * calls a function with three arguments asynchronously threadsafe. for more see other asycCall + */ + 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) + { + CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ, Targ1&, Targ2>(instance, function, argument, argument1, argument2)); + send(p); + } + + /** + * calls a function with three arguments asynchronously threadsafe. for more see other asycCall + */ + 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) + { + CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ, Targ1, Targ2&>(instance, function, argument, argument1, argument2)); + send(p); + } + + /** + * calls a function with three arguments asynchronously threadsafe. for more see other asycCall + */ + 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) + { + CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ, Targ1&, Targ2&>(instance, function, argument, argument1, argument2)); + send(p); + } + + /** + * calls a function with three arguments asynchronously threadsafe. for more see other asycCall + */ + 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) + { + CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ&, Targ1&, Targ2&>(instance, function, argument, argument1, argument2)); + send(p); + } + + /** + * calls a function with three arguments asynchronously threadsafe. for more see other asycCall + */ + 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) + { + CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ&, Targ1&, Targ2>(instance, function, argument, argument1, argument2)); + send(p); + } + + /** + * calls a function with three arguments asynchronously threadsafe. for more see other asycCall + */ + 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) + { + CAmDelegagePtr p(new CAmThreeArgDelegate<TClass1, Targ&, Targ1, Targ2&>(instance, function, argument, argument1, argument2)); + send(p); + } + + /** * calls a function with four arguments asynchronously threadsafe. for more see other asycCall */ template<class TClass1, class Targ, class Targ1, class Targ2, class Targ3> @@ -836,7 +988,7 @@ public: 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... + //working with friend class here is not the finest of all programming stiles but it worCAmTwoArgDelegateks... retVal = p->returnResults(argument, argument1, argument2); delete p; } |