summaryrefslogtreecommitdiff
path: root/AudioManagerCore/src
diff options
context:
space:
mode:
Diffstat (limited to 'AudioManagerCore/src')
-rw-r--r--AudioManagerCore/src/CAmCommandReceiver.cpp173
-rw-r--r--AudioManagerCore/src/CAmCommandSender.cpp323
-rw-r--r--AudioManagerCore/src/CAmControlReceiver.cpp282
-rw-r--r--AudioManagerCore/src/CAmControlSender.cpp205
-rw-r--r--AudioManagerCore/src/CAmDatabaseHandlerMap.cpp3666
-rw-r--r--AudioManagerCore/src/CAmLog.cpp85
-rw-r--r--AudioManagerCore/src/CAmRouter.cpp1479
-rw-r--r--AudioManagerCore/src/CAmRoutingReceiver.cpp314
-rw-r--r--AudioManagerCore/src/CAmRoutingSender.cpp1250
9 files changed, 4093 insertions, 3684 deletions
diff --git a/AudioManagerCore/src/CAmCommandReceiver.cpp b/AudioManagerCore/src/CAmCommandReceiver.cpp
index 8b60c66..78d8cbe 100644
--- a/AudioManagerCore/src/CAmCommandReceiver.cpp
+++ b/AudioManagerCore/src/CAmCommandReceiver.cpp
@@ -29,152 +29,151 @@
#include "CAmDltWrapper.h"
#include "CAmSocketHandler.h"
-#define __METHOD_NAME__ std::string (std::string("CAmCommandReceiver::") + __func__)
+#define __METHOD_NAME__ std::string(std::string("CAmCommandReceiver::") + __func__)
namespace am
{
-CAmCommandReceiver::CAmCommandReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
- mDatabaseHandler(iDatabaseHandler),
- mControlSender(iControlSender),
- mDBusWrapper(NULL),
- mSocketHandler(iSocketHandler),
- handleCount(0),
- mListStartupHandles(),
- mListRundownHandles(),
- mWaitStartup(false),
- mWaitRundown(false),
- mLastErrorStartup(E_OK),
- mLastErrorRundown(E_OK)
-
-{
- assert(mDatabaseHandler!=NULL);
- assert(mSocketHandler!=NULL);
- assert(mControlSender!=NULL);
-}
-
-CAmCommandReceiver::CAmCommandReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
- mDatabaseHandler(iDatabaseHandler),
- mControlSender(iControlSender),
- mDBusWrapper(iDBusWrapper),
- mSocketHandler(iSocketHandler),
- handleCount(0),
- mListStartupHandles(),
- mListRundownHandles(),
- mWaitStartup(false),
- mWaitRundown(false),
- mLastErrorStartup(E_UNKNOWN),
- mLastErrorRundown(E_UNKNOWN)
-{
- assert(mDatabaseHandler!=NULL);
- assert(mSocketHandler!=NULL);
- assert(mControlSender!=NULL);
- assert(mDBusWrapper!=NULL);
+CAmCommandReceiver::CAmCommandReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler)
+ : mDatabaseHandler(iDatabaseHandler)
+ , mControlSender(iControlSender)
+ , mDBusWrapper(NULL)
+ , mSocketHandler(iSocketHandler)
+ , handleCount(0)
+ , mListStartupHandles()
+ , mListRundownHandles()
+ , mWaitStartup(false)
+ , mWaitRundown(false)
+ , mLastErrorStartup(E_OK)
+ , mLastErrorRundown(E_OK)
+{
+ assert(mDatabaseHandler != NULL);
+ assert(mSocketHandler != NULL);
+ assert(mControlSender != NULL);
+}
+
+CAmCommandReceiver::CAmCommandReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper)
+ : mDatabaseHandler(iDatabaseHandler)
+ , mControlSender(iControlSender)
+ , mDBusWrapper(iDBusWrapper)
+ , mSocketHandler(iSocketHandler)
+ , handleCount(0)
+ , mListStartupHandles()
+ , mListRundownHandles()
+ , mWaitStartup(false)
+ , mWaitRundown(false)
+ , mLastErrorStartup(E_UNKNOWN)
+ , mLastErrorRundown(E_UNKNOWN)
+{
+ assert(mDatabaseHandler != NULL);
+ assert(mSocketHandler != NULL);
+ assert(mControlSender != NULL);
+ assert(mDBusWrapper != NULL);
}
CAmCommandReceiver::~CAmCommandReceiver()
{
}
-am_Error_e CAmCommandReceiver::connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
+am_Error_e CAmCommandReceiver::connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t &mainConnectionID)
{
- logInfo(__METHOD_NAME__,"sourceID=", sourceID, "sinkID=", sinkID);
+ logInfo(__METHOD_NAME__, "sourceID=", sourceID, "sinkID=", sinkID);
return (mControlSender->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID));
}
am_Error_e CAmCommandReceiver::disconnect(const am_mainConnectionID_t mainConnectionID)
{
- logInfo(__METHOD_NAME__,"mainConnectionID=", mainConnectionID);
+ logInfo(__METHOD_NAME__, "mainConnectionID=", mainConnectionID);
return (mControlSender->hookUserDisconnectionRequest(mainConnectionID));
}
am_Error_e CAmCommandReceiver::setVolume(const am_sinkID_t sinkID, const am_mainVolume_t volume)
{
- logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volume=", volume);
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "volume=", volume);
return (mControlSender->hookUserVolumeChange(sinkID, volume));
}
am_Error_e CAmCommandReceiver::volumeStep(const am_sinkID_t sinkID, const int16_t volumeStep)
{
- logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volumeStep=", volumeStep);
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "volumeStep=", volumeStep);
return (mControlSender->hookUserVolumeStep(sinkID, volumeStep));
}
am_Error_e CAmCommandReceiver::setSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
{
- logInfo(__METHOD_NAME__,"sinkID=", sinkID, "muteState=", muteState);
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "muteState=", muteState);
return (mControlSender->hookUserSetSinkMuteState(sinkID, muteState));
}
-am_Error_e CAmCommandReceiver::setMainSinkSoundProperty(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+am_Error_e CAmCommandReceiver::setMainSinkSoundProperty(const am_MainSoundProperty_s &soundProperty, const am_sinkID_t sinkID)
{
- logInfo(__METHOD_NAME__,"sinkID=", sinkID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value);
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value);
return (mControlSender->hookUserSetMainSinkSoundProperty(sinkID, soundProperty));
}
-am_Error_e CAmCommandReceiver::setMainSourceSoundProperty(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+am_Error_e CAmCommandReceiver::setMainSourceSoundProperty(const am_MainSoundProperty_s &soundProperty, const am_sourceID_t sourceID)
{
- logInfo(__METHOD_NAME__,"sourceID=", sourceID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value);
+ logInfo(__METHOD_NAME__, "sourceID=", sourceID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value);
return (mControlSender->hookUserSetMainSourceSoundProperty(sourceID, soundProperty));
}
-am_Error_e CAmCommandReceiver::setSystemProperty(const am_SystemProperty_s & property)
+am_Error_e CAmCommandReceiver::setSystemProperty(const am_SystemProperty_s &property)
{
- logInfo(__METHOD_NAME__,"type=", property.type, "systemPropertyValue=", property.value);
+ logInfo(__METHOD_NAME__, "type=", property.type, "systemPropertyValue=", property.value);
return (mControlSender->hookUserSetSystemProperty(property));
}
-am_Error_e CAmCommandReceiver::getVolume(const am_sinkID_t sinkID, am_mainVolume_t& mainVolume) const
+am_Error_e CAmCommandReceiver::getVolume(const am_sinkID_t sinkID, am_mainVolume_t &mainVolume) const
{
return (mDatabaseHandler->getSinkMainVolume(sinkID, mainVolume));
}
-am_Error_e CAmCommandReceiver::getListMainConnections(std::vector<am_MainConnectionType_s> & listConnections) const
+am_Error_e CAmCommandReceiver::getListMainConnections(std::vector<am_MainConnectionType_s> &listConnections) const
{
return (mDatabaseHandler->getListVisibleMainConnections(listConnections));
}
-am_Error_e CAmCommandReceiver::getListMainSinks(std::vector<am_SinkType_s>& listMainSinks) const
+am_Error_e CAmCommandReceiver::getListMainSinks(std::vector<am_SinkType_s> &listMainSinks) const
{
return (mDatabaseHandler->getListMainSinks(listMainSinks));
}
-am_Error_e CAmCommandReceiver::getListMainSources(std::vector<am_SourceType_s>& listMainSources) const
+am_Error_e CAmCommandReceiver::getListMainSources(std::vector<am_SourceType_s> &listMainSources) const
{
return (mDatabaseHandler->getListMainSources(listMainSources));
}
-am_Error_e CAmCommandReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> & listSoundProperties) const
+am_Error_e CAmCommandReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> &listSoundProperties) const
{
return (mDatabaseHandler->getListMainSinkSoundProperties(sinkID, listSoundProperties));
}
-am_Error_e CAmCommandReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> & listSourceProperties) const
+am_Error_e CAmCommandReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> &listSourceProperties) const
{
return (mDatabaseHandler->getListMainSourceSoundProperties(sourceID, listSourceProperties));
}
-am_Error_e CAmCommandReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
+am_Error_e CAmCommandReceiver::getListSourceClasses(std::vector<am_SourceClass_s> &listSourceClasses) const
{
return (mDatabaseHandler->getListSourceClasses(listSourceClasses));
}
-am_Error_e CAmCommandReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
+am_Error_e CAmCommandReceiver::getListSinkClasses(std::vector<am_SinkClass_s> &listSinkClasses) const
{
return (mDatabaseHandler->getListSinkClasses(listSinkClasses));
}
-am_Error_e CAmCommandReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
+am_Error_e CAmCommandReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> &listSystemProperties) const
{
return (mDatabaseHandler->getListSystemProperties(listSystemProperties));
}
-am_Error_e CAmCommandReceiver::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const
+am_Error_e CAmCommandReceiver::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t &delay) const
{
return (mDatabaseHandler->getTimingInformation(mainConnectionID, delay));
}
-am_Error_e CAmCommandReceiver::getDBusConnectionWrapper(CAmDbusWrapper*& dbusConnectionWrapper) const
+am_Error_e CAmCommandReceiver::getDBusConnectionWrapper(CAmDbusWrapper * &dbusConnectionWrapper) const
{
#ifdef WITH_DBUS_WRAPPER
dbusConnectionWrapper = mDBusWrapper;
@@ -185,81 +184,91 @@ am_Error_e CAmCommandReceiver::getDBusConnectionWrapper(CAmDbusWrapper*& dbusCon
#endif /*WITH_DBUS_WRAPPER*/
}
-am_Error_e CAmCommandReceiver::getSocketHandler(CAmSocketHandler *& socketHandler) const
+am_Error_e CAmCommandReceiver::getSocketHandler(CAmSocketHandler * &socketHandler) const
{
socketHandler = mSocketHandler;
return (E_OK);
}
-void CAmCommandReceiver::getInterfaceVersion(std::string & version) const
+void CAmCommandReceiver::getInterfaceVersion(std::string &version) const
{
version = CommandVersion;
}
void CAmCommandReceiver::confirmCommandReady(const uint16_t handle, const am_Error_e error)
{
- if (error !=E_OK)
- mLastErrorStartup=error;
+ if (error != E_OK)
+ {
+ mLastErrorStartup = error;
+ }
+
mListStartupHandles.erase(std::remove(mListStartupHandles.begin(), mListStartupHandles.end(), handle), mListStartupHandles.end());
if (mWaitStartup && mListStartupHandles.empty())
+ {
mControlSender->confirmCommandReady(mLastErrorStartup);
+ }
}
void CAmCommandReceiver::confirmCommandRundown(const uint16_t handle, const am_Error_e error)
{
- if (error !=E_OK)
- mLastErrorRundown=error;
+ if (error != E_OK)
+ {
+ mLastErrorRundown = error;
+ }
+
mListRundownHandles.erase(std::remove(mListRundownHandles.begin(), mListRundownHandles.end(), handle), mListRundownHandles.end());
if (mWaitRundown && mListRundownHandles.empty())
+ {
mControlSender->confirmCommandRundown(mLastErrorRundown);
+ }
}
uint16_t CAmCommandReceiver::getStartupHandle()
{
- uint16_t handle = ++handleCount; //todo: handle overflow
+ uint16_t handle = ++handleCount; // todo: handle overflow
mListStartupHandles.push_back(handle);
return (handle);
}
uint16_t CAmCommandReceiver::getRundownHandle()
{
- uint16_t handle = ++handleCount; //todo: handle overflow
+ uint16_t handle = ++handleCount; // todo: handle overflow
mListRundownHandles.push_back(handle);
return (handle);
}
void CAmCommandReceiver::waitOnStartup(bool startup)
{
- mWaitStartup = startup;
- mLastErrorStartup=E_OK;
+ mWaitStartup = startup;
+ mLastErrorStartup = E_OK;
}
-am_Error_e CAmCommandReceiver::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations) const
+am_Error_e CAmCommandReceiver::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector<am_NotificationConfiguration_s> &listMainNotificationConfigurations) const
{
- return (mDatabaseHandler->getListMainSinkNotificationConfigurations(sinkID,listMainNotificationConfigurations));
+ return (mDatabaseHandler->getListMainSinkNotificationConfigurations(sinkID, listMainNotificationConfigurations));
}
-am_Error_e CAmCommandReceiver::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations) const
+am_Error_e CAmCommandReceiver::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector<am_NotificationConfiguration_s> &listMainNotificationConfigurations) const
{
- return (mDatabaseHandler->getListMainSourceNotificationConfigurations(sourceID,listMainNotificationConfigurations));
+ return (mDatabaseHandler->getListMainSourceNotificationConfigurations(sourceID, listMainNotificationConfigurations));
}
-am_Error_e CAmCommandReceiver::setMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
+am_Error_e CAmCommandReceiver::setMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &mainNotificationConfiguration)
{
- logInfo(__METHOD_NAME__,"sinkID=", sinkID, " type=",mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=",mainNotificationConfiguration.status);
- return (mControlSender->hookUserSetMainSinkNotificationConfiguration(sinkID,mainNotificationConfiguration));
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, " type=", mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=", mainNotificationConfiguration.status);
+ return (mControlSender->hookUserSetMainSinkNotificationConfiguration(sinkID, mainNotificationConfiguration));
}
-am_Error_e CAmCommandReceiver::setMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
+am_Error_e CAmCommandReceiver::setMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &mainNotificationConfiguration)
{
- logInfo(__METHOD_NAME__,"sourceID=", sourceID, " type=",mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=",mainNotificationConfiguration.status);
- return (mControlSender->hookUserSetMainSourceNotificationConfiguration(sourceID,mainNotificationConfiguration));
+ logInfo(__METHOD_NAME__, "sourceID=", sourceID, " type=", mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=", mainNotificationConfiguration.status);
+ return (mControlSender->hookUserSetMainSourceNotificationConfiguration(sourceID, mainNotificationConfiguration));
}
void CAmCommandReceiver::waitOnRundown(bool rundown)
{
- mWaitRundown = rundown;
- mLastErrorStartup=E_OK;
+ mWaitRundown = rundown;
+ mLastErrorStartup = E_OK;
}
}
diff --git a/AudioManagerCore/src/CAmCommandSender.cpp b/AudioManagerCore/src/CAmCommandSender.cpp
index 1a61883..d1a4a22 100644
--- a/AudioManagerCore/src/CAmCommandSender.cpp
+++ b/AudioManagerCore/src/CAmCommandSender.cpp
@@ -35,7 +35,7 @@
#include "CAmDltWrapper.h"
#include "audiomanagerconfig.h"
-#define __METHOD_NAME__ std::string (std::string("CAmCommandSender::") + __func__)
+#define __METHOD_NAME__ std::string(std::string("CAmCommandSender::") + __func__)
namespace am
{
@@ -43,135 +43,143 @@ namespace am
/**
* macro to call all interfaces
*/
-#define CALL_ALL_INTERFACES(...) \
- std::vector<IAmCommandSend*>::iterator iter = mListInterfaces.begin(); \
- std::vector<IAmCommandSend*>::iterator iterEnd = mListInterfaces.end(); \
- for (; iter<iterEnd;++iter) \
- { \
- (*iter)->__VA_ARGS__; \
- }
-
-CAmCommandSender::CAmCommandSender(const std::vector<std::string>& listOfPluginDirectories, CAmSocketHandler *iSocketHandler) :
- CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks(),
- mListInterfaces(),
- mListLibraryHandles(),
- mListLibraryNames(),
- mCommandReceiver(),
- mSerializer(iSocketHandler)
+#define CALL_ALL_INTERFACES(...) \
+ std::vector<IAmCommandSend *>::iterator iter = mListInterfaces.begin(); \
+ std::vector<IAmCommandSend *>::iterator iterEnd = mListInterfaces.end(); \
+ for (; iter < iterEnd; ++iter) \
+ { \
+ (*iter)->__VA_ARGS__; \
+ }
+
+CAmCommandSender::CAmCommandSender(const std::vector<std::string> &listOfPluginDirectories, CAmSocketHandler *iSocketHandler)
+ : CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks()
+ , mListInterfaces()
+ , mListLibraryHandles()
+ , mListLibraryNames()
+ , mCommandReceiver()
+ , mSerializer(iSocketHandler)
{
loadPlugins(listOfPluginDirectories);
- dboNewMainConnection = [&](const am_MainConnectionType_s& mainConnection) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbNewMainConnection, mainConnection);
- };
+ dboNewMainConnection = [&](const am_MainConnectionType_s &mainConnection) {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbNewMainConnection, mainConnection);
+ };
dboRemovedMainConnection = [&](const am_mainConnectionID_t mainConnection) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedMainConnection, mainConnection);
- };
- dboNewSink = [&](const am_Sink_s& sink) {
- if (sink.visible)
- {
- am_SinkType_s s;
- s.availability = sink.available;
- s.muteState = sink.muteState;
- s.name = sink.name;
- s.sinkClassID = sink.sinkClassID;
- s.sinkID = sink.sinkID;
- s.volume = sink.mainVolume;
- typedef void(CAmCommandSender::*TMeth)(am::am_SinkType_s);
- mSerializer.asyncCall<CAmCommandSender, TMeth, am::am_SinkType_s>(this, &CAmCommandSender::cbNewSink, s);
- }
- };
- dboNewSource = [&](const am_Source_s& source) {
- if (source.visible)
- {
- am_SourceType_s s;
- s.availability = source.available;
- s.name = source.name;
- s.sourceClassID = source.sourceClassID;
- s.sourceID = source.sourceID;
- typedef void(CAmCommandSender::*TMeth)(am::am_SourceType_s);
- mSerializer.asyncCall<CAmCommandSender, TMeth, am::am_SourceType_s>(this, &CAmCommandSender::cbNewSource, s);
- }
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedMainConnection, mainConnection);
+ };
+ dboNewSink = [&](const am_Sink_s &sink) {
+ if (sink.visible)
+ {
+ am_SinkType_s s;
+ s.availability = sink.available;
+ s.muteState = sink.muteState;
+ s.name = sink.name;
+ s.sinkClassID = sink.sinkClassID;
+ s.sinkID = sink.sinkID;
+ s.volume = sink.mainVolume;
+ typedef void (CAmCommandSender::*TMeth)(am::am_SinkType_s);
+ mSerializer.asyncCall<CAmCommandSender, TMeth, am::am_SinkType_s>(this, &CAmCommandSender::cbNewSink, s);
+ }
+ };
+ dboNewSource = [&](const am_Source_s &source) {
+ if (source.visible)
+ {
+ am_SourceType_s s;
+ s.availability = source.available;
+ s.name = source.name;
+ s.sourceClassID = source.sourceClassID;
+ s.sourceID = source.sourceID;
+ typedef void (CAmCommandSender::*TMeth)(am::am_SourceType_s);
+ mSerializer.asyncCall<CAmCommandSender, TMeth, am::am_SourceType_s>(this, &CAmCommandSender::cbNewSource, s);
+ }
+ };
dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible) {
- if (visible)
- mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedSink, sinkID);
- };
+ if (visible)
+ {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedSink, sinkID);
+ }
+ };
dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible) {
- if (visible)
- mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedSource, sourceID);
- };
+ if (visible)
+ {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedSource, sourceID);
+ }
+ };
dboNumberOfSinkClassesChanged = [&]() {
- mSerializer.asyncCall(this, &CAmCommandSender::cbNumberOfSinkClassesChanged);
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbNumberOfSinkClassesChanged);
+ };
dboNumberOfSourceClassesChanged = [&]() {
- mSerializer.asyncCall(this, &CAmCommandSender::cbNumberOfSourceClassesChanged);
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbNumberOfSourceClassesChanged);
+ };
dboMainConnectionStateChanged = [&](const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbMainConnectionStateChanged, connectionID, connectionState);
- };
- dboMainSinkSoundPropertyChanged = [&](const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty);
- };
- dboMainSourceSoundPropertyChanged = [&](const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty);
- };
- dboSinkAvailabilityChanged = [&](const am_sinkID_t sinkID, const am_Availability_s & availability) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbSinkAvailabilityChanged, sinkID, availability);
- };
- dboSourceAvailabilityChanged = [&](const am_sourceID_t sourceID, const am_Availability_s & availability) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbSourceAvailabilityChanged, sourceID, availability);
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbMainConnectionStateChanged, connectionID, connectionState);
+ };
+ dboMainSinkSoundPropertyChanged = [&](const am_sinkID_t sinkID, const am_MainSoundProperty_s &SoundProperty) {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty);
+ };
+ dboMainSourceSoundPropertyChanged = [&](const am_sourceID_t sourceID, const am_MainSoundProperty_s &SoundProperty) {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty);
+ };
+ dboSinkAvailabilityChanged = [&](const am_sinkID_t sinkID, const am_Availability_s &availability) {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbSinkAvailabilityChanged, sinkID, availability);
+ };
+ dboSourceAvailabilityChanged = [&](const am_sourceID_t sourceID, const am_Availability_s &availability) {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbSourceAvailabilityChanged, sourceID, availability);
+ };
dboVolumeChanged = [&](const am_sinkID_t sinkID, const am_mainVolume_t volume) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbVolumeChanged, sinkID, volume);
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbVolumeChanged, sinkID, volume);
+ };
dboSinkMuteStateChanged = [&](const am_sinkID_t sinkID, const am_MuteState_e muteState) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbSinkMuteStateChanged, sinkID, muteState);
- };
- dboSystemPropertyChanged = [&](const am_SystemProperty_s& SystemProperty) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbSystemPropertyChanged, SystemProperty);
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbSinkMuteStateChanged, sinkID, muteState);
+ };
+ dboSystemPropertyChanged = [&](const am_SystemProperty_s &SystemProperty) {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbSystemPropertyChanged, SystemProperty);
+ };
dboTimingInformationChanged = [&](const am_mainConnectionID_t mainConnection, const am_timeSync_t time) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbTimingInformationChanged, mainConnection, time);
- };
- dboSinkUpdated = [&](const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties, const bool visible) {
- if (visible)
- mSerializer.asyncCall(this, &CAmCommandSender::cbSinkUpdated, sinkID, sinkClassID, listMainSoundProperties);
- };
- dboSourceUpdated = [&](const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties, const bool visible) {
- if (visible)
- mSerializer.asyncCall(this, &CAmCommandSender::cbSinkUpdated, sourceID, sourceClassID, listMainSoundProperties);
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbTimingInformationChanged, mainConnection, time);
+ };
+ dboSinkUpdated = [&](const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties, const bool visible) {
+ if (visible)
+ {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbSinkUpdated, sinkID, sinkClassID, listMainSoundProperties);
+ }
+ };
+ dboSourceUpdated = [&](const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties, const bool visible) {
+ if (visible)
+ {
+ mSerializer.asyncCall(this, &CAmCommandSender::cbSinkUpdated, sourceID, sourceClassID, listMainSoundProperties);
+ }
+ };
dboSinkMainNotificationConfigurationChanged = [&](const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbSinkMainNotificationConfigurationChanged, sinkID, mainNotificationConfiguration);
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbSinkMainNotificationConfigurationChanged, sinkID, mainNotificationConfiguration);
+ };
dboSourceMainNotificationConfigurationChanged = [&](const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration) {
- mSerializer.asyncCall(this, &CAmCommandSender::cbSourceMainNotificationConfigurationChanged, sourceID, mainNotificationConfiguration);
- };
+ mSerializer.asyncCall(this, &CAmCommandSender::cbSourceMainNotificationConfigurationChanged, sourceID, mainNotificationConfiguration);
+ };
}
-void CAmCommandSender::loadPlugins(const std::vector<std::string>& listOfPluginDirectories)
+void CAmCommandSender::loadPlugins(const std::vector<std::string> &listOfPluginDirectories)
{
if (listOfPluginDirectories.empty())
{
- logError(__METHOD_NAME__,"List of commandplugins is empty");
+ logError(__METHOD_NAME__, "List of commandplugins is empty");
}
- std::vector<std::string> sharedLibraryNameList;
- std::vector<std::string>::const_iterator dirIter = listOfPluginDirectories.begin();
+ std::vector<std::string> sharedLibraryNameList;
+ std::vector<std::string>::const_iterator dirIter = listOfPluginDirectories.begin();
std::vector<std::string>::const_iterator dirIterEnd = listOfPluginDirectories.end();
// search communicator plugins in configured directories
for (; dirIter < dirIterEnd; ++dirIter)
{
- const char* directoryName = dirIter->c_str();
- logInfo(__METHOD_NAME__,"Searching for CommandPlugins in", *dirIter);
+ const char *directoryName = dirIter->c_str();
+ logInfo(__METHOD_NAME__, "Searching for CommandPlugins in", *dirIter);
DIR *directory = opendir(directoryName);
if (!directory)
{
- logError(__METHOD_NAME__,"Error opening directory ", *dirIter);
+ logError(__METHOD_NAME__, "Error opening directory ", *dirIter);
continue;
}
@@ -180,10 +188,10 @@ void CAmCommandSender::loadPlugins(const std::vector<std::string>& listOfPluginD
while ((itemInDirectory = readdir(directory)))
{
unsigned char entryType = itemInDirectory->d_type;
- std::string entryName = itemInDirectory->d_name;
- std::string fullName = *dirIter + "/" + entryName;
+ std::string entryName = itemInDirectory->d_name;
+ std::string fullName = *dirIter + "/" + entryName;
- bool regularFile = (entryType == DT_REG || entryType == DT_LNK);
+ bool regularFile = (entryType == DT_REG || entryType == DT_LNK);
bool sharedLibExtension = ("so" == entryName.substr(entryName.find_last_of(".") + 1));
// Handle cases where readdir() could not determine the file type
@@ -193,7 +201,7 @@ void CAmCommandSender::loadPlugins(const std::vector<std::string>& listOfPluginD
if (stat(fullName.c_str(), &buf))
{
- logInfo(__METHOD_NAME__,"Failed to stat file: ", entryName, errno);
+ logInfo(__METHOD_NAME__, "Failed to stat file: ", entryName, errno);
continue;
}
@@ -206,36 +214,37 @@ void CAmCommandSender::loadPlugins(const std::vector<std::string>& listOfPluginD
sharedLibraryNameList.push_back(name + "/" + entryName);
}
}
+
closedir(directory);
}
// iterate all communicator plugins and start them
- std::vector<std::string>::iterator iter = sharedLibraryNameList.begin();
+ std::vector<std::string>::iterator iter = sharedLibraryNameList.begin();
std::vector<std::string>::iterator iterEnd = sharedLibraryNameList.end();
for (; iter < iterEnd; ++iter)
{
- logInfo(__METHOD_NAME__,"Loading CommandSender plugin", *iter);
- IAmCommandSend* (*createFunc)();
- void* tempLibHandle = NULL;
- createFunc = getCreateFunction<IAmCommandSend*()>(*iter, tempLibHandle);
+ logInfo(__METHOD_NAME__, "Loading CommandSender plugin", *iter);
+ IAmCommandSend *(*createFunc)();
+ void *tempLibHandle = NULL;
+ createFunc = getCreateFunction<IAmCommandSend *()>(*iter, tempLibHandle);
if (!createFunc)
{
- logInfo(__METHOD_NAME__,"Entry point of CommandPlugin not found", *iter);
+ logInfo(__METHOD_NAME__, "Entry point of CommandPlugin not found", *iter);
continue;
}
- IAmCommandSend* commander = createFunc();
+ IAmCommandSend *commander = createFunc();
if (!commander)
{
- logInfo(__METHOD_NAME__,"CommandPlugin initialization failed. Entry Function not callable");
+ logInfo(__METHOD_NAME__, "CommandPlugin initialization failed. Entry Function not callable");
dlclose(tempLibHandle);
continue;
}
- //check libversion
+ // check libversion
std::string version, cVersion(CommandVersion);
commander->getInterfaceVersion(version);
uint16_t minorVersion, majorVersion, cMinorVersion, cMajorVersion;
@@ -246,7 +255,7 @@ void CAmCommandSender::loadPlugins(const std::vector<std::string>& listOfPluginD
if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion > cMinorVersion)))
{
- logError(__METHOD_NAME__,"CommandInterface initialization failed. Version of Interface to old");
+ logError(__METHOD_NAME__, "CommandInterface initialization failed. Version of Interface to old");
dlclose(tempLibHandle);
continue;
}
@@ -259,7 +268,7 @@ void CAmCommandSender::loadPlugins(const std::vector<std::string>& listOfPluginD
CAmCommandSender::~CAmCommandSender()
{
- //unloadLibraries();
+ // unloadLibraries();
}
am_Error_e CAmCommandSender::startupInterfaces(CAmCommandReceiver *iCommandReceiver)
@@ -267,8 +276,8 @@ am_Error_e CAmCommandSender::startupInterfaces(CAmCommandReceiver *iCommandRecei
mCommandReceiver = iCommandReceiver;
am_Error_e returnError = E_OK;
- std::vector<IAmCommandSend*>::iterator iter = mListInterfaces.begin();
- std::vector<IAmCommandSend*>::iterator iterEnd = mListInterfaces.end();
+ std::vector<IAmCommandSend *>::iterator iter = mListInterfaces.begin();
+ std::vector<IAmCommandSend *>::iterator iterEnd = mListInterfaces.end();
for (; iter < iterEnd; ++iter)
{
am_Error_e error = (*iter)->startupInterface(iCommandReceiver);
@@ -277,6 +286,7 @@ am_Error_e CAmCommandSender::startupInterfaces(CAmCommandReceiver *iCommandRecei
returnError = error;
}
}
+
return (returnError);
}
@@ -292,47 +302,47 @@ void CAmCommandSender::cbNumberOfSourceClassesChanged()
void CAmCommandSender::cbMainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
{
- CALL_ALL_INTERFACES(cbMainConnectionStateChanged(connectionID,connectionState))
+ CALL_ALL_INTERFACES(cbMainConnectionStateChanged(connectionID, connectionState))
}
-void CAmCommandSender::cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)
+void CAmCommandSender::cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s &SoundProperty)
{
- CALL_ALL_INTERFACES(cbMainSinkSoundPropertyChanged(sinkID,SoundProperty))
+ CALL_ALL_INTERFACES(cbMainSinkSoundPropertyChanged(sinkID, SoundProperty))
}
-void CAmCommandSender::cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty)
+void CAmCommandSender::cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s &SoundProperty)
{
- CALL_ALL_INTERFACES(cbMainSourceSoundPropertyChanged(sourceID,SoundProperty))
+ CALL_ALL_INTERFACES(cbMainSourceSoundPropertyChanged(sourceID, SoundProperty))
}
-void CAmCommandSender::cbSinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability)
+void CAmCommandSender::cbSinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s &availability)
{
- CALL_ALL_INTERFACES(cbSinkAvailabilityChanged(sinkID,availability))
+ CALL_ALL_INTERFACES(cbSinkAvailabilityChanged(sinkID, availability))
}
-void CAmCommandSender::cbSourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability)
+void CAmCommandSender::cbSourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s &availability)
{
- CALL_ALL_INTERFACES(cbSourceAvailabilityChanged(sourceID,availability))
+ CALL_ALL_INTERFACES(cbSourceAvailabilityChanged(sourceID, availability))
}
void CAmCommandSender::cbVolumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume)
{
- CALL_ALL_INTERFACES(cbVolumeChanged(sinkID,volume))
+ CALL_ALL_INTERFACES(cbVolumeChanged(sinkID, volume))
}
void CAmCommandSender::cbSinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState)
{
- CALL_ALL_INTERFACES(cbSinkMuteStateChanged(sinkID,muteState))
+ CALL_ALL_INTERFACES(cbSinkMuteStateChanged(sinkID, muteState))
}
-void CAmCommandSender::cbSystemPropertyChanged(const am_SystemProperty_s & SystemProperty)
+void CAmCommandSender::cbSystemPropertyChanged(const am_SystemProperty_s &SystemProperty)
{
CALL_ALL_INTERFACES(cbSystemPropertyChanged(SystemProperty))
}
void CAmCommandSender::cbTimingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
{
- CALL_ALL_INTERFACES(cbTimingInformationChanged(mainConnection,time))
+ CALL_ALL_INTERFACES(cbTimingInformationChanged(mainConnection, time))
}
void CAmCommandSender::cbNewMainConnection(const am_MainConnectionType_s mainConnection)
@@ -369,20 +379,20 @@ void CAmCommandSender::setCommandReady()
{
mCommandReceiver->waitOnStartup(false);
- //create a list of handles
+ // create a list of handles
std::vector<uint16_t> listStartupHandles;
for (size_t i = 0; i < mListInterfaces.size(); i++)
{
listStartupHandles.push_back(mCommandReceiver->getStartupHandle());
}
- //set the receiver ready to wait for replies
+ // set the receiver ready to wait for replies
mCommandReceiver->waitOnStartup(true);
- //now do the calls
- std::vector<IAmCommandSend*>::iterator iter = mListInterfaces.begin();
- std::vector<IAmCommandSend*>::iterator iterEnd = mListInterfaces.end();
- std::vector<uint16_t>::const_iterator handleIter(listStartupHandles.begin());
+ // now do the calls
+ std::vector<IAmCommandSend *>::iterator iter = mListInterfaces.begin();
+ std::vector<IAmCommandSend *>::iterator iterEnd = mListInterfaces.end();
+ std::vector<uint16_t>::const_iterator handleIter(listStartupHandles.begin());
for (; iter < iterEnd; ++iter)
{
(*iter)->setCommandReady(*(handleIter++));
@@ -392,74 +402,75 @@ void CAmCommandSender::setCommandReady()
void CAmCommandSender::setCommandRundown()
{
mCommandReceiver->waitOnRundown(false);
- //create a list of handles
+ // create a list of handles
std::vector<uint16_t> listStartupHandles;
for (size_t i = 0; i < mListInterfaces.size(); i++)
{
listStartupHandles.push_back(mCommandReceiver->getRundownHandle());
}
- //set the receiver ready to wait for replies
+ // set the receiver ready to wait for replies
mCommandReceiver->waitOnRundown(true);
- //now do the calls
- std::vector<IAmCommandSend*>::iterator iter = mListInterfaces.begin();
- std::vector<IAmCommandSend*>::iterator iterEnd = mListInterfaces.end();
- std::vector<uint16_t>::const_iterator handleIter(listStartupHandles.begin());
+ // now do the calls
+ std::vector<IAmCommandSend *>::iterator iter = mListInterfaces.begin();
+ std::vector<IAmCommandSend *>::iterator iterEnd = mListInterfaces.end();
+ std::vector<uint16_t>::const_iterator handleIter(listStartupHandles.begin());
for (; iter < iterEnd; ++iter)
{
(*iter)->setCommandRundown(*(handleIter++));
}
}
-void CAmCommandSender::getInterfaceVersion(std::string & version) const
+void CAmCommandSender::getInterfaceVersion(std::string &version) const
{
version = CommandVersion;
}
-am_Error_e am::CAmCommandSender::getListPlugins(std::vector<std::string> & interfaces) const
+am_Error_e am::CAmCommandSender::getListPlugins(std::vector<std::string> &interfaces) const
{
interfaces = mListLibraryNames;
return (E_OK);
}
-void CAmCommandSender::cbSinkUpdated(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+void CAmCommandSender::cbSinkUpdated(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
- CALL_ALL_INTERFACES(cbSinkUpdated(sinkID,sinkClassID,listMainSoundProperties));
+ CALL_ALL_INTERFACES(cbSinkUpdated(sinkID, sinkClassID, listMainSoundProperties));
}
-void CAmCommandSender::cbSourceUpdated(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+void CAmCommandSender::cbSourceUpdated(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
- CALL_ALL_INTERFACES(cbSourceUpdated(sourceID,sourceClassID,listMainSoundProperties));
+ CALL_ALL_INTERFACES(cbSourceUpdated(sourceID, sourceClassID, listMainSoundProperties));
}
-void CAmCommandSender::cbSinkNotification(const am_sinkID_t sinkID, const am_NotificationPayload_s& notification)
+void CAmCommandSender::cbSinkNotification(const am_sinkID_t sinkID, const am_NotificationPayload_s &notification)
{
- CALL_ALL_INTERFACES(cbSinkNotification(sinkID,notification));
+ CALL_ALL_INTERFACES(cbSinkNotification(sinkID, notification));
}
-void CAmCommandSender::cbSourceNotification(const am_sourceID_t sourceID, const am_NotificationPayload_s& notification)
+void CAmCommandSender::cbSourceNotification(const am_sourceID_t sourceID, const am_NotificationPayload_s &notification)
{
- CALL_ALL_INTERFACES(cbSourceNotification(sourceID,notification));
+ CALL_ALL_INTERFACES(cbSourceNotification(sourceID, notification));
}
-void CAmCommandSender::cbSinkMainNotificationConfigurationChanged(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
+void CAmCommandSender::cbSinkMainNotificationConfigurationChanged(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &mainNotificationConfiguration)
{
- CALL_ALL_INTERFACES(cbMainSinkNotificationConfigurationChanged(sinkID,mainNotificationConfiguration));
+ CALL_ALL_INTERFACES(cbMainSinkNotificationConfigurationChanged(sinkID, mainNotificationConfiguration));
}
-void CAmCommandSender::cbSourceMainNotificationConfigurationChanged(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
+void CAmCommandSender::cbSourceMainNotificationConfigurationChanged(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &mainNotificationConfiguration)
{
- CALL_ALL_INTERFACES(cbMainSourceNotificationConfigurationChanged(sourceID,mainNotificationConfiguration));
+ CALL_ALL_INTERFACES(cbMainSourceNotificationConfigurationChanged(sourceID, mainNotificationConfiguration));
}
void CAmCommandSender::unloadLibraries(void)
{
- std::vector<void*>::iterator iterator = mListLibraryHandles.begin();
+ std::vector<void *>::iterator iterator = mListLibraryHandles.begin();
for (; iterator < mListLibraryHandles.end(); ++iterator)
{
dlclose(*iterator);
}
+
mListLibraryHandles.clear();
}
diff --git a/AudioManagerCore/src/CAmControlReceiver.cpp b/AudioManagerCore/src/CAmControlReceiver.cpp
index 3280c04..6fec509 100644
--- a/AudioManagerCore/src/CAmControlReceiver.cpp
+++ b/AudioManagerCore/src/CAmControlReceiver.cpp
@@ -35,78 +35,78 @@
namespace am {
-#define __METHOD_NAME__ std::string (std::string("CAmControlReceiver::") + __func__)
+#define __METHOD_NAME__ std::string(std::string("CAmControlReceiver::") + __func__)
-CAmControlReceiver::CAmControlReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter) :
- mDatabaseHandler(iDatabaseHandler),
- mRoutingSender(iRoutingSender),
- mCommandSender(iCommandSender),
- mSocketHandler(iSocketHandler),
- mRouter(iRouter),
- mNodeStateCommunicator(NULL)
+CAmControlReceiver::CAmControlReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter *iRouter)
+ : mDatabaseHandler(iDatabaseHandler)
+ , mRoutingSender(iRoutingSender)
+ , mCommandSender(iCommandSender)
+ , mSocketHandler(iSocketHandler)
+ , mRouter(iRouter)
+ , mNodeStateCommunicator(NULL)
{
- assert(mDatabaseHandler!=NULL);
- assert(mRoutingSender!=NULL);
- assert(mCommandSender!=NULL);
- assert(mSocketHandler!=NULL);
- assert(mRouter!=NULL);
+ assert(mDatabaseHandler != NULL);
+ assert(mRoutingSender != NULL);
+ assert(mCommandSender != NULL);
+ assert(mSocketHandler != NULL);
+ assert(mRouter != NULL);
}
CAmControlReceiver::~CAmControlReceiver()
{
}
-am_Error_e CAmControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
+am_Error_e CAmControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> &returnList)
{
return (mRouter->getRoute(onlyfree, sourceID, sinkID, returnList));
}
-am_Error_e CAmControlReceiver::connect(am_Handle_s & handle, am_connectionID_t & connectionID, const am_CustomConnectionFormat_t format, const am_sourceID_t sourceID, const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::connect(am_Handle_s &handle, am_connectionID_t &connectionID, const am_CustomConnectionFormat_t format, const am_sourceID_t sourceID, const am_sinkID_t sinkID)
{
- return (mRoutingSender->asyncConnect(handle, connectionID, sourceID, sinkID, format));
+ return (mRoutingSender->asyncConnect(handle, connectionID, sourceID, sinkID, format));
}
-am_Error_e CAmControlReceiver::disconnect(am_Handle_s & handle, const am_connectionID_t connectionID)
+am_Error_e CAmControlReceiver::disconnect(am_Handle_s &handle, const am_connectionID_t connectionID)
{
return (mRoutingSender->asyncDisconnect(handle, connectionID));
}
-am_Error_e CAmControlReceiver::crossfade(am_Handle_s & handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_CustomRampType_t rampType, const am_time_t rampTime)
+am_Error_e CAmControlReceiver::crossfade(am_Handle_s &handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_CustomRampType_t rampType, const am_time_t rampTime)
{
return (mRoutingSender->asyncCrossFade(handle, crossfaderID, hotSource, rampType, rampTime));
}
-am_Error_e CAmControlReceiver::setSourceState(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SourceState_e state)
+am_Error_e CAmControlReceiver::setSourceState(am_Handle_s &handle, const am_sourceID_t sourceID, const am_SourceState_e state)
{
return (mRoutingSender->asyncSetSourceState(handle, sourceID, state));
}
-am_Error_e CAmControlReceiver::setSinkVolume(am_Handle_s & handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time)
+am_Error_e CAmControlReceiver::setSinkVolume(am_Handle_s &handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time)
{
return (mRoutingSender->asyncSetSinkVolume(handle, sinkID, volume, ramp, time));
}
-am_Error_e CAmControlReceiver::setSourceVolume(am_Handle_s & handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_CustomRampType_t rampType, const am_time_t time)
+am_Error_e CAmControlReceiver::setSourceVolume(am_Handle_s &handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_CustomRampType_t rampType, const am_time_t time)
{
return (mRoutingSender->asyncSetSourceVolume(handle, sourceID, volume, rampType, time));
}
-am_Error_e CAmControlReceiver::setSinkSoundProperty(am_Handle_s & handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
+am_Error_e CAmControlReceiver::setSinkSoundProperty(am_Handle_s &handle, const am_sinkID_t sinkID, const am_SoundProperty_s &soundProperty)
{
return (mRoutingSender->asyncSetSinkSoundProperty(handle, sinkID, soundProperty));
}
-am_Error_e CAmControlReceiver::setSinkSoundProperties(am_Handle_s & handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s> & listSoundProperties)
+am_Error_e CAmControlReceiver::setSinkSoundProperties(am_Handle_s &handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s> &listSoundProperties)
{
return (mRoutingSender->asyncSetSinkSoundProperties(handle, listSoundProperties, sinkID));
}
-am_Error_e CAmControlReceiver::setSourceSoundProperty(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
+am_Error_e CAmControlReceiver::setSourceSoundProperty(am_Handle_s &handle, const am_sourceID_t sourceID, const am_SoundProperty_s &soundProperty)
{
return (mRoutingSender->asyncSetSourceSoundProperty(handle, sourceID, soundProperty));
}
-am_Error_e CAmControlReceiver::setSourceSoundProperties(am_Handle_s & handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s> & listSoundProperties)
+am_Error_e CAmControlReceiver::setSourceSoundProperties(am_Handle_s &handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s> &listSoundProperties)
{
return (mRoutingSender->asyncSetSourceSoundProperties(handle, listSoundProperties, sourceID));
}
@@ -121,57 +121,57 @@ am_Error_e CAmControlReceiver::abortAction(const am_Handle_s handle)
return (mRoutingSender->asyncAbort(handle));
}
-am_Error_e CAmControlReceiver::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
+am_Error_e CAmControlReceiver::enterDomainDB(const am_Domain_s &domainData, am_domainID_t &domainID)
{
return (mDatabaseHandler->enterDomainDB(domainData, domainID));
}
-am_Error_e CAmControlReceiver::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
+am_Error_e CAmControlReceiver::enterMainConnectionDB(const am_MainConnection_s &mainConnectionData, am_mainConnectionID_t &connectionID)
{
return (mDatabaseHandler->enterMainConnectionDB(mainConnectionData, connectionID));
}
-am_Error_e CAmControlReceiver::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+am_Error_e CAmControlReceiver::enterSinkDB(const am_Sink_s &sinkData, am_sinkID_t &sinkID)
{
return (mDatabaseHandler->enterSinkDB(sinkData, sinkID));
}
-am_Error_e CAmControlReceiver::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+am_Error_e CAmControlReceiver::enterCrossfaderDB(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID)
{
return (mDatabaseHandler->enterCrossfaderDB(crossfaderData, crossfaderID));
}
-am_Error_e CAmControlReceiver::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+am_Error_e CAmControlReceiver::enterGatewayDB(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID)
{
return (mDatabaseHandler->enterGatewayDB(gatewayData, gatewayID));
}
-am_Error_e CAmControlReceiver::enterConverterDB(const am_Converter_s & converterData, am_converterID_t & converterID)
+am_Error_e CAmControlReceiver::enterConverterDB(const am_Converter_s &converterData, am_converterID_t &converterID)
{
return (mDatabaseHandler->enterConverterDB(converterData, converterID));
}
-am_Error_e CAmControlReceiver::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+am_Error_e CAmControlReceiver::enterSourceDB(const am_Source_s &sourceData, am_sourceID_t &sourceID)
{
return (mDatabaseHandler->enterSourceDB(sourceData, sourceID));
}
-am_Error_e CAmControlReceiver::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
+am_Error_e CAmControlReceiver::enterSinkClassDB(const am_SinkClass_s &sinkClass, am_sinkClass_t &sinkClassID)
{
return (mDatabaseHandler->enterSinkClassDB(sinkClass, sinkClassID));
}
-am_Error_e CAmControlReceiver::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
+am_Error_e CAmControlReceiver::enterSourceClassDB(am_sourceClass_t &sourceClassID, const am_SourceClass_s &sourceClass)
{
return (mDatabaseHandler->enterSourceClassDB(sourceClassID, sourceClass));
}
-am_Error_e CAmControlReceiver::enterSystemPropertiesListDB(const std::vector<am_SystemProperty_s> & listSystemProperties)
+am_Error_e CAmControlReceiver::enterSystemPropertiesListDB(const std::vector<am_SystemProperty_s> &listSystemProperties)
{
return (mDatabaseHandler->enterSystemProperties(listSystemProperties));
}
-am_Error_e CAmControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID)
+am_Error_e CAmControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t> &listConnectionID)
{
return (mDatabaseHandler->changeMainConnectionRouteDB(mainconnectionID, listConnectionID));
}
@@ -186,7 +186,7 @@ am_Error_e CAmControlReceiver::changeSinkMainVolumeDB(const am_mainVolume_t main
return (mDatabaseHandler->changeSinkMainVolumeDB(mainVolume, sinkID));
}
-am_Error_e CAmControlReceiver::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::changeSinkAvailabilityDB(const am_Availability_s &availability, const am_sinkID_t sinkID)
{
return (mDatabaseHandler->changeSinkAvailabilityDB(availability, sinkID));
}
@@ -201,22 +201,22 @@ am_Error_e CAmControlReceiver::changeSinkMuteStateDB(const am_MuteState_e muteSt
return (mDatabaseHandler->changeSinkMuteStateDB(muteState, sinkID));
}
-am_Error_e CAmControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s &soundProperty, const am_sinkID_t sinkID)
{
return (mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty, sinkID));
}
-am_Error_e CAmControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+am_Error_e CAmControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s &soundProperty, const am_sourceID_t sourceID)
{
return (mDatabaseHandler->changeMainSourceSoundPropertyDB(soundProperty, sourceID));
}
-am_Error_e CAmControlReceiver::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
+am_Error_e CAmControlReceiver::changeSourceAvailabilityDB(const am_Availability_s &availability, const am_sourceID_t sourceID)
{
return (mDatabaseHandler->changeSourceAvailabilityDB(availability, sourceID));
}
-am_Error_e CAmControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s & property)
+am_Error_e CAmControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s &property)
{
return (mDatabaseHandler->changeSystemPropertyDB(property));
}
@@ -256,138 +256,137 @@ am_Error_e CAmControlReceiver::removeDomainDB(const am_domainID_t domainID)
return (mDatabaseHandler->removeDomainDB(domainID));
}
-am_Error_e CAmControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
+am_Error_e CAmControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s &classInfo) const
{
return (mDatabaseHandler->getSourceClassInfoDB(sourceID, classInfo));
}
-am_Error_e CAmControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
+am_Error_e CAmControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s &sinkClass) const
{
return (mDatabaseHandler->getSinkClassInfoDB(sinkID, sinkClass));
}
-am_Error_e CAmControlReceiver::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const
+am_Error_e CAmControlReceiver::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s &sinkData) const
{
return (mDatabaseHandler->getSinkInfoDB(sinkID, sinkData));
}
-am_Error_e CAmControlReceiver::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const
+am_Error_e CAmControlReceiver::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s &sourceData) const
{
return (mDatabaseHandler->getSourceInfoDB(sourceID, sourceData));
}
-am_Error_e CAmControlReceiver::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const
+am_Error_e CAmControlReceiver::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s &mainConnectionData) const
{
return (mDatabaseHandler->getMainConnectionInfoDB(mainConnectionID, mainConnectionData));
}
-am_Error_e CAmControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
+am_Error_e CAmControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s &gatewayData) const
{
return (mDatabaseHandler->getGatewayInfoDB(gatewayID, gatewayData));
}
-am_Error_e CAmControlReceiver::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s & converterData) const
+am_Error_e CAmControlReceiver::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s &converterData) const
{
return (mDatabaseHandler->getConverterInfoDB(converterID, converterData));
}
-
-am_Error_e CAmControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
+am_Error_e CAmControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s &crossfaderData) const
{
return (mDatabaseHandler->getCrossfaderInfoDB(crossfaderID, crossfaderData));
}
-am_Error_e CAmControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
+am_Error_e CAmControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> &listSinkID) const
{
return (mDatabaseHandler->getListSinksOfDomain(domainID, listSinkID));
}
-am_Error_e CAmControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
+am_Error_e CAmControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> &listSourceID) const
{
return (mDatabaseHandler->getListSourcesOfDomain(domainID, listSourceID));
}
-am_Error_e CAmControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listGatewaysID) const
+am_Error_e CAmControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> &listGatewaysID) const
{
return (mDatabaseHandler->getListCrossfadersOfDomain(domainID, listGatewaysID));
}
-am_Error_e CAmControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
+am_Error_e CAmControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> &listGatewaysID) const
{
return (mDatabaseHandler->getListGatewaysOfDomain(domainID, listGatewaysID));
}
-am_Error_e CAmControlReceiver::getListConvertersOfDomain(const am_domainID_t domainID,std::vector<am_converterID_t>& listConverterID) const
+am_Error_e CAmControlReceiver::getListConvertersOfDomain(const am_domainID_t domainID, std::vector<am_converterID_t> &listConverterID) const
{
- return (mDatabaseHandler->getListConvertersOfDomain(domainID,listConverterID));
+ return (mDatabaseHandler->getListConvertersOfDomain(domainID, listConverterID));
}
-am_Error_e CAmControlReceiver::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
+am_Error_e CAmControlReceiver::getListMainConnections(std::vector<am_MainConnection_s> &listMainConnections) const
{
return (mDatabaseHandler->getListMainConnections(listMainConnections));
}
-am_Error_e CAmControlReceiver::getListDomains(std::vector<am_Domain_s> & listDomains) const
+am_Error_e CAmControlReceiver::getListDomains(std::vector<am_Domain_s> &listDomains) const
{
return (mDatabaseHandler->getListDomains(listDomains));
}
-am_Error_e CAmControlReceiver::getListConnections(std::vector<am_Connection_s> & listConnections) const
+am_Error_e CAmControlReceiver::getListConnections(std::vector<am_Connection_s> &listConnections) const
{
return (mDatabaseHandler->getListConnections(listConnections));
}
-am_Error_e CAmControlReceiver::getListSinks(std::vector<am_Sink_s> & listSinks) const
+am_Error_e CAmControlReceiver::getListSinks(std::vector<am_Sink_s> &listSinks) const
{
return (mDatabaseHandler->getListSinks(listSinks));
}
-am_Error_e CAmControlReceiver::getListSources(std::vector<am_Source_s> & listSources) const
+am_Error_e CAmControlReceiver::getListSources(std::vector<am_Source_s> &listSources) const
{
return (mDatabaseHandler->getListSources(listSources));
}
-am_Error_e CAmControlReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
+am_Error_e CAmControlReceiver::getListSourceClasses(std::vector<am_SourceClass_s> &listSourceClasses) const
{
return (mDatabaseHandler->getListSourceClasses(listSourceClasses));
}
-am_Error_e CAmControlReceiver::getListHandles(std::vector<am_Handle_s> & listHandles) const
+am_Error_e CAmControlReceiver::getListHandles(std::vector<am_Handle_s> &listHandles) const
{
return (mRoutingSender->getListHandles(listHandles));
}
-am_Error_e CAmControlReceiver::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
+am_Error_e CAmControlReceiver::getListCrossfaders(std::vector<am_Crossfader_s> &listCrossfaders) const
{
return (mDatabaseHandler->getListCrossfaders(listCrossfaders));
}
-am_Error_e CAmControlReceiver::getListGateways(std::vector<am_Gateway_s> & listGateways) const
+am_Error_e CAmControlReceiver::getListGateways(std::vector<am_Gateway_s> &listGateways) const
{
return (mDatabaseHandler->getListGateways(listGateways));
}
-am_Error_e CAmControlReceiver::getListConverters(std::vector<am_Converter_s>& listConverters) const
+am_Error_e CAmControlReceiver::getListConverters(std::vector<am_Converter_s> &listConverters) const
{
return (mDatabaseHandler->getListConverters(listConverters));
}
-am_Error_e CAmControlReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
+am_Error_e CAmControlReceiver::getListSinkClasses(std::vector<am_SinkClass_s> &listSinkClasses) const
{
return (mDatabaseHandler->getListSinkClasses(listSinkClasses));
}
-am_Error_e CAmControlReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
+am_Error_e CAmControlReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> &listSystemProperties) const
{
return (mDatabaseHandler->getListSystemProperties(listSystemProperties));
}
-am_Error_e CAmControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s & classInfo)
+am_Error_e CAmControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s &classInfo)
{
return (mDatabaseHandler->changeSinkClassInfoDB(classInfo));
}
-am_Error_e CAmControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s & classInfo)
+am_Error_e CAmControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s &classInfo)
{
return(mDatabaseHandler->changeSourceClassInfoDB(classInfo));
}
@@ -410,32 +409,34 @@ void CAmControlReceiver::setCommandReady()
void CAmControlReceiver::setRoutingReady()
{
- logVerbose(__METHOD_NAME__);
+ logVerbose(__METHOD_NAME__);
mRoutingSender->setRoutingReady();
}
void CAmControlReceiver::confirmControllerReady(const am_Error_e error)
{
- if (error!=E_OK)
- logError(__METHOD_NAME__,"controller reported error", error);
+ if (error != E_OK)
+ {
+ logError(__METHOD_NAME__, "controller reported error", error);
+ }
}
void CAmControlReceiver::confirmControllerRundown(const am_Error_e error)
{
- if (error!=E_OK)
- {
- logError(__METHOD_NAME__,"exited with error ",error);
- //we might be blocked here -> so lets better exit right away
- throw std::runtime_error("controller Confirmed with error");
- }
+ if (error != E_OK)
+ {
+ logError(__METHOD_NAME__, "exited with error ", error);
+ // we might be blocked here -> so lets better exit right away
+ throw std::runtime_error("controller Confirmed with error");
+ }
- logVerbose (__METHOD_NAME__,"will exit now");
+ logVerbose(__METHOD_NAME__, "will exit now");
- //end the mainloop here...
- mSocketHandler->exit_mainloop();
+ // end the mainloop here...
+ mSocketHandler->exit_mainloop();
}
-am_Error_e CAmControlReceiver::getSocketHandler(CAmSocketHandler *& socketHandler)
+am_Error_e CAmControlReceiver::getSocketHandler(CAmSocketHandler * &socketHandler)
{
socketHandler = mSocketHandler;
return (E_OK);
@@ -443,7 +444,7 @@ am_Error_e CAmControlReceiver::getSocketHandler(CAmSocketHandler *& socketHandle
void CAmControlReceiver::setCommandRundown()
{
- logInfo(__METHOD_NAME__);
+ logInfo(__METHOD_NAME__);
mCommandSender->setCommandRundown();
}
@@ -453,129 +454,128 @@ void CAmControlReceiver::setRoutingRundown()
mRoutingSender->setRoutingRundown();
}
-void CAmControlReceiver::getInterfaceVersion(std::string & version) const
+void CAmControlReceiver::getInterfaceVersion(std::string &version) const
{
version = ControlVersion;
}
-am_Error_e CAmControlReceiver::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+am_Error_e CAmControlReceiver::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s> &listSoundProperties, const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
- return (mDatabaseHandler->changeSourceDB(sourceID,sourceClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties));
+ return (mDatabaseHandler->changeSourceDB(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties));
}
-am_Error_e CAmControlReceiver::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+am_Error_e CAmControlReceiver::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s> &listSoundProperties, const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
- return (mDatabaseHandler->changeSinkDB(sinkID,sinkClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties));
+ return (mDatabaseHandler->changeSinkDB(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties));
}
-am_Error_e CAmControlReceiver::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix)
+am_Error_e CAmControlReceiver::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t> &listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkConnectionFormats, const std::vector<bool> &convertionMatrix)
{
- return (mDatabaseHandler->changeGatewayDB(gatewayID,listSourceConnectionFormats,listSinkConnectionFormats,convertionMatrix));
+ return (mDatabaseHandler->changeGatewayDB(gatewayID, listSourceConnectionFormats, listSinkConnectionFormats, convertionMatrix));
}
-am_Error_e CAmControlReceiver::changeConverterDB(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix)
+am_Error_e CAmControlReceiver::changeConverterDB(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t> &listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkConnectionFormats, const std::vector<bool> &convertionMatrix)
{
- return (mDatabaseHandler->changeConverterDB(converterID,listSourceConnectionFormats,listSinkConnectionFormats,convertionMatrix));
+ return (mDatabaseHandler->changeConverterDB(converterID, listSourceConnectionFormats, listSinkConnectionFormats, convertionMatrix));
}
-am_Error_e CAmControlReceiver::setVolumes(am_Handle_s& handle, const std::vector<am_Volumes_s>& listVolumes)
+am_Error_e CAmControlReceiver::setVolumes(am_Handle_s &handle, const std::vector<am_Volumes_s> &listVolumes)
{
- return (mRoutingSender->asyncSetVolumes(handle,listVolumes));
+ return (mRoutingSender->asyncSetVolumes(handle, listVolumes));
}
-am_Error_e CAmControlReceiver::setSinkNotificationConfiguration(am_Handle_s& handle, const am_sinkID_t sinkID, const am_NotificationConfiguration_s& notificationConfiguration)
+am_Error_e CAmControlReceiver::setSinkNotificationConfiguration(am_Handle_s &handle, const am_sinkID_t sinkID, const am_NotificationConfiguration_s &notificationConfiguration)
{
- return (mRoutingSender->asyncSetSinkNotificationConfiguration(handle,sinkID,notificationConfiguration));
+ return (mRoutingSender->asyncSetSinkNotificationConfiguration(handle, sinkID, notificationConfiguration));
}
-am_Error_e CAmControlReceiver::setSourceNotificationConfiguration(am_Handle_s& handle, const am_sourceID_t sourceID, const am_NotificationConfiguration_s& notificationConfiguration)
+am_Error_e CAmControlReceiver::setSourceNotificationConfiguration(am_Handle_s &handle, const am_sourceID_t sourceID, const am_NotificationConfiguration_s &notificationConfiguration)
{
- return (mRoutingSender->asyncSetSourceNotificationConfiguration(handle,sourceID,notificationConfiguration));
+ return (mRoutingSender->asyncSetSourceNotificationConfiguration(handle, sourceID, notificationConfiguration));
}
-void CAmControlReceiver::sendMainSinkNotificationPayload(const am_sinkID_t sinkID, const am_NotificationPayload_s& notificationPayload)
+void CAmControlReceiver::sendMainSinkNotificationPayload(const am_sinkID_t sinkID, const am_NotificationPayload_s &notificationPayload)
{
- logVerbose(__METHOD_NAME__,"sinkID=",sinkID,"type=",notificationPayload.type,"value=",notificationPayload.value);
- mCommandSender->cbSinkNotification(sinkID,notificationPayload);
+ logVerbose(__METHOD_NAME__, "sinkID=", sinkID, "type=", notificationPayload.type, "value=", notificationPayload.value);
+ mCommandSender->cbSinkNotification(sinkID, notificationPayload);
}
-void CAmControlReceiver::sendMainSourceNotificationPayload(const am_sourceID_t sourceID, const am_NotificationPayload_s& notificationPayload)
+void CAmControlReceiver::sendMainSourceNotificationPayload(const am_sourceID_t sourceID, const am_NotificationPayload_s &notificationPayload)
{
- logVerbose(__METHOD_NAME__,"sourceID=",sourceID,"type=",notificationPayload.type,"value=",notificationPayload.value);
- mCommandSender->cbSourceNotification(sourceID,notificationPayload);
+ logVerbose(__METHOD_NAME__, "sourceID=", sourceID, "type=", notificationPayload.type, "value=", notificationPayload.value);
+ mCommandSender->cbSourceNotification(sourceID, notificationPayload);
}
-am_Error_e CAmControlReceiver::changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
+am_Error_e CAmControlReceiver::changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &mainNotificationConfiguration)
{
- logVerbose(__METHOD_NAME__,"sinkID", sinkID);
- return (mDatabaseHandler->changeMainSinkNotificationConfigurationDB(sinkID,mainNotificationConfiguration));
+ logVerbose(__METHOD_NAME__, "sinkID", sinkID);
+ return (mDatabaseHandler->changeMainSinkNotificationConfigurationDB(sinkID, mainNotificationConfiguration));
}
-am_Error_e CAmControlReceiver::changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
+am_Error_e CAmControlReceiver::changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &mainNotificationConfiguration)
{
- logVerbose(__METHOD_NAME__,"sourceID", sourceID);
- return (mDatabaseHandler->changeMainSourceNotificationConfigurationDB(sourceID,mainNotificationConfiguration));
+ logVerbose(__METHOD_NAME__, "sourceID", sourceID);
+ return (mDatabaseHandler->changeMainSourceNotificationConfigurationDB(sourceID, mainNotificationConfiguration));
}
-am_Error_e CAmControlReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s>& listSoundproperties) const
+am_Error_e CAmControlReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> &listSoundproperties) const
{
- logVerbose(__METHOD_NAME__,"sinkID", sinkID);
- return (mDatabaseHandler->getListMainSinkSoundProperties(sinkID,listSoundproperties));
+ logVerbose(__METHOD_NAME__, "sinkID", sinkID);
+ return (mDatabaseHandler->getListMainSinkSoundProperties(sinkID, listSoundproperties));
}
-am_Error_e CAmControlReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s>& listSoundproperties) const
+am_Error_e CAmControlReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> &listSoundproperties) const
{
- logVerbose(__METHOD_NAME__,"sourceID", sourceID);
- return (mDatabaseHandler->getListMainSourceSoundProperties(sourceID, listSoundproperties));
+ logVerbose(__METHOD_NAME__, "sourceID", sourceID);
+ return (mDatabaseHandler->getListMainSourceSoundProperties(sourceID, listSoundproperties));
}
-am_Error_e CAmControlReceiver::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_SoundProperty_s>& listSoundproperties) const
+am_Error_e CAmControlReceiver::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_SoundProperty_s> &listSoundproperties) const
{
- logVerbose(__METHOD_NAME__,"sinkID", sinkID);
- return (mDatabaseHandler->getListSinkSoundProperties(sinkID,listSoundproperties));
+ logVerbose(__METHOD_NAME__, "sinkID", sinkID);
+ return (mDatabaseHandler->getListSinkSoundProperties(sinkID, listSoundproperties));
}
-am_Error_e CAmControlReceiver::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_SoundProperty_s>& listSoundproperties) const
+am_Error_e CAmControlReceiver::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_SoundProperty_s> &listSoundproperties) const
{
- logVerbose(__METHOD_NAME__,"sourceID", sourceID);
- return (mDatabaseHandler->getListSourceSoundProperties(sourceID, listSoundproperties));
+ logVerbose(__METHOD_NAME__, "sourceID", sourceID);
+ return (mDatabaseHandler->getListSourceSoundProperties(sourceID, listSoundproperties));
}
-am_Error_e CAmControlReceiver::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const
+am_Error_e CAmControlReceiver::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t &value) const
{
- logVerbose(__METHOD_NAME__,"sinkID", sinkID);
- return (mDatabaseHandler->getMainSinkSoundPropertyValue(sinkID,propertyType,value));
+ logVerbose(__METHOD_NAME__, "sinkID", sinkID);
+ return (mDatabaseHandler->getMainSinkSoundPropertyValue(sinkID, propertyType, value));
}
-am_Error_e CAmControlReceiver::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t& value) const
+am_Error_e CAmControlReceiver::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t &value) const
{
- logVerbose(__METHOD_NAME__,"sinkID", sinkID);
- return (mDatabaseHandler->getSinkSoundPropertyValue(sinkID,propertyType,value));
+ logVerbose(__METHOD_NAME__, "sinkID", sinkID);
+ return (mDatabaseHandler->getSinkSoundPropertyValue(sinkID, propertyType, value));
}
-am_Error_e CAmControlReceiver::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const
+am_Error_e CAmControlReceiver::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t &value) const
{
- logVerbose(__METHOD_NAME__,"sourceID", sourceID);
- return (mDatabaseHandler->getMainSourceSoundPropertyValue(sourceID,propertyType,value));
+ logVerbose(__METHOD_NAME__, "sourceID", sourceID);
+ return (mDatabaseHandler->getMainSourceSoundPropertyValue(sourceID, propertyType, value));
}
-am_Error_e CAmControlReceiver::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t& value) const
+am_Error_e CAmControlReceiver::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t &value) const
{
- logVerbose(__METHOD_NAME__,"sourceID", sourceID);
- return (mDatabaseHandler->getSourceSoundPropertyValue(sourceID,propertyType,value));
+ logVerbose(__METHOD_NAME__, "sourceID", sourceID);
+ return (mDatabaseHandler->getSourceSoundPropertyValue(sourceID, propertyType, value));
}
-am_Error_e CAmControlReceiver::resyncConnectionState(const am_domainID_t domainID,std::vector<am_Connection_s>& listOfExistingConnections)
+am_Error_e CAmControlReceiver::resyncConnectionState(const am_domainID_t domainID, std::vector<am_Connection_s> &listOfExistingConnections)
{
- logInfo(__METHOD_NAME__,"domainID", domainID);
- return (mRoutingSender->resyncConnectionState(domainID,listOfExistingConnections));
+ logInfo(__METHOD_NAME__, "domainID", domainID);
+ return (mRoutingSender->resyncConnectionState(domainID, listOfExistingConnections));
}
am_Error_e CAmControlReceiver::removeHandle(const am_Handle_s handle)
{
- logInfo(__METHOD_NAME__,"handle", handle.handle);
- return (mRoutingSender->removeHandle(handle));
+ logInfo(__METHOD_NAME__, "handle", handle.handle);
+ return (mRoutingSender->removeHandle(handle));
}
}
-
diff --git a/AudioManagerCore/src/CAmControlSender.cpp b/AudioManagerCore/src/CAmControlSender.cpp
index d80460d..1baeb30 100644
--- a/AudioManagerCore/src/CAmControlSender.cpp
+++ b/AudioManagerCore/src/CAmControlSender.cpp
@@ -37,25 +37,25 @@
namespace am
{
-#define REQUIRED_INTERFACE_VERSION_MAJOR 1 //!< major interface version. All versions smaller than this will be rejected
+#define REQUIRED_INTERFACE_VERSION_MAJOR 1 //!< major interface version. All versions smaller than this will be rejected
#define REQUIRED_INTERFACE_VERSION_MINOR 0 //!< minor interface version. All versions smaller than this will be rejected
-CAmControlSender* CAmControlSender::mInstance=NULL;
+CAmControlSender *CAmControlSender::mInstance = NULL;
-CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandler* sockethandler) :
- receiverCallbackT(this, &CAmControlSender::receiverCallback),
- checkerCallbackT(this, &CAmControlSender::checkerCallback),
- dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback),
- mPipe(),
- mlibHandle(NULL),
- mController(NULL),
- mSignal(0)
+CAmControlSender::CAmControlSender(std::string controlPluginFile, CAmSocketHandler *sockethandler)
+ : receiverCallbackT(this, &CAmControlSender::receiverCallback)
+ , checkerCallbackT(this, &CAmControlSender::checkerCallback)
+ , dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback)
+ , mPipe()
+ , mlibHandle(NULL)
+ , mController(NULL)
+ , mSignal(0)
{
assert(sockethandler);
- //Check if a folder is given, then select the first plugin
+ // Check if a folder is given, then select the first plugin
struct stat buf;
- const char* conFile(controlPluginFile.c_str());
+ const char *conFile(controlPluginFile.c_str());
stat(conFile, &buf);
if (S_ISDIR(buf.st_mode))
{
@@ -74,35 +74,38 @@ CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandle
while ((itemInDirectory = readdir(directory)))
{
unsigned char entryType = itemInDirectory->d_type;
- std::string entryName = itemInDirectory->d_name;
- std::string fullName = directoryName + "/" + entryName;
+ std::string entryName = itemInDirectory->d_name;
+ std::string fullName = directoryName + "/" + entryName;
- bool regularFile = (entryType == DT_REG || entryType == DT_LNK);
+ bool regularFile = (entryType == DT_REG || entryType == DT_LNK);
bool sharedLibExtension = ("so" == entryName.substr(entryName.find_last_of(".") + 1));
// Handle cases where readdir() could not determine the file type
- if (entryType == DT_UNKNOWN) {
- struct stat buf;
+ if (entryType == DT_UNKNOWN)
+ {
+ struct stat buf;
- if (stat(fullName.c_str(), &buf)) {
- logInfo(__PRETTY_FUNCTION__,"Failed to stat file: ", entryName, errno);
- continue;
- }
+ if (stat(fullName.c_str(), &buf))
+ {
+ logInfo(__PRETTY_FUNCTION__, "Failed to stat file: ", entryName, errno);
+ continue;
+ }
- regularFile = S_ISREG(buf.st_mode);
- }
+ regularFile = S_ISREG(buf.st_mode);
+ }
if (regularFile && sharedLibExtension)
{
- controlPluginFile=directoryName + "/" + entryName;
- logInfo("Found ControlPlugin:", controlPluginFile);
- break;
+ controlPluginFile = directoryName + "/" + entryName;
+ logInfo("Found ControlPlugin:", controlPluginFile);
+ break;
}
}
+
closedir(directory);
-
+
}
-
+
std::ifstream isfile(controlPluginFile.c_str());
if (!isfile)
{
@@ -111,13 +114,13 @@ CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandle
}
else if (!controlPluginFile.empty())
{
- mInstance=this;
- IAmControlSend* (*createFunc)();
- createFunc = getCreateFunction<IAmControlSend*()>(controlPluginFile, mlibHandle);
- assert(createFunc!=NULL);
- mController = createFunc();
+ mInstance = this;
+ IAmControlSend *(*createFunc)();
+ createFunc = getCreateFunction<IAmControlSend *()>(controlPluginFile, mlibHandle);
+ assert(createFunc != NULL);
+ mController = createFunc();
mControlPluginFile = controlPluginFile;
- //check libversion
+ // check libversion
std::string version, cVersion(ControlVersion);
mController->getInterfaceVersion(version);
uint16_t minorVersion, majorVersion, cMinorVersion, cMajorVersion;
@@ -125,12 +128,10 @@ CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandle
std::istringstream(version.substr(2, 1)) >> minorVersion;
std::istringstream(cVersion.substr(0, 1)) >> cMajorVersion;
std::istringstream(cVersion.substr(2, 1)) >> cMinorVersion;
-
-
if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion < cMinorVersion)))
{
- logError("ControlSender::ControlSender: Interface Version of Controller too old, required version:",ControlVersion," Controller Version:",version,"exiting now");
+ logError("ControlSender::ControlSender: Interface Version of Controller too old, required version:", ControlVersion, " Controller Version:", version, "exiting now");
throw std::runtime_error("Interface Version of Controller too old");
}
}
@@ -139,14 +140,14 @@ CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandle
logError("ControlSender::ControlSender: No controller loaded !");
}
- //here we need a pipe to be able to call the rundown function out of the mainloop
+ // here we need a pipe to be able to call the rundown function out of the mainloop
if (pipe(mPipe) == -1)
{
logError("CAmControlSender could not create pipe!");
}
- //add the pipe to the poll - nothing needs to be proccessed here we just need the pipe to trigger the ppoll
- short event = 0;
+ // add the pipe to the poll - nothing needs to be proccessed here we just need the pipe to trigger the ppoll
+ short event = 0;
sh_pollHandle_t handle;
event |= POLLIN;
sockethandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, &checkerCallbackT, &dispatcherCallbackT, NULL, handle);
@@ -159,8 +160,8 @@ CAmControlSender::~CAmControlSender()
if (mlibHandle)
{
- void (*destroyFunc)(IAmControlSend*);
- destroyFunc = getDestroyFunction<void(IAmControlSend*)>(mControlPluginFile, mlibHandle);
+ void (*destroyFunc)(IAmControlSend *);
+ destroyFunc = getDestroyFunction<void(IAmControlSend *)>(mControlPluginFile, mlibHandle);
if (destroyFunc)
{
destroyFunc(mController);
@@ -169,11 +170,12 @@ CAmControlSender::~CAmControlSender()
{
logError("CAmControlSender Dtor: destroyFunc is invalid or not found");
}
+
dlclose(mlibHandle);
}
}
-am_Error_e CAmControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
+am_Error_e CAmControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t &mainConnectionID)
{
assert(mController);
return (mController->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID));
@@ -185,19 +187,19 @@ am_Error_e CAmControlSender::hookUserDisconnectionRequest(const am_mainConnectio
return (mController->hookUserDisconnectionRequest(connectionID));
}
-am_Error_e CAmControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty)
+am_Error_e CAmControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s &soundProperty)
{
assert(mController);
return (mController->hookUserSetMainSinkSoundProperty(sinkID, soundProperty));
}
-am_Error_e CAmControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s & soundProperty)
+am_Error_e CAmControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s &soundProperty)
{
assert(mController);
return (mController->hookUserSetMainSourceSoundProperty(sourceID, soundProperty));
}
-am_Error_e CAmControlSender::hookUserSetSystemProperty(const am_SystemProperty_s & property)
+am_Error_e CAmControlSender::hookUserSetSystemProperty(const am_SystemProperty_s &property)
{
assert(mController);
return (mController->hookUserSetSystemProperty(property));
@@ -221,7 +223,7 @@ am_Error_e CAmControlSender::hookUserSetSinkMuteState(const am_sinkID_t sinkID,
return (mController->hookUserSetSinkMuteState(sinkID, muteState));
}
-am_Error_e CAmControlSender::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
+am_Error_e CAmControlSender::hookSystemRegisterDomain(const am_Domain_s &domainData, am_domainID_t &domainID)
{
assert(mController);
return (mController->hookSystemRegisterDomain(domainData, domainID));
@@ -239,7 +241,7 @@ void CAmControlSender::hookSystemDomainRegistrationComplete(const am_domainID_t
return (mController->hookSystemDomainRegistrationComplete(domainID));
}
-am_Error_e CAmControlSender::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+am_Error_e CAmControlSender::hookSystemRegisterSink(const am_Sink_s &sinkData, am_sinkID_t &sinkID)
{
assert(mController);
return (mController->hookSystemRegisterSink(sinkData, sinkID));
@@ -251,7 +253,7 @@ am_Error_e CAmControlSender::hookSystemDeregisterSink(const am_sinkID_t sinkID)
return (mController->hookSystemDeregisterSink(sinkID));
}
-am_Error_e CAmControlSender::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+am_Error_e CAmControlSender::hookSystemRegisterSource(const am_Source_s &sourceData, am_sourceID_t &sourceID)
{
assert(mController);
return (mController->hookSystemRegisterSource(sourceData, sourceID));
@@ -263,13 +265,13 @@ am_Error_e CAmControlSender::hookSystemDeregisterSource(const am_sourceID_t sour
return (mController->hookSystemDeregisterSource(sourceID));
}
-am_Error_e CAmControlSender::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+am_Error_e CAmControlSender::hookSystemRegisterGateway(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID)
{
assert(mController);
return (mController->hookSystemRegisterGateway(gatewayData, gatewayID));
}
-am_Error_e CAmControlSender::hookSystemRegisterConverter(const am_Converter_s& converterData, am_converterID_t& converterID)
+am_Error_e CAmControlSender::hookSystemRegisterConverter(const am_Converter_s &converterData, am_converterID_t &converterID)
{
assert(mController);
return (mController->hookSystemRegisterConverter(converterData, converterID));
@@ -287,7 +289,7 @@ am_Error_e CAmControlSender::hookSystemDeregisterConverter(const am_converterID_
return (mController->hookSystemDeregisterConverter(converterID));
}
-am_Error_e CAmControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+am_Error_e CAmControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID)
{
assert(mController);
return (mController->hookSystemRegisterCrossfader(crossfaderData, crossfaderID));
@@ -317,13 +319,13 @@ void CAmControlSender::hookSystemInterruptStateChange(const am_sourceID_t source
mController->hookSystemInterruptStateChange(sourceID, interruptState);
}
-void CAmControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
+void CAmControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s &availability)
{
assert(mController);
mController->hookSystemSinkAvailablityStateChange(sinkID, availability);
}
-void CAmControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
+void CAmControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s &availability)
{
assert(mController);
mController->hookSystemSourceAvailablityStateChange(sourceID, availability);
@@ -335,7 +337,7 @@ void CAmControlSender::hookSystemDomainStateChange(const am_domainID_t domainID,
mController->hookSystemDomainStateChange(domainID, state);
}
-void CAmControlSender::hookSystemReceiveEarlyData(const std::vector<am_EarlyData_s> & data)
+void CAmControlSender::hookSystemReceiveEarlyData(const std::vector<am_EarlyData_s> &data)
{
assert(mController);
mController->hookSystemReceiveEarlyData(data);
@@ -403,6 +405,7 @@ am_Error_e CAmControlSender::startupController(IAmControlReceive *controlreceive
throw std::runtime_error("ControlSender::startupController: no Controller to startup! Exiting now ...");
return (E_NON_EXISTENT);
}
+
return (mController->startupController(controlreceiveinterface));
}
@@ -433,17 +436,17 @@ void CAmControlSender::setControllerReady()
void CAmControlSender::setControllerRundown(const int16_t signal)
{
assert(mController);
- logInfo("CAmControlSender::setControllerRundown received, signal=",signal);
+ logInfo("CAmControlSender::setControllerRundown received, signal=", signal);
mController->setControllerRundown(signal);
}
-am_Error_e am::CAmControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector<am_CustomConnectionFormat_t> listPossibleConnectionFormats, std::vector<am_CustomConnectionFormat_t> & listPrioConnectionFormats)
+am_Error_e am::CAmControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector<am_CustomConnectionFormat_t> listPossibleConnectionFormats, std::vector<am_CustomConnectionFormat_t> &listPrioConnectionFormats)
{
assert(mController);
return (mController->getConnectionFormatChoice(sourceID, sinkID, listRoute, listPossibleConnectionFormats, listPrioConnectionFormats));
}
-void CAmControlSender::getInterfaceVersion(std::string & version) const
+void CAmControlSender::getInterfaceVersion(std::string &version) const
{
version = ControlVersion;
}
@@ -472,116 +475,114 @@ void CAmControlSender::confirmRoutingRundown(const am_Error_e error)
mController->confirmRoutingRundown(error);
}
-am_Error_e CAmControlSender::hookSystemUpdateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+am_Error_e CAmControlSender::hookSystemUpdateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s> &listSoundProperties, const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
assert(mController);
- return (mController->hookSystemUpdateSink(sinkID,sinkClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties));
+ return (mController->hookSystemUpdateSink(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties));
}
-am_Error_e CAmControlSender::hookSystemUpdateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+am_Error_e CAmControlSender::hookSystemUpdateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s> &listSoundProperties, const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
assert(mController);
- return (mController->hookSystemUpdateSource(sourceID,sourceClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties));
+ return (mController->hookSystemUpdateSource(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties));
}
-am_Error_e CAmControlSender::hookSystemUpdateGateway(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFromats, const std::vector<bool>& convertionMatrix)
+am_Error_e CAmControlSender::hookSystemUpdateGateway(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t> &listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkConnectionFromats, const std::vector<bool> &convertionMatrix)
{
assert(mController);
- return (mController->hookSystemUpdateGateway(gatewayID,listSourceConnectionFormats,listSinkConnectionFromats,convertionMatrix));
+ return (mController->hookSystemUpdateGateway(gatewayID, listSourceConnectionFormats, listSinkConnectionFromats, convertionMatrix));
}
-am_Error_e CAmControlSender::hookSystemUpdateConverter(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFromats, const std::vector<bool>& convertionMatrix)
+am_Error_e CAmControlSender::hookSystemUpdateConverter(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t> &listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkConnectionFromats, const std::vector<bool> &convertionMatrix)
{
assert(mController);
- return (mController->hookSystemUpdateConverter(converterID,listSourceConnectionFormats,listSinkConnectionFromats,convertionMatrix));
+ return (mController->hookSystemUpdateConverter(converterID, listSourceConnectionFormats, listSinkConnectionFromats, convertionMatrix));
}
-void CAmControlSender::cbAckSetVolume(const am_Handle_s handle, const std::vector<am_Volumes_s>& listVolumes, const am_Error_e error)
+void CAmControlSender::cbAckSetVolume(const am_Handle_s handle, const std::vector<am_Volumes_s> &listVolumes, const am_Error_e error)
{
assert(mController);
- mController->cbAckSetVolumes(handle,listVolumes,error);
+ mController->cbAckSetVolumes(handle, listVolumes, error);
}
void CAmControlSender::cbAckSetSinkNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
{
assert(mController);
- mController->cbAckSetSinkNotificationConfiguration(handle,error);
+ mController->cbAckSetSinkNotificationConfiguration(handle, error);
}
void CAmControlSender::cbAckSetSourceNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
{
assert(mController);
- mController->cbAckSetSourceNotificationConfiguration(handle,error);
+ mController->cbAckSetSourceNotificationConfiguration(handle, error);
}
-void CAmControlSender::hookSinkNotificationDataChanged(const am_sinkID_t sinkID, const am_NotificationPayload_s& payload)
+void CAmControlSender::hookSinkNotificationDataChanged(const am_sinkID_t sinkID, const am_NotificationPayload_s &payload)
{
assert(mController);
- mController->hookSinkNotificationDataChanged(sinkID,payload);
+ mController->hookSinkNotificationDataChanged(sinkID, payload);
}
-void CAmControlSender::hookSourceNotificationDataChanged(const am_sourceID_t sourceID, const am_NotificationPayload_s& payload)
+void CAmControlSender::hookSourceNotificationDataChanged(const am_sourceID_t sourceID, const am_NotificationPayload_s &payload)
{
assert(mController);
- mController->hookSourceNotificationDataChanged(sourceID,payload);
+ mController->hookSourceNotificationDataChanged(sourceID, payload);
}
-am_Error_e CAmControlSender::hookUserSetMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& notificationConfiguration)
+am_Error_e CAmControlSender::hookUserSetMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &notificationConfiguration)
{
assert(mController);
- return (mController->hookUserSetMainSinkNotificationConfiguration(sinkID,notificationConfiguration));
+ return (mController->hookUserSetMainSinkNotificationConfiguration(sinkID, notificationConfiguration));
}
-am_Error_e CAmControlSender::hookUserSetMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& notificationConfiguration)
+am_Error_e CAmControlSender::hookUserSetMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &notificationConfiguration)
{
assert(mController);
- return (mController->hookUserSetMainSourceNotificationConfiguration(sourceID,notificationConfiguration));
+ return (mController->hookUserSetMainSourceNotificationConfiguration(sourceID, notificationConfiguration));
}
-void CAmControlSender::receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void* userData)
+void CAmControlSender::receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
{
- (void) handle;
- (void) userData;
- //get the signal number from the socket
- ssize_t result = read(pollfd.fd, &mSignal, sizeof(mSignal));
+ (void)handle;
+ (void)userData;
+ // get the signal number from the socket
+ ssize_t result = read(pollfd.fd, &mSignal, sizeof(mSignal));
}
-bool CAmControlSender::checkerCallback(const sh_pollHandle_t handle, void* userData)
+bool CAmControlSender::checkerCallback(const sh_pollHandle_t handle, void *userData)
{
- (void) handle;
- (void) userData;
- return (true);
+ (void)handle;
+ (void)userData;
+ return (true);
}
void CAmControlSender::hookSystemSingleTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t time)
{
assert(mController);
- mController->hookSystemSingleTimingInformationChanged(connectionID,time);
+ mController->hookSystemSingleTimingInformationChanged(connectionID, time);
}
/**for testing only contructor - do not use !
*
*/
-CAmControlSender::CAmControlSender() :
- receiverCallbackT(this, &CAmControlSender::receiverCallback),
- checkerCallbackT(this, &CAmControlSender::checkerCallback),
- dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback),
- mlibHandle(NULL),
- mController(NULL),
- mSignal(0)
+CAmControlSender::CAmControlSender()
+ : receiverCallbackT(this, &CAmControlSender::receiverCallback)
+ , checkerCallbackT(this, &CAmControlSender::checkerCallback)
+ , dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback)
+ , mlibHandle(NULL)
+ , mController(NULL)
+ , mSignal(0)
{
logInfo("CAmControlSender was loaded in test mode!");
std::memset(mPipe, -1, sizeof(mPipe));
}
-bool CAmControlSender::dispatcherCallback(const sh_pollHandle_t handle, void* userData)
+bool CAmControlSender::dispatcherCallback(const sh_pollHandle_t handle, void *userData)
{
- (void)handle;
- (void)userData;
- setControllerRundown(mSignal);
- return (false);
+ (void)handle;
+ (void)userData;
+ setControllerRundown(mSignal);
+ return (false);
}
}
-
-
diff --git a/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp b/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
index 895b234..8e5c192 100644
--- a/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
+++ b/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
@@ -33,53 +33,56 @@
#include "CAmRouter.h"
#include "CAmDltWrapper.h"
-#define __METHOD_NAME__ std::string (std::string("CAmDatabaseHandlerMap::") + __func__)
-
+#define __METHOD_NAME__ std::string(std::string("CAmDatabaseHandlerMap::") + __func__)
#ifdef WITH_DATABASE_CHANGE_CHECK
-# define DB_COND_UPDATE_RIE(x,y) \
- if (isDataEqual(x,y)) return (E_NO_CHANGE); else x = y
-# define DB_COND_UPDATE_INIT \
- bool modified = false
-# define DB_COND_UPDATE(x,y) \
- if (!isDataEqual(x,y)) { x = y; modified = true; }
-# define DB_COND_ISMODIFIED \
- (modified == true)
-#else
-# define DB_COND_UPDATE_RIE(x,y) \
- x = y
-# define DB_COND_UPDATE_INIT
-# define DB_COND_UPDATE(x,y) \
- x = y
-# define DB_COND_ISMODIFIED \
- (true)
-#endif
-
-
-#define NOTIFY_OBSERVERS(CALL)\
- for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\
- if(nextObserver->CALL)\
- nextObserver->CALL();
-
-#define NOTIFY_OBSERVERS1(CALL, ARG1)\
- for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\
- if(nextObserver->CALL)\
- nextObserver->CALL(ARG1);
-
-#define NOTIFY_OBSERVERS2(CALL, ARG1, ARG2)\
- for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\
- if(nextObserver->CALL)\
- nextObserver->CALL(ARG1, ARG2);
-
-#define NOTIFY_OBSERVERS3(CALL, ARG1, ARG2, ARG3)\
- for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\
- if(nextObserver->CALL)\
- nextObserver->CALL(ARG1, ARG2, ARG3);
-
-#define NOTIFY_OBSERVERS4(CALL, ARG1, ARG2, ARG3, ARG4)\
- for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\
- if(nextObserver->CALL)\
- nextObserver->CALL(ARG1, ARG2, ARG3, ARG4);
+# define DB_COND_UPDATE_RIE(x, y) \
+ if (isDataEqual(x, y)) { return (E_NO_CHANGE);} else x = y
+# define DB_COND_UPDATE_INIT \
+ bool modified = false
+# define DB_COND_UPDATE(x, y) \
+ if (!isDataEqual(x, y)) { x = y; modified = true; }
+# define DB_COND_ISMODIFIED \
+ (modified == true)
+#else // ifdef WITH_DATABASE_CHANGE_CHECK
+# define DB_COND_UPDATE_RIE(x, y) \
+ x = y
+# define DB_COND_UPDATE_INIT
+# define DB_COND_UPDATE(x, y) \
+ x = y
+# define DB_COND_ISMODIFIED \
+ (true)
+#endif // ifdef WITH_DATABASE_CHANGE_CHECK
+
+#define NOTIFY_OBSERVERS(CALL) \
+ for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \
+ if (nextObserver->CALL) { \
+ nextObserver->CALL();} \
+ }
+
+#define NOTIFY_OBSERVERS1(CALL, ARG1) \
+ for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \
+ if (nextObserver->CALL) { \
+ nextObserver->CALL(ARG1);} \
+ }
+
+#define NOTIFY_OBSERVERS2(CALL, ARG1, ARG2) \
+ for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \
+ if (nextObserver->CALL) { \
+ nextObserver->CALL(ARG1, ARG2);} \
+ }
+
+#define NOTIFY_OBSERVERS3(CALL, ARG1, ARG2, ARG3) \
+ for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \
+ if (nextObserver->CALL) { \
+ nextObserver->CALL(ARG1, ARG2, ARG3);} \
+ }
+
+#define NOTIFY_OBSERVERS4(CALL, ARG1, ARG2, ARG3, ARG4) \
+ for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \
+ if (nextObserver->CALL) { \
+ nextObserver->CALL(ARG1, ARG2, ARG3, ARG4);} \
+ }
namespace am
{
@@ -87,34 +90,40 @@ namespace am
/*
* Checks if content of data is equal
*/
-template <typename T> bool isDataEqual(const T & left, const T & right)
+template <typename T>
+bool isDataEqual(const T &left, const T &right)
{
- return static_cast<bool>(!std::memcmp(&left, &right, sizeof(T)));
+ return static_cast<bool>(!std::memcmp(&left, &right, sizeof(T)));
}
-template <typename T, typename L = std::vector<T> > bool isDataEqual(const L & left, const L & right)
+template <typename T, typename L = std::vector<T> >
+bool isDataEqual(const L &left, const L &right)
{
- return std::equal(left.begin(), left.end(), right.begin(), isDataEqual);
+ return std::equal(left.begin(), left.end(), right.begin(), isDataEqual);
}
-
/*
* Returns an object for given key
*/
-template <typename TMapKeyType, class TMapObjectType> TMapObjectType const * objectForKeyIfExistsInMap(const TMapKeyType & key, const std::unordered_map<TMapKeyType,TMapObjectType> & map)
+template <typename TMapKeyType, class TMapObjectType>
+TMapObjectType const *objectForKeyIfExistsInMap(const TMapKeyType &key, const std::unordered_map<TMapKeyType, TMapObjectType> &map)
{
- typename std::unordered_map<TMapKeyType,TMapObjectType>::const_iterator iter = map.find(key);
- if( iter!=map.end() )
- return &iter->second;
- return NULL;
+ typename std::unordered_map<TMapKeyType, TMapObjectType>::const_iterator iter = map.find(key);
+ if ( iter != map.end())
+ {
+ return &iter->second;
+ }
+
+ return NULL;
}
/*
* Checks whether any object with key exists in a given map
*/
-template <typename TMapKeyType, class TMapObjectType> bool existsObjectWithKeyInMap(const TMapKeyType & key, const std::unordered_map<TMapKeyType,TMapObjectType> & map)
+template <typename TMapKeyType, class TMapObjectType>
+bool existsObjectWithKeyInMap(const TMapKeyType &key, const std::unordered_map<TMapKeyType, TMapObjectType> &map)
{
- return objectForKeyIfExistsInMap(key, map)!=NULL;
+ return objectForKeyIfExistsInMap(key, map) != NULL;
}
/**
@@ -126,489 +135,515 @@ template <typename TMapKeyType, class TMapObjectType> bool existsObjectWithKeyIn
* @param comparator Search predicate.
* @return NULL or pointer to the found object.
*/
-template <class TReturn, typename TIdentifier> const TReturn * objectMatchingPredicate(const std::unordered_map<TIdentifier, TReturn> & map,
- std::function<bool(const TReturn & refObject)> comparator)
-{
- typename std::unordered_map<TIdentifier, TReturn>::const_iterator elementIterator = map.begin();
- for (;elementIterator != map.end(); ++elementIterator)
- {
- if( comparator(elementIterator->second) )
- return &elementIterator->second;
- }
+template <class TReturn, typename TIdentifier>
+const TReturn *objectMatchingPredicate(const std::unordered_map<TIdentifier, TReturn> &map,
+ std::function<bool(const TReturn &refObject)> comparator)
+{
+ typename std::unordered_map<TIdentifier, TReturn>::const_iterator elementIterator = map.begin();
+ for (; elementIterator != map.end(); ++elementIterator)
+ {
+ if ( comparator(elementIterator->second))
+ {
+ return &elementIterator->second;
+ }
+ }
+
return NULL;
}
-
/* Domain */
-void CAmDatabaseHandlerMap::AmDomain::getDescription (std::string & outString) const
+void CAmDatabaseHandlerMap::AmDomain::getDescription(std::string &outString) const
{
- std::ostringstream fmt;
- fmt << "Domain(" << name.c_str() << ") id(" << domainID << ")" << std::endl <<
- "bus name(" << busname.c_str() <<
- ") node name(" << nodename.c_str() <<
- ") early(" << early <<
- ") domainID(" << domainID <<
- ") complete(" << complete <<
- ") state(" << state <<
- ") reserved(" << reserved << ")" << std::endl;
- outString = fmt.str();
+ std::ostringstream fmt;
+ fmt << "Domain(" << name.c_str() << ") id(" << domainID << ")" << std::endl <<
+ "bus name(" << busname.c_str() <<
+ ") node name(" << nodename.c_str() <<
+ ") early(" << early <<
+ ") domainID(" << domainID <<
+ ") complete(" << complete <<
+ ") state(" << state <<
+ ") reserved(" << reserved << ")" << std::endl;
+ outString = fmt.str();
}
/* Source */
-void CAmDatabaseHandlerMap::AmSource::getSourceType(am_SourceType_s & sourceType) const
-{
- sourceType.name = name;
- sourceType.sourceClassID = sourceClassID;
- sourceType.availability = available;
- sourceType.sourceID = sourceID;
-}
-
-void CAmDatabaseHandlerMap::AmSource::getDescription (std::string & outString) const
-{
- std::ostringstream fmt;
- fmt << "Source(" << name.c_str() << ") id(" << sourceID << ")" << std::endl <<
- "sourceClassID(" << sourceClassID <<
- ") domainID(" << domainID <<
- ") visible(" << visible <<
- ") volume(" << volume <<
- ") interruptState(" << interruptState <<
- ") sourceState(" << sourceState <<
- ") reserved(" << reserved << ")" <<
- ") available([availability:" << available.availability << " availabilityReason:" << available.availabilityReason << "]"
- ") listSoundProperties (";
- std::for_each(listSoundProperties.begin(), listSoundProperties.end(), [&](const am_SoundProperty_s & ref) {
- fmt << "[type:" << ref.type << " value:" << ref.value <<"]";
- });
- fmt << ") listConnectionFormats (";
- std::for_each(listConnectionFormats.begin(), listConnectionFormats.end(), [&](const am_CustomConnectionFormat_t & ref) {
- fmt << "[" << ref << "]";
- });
- fmt << ") listMainSoundProperties (";
- std::for_each(listMainSoundProperties.begin(), listMainSoundProperties.end(), [&](const am_MainSoundProperty_s & ref) {
- fmt << "[type:" << ref.type << " value:" << ref.value <<"]";
- });
- fmt << ") listMainNotificationConfigurations (";
- std::for_each(listMainNotificationConfigurations.begin(), listMainNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s & ref) {
- fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter <<"]";
- });
- fmt << ") listNotificationConfigurations (";
- std::for_each(listNotificationConfigurations.begin(), listNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s & ref) {
- fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter <<"]";
- });
- fmt << ")" << std::endl;
- outString = fmt.str();
+void CAmDatabaseHandlerMap::AmSource::getSourceType(am_SourceType_s &sourceType) const
+{
+ sourceType.name = name;
+ sourceType.sourceClassID = sourceClassID;
+ sourceType.availability = available;
+ sourceType.sourceID = sourceID;
+}
+
+void CAmDatabaseHandlerMap::AmSource::getDescription(std::string &outString) const
+{
+ std::ostringstream fmt;
+ fmt << "Source(" << name.c_str() << ") id(" << sourceID << ")" << std::endl <<
+ "sourceClassID(" << sourceClassID <<
+ ") domainID(" << domainID <<
+ ") visible(" << visible <<
+ ") volume(" << volume <<
+ ") interruptState(" << interruptState <<
+ ") sourceState(" << sourceState <<
+ ") reserved(" << reserved << ")" <<
+ ") available([availability:" << available.availability << " availabilityReason:" << available.availabilityReason << "]"
+ ") listSoundProperties (";
+ std::for_each(listSoundProperties.begin(), listSoundProperties.end(), [&](const am_SoundProperty_s &ref) {
+ fmt << "[type:" << ref.type << " value:" << ref.value << "]";
+ });
+ fmt << ") listConnectionFormats (";
+ std::for_each(listConnectionFormats.begin(), listConnectionFormats.end(), [&](const am_CustomConnectionFormat_t &ref) {
+ fmt << "[" << ref << "]";
+ });
+ fmt << ") listMainSoundProperties (";
+ std::for_each(listMainSoundProperties.begin(), listMainSoundProperties.end(), [&](const am_MainSoundProperty_s &ref) {
+ fmt << "[type:" << ref.type << " value:" << ref.value << "]";
+ });
+ fmt << ") listMainNotificationConfigurations (";
+ std::for_each(listMainNotificationConfigurations.begin(), listMainNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s &ref) {
+ fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter << "]";
+ });
+ fmt << ") listNotificationConfigurations (";
+ std::for_each(listNotificationConfigurations.begin(), listNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s &ref) {
+ fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter << "]";
+ });
+ fmt << ")" << std::endl;
+ outString = fmt.str();
}
/* Sink */
-void CAmDatabaseHandlerMap::AmSink::getDescription (std::string & outString) const
-{
- std::ostringstream fmt;
- fmt << "Sink(" << name.c_str() << ") id(" << sinkID << ")" << std::endl <<
- "sinkClassID(" << sinkClassID <<
- ") domainID(" << domainID <<
- ") visible(" << visible <<
- ") volume(" << volume <<
- ") muteState(" << muteState <<
- ") mainVolume(" << mainVolume <<
- ") reserved(" << reserved << ")" <<
- ") available([availability:" << available.availability << " availabilityReason:" << available.availabilityReason << "]"
- ") listSoundProperties (";
- std::for_each(listSoundProperties.begin(), listSoundProperties.end(), [&](const am_SoundProperty_s & ref) {
- fmt << "[type:" << ref.type << " value:" << ref.value <<"]";
- });
- fmt << ") listConnectionFormats (";
- std::for_each(listConnectionFormats.begin(), listConnectionFormats.end(), [&](const am_CustomConnectionFormat_t & ref) {
- fmt << "[" << ref << "]";
- });
- fmt << ") listMainSoundProperties (";
- std::for_each(listMainSoundProperties.begin(), listMainSoundProperties.end(), [&](const am_MainSoundProperty_s & ref) {
- fmt << "[type:" << ref.type << " value:" << ref.value <<"]";
- });
- fmt << ") listMainNotificationConfigurations (";
- std::for_each(listMainNotificationConfigurations.begin(), listMainNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s & ref) {
- fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter <<"]";
- });
- fmt << ") listNotificationConfigurations (";
- std::for_each(listNotificationConfigurations.begin(), listNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s & ref) {
- fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter <<"]";
- });
- fmt << ")" << std::endl;
- outString = fmt.str();
-}
-
-void CAmDatabaseHandlerMap::AmSink::getSinkType(am_SinkType_s & sinkType) const
-{
- sinkType.name = name;
- sinkType.sinkID = sinkID;
- sinkType.availability = available;
- sinkType.muteState = muteState;
- sinkType.volume = mainVolume;
- sinkType.sinkClassID = sinkClassID;
+void CAmDatabaseHandlerMap::AmSink::getDescription(std::string &outString) const
+{
+ std::ostringstream fmt;
+ fmt << "Sink(" << name.c_str() << ") id(" << sinkID << ")" << std::endl <<
+ "sinkClassID(" << sinkClassID <<
+ ") domainID(" << domainID <<
+ ") visible(" << visible <<
+ ") volume(" << volume <<
+ ") muteState(" << muteState <<
+ ") mainVolume(" << mainVolume <<
+ ") reserved(" << reserved << ")" <<
+ ") available([availability:" << available.availability << " availabilityReason:" << available.availabilityReason << "]"
+ ") listSoundProperties (";
+ std::for_each(listSoundProperties.begin(), listSoundProperties.end(), [&](const am_SoundProperty_s &ref) {
+ fmt << "[type:" << ref.type << " value:" << ref.value << "]";
+ });
+ fmt << ") listConnectionFormats (";
+ std::for_each(listConnectionFormats.begin(), listConnectionFormats.end(), [&](const am_CustomConnectionFormat_t &ref) {
+ fmt << "[" << ref << "]";
+ });
+ fmt << ") listMainSoundProperties (";
+ std::for_each(listMainSoundProperties.begin(), listMainSoundProperties.end(), [&](const am_MainSoundProperty_s &ref) {
+ fmt << "[type:" << ref.type << " value:" << ref.value << "]";
+ });
+ fmt << ") listMainNotificationConfigurations (";
+ std::for_each(listMainNotificationConfigurations.begin(), listMainNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s &ref) {
+ fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter << "]";
+ });
+ fmt << ") listNotificationConfigurations (";
+ std::for_each(listNotificationConfigurations.begin(), listNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s &ref) {
+ fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter << "]";
+ });
+ fmt << ")" << std::endl;
+ outString = fmt.str();
+}
+
+void CAmDatabaseHandlerMap::AmSink::getSinkType(am_SinkType_s &sinkType) const
+{
+ sinkType.name = name;
+ sinkType.sinkID = sinkID;
+ sinkType.availability = available;
+ sinkType.muteState = muteState;
+ sinkType.volume = mainVolume;
+ sinkType.sinkClassID = sinkClassID;
}
/* Connection */
-void CAmDatabaseHandlerMap::AmConnection::getDescription (std::string & outString) const
+void CAmDatabaseHandlerMap::AmConnection::getDescription(std::string &outString) const
{
- std::ostringstream fmt;
- fmt << "Connection id(" << connectionID << ") " << std::endl <<
- "sourceID(" << sourceID <<
- ") sinkID(" << sinkID <<
- ") delay(" << delay <<
- ") connectionFormat(" << connectionFormat <<
- ") reserved(" << reserved << ")" << std::endl;
- outString = fmt.str();
+ std::ostringstream fmt;
+ fmt << "Connection id(" << connectionID << ") " << std::endl <<
+ "sourceID(" << sourceID <<
+ ") sinkID(" << sinkID <<
+ ") delay(" << delay <<
+ ") connectionFormat(" << connectionFormat <<
+ ") reserved(" << reserved << ")" << std::endl;
+ outString = fmt.str();
}
/* Main Connection */
-void CAmDatabaseHandlerMap::AmMainConnection::getDescription (std::string & outString) const
+void CAmDatabaseHandlerMap::AmMainConnection::getDescription(std::string &outString) const
{
- std::ostringstream fmt;
- fmt << "MainConnection id(" << mainConnectionID << ") " << std::endl <<
- "connectionState(" << connectionState <<
- ") sinkID(" << sinkID <<
- ") sourceID(" << sourceID <<
- ") delay(" << delay <<
- ") listConnectionID (";
- std::for_each(listConnectionID.begin(), listConnectionID.end(), [&](const am_connectionID_t & connID) {
- fmt << "["<< connID << "]";
- });
- fmt << ")" << std::endl;
- outString = fmt.str();
+ std::ostringstream fmt;
+ fmt << "MainConnection id(" << mainConnectionID << ") " << std::endl <<
+ "connectionState(" << connectionState <<
+ ") sinkID(" << sinkID <<
+ ") sourceID(" << sourceID <<
+ ") delay(" << delay <<
+ ") listConnectionID (";
+ std::for_each(listConnectionID.begin(), listConnectionID.end(), [&](const am_connectionID_t &connID) {
+ fmt << "[" << connID << "]";
+ });
+ fmt << ")" << std::endl;
+ outString = fmt.str();
}
-void CAmDatabaseHandlerMap::am_MainConnection_Database_s::getMainConnectionType(am_MainConnectionType_s & connectionType) const
+void CAmDatabaseHandlerMap::am_MainConnection_Database_s::getMainConnectionType(am_MainConnectionType_s &connectionType) const
{
- connectionType.mainConnectionID = mainConnectionID;
- connectionType.sourceID = sourceID;
- connectionType.sinkID = sinkID;
- connectionType.connectionState = connectionState;
- connectionType.delay = delay;
+ connectionType.mainConnectionID = mainConnectionID;
+ connectionType.sourceID = sourceID;
+ connectionType.sinkID = sinkID;
+ connectionType.connectionState = connectionState;
+ connectionType.delay = delay;
}
/* Source Class */
-void CAmDatabaseHandlerMap::AmSourceClass::getDescription (std::string & outString) const
+void CAmDatabaseHandlerMap::AmSourceClass::getDescription(std::string &outString) const
{
- std::ostringstream fmt;
- fmt << "Source class(" << name.c_str() << ") id(" << sourceClassID << ")\n" <<
- ") listClassProperties (";
- std::for_each(listClassProperties.begin(), listClassProperties.end(), [&](const am_ClassProperty_s & ref) {
- fmt << "[classProperty:" << ref.classProperty << " value:" << ref.value << "]";
- });
- fmt << ")" << std::endl;
- outString = fmt.str();
+ std::ostringstream fmt;
+ fmt << "Source class(" << name.c_str() << ") id(" << sourceClassID << ")\n" <<
+ ") listClassProperties (";
+ std::for_each(listClassProperties.begin(), listClassProperties.end(), [&](const am_ClassProperty_s &ref) {
+ fmt << "[classProperty:" << ref.classProperty << " value:" << ref.value << "]";
+ });
+ fmt << ")" << std::endl;
+ outString = fmt.str();
}
/* Sink Class */
-void CAmDatabaseHandlerMap::AmSinkClass::getDescription (std::string & outString) const
+void CAmDatabaseHandlerMap::AmSinkClass::getDescription(std::string &outString) const
{
- std::ostringstream fmt;
- fmt << "Sink class(" << name.c_str() << ") id(" << sinkClassID << ")\n" <<
- ") listClassProperties (";
- std::for_each(listClassProperties.begin(), listClassProperties.end(), [&](const am_ClassProperty_s & ref) {
- fmt << "[classProperty:" << ref.classProperty << " value:" << ref.value << "]";
- });
- fmt << ")" << std::endl;
- outString = fmt.str();
+ std::ostringstream fmt;
+ fmt << "Sink class(" << name.c_str() << ") id(" << sinkClassID << ")\n" <<
+ ") listClassProperties (";
+ std::for_each(listClassProperties.begin(), listClassProperties.end(), [&](const am_ClassProperty_s &ref) {
+ fmt << "[classProperty:" << ref.classProperty << " value:" << ref.value << "]";
+ });
+ fmt << ")" << std::endl;
+ outString = fmt.str();
}
-
/* Gateway */
-void CAmDatabaseHandlerMap::AmGateway::getDescription (std::string & outString) const
-{
- std::ostringstream fmt;
- fmt << "Gateway(" << name.c_str() << ") id(" << gatewayID << ")\n" <<
- "sinkID(" << sinkID <<
- ") sourceID(" << sourceID <<
- ") domainSinkID(" << domainSinkID <<
- ") domainSourceID(" << domainSourceID <<
- ") controlDomainID(" << controlDomainID <<
- ") listSourceFormats (";
- std::for_each(listSourceFormats.begin(), listSourceFormats.end(), [&](const am_CustomConnectionFormat_t & ref) {
- fmt << "[" << ref << "]";
- });
- fmt << ") listSinkFormats (";
- std::for_each(listSinkFormats.begin(), listSinkFormats.end(), [&](const am_CustomConnectionFormat_t & ref) {
- fmt << "[" << ref << "]";
- });
- fmt << ") convertionMatrix (";
- std::for_each(convertionMatrix.begin(), convertionMatrix.end(), [&](const bool & ref) {
- fmt << "[" << ref << "]";
- });
- fmt << ")" << std::endl;
- outString = fmt.str();
+void CAmDatabaseHandlerMap::AmGateway::getDescription(std::string &outString) const
+{
+ std::ostringstream fmt;
+ fmt << "Gateway(" << name.c_str() << ") id(" << gatewayID << ")\n" <<
+ "sinkID(" << sinkID <<
+ ") sourceID(" << sourceID <<
+ ") domainSinkID(" << domainSinkID <<
+ ") domainSourceID(" << domainSourceID <<
+ ") controlDomainID(" << controlDomainID <<
+ ") listSourceFormats (";
+ std::for_each(listSourceFormats.begin(), listSourceFormats.end(), [&](const am_CustomConnectionFormat_t &ref) {
+ fmt << "[" << ref << "]";
+ });
+ fmt << ") listSinkFormats (";
+ std::for_each(listSinkFormats.begin(), listSinkFormats.end(), [&](const am_CustomConnectionFormat_t &ref) {
+ fmt << "[" << ref << "]";
+ });
+ fmt << ") convertionMatrix (";
+ std::for_each(convertionMatrix.begin(), convertionMatrix.end(), [&](const bool &ref) {
+ fmt << "[" << ref << "]";
+ });
+ fmt << ")" << std::endl;
+ outString = fmt.str();
}
/* Converter */
-void CAmDatabaseHandlerMap::AmConverter::getDescription (std::string & outString) const
-{
- std::ostringstream fmt;
- fmt << "Converter(" << name.c_str() << ") id(" << converterID << ")\n" <<
- "sinkID(" << sinkID <<
- ") sourceID(" << sourceID <<
- ") domainSinkID(" << domainID <<
- ") listSourceFormats (";
- std::for_each(listSourceFormats.begin(), listSourceFormats.end(), [&](const am_CustomConnectionFormat_t & ref) {
- fmt << "[" << ref << "]";
- });
- fmt << ") listSinkFormats (";
- std::for_each(listSinkFormats.begin(), listSinkFormats.end(), [&](const am_CustomConnectionFormat_t & ref) {
- fmt << "[" << ref << "]";
- });
- fmt << ") convertionMatrix (";
- std::for_each(convertionMatrix.begin(), convertionMatrix.end(), [&](const bool & ref) {
- fmt << "[" << ref << "]";
- });
- fmt << ")" << std::endl;
- outString = fmt.str();
+void CAmDatabaseHandlerMap::AmConverter::getDescription(std::string &outString) const
+{
+ std::ostringstream fmt;
+ fmt << "Converter(" << name.c_str() << ") id(" << converterID << ")\n" <<
+ "sinkID(" << sinkID <<
+ ") sourceID(" << sourceID <<
+ ") domainSinkID(" << domainID <<
+ ") listSourceFormats (";
+ std::for_each(listSourceFormats.begin(), listSourceFormats.end(), [&](const am_CustomConnectionFormat_t &ref) {
+ fmt << "[" << ref << "]";
+ });
+ fmt << ") listSinkFormats (";
+ std::for_each(listSinkFormats.begin(), listSinkFormats.end(), [&](const am_CustomConnectionFormat_t &ref) {
+ fmt << "[" << ref << "]";
+ });
+ fmt << ") convertionMatrix (";
+ std::for_each(convertionMatrix.begin(), convertionMatrix.end(), [&](const bool &ref) {
+ fmt << "[" << ref << "]";
+ });
+ fmt << ")" << std::endl;
+ outString = fmt.str();
}
/* Crossfader */
-void CAmDatabaseHandlerMap::AmCrossfader::getDescription (std::string & outString) const
-{
- std::ostringstream fmt;
- fmt << "Crossfader(" << name.c_str() << ") id(" << crossfaderID << ")\n" <<
- "sinkID_A(" << sinkID_A <<
- ") sinkID_B(" << sinkID_B <<
- ") sourceID(" << sourceID <<
- ") hotSink(" << hotSink <<
- ")" << std::endl;
- outString = fmt.str();
-}
-
-bool CAmDatabaseHandlerMap::AmMappedData::increaseID(int16_t & resultID, AmIdentifier & elementID,
- int16_t const desiredStaticID = 0)
-{
- if( desiredStaticID > 0 && desiredStaticID < elementID.mMin )
- {
- resultID = desiredStaticID;
- return true;
- }
- else if( elementID.mCurrentValue < elementID.mMax ) //The last used value is 'limit' - 1. e.g. SHRT_MAX - 1, SHRT_MAX is reserved.
- {
- resultID = elementID.mCurrentValue++;
- return true;
- }
- else
- {
- resultID = -1;
- return false;
- }
-}
-
-template <typename TMapKey,class TMapObject> bool CAmDatabaseHandlerMap::AmMappedData::getNextConnectionID(int16_t & resultID, AmIdentifier & connID,
- const std::unordered_map<TMapKey, TMapObject> & map)
-{
- TMapKey nextID;
- int16_t const lastID = connID.mCurrentValue;
- if( connID.mCurrentValue < connID.mMax )
- nextID = connID.mCurrentValue++;
- else
- nextID = connID.mCurrentValue = connID.mMin;
-
- bool notFreeIDs = false;
- while( existsObjectWithKeyInMap(nextID, map) )
- {
-
- if( connID.mCurrentValue < connID.mMax )
- nextID = connID.mCurrentValue++;
- else
- {
- connID.mCurrentValue = connID.mMin;
- nextID = connID.mCurrentValue;
- }
-
- if( connID.mCurrentValue == lastID )
- {
- notFreeIDs = true;
- break;
- }
- }
- if(notFreeIDs)
- {
- resultID = -1;
- return false;
- }
- resultID = nextID;
- return true;
-}
-
-bool CAmDatabaseHandlerMap::AmMappedData::increaseMainConnectionID(int16_t & resultID)
-{
- return getNextConnectionID(resultID, mCurrentMainConnectionID, mMainConnectionMap);
-}
-
-bool CAmDatabaseHandlerMap::AmMappedData::increaseConnectionID(int16_t & resultID)
-{
- return getNextConnectionID(resultID, mCurrentConnectionID, mConnectionMap);
-}
-
-
-CAmDatabaseHandlerMap::CAmDatabaseHandlerMap(): IAmDatabaseHandler(),
- mFirstStaticSink(true),
- mFirstStaticSource(true),
- mFirstStaticGateway(true),
- mFirstStaticConverter(true),
- mFirstStaticSinkClass(true),
- mFirstStaticSourceClass(true),
- mFirstStaticCrossfader(true),
- mListConnectionFormat(),
- mMappedData(),
- mDatabaseObservers()
-{
- logVerbose(__METHOD_NAME__,"Init ");
+void CAmDatabaseHandlerMap::AmCrossfader::getDescription(std::string &outString) const
+{
+ std::ostringstream fmt;
+ fmt << "Crossfader(" << name.c_str() << ") id(" << crossfaderID << ")\n" <<
+ "sinkID_A(" << sinkID_A <<
+ ") sinkID_B(" << sinkID_B <<
+ ") sourceID(" << sourceID <<
+ ") hotSink(" << hotSink <<
+ ")" << std::endl;
+ outString = fmt.str();
+}
+
+bool CAmDatabaseHandlerMap::AmMappedData::increaseID(int16_t &resultID, AmIdentifier &elementID,
+ int16_t const desiredStaticID = 0)
+{
+ if ( desiredStaticID > 0 && desiredStaticID < elementID.mMin )
+ {
+ resultID = desiredStaticID;
+ return true;
+ }
+ else if ( elementID.mCurrentValue < elementID.mMax ) // The last used value is 'limit' - 1. e.g. SHRT_MAX - 1, SHRT_MAX is reserved.
+ {
+ resultID = elementID.mCurrentValue++;
+ return true;
+ }
+ else
+ {
+ resultID = -1;
+ return false;
+ }
+}
+
+template <typename TMapKey, class TMapObject>
+bool CAmDatabaseHandlerMap::AmMappedData::getNextConnectionID(int16_t &resultID, AmIdentifier &connID,
+ const std::unordered_map<TMapKey, TMapObject> &map)
+{
+ TMapKey nextID;
+ int16_t const lastID = connID.mCurrentValue;
+ if ( connID.mCurrentValue < connID.mMax )
+ {
+ nextID = connID.mCurrentValue++;
+ }
+ else
+ {
+ nextID = connID.mCurrentValue = connID.mMin;
+ }
+
+ bool notFreeIDs = false;
+ while ( existsObjectWithKeyInMap(nextID, map))
+ {
+
+ if ( connID.mCurrentValue < connID.mMax )
+ {
+ nextID = connID.mCurrentValue++;
+ }
+ else
+ {
+ connID.mCurrentValue = connID.mMin;
+ nextID = connID.mCurrentValue;
+ }
+
+ if ( connID.mCurrentValue == lastID )
+ {
+ notFreeIDs = true;
+ break;
+ }
+ }
+
+ if (notFreeIDs)
+ {
+ resultID = -1;
+ return false;
+ }
+
+ resultID = nextID;
+ return true;
+}
+
+bool CAmDatabaseHandlerMap::AmMappedData::increaseMainConnectionID(int16_t &resultID)
+{
+ return getNextConnectionID(resultID, mCurrentMainConnectionID, mMainConnectionMap);
+}
+
+bool CAmDatabaseHandlerMap::AmMappedData::increaseConnectionID(int16_t &resultID)
+{
+ return getNextConnectionID(resultID, mCurrentConnectionID, mConnectionMap);
+}
+
+CAmDatabaseHandlerMap::CAmDatabaseHandlerMap()
+ : IAmDatabaseHandler()
+ , mFirstStaticSink(true)
+ , mFirstStaticSource(true)
+ , mFirstStaticGateway(true)
+ , mFirstStaticConverter(true)
+ , mFirstStaticSinkClass(true)
+ , mFirstStaticSourceClass(true)
+ , mFirstStaticCrossfader(true)
+ , mListConnectionFormat()
+ , mMappedData()
+ , mDatabaseObservers()
+{
+ logVerbose(__METHOD_NAME__, "Init ");
}
CAmDatabaseHandlerMap::~CAmDatabaseHandlerMap()
{
- logVerbose(__METHOD_NAME__,"Destroy");
- for(AmDatabaseObserverCallbacks * ptr: mDatabaseObservers)
- ptr->mpDatabaseHandler=nullptr;
+ logVerbose(__METHOD_NAME__, "Destroy");
+ for (AmDatabaseObserverCallbacks *ptr: mDatabaseObservers)
+ {
+ ptr->mpDatabaseHandler = nullptr;
+ }
}
-am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
+am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s &domainData, am_domainID_t &domainID)
{
- if(domainData.name.empty())
+ if (domainData.name.empty())
{
- logError(__METHOD_NAME__,"DomainName must not be emtpy!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "DomainName must not be emtpy!");
+ return (E_NOT_POSSIBLE);
}
- if(domainData.busname.empty())
+
+ if (domainData.busname.empty())
{
- logError(__METHOD_NAME__,"Busname must not be emtpy!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "Busname must not be emtpy!");
+ return (E_NOT_POSSIBLE);
}
- if(!(domainData.state>=DS_UNKNOWN && domainData.state<=DS_MAX))
+
+ if (!(domainData.state >= DS_UNKNOWN && domainData.state <= DS_MAX))
{
- logError(__METHOD_NAME__,"State must not be valid!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "State must not be valid!");
+ return (E_NOT_POSSIBLE);
}
- //first check for a reserved domain
- am_Domain_s const *reservedDomain = objectMatchingPredicate<AmDomain, am_domainID_t>(mMappedData.mDomainMap, [&](const AmDomain & obj){
- return domainData.name.compare(obj.name)==0;
- });
+
+ // first check for a reserved domain
+ am_Domain_s const *reservedDomain = objectMatchingPredicate<AmDomain, am_domainID_t>(mMappedData.mDomainMap, [&](const AmDomain &obj){
+ return domainData.name.compare(obj.name) == 0;
+ });
int16_t nextID = 0;
- if( NULL != reservedDomain )
+ if ( NULL != reservedDomain )
{
- nextID = reservedDomain->domainID;
- domainID = nextID;
- mMappedData.mDomainMap[nextID] = domainData;
- mMappedData.mDomainMap[nextID].domainID = nextID;
- mMappedData.mDomainMap[nextID].reserved = 0;
- logVerbose("DatabaseHandler::enterDomainDB entered reserved domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "reserved ID:", domainID);
+ nextID = reservedDomain->domainID;
+ domainID = nextID;
+ mMappedData.mDomainMap[nextID] = domainData;
+ mMappedData.mDomainMap[nextID].domainID = nextID;
+ mMappedData.mDomainMap[nextID].reserved = 0;
+ logVerbose("DatabaseHandler::enterDomainDB entered reserved domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "reserved ID:", domainID);
- NOTIFY_OBSERVERS1(dboNewDomain, mMappedData.mDomainMap[nextID])
+ NOTIFY_OBSERVERS1(dboNewDomain, mMappedData.mDomainMap[nextID])
- return (E_OK);
+ return (E_OK);
}
else
{
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentDomainID, domainData.domainID))
- {
- domainID = nextID;
- mMappedData.mDomainMap[nextID] = domainData;
- mMappedData.mDomainMap[nextID].domainID = nextID;
- logVerbose("DatabaseHandler::enterDomainDB entered new domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "assigned ID:", domainID);
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentDomainID, domainData.domainID))
+ {
+ domainID = nextID;
+ mMappedData.mDomainMap[nextID] = domainData;
+ mMappedData.mDomainMap[nextID].domainID = nextID;
+ logVerbose("DatabaseHandler::enterDomainDB entered new domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "assigned ID:", domainID);
- NOTIFY_OBSERVERS1(dboNewDomain, mMappedData.mDomainMap[nextID])
+ NOTIFY_OBSERVERS1(dboNewDomain, mMappedData.mDomainMap[nextID])
- return (E_OK);
- }
- else
- {
- domainID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (E_UNKNOWN);
- }
+ return (E_OK);
+ }
+ else
+ {
+ domainID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (E_UNKNOWN);
+ }
}
}
-int16_t CAmDatabaseHandlerMap::calculateDelayForRoute(const std::vector<am_connectionID_t>& listConnectionID)
+int16_t CAmDatabaseHandlerMap::calculateDelayForRoute(const std::vector<am_connectionID_t> &listConnectionID)
{
- int16_t delay = 0;
- std::vector<am_connectionID_t>::const_iterator elementIterator = listConnectionID.begin();
- for (; elementIterator < listConnectionID.end(); ++elementIterator)
- {
- am_connectionID_t key = *elementIterator;
- std::unordered_map<am_connectionID_t, am_Connection_Database_s>::const_iterator it = mMappedData.mConnectionMap.find(key);
- if (it!=mMappedData.mConnectionMap.end())
- {
- int16_t temp_delay = it->second.delay;
- if (temp_delay != -1 && delay != -1)
- delay += temp_delay;
- else
- delay = -1;
- }
- }
- return delay;
+ int16_t delay = 0;
+ std::vector<am_connectionID_t>::const_iterator elementIterator = listConnectionID.begin();
+ for (; elementIterator < listConnectionID.end(); ++elementIterator)
+ {
+ am_connectionID_t key = *elementIterator;
+ std::unordered_map<am_connectionID_t, am_Connection_Database_s>::const_iterator it = mMappedData.mConnectionMap.find(key);
+ if (it != mMappedData.mConnectionMap.end())
+ {
+ int16_t temp_delay = it->second.delay;
+ if (temp_delay != -1 && delay != -1)
+ {
+ delay += temp_delay;
+ }
+ else
+ {
+ delay = -1;
+ }
+ }
+ }
+
+ return delay;
}
-am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
+am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_s &mainConnectionData, am_mainConnectionID_t &connectionID)
{
- if(mainConnectionData.mainConnectionID!=0)
+ if (mainConnectionData.mainConnectionID != 0)
{
- logError(__METHOD_NAME__,"mainConnectionID must be 0!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "mainConnectionID must be 0!");
+ return (E_NOT_POSSIBLE);
}
- if(!(mainConnectionData.connectionState>=CS_UNKNOWN && mainConnectionData.connectionState<=CS_MAX))
+
+ if (!(mainConnectionData.connectionState >= CS_UNKNOWN && mainConnectionData.connectionState <= CS_MAX))
{
- logError(__METHOD_NAME__,"connectionState must be valid!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "connectionState must be valid!");
+ return (E_NOT_POSSIBLE);
}
- if(!existSink(mainConnectionData.sinkID))
+
+ if (!existSink(mainConnectionData.sinkID))
{
- logError(__METHOD_NAME__,"sinkID must be valid!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkID must be valid!");
+ return (E_NOT_POSSIBLE);
}
- if(!existSource(mainConnectionData.sourceID))
+
+ if (!existSource(mainConnectionData.sourceID))
{
- logError(__METHOD_NAME__,"sourceID must be valid!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sourceID must be valid!");
+ return (E_NOT_POSSIBLE);
}
- int16_t delay = 0;
+ int16_t delay = 0;
int16_t nextID = 0;
- if(mMappedData.increaseMainConnectionID(nextID))
- {
- connectionID = nextID;
- mMappedData.mMainConnectionMap[nextID] = mainConnectionData;
- mMappedData.mMainConnectionMap[nextID].mainConnectionID = nextID;
- }
- else
- {
- connectionID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (E_UNKNOWN);
- }
-
- //now check the connectionTable for all connections in the route. IF connectionID exist
+ if (mMappedData.increaseMainConnectionID(nextID))
+ {
+ connectionID = nextID;
+ mMappedData.mMainConnectionMap[nextID] = mainConnectionData;
+ mMappedData.mMainConnectionMap[nextID].mainConnectionID = nextID;
+ }
+ else
+ {
+ connectionID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (E_UNKNOWN);
+ }
+
+ // now check the connectionTable for all connections in the route. IF connectionID exist
delay = calculateDelayForRoute(mainConnectionData.listConnectionID);
logVerbose("DatabaseHandler::enterMainConnectionDB entered new mainConnection with sourceID", mainConnectionData.sourceID, "sinkID:", mainConnectionData.sinkID, "delay:", delay, "assigned ID:", connectionID);
-
if (mDatabaseObservers.size())
{
- am_MainConnectionType_s mainConnection;
- mMappedData.mMainConnectionMap[nextID].getMainConnectionType(mainConnection);
+ am_MainConnectionType_s mainConnection;
+ mMappedData.mMainConnectionMap[nextID].getMainConnectionType(mainConnection);
NOTIFY_OBSERVERS1(dboNewMainConnection, mainConnection)
NOTIFY_OBSERVERS2(dboMainConnectionStateChanged, connectionID, mMappedData.mMainConnectionMap[nextID].connectionState)
}
- //finally, we update the delay value for the maintable
+ // finally, we update the delay value for the maintable
if (delay == 0)
+ {
delay = -1;
+ }
+
(void)changeDelayMainConnection(delay, connectionID);
return (E_OK);
@@ -618,258 +653,278 @@ am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_
* Helper method, that inserts a new struct in the map and copies the given into it.
* This method uses the increaseID function to secure the global id is properly increased.
**/
-bool CAmDatabaseHandlerMap::insertSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+bool CAmDatabaseHandlerMap::insertSinkDB(const am_Sink_s &sinkData, am_sinkID_t &sinkID)
{
int16_t nextID = 0;
- if( mMappedData.increaseID(nextID, mMappedData.mCurrentSinkID, sinkData.sinkID) )
- {
- sinkID = nextID;
- mMappedData.mSinkMap[nextID] = sinkData;
- mMappedData.mSinkMap[nextID].sinkID = nextID;
- filterDuplicateNotificationConfigurationTypes(mMappedData.mSinkMap[nextID].listNotificationConfigurations);
- filterDuplicateNotificationConfigurationTypes(mMappedData.mSinkMap[nextID].listMainNotificationConfigurations);
- return (true);
- }
- else
- {
- sinkID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached!");
- return (false);
- }
+ if ( mMappedData.increaseID(nextID, mMappedData.mCurrentSinkID, sinkData.sinkID))
+ {
+ sinkID = nextID;
+ mMappedData.mSinkMap[nextID] = sinkData;
+ mMappedData.mSinkMap[nextID].sinkID = nextID;
+ filterDuplicateNotificationConfigurationTypes(mMappedData.mSinkMap[nextID].listNotificationConfigurations);
+ filterDuplicateNotificationConfigurationTypes(mMappedData.mSinkMap[nextID].listMainNotificationConfigurations);
+ return (true);
+ }
+ else
+ {
+ sinkID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached!");
+ return (false);
+ }
}
-am_Error_e CAmDatabaseHandlerMap::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+am_Error_e CAmDatabaseHandlerMap::enterSinkDB(const am_Sink_s &sinkData, am_sinkID_t &sinkID)
{
- if(sinkData.sinkID>=DYNAMIC_ID_BOUNDARY)
+ if (sinkData.sinkID >= DYNAMIC_ID_BOUNDARY)
{
- logError(__METHOD_NAME__,"sinkID must be below:",DYNAMIC_ID_BOUNDARY);
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkID must be below:", DYNAMIC_ID_BOUNDARY);
+ return (E_NOT_POSSIBLE);
}
- if(!existDomain(sinkData.domainID))
+
+ if (!existDomain(sinkData.domainID))
{
- logError(__METHOD_NAME__,"domainID must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "domainID must be valid");
+ return (E_NOT_POSSIBLE);
}
- if(sinkData.name.empty())
+
+ if (sinkData.name.empty())
{
- logError(__METHOD_NAME__,"sinkName must not be zero");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkName must not be zero");
+ return (E_NOT_POSSIBLE);
}
- if(!existSinkClass(sinkData.sinkClassID))
+
+ if (!existSinkClass(sinkData.sinkClassID))
{
- logError(__METHOD_NAME__,"sinkClass must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkClass must be valid");
+ return (E_NOT_POSSIBLE);
}
- if(!(sinkData.muteState>=MS_UNKNOWN && sinkData.muteState<=MS_MAX))
+ if (!(sinkData.muteState >= MS_UNKNOWN && sinkData.muteState <= MS_MAX))
{
- logError(__METHOD_NAME__,"muteState must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "muteState must be valid");
+ return (E_NOT_POSSIBLE);
}
- am_sinkID_t temp_SinkID = 0;
+ am_sinkID_t temp_SinkID = 0;
am_sinkID_t temp_SinkIndex = 0;
- //if sinkID is zero and the first Static Sink was already entered, the ID is created
- am_Sink_s const *reservedDomain = objectMatchingPredicate<AmSink, am_sinkID_t>(mMappedData.mSinkMap, [&](const AmSink & obj){
- return true==obj.reserved && obj.name.compare(sinkData.name)==0;
- });
- if( NULL!=reservedDomain )
- {
- am_sinkID_t oldSinkID = reservedDomain->sinkID;
- mMappedData.mSinkMap[oldSinkID] = sinkData;
- mMappedData.mSinkMap[oldSinkID].reserved = 0;
- temp_SinkID = oldSinkID;
- temp_SinkIndex = oldSinkID;
+ // if sinkID is zero and the first Static Sink was already entered, the ID is created
+ am_Sink_s const *reservedDomain = objectMatchingPredicate<AmSink, am_sinkID_t>(mMappedData.mSinkMap, [&](const AmSink &obj){
+ return true == obj.reserved && obj.name.compare(sinkData.name) == 0;
+ });
+ if ( NULL != reservedDomain )
+ {
+ am_sinkID_t oldSinkID = reservedDomain->sinkID;
+ mMappedData.mSinkMap[oldSinkID] = sinkData;
+ mMappedData.mSinkMap[oldSinkID].reserved = 0;
+ temp_SinkID = oldSinkID;
+ temp_SinkIndex = oldSinkID;
}
else
{
- bool result;
- if ( sinkData.sinkID != 0 || mFirstStaticSink )
- {
- //check if the ID already exists
- if (existSinkNameOrID(sinkData.sinkID, sinkData.name))
- {
- sinkID = sinkData.sinkID;
- return (E_ALREADY_EXISTS);
- }
- }
- result = insertSinkDB(sinkData, temp_SinkID);
- if( false == result )
- return (E_UNKNOWN);
- temp_SinkIndex = temp_SinkID;
- }
- //if the first static sink is entered, we need to set it onto the boundary
+ bool result;
+ if ( sinkData.sinkID != 0 || mFirstStaticSink )
+ {
+ // check if the ID already exists
+ if (existSinkNameOrID(sinkData.sinkID, sinkData.name))
+ {
+ sinkID = sinkData.sinkID;
+ return (E_ALREADY_EXISTS);
+ }
+ }
+
+ result = insertSinkDB(sinkData, temp_SinkID);
+ if ( false == result )
+ {
+ return (E_UNKNOWN);
+ }
+
+ temp_SinkIndex = temp_SinkID;
+ }
+
+ // if the first static sink is entered, we need to set it onto the boundary
if (sinkData.sinkID == 0 && mFirstStaticSink)
{
mFirstStaticSink = false;
}
+
mMappedData.mSinkMap[temp_SinkIndex].sinkID = temp_SinkID;
- sinkID = temp_SinkID;
+ sinkID = temp_SinkID;
- am_Sink_s & sink = mMappedData.mSinkMap[temp_SinkID];
+ am_Sink_s &sink = mMappedData.mSinkMap[temp_SinkID];
logVerbose("DatabaseHandler::enterSinkDB entered new sink with name", sink.name, "domainID:", sink.domainID, "classID:", sink.sinkClassID, "volume:", sink.volume, "assigned ID:", sink.sinkID);
- sink.sinkID=sinkID;
- NOTIFY_OBSERVERS1(dboNewSink, sink)
+ sink.sinkID = sinkID;
+ NOTIFY_OBSERVERS1(dboNewSink, sink)
return (E_OK);
}
-bool CAmDatabaseHandlerMap::insertCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+bool CAmDatabaseHandlerMap::insertCrossfaderDB(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID)
{
int16_t nextID = 0;
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentCrossfaderID, crossfaderData.crossfaderID))
- {
- crossfaderID = nextID;
- mMappedData.mCrossfaderMap[nextID] = crossfaderData;
- mMappedData.mCrossfaderMap[nextID].crossfaderID = nextID;
- return (true);
- }
- else
- {
- crossfaderID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (false);
- }
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentCrossfaderID, crossfaderData.crossfaderID))
+ {
+ crossfaderID = nextID;
+ mMappedData.mCrossfaderMap[nextID] = crossfaderData;
+ mMappedData.mCrossfaderMap[nextID].crossfaderID = nextID;
+ return (true);
+ }
+ else
+ {
+ crossfaderID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (false);
+ }
}
-am_Error_e CAmDatabaseHandlerMap::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+am_Error_e CAmDatabaseHandlerMap::enterCrossfaderDB(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID)
{
- if(crossfaderData.crossfaderID>=DYNAMIC_ID_BOUNDARY)
+ if (crossfaderData.crossfaderID >= DYNAMIC_ID_BOUNDARY)
{
- logError(__METHOD_NAME__,"crossfaderID must be below:",DYNAMIC_ID_BOUNDARY);
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "crossfaderID must be below:", DYNAMIC_ID_BOUNDARY);
+ return (E_NOT_POSSIBLE);
}
- if(!(crossfaderData.hotSink>=HS_UNKNOWN && crossfaderData.hotSink<=HS_MAX))
+ if (!(crossfaderData.hotSink >= HS_UNKNOWN && crossfaderData.hotSink <= HS_MAX))
{
- logError(__METHOD_NAME__,"hotSink must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "hotSink must be valid");
+ return (E_NOT_POSSIBLE);
}
- if(crossfaderData.name.empty())
+
+ if (crossfaderData.name.empty())
{
- logError(__METHOD_NAME__,"crossfaderName must not be zero");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "crossfaderName must not be zero");
+ return (E_NOT_POSSIBLE);
}
- if(!existSink(crossfaderData.sinkID_A))
+ if (!existSink(crossfaderData.sinkID_A))
{
- logError(__METHOD_NAME__,"sinkID_A must exist");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkID_A must exist");
+ return (E_NOT_POSSIBLE);
}
- if(!existSink(crossfaderData.sinkID_B))
+
+ if (!existSink(crossfaderData.sinkID_B))
{
- logError(__METHOD_NAME__,"sinkID_B must exist");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkID_B must exist");
+ return (E_NOT_POSSIBLE);
}
- if(!existSource(crossfaderData.sourceID))
+
+ if (!existSource(crossfaderData.sourceID))
{
- logError(__METHOD_NAME__,"sourceID must exist");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sourceID must exist");
+ return (E_NOT_POSSIBLE);
}
- am_crossfaderID_t temp_CrossfaderID = 0;
+ am_crossfaderID_t temp_CrossfaderID = 0;
am_crossfaderID_t temp_CrossfaderIndex = 0;
bool result;
- //if gatewayData is zero and the first Static Sink was already entered, the ID is created
+ // if gatewayData is zero and the first Static Sink was already entered, the ID is created
if (crossfaderData.crossfaderID != 0 || mFirstStaticCrossfader)
{
- //check if the ID already exists
+ // check if the ID already exists
if (existCrossFader(crossfaderData.crossfaderID))
{
- crossfaderID = crossfaderData.crossfaderID;
+ crossfaderID = crossfaderData.crossfaderID;
return (E_ALREADY_EXISTS);
}
}
+
result = insertCrossfaderDB(crossfaderData, temp_CrossfaderID);
- if( false == result )
- return (E_UNKNOWN);
- temp_CrossfaderIndex = temp_CrossfaderID;
+ if ( false == result )
+ {
+ return (E_UNKNOWN);
+ }
+
+ temp_CrossfaderIndex = temp_CrossfaderID;
- //if the first static sink is entered, we need to set it onto the boundary
- if ( 0==crossfaderData.crossfaderID && mFirstStaticCrossfader)
+ // if the first static sink is entered, we need to set it onto the boundary
+ if ( 0 == crossfaderData.crossfaderID && mFirstStaticCrossfader)
{
mFirstStaticCrossfader = false;
}
- mMappedData.mCrossfaderMap[temp_CrossfaderIndex].crossfaderID = temp_CrossfaderID;
- crossfaderID = temp_CrossfaderID;
- logVerbose("DatabaseHandler::enterCrossfaderDB entered new crossfader with name=", crossfaderData.name, "sinkA= ", crossfaderData.sinkID_A, "sinkB=", crossfaderData.sinkID_B, "source=", crossfaderData.sourceID, "assigned ID:", crossfaderID);
+ mMappedData.mCrossfaderMap[temp_CrossfaderIndex].crossfaderID = temp_CrossfaderID;
+ crossfaderID = temp_CrossfaderID;
+ logVerbose("DatabaseHandler::enterCrossfaderDB entered new crossfader with name=", crossfaderData.name, "sinkA= ", crossfaderData.sinkID_A, "sinkB=", crossfaderData.sinkID_B, "source=", crossfaderData.sourceID, "assigned ID:", crossfaderID);
- NOTIFY_OBSERVERS1(dboNewCrossfader, mMappedData.mCrossfaderMap[temp_CrossfaderIndex])
+ NOTIFY_OBSERVERS1(dboNewCrossfader, mMappedData.mCrossfaderMap[temp_CrossfaderIndex])
return (E_OK);
}
-bool CAmDatabaseHandlerMap::insertGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+bool CAmDatabaseHandlerMap::insertGatewayDB(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID)
{
int16_t nextID = 0;
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentGatewayID, gatewayData.gatewayID))
- {
- gatewayID = nextID;
- mMappedData.mGatewayMap[nextID] = gatewayData;
- mMappedData.mGatewayMap[nextID].gatewayID = nextID;
- return (true);
- }
- else
- {
- gatewayID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (false);
- }
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentGatewayID, gatewayData.gatewayID))
+ {
+ gatewayID = nextID;
+ mMappedData.mGatewayMap[nextID] = gatewayData;
+ mMappedData.mGatewayMap[nextID].gatewayID = nextID;
+ return (true);
+ }
+ else
+ {
+ gatewayID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (false);
+ }
}
-am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID)
{
- if(gatewayData.gatewayID>=DYNAMIC_ID_BOUNDARY)
+ if (gatewayData.gatewayID >= DYNAMIC_ID_BOUNDARY)
{
- logError(__METHOD_NAME__,"gatewayID must be below:",DYNAMIC_ID_BOUNDARY);
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "gatewayID must be below:", DYNAMIC_ID_BOUNDARY);
+ return (E_NOT_POSSIBLE);
}
- if(!existDomain(gatewayData.controlDomainID))
+ if (!existDomain(gatewayData.controlDomainID))
{
- logError(__METHOD_NAME__,"controlDomainID must be exist");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "controlDomainID must be exist");
+ return (E_NOT_POSSIBLE);
}
- if(gatewayData.name.empty())
+ if (gatewayData.name.empty())
{
- logError(__METHOD_NAME__,"gatewayName must not be empty");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "gatewayName must not be empty");
+ return (E_NOT_POSSIBLE);
}
- //might be that the sinks and sources are not there during registration time
- //assert(existSink(gatewayData.sinkID));
- //assert(existSource(gatewayData.sourceID));
+ // might be that the sinks and sources are not there during registration time
+ // assert(existSink(gatewayData.sinkID));
+ // assert(existSource(gatewayData.sourceID));
- am_gatewayID_t temp_GatewayID = 0;
+ am_gatewayID_t temp_GatewayID = 0;
am_gatewayID_t temp_GatewayIndex = 0;
- //if gatewayData is zero and the first Static Sink was already entered, the ID is created
+ // if gatewayData is zero and the first Static Sink was already entered, the ID is created
bool result;
if (gatewayData.gatewayID != 0 || mFirstStaticGateway)
{
- //check if the ID already exists
+ // check if the ID already exists
if (existGateway(gatewayData.gatewayID))
{
- gatewayID = gatewayData.gatewayID;
+ gatewayID = gatewayData.gatewayID;
return (E_ALREADY_EXISTS);
}
}
+
result = insertGatewayDB(gatewayData, temp_GatewayID);
- if( false == result )
- return (E_UNKNOWN);
+ if ( false == result )
+ {
+ return (E_UNKNOWN);
+ }
- temp_GatewayIndex = temp_GatewayID;
- //if the ID is not created, we add it to the query
+ temp_GatewayIndex = temp_GatewayID;
+ // if the ID is not created, we add it to the query
if (gatewayData.gatewayID == 0 && mFirstStaticGateway)
{
mFirstStaticGateway = false;
}
+
mMappedData.mGatewayMap[temp_GatewayIndex].gatewayID = temp_GatewayID;
- gatewayID = temp_GatewayID;
+ gatewayID = temp_GatewayID;
logVerbose("DatabaseHandler::enterGatewayDB entered new gateway with name", gatewayData.name, "sourceID:", gatewayData.sourceID, "sinkID:", gatewayData.sinkID, "assigned ID:", gatewayID);
@@ -877,85 +932,89 @@ am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s & gatewayDat
return (E_OK);
}
-bool CAmDatabaseHandlerMap::insertConverterDB(const am_Converter_s & converteData, am_converterID_t & converterID)
+bool CAmDatabaseHandlerMap::insertConverterDB(const am_Converter_s &converteData, am_converterID_t &converterID)
{
int16_t nextID = 0;
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentConverterID, converteData.converterID))
- {
- converterID = nextID;
- mMappedData.mConverterMap[nextID] = converteData;
- mMappedData.mConverterMap[nextID].converterID = nextID;
- return (true);
- }
- else
- {
- converterID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (false);
- }
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentConverterID, converteData.converterID))
+ {
+ converterID = nextID;
+ mMappedData.mConverterMap[nextID] = converteData;
+ mMappedData.mConverterMap[nextID].converterID = nextID;
+ return (true);
+ }
+ else
+ {
+ converterID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (false);
+ }
}
-am_Error_e CAmDatabaseHandlerMap::enterConverterDB(const am_Converter_s & converterData, am_converterID_t & converterID)
+am_Error_e CAmDatabaseHandlerMap::enterConverterDB(const am_Converter_s &converterData, am_converterID_t &converterID)
{
- if(converterData.converterID>=DYNAMIC_ID_BOUNDARY)
+ if (converterData.converterID >= DYNAMIC_ID_BOUNDARY)
{
- logError(__METHOD_NAME__,"converterID must be below:",DYNAMIC_ID_BOUNDARY);
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "converterID must be below:", DYNAMIC_ID_BOUNDARY);
+ return (E_NOT_POSSIBLE);
}
- if(!existSink(converterData.sinkID))
+ if (!existSink(converterData.sinkID))
{
- logError(__METHOD_NAME__,"sinkID must exists");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkID must exists");
+ return (E_NOT_POSSIBLE);
}
- if(!existSource(converterData.sourceID))
+ if (!existSource(converterData.sourceID))
{
- logError(__METHOD_NAME__,"sourceID must exists");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sourceID must exists");
+ return (E_NOT_POSSIBLE);
}
- if(!existDomain(converterData.domainID))
+ if (!existDomain(converterData.domainID))
{
- logError(__METHOD_NAME__,"domainID must exists");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "domainID must exists");
+ return (E_NOT_POSSIBLE);
}
- if(converterData.name.empty())
+ if (converterData.name.empty())
{
- logError(__METHOD_NAME__,"converterName must not be empty");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "converterName must not be empty");
+ return (E_NOT_POSSIBLE);
}
- //might be that the sinks and sources are not there during registration time
- //assert(existSink(gatewayData.sinkID));
- //assert(existSource(gatewayData.sourceID));
+ // might be that the sinks and sources are not there during registration time
+ // assert(existSink(gatewayData.sinkID));
+ // assert(existSource(gatewayData.sourceID));
- am_converterID_t tempID = 0;
+ am_converterID_t tempID = 0;
am_converterID_t tempIndex = 0;
- //if gatewayData is zero and the first Static Sink was already entered, the ID is created
+ // if gatewayData is zero and the first Static Sink was already entered, the ID is created
bool result;
if (converterData.converterID != 0 || mFirstStaticConverter)
{
- //check if the ID already exists
+ // check if the ID already exists
if (existConverter(converterData.converterID))
{
- converterID = converterData.converterID;
+ converterID = converterData.converterID;
return (E_ALREADY_EXISTS);
}
}
+
result = insertConverterDB(converterData, tempID);
- if( false == result )
- return (E_UNKNOWN);
+ if ( false == result )
+ {
+ return (E_UNKNOWN);
+ }
- tempIndex = tempID;
- //if the ID is not created, we add it to the query
+ tempIndex = tempID;
+ // if the ID is not created, we add it to the query
if (converterData.converterID == 0 && mFirstStaticConverter)
{
- mFirstStaticConverter = false;
+ mFirstStaticConverter = false;
}
+
mMappedData.mConverterMap[tempIndex].converterID = tempID;
- converterID = tempID;
+ converterID = tempID;
logVerbose("DatabaseHandler::enterConverterDB entered new converter with name", converterData.name, "sourceID:", converterData.sourceID, "sinkID:", converterData.sinkID, "assigned ID:", converterID);
NOTIFY_OBSERVERS1(dboNewConverter, mMappedData.mConverterMap[tempIndex])
@@ -963,113 +1022,124 @@ am_Error_e CAmDatabaseHandlerMap::enterConverterDB(const am_Converter_s & conver
return (E_OK);
}
-void CAmDatabaseHandlerMap::dump( std::ostream & output ) const
+void CAmDatabaseHandlerMap::dump(std::ostream &output) const
{
- output << std::endl << "****************** DUMP START ******************" << std::endl;
- AmMappedData::printMap(mMappedData.mDomainMap, output);
- AmMappedData::printMap(mMappedData.mSourceMap, output);
- AmMappedData::printMap(mMappedData.mSinkMap, output);
- AmMappedData::printMap(mMappedData.mSourceClassesMap, output);
- AmMappedData::printMap(mMappedData.mSinkClassesMap, output);
- AmMappedData::printMap(mMappedData.mConnectionMap, output);
- AmMappedData::printMap(mMappedData.mMainConnectionMap, output);
- AmMappedData::printMap(mMappedData.mCrossfaderMap, output);
- AmMappedData::printMap(mMappedData.mGatewayMap, output);
- AmVectorSystemProperties::const_iterator iter = mMappedData.mSystemProperties.begin();
- output << "System properties" << "\n";
- for(; iter!=mMappedData.mSystemProperties.end(); iter++)
- output << "[type:" << iter->type << " value:" << iter->value << "]";
- output << std::endl << "****************** DUMP END ******************" << std::endl;
+ output << std::endl << "****************** DUMP START ******************" << std::endl;
+ AmMappedData::printMap(mMappedData.mDomainMap, output);
+ AmMappedData::printMap(mMappedData.mSourceMap, output);
+ AmMappedData::printMap(mMappedData.mSinkMap, output);
+ AmMappedData::printMap(mMappedData.mSourceClassesMap, output);
+ AmMappedData::printMap(mMappedData.mSinkClassesMap, output);
+ AmMappedData::printMap(mMappedData.mConnectionMap, output);
+ AmMappedData::printMap(mMappedData.mMainConnectionMap, output);
+ AmMappedData::printMap(mMappedData.mCrossfaderMap, output);
+ AmMappedData::printMap(mMappedData.mGatewayMap, output);
+ AmVectorSystemProperties::const_iterator iter = mMappedData.mSystemProperties.begin();
+ output << "System properties" << "\n";
+ for (; iter != mMappedData.mSystemProperties.end(); iter++)
+ {
+ output << "[type:" << iter->type << " value:" << iter->value << "]";
+ }
+
+ output << std::endl << "****************** DUMP END ******************" << std::endl;
}
-bool CAmDatabaseHandlerMap::insertSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+bool CAmDatabaseHandlerMap::insertSourceDB(const am_Source_s &sourceData, am_sourceID_t &sourceID)
{
int16_t nextID = 0;
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentSourceID, sourceData.sourceID))
- {
- sourceID = nextID;
- mMappedData.mSourceMap[nextID] = sourceData;
- mMappedData.mSourceMap[nextID].sourceID = nextID;
- filterDuplicateNotificationConfigurationTypes(mMappedData.mSourceMap[nextID].listNotificationConfigurations);
- filterDuplicateNotificationConfigurationTypes(mMappedData.mSourceMap[nextID].listMainNotificationConfigurations);
- return (true);
- }
- else
- {
- sourceID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (false);
- }
-}
-
-am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
-{
- if(sourceData.sourceID>=DYNAMIC_ID_BOUNDARY)
- {
- logError(__METHOD_NAME__,"sourceID must be below:",DYNAMIC_ID_BOUNDARY);
- return (E_NOT_POSSIBLE);
- }
- if(!existDomain(sourceData.domainID))
- {
- logError(__METHOD_NAME__,"domainID must be valid");
- return (E_NOT_POSSIBLE);
- }
- if(sourceData.name.empty())
- {
- logError(__METHOD_NAME__,"sourceName must not be zero");
- return (E_NOT_POSSIBLE);
- }
- if(!existSourceClass(sourceData.sourceClassID))
- {
- logError(__METHOD_NAME__,"sourceClassID must be valid");
- return (E_NOT_POSSIBLE);
- }
-
- if(!(sourceData.sourceState>=SS_UNKNNOWN && sourceData.sourceState<=SS_MAX))
- {
- logError(__METHOD_NAME__,"sourceState must be valid");
- return (E_NOT_POSSIBLE);
- }
-
- bool isFirstStatic = sourceData.sourceID == 0 && mFirstStaticSource;
- am_sourceID_t temp_SourceID = 0;
- am_sourceID_t temp_SourceIndex = 0;
- AmSource const *reservedSource = objectMatchingPredicate<AmSource, am_sourceID_t>(mMappedData.mSourceMap, [&](const AmSource & obj){
- return true==obj.reserved && obj.name.compare(sourceData.name)==0;
- });
- if( NULL != reservedSource )
- {
- am_sourceID_t oldSourceID = reservedSource->sourceID;
- mMappedData.mSourceMap[oldSourceID] = sourceData;
- mMappedData.mSourceMap[oldSourceID].reserved = 0;
- temp_SourceID = oldSourceID;
- temp_SourceIndex = oldSourceID;
- }
- else
- {
- bool result;
- if ( !isFirstStatic )
- {
- //check if the ID already exists
- if (existSourceNameOrID(sourceData.sourceID, sourceData.name))
- {
- sourceID = sourceData.sourceID;
- return (E_ALREADY_EXISTS);
- }
- }
- result = insertSourceDB(sourceData, temp_SourceID);
- if( false == result )
- return (E_UNKNOWN);
- temp_SourceIndex = temp_SourceID;
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentSourceID, sourceData.sourceID))
+ {
+ sourceID = nextID;
+ mMappedData.mSourceMap[nextID] = sourceData;
+ mMappedData.mSourceMap[nextID].sourceID = nextID;
+ filterDuplicateNotificationConfigurationTypes(mMappedData.mSourceMap[nextID].listNotificationConfigurations);
+ filterDuplicateNotificationConfigurationTypes(mMappedData.mSourceMap[nextID].listMainNotificationConfigurations);
+ return (true);
+ }
+ else
+ {
+ sourceID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (false);
+ }
+}
+
+am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s &sourceData, am_sourceID_t &sourceID)
+{
+ if (sourceData.sourceID >= DYNAMIC_ID_BOUNDARY)
+ {
+ logError(__METHOD_NAME__, "sourceID must be below:", DYNAMIC_ID_BOUNDARY);
+ return (E_NOT_POSSIBLE);
+ }
+
+ if (!existDomain(sourceData.domainID))
+ {
+ logError(__METHOD_NAME__, "domainID must be valid");
+ return (E_NOT_POSSIBLE);
+ }
+
+ if (sourceData.name.empty())
+ {
+ logError(__METHOD_NAME__, "sourceName must not be zero");
+ return (E_NOT_POSSIBLE);
+ }
+
+ if (!existSourceClass(sourceData.sourceClassID))
+ {
+ logError(__METHOD_NAME__, "sourceClassID must be valid");
+ return (E_NOT_POSSIBLE);
+ }
+
+ if (!(sourceData.sourceState >= SS_UNKNNOWN && sourceData.sourceState <= SS_MAX))
+ {
+ logError(__METHOD_NAME__, "sourceState must be valid");
+ return (E_NOT_POSSIBLE);
+ }
+
+ bool isFirstStatic = sourceData.sourceID == 0 && mFirstStaticSource;
+ am_sourceID_t temp_SourceID = 0;
+ am_sourceID_t temp_SourceIndex = 0;
+ AmSource const *reservedSource = objectMatchingPredicate<AmSource, am_sourceID_t>(mMappedData.mSourceMap, [&](const AmSource &obj){
+ return true == obj.reserved && obj.name.compare(sourceData.name) == 0;
+ });
+ if ( NULL != reservedSource )
+ {
+ am_sourceID_t oldSourceID = reservedSource->sourceID;
+ mMappedData.mSourceMap[oldSourceID] = sourceData;
+ mMappedData.mSourceMap[oldSourceID].reserved = 0;
+ temp_SourceID = oldSourceID;
+ temp_SourceIndex = oldSourceID;
+ }
+ else
+ {
+ bool result;
+ if ( !isFirstStatic )
+ {
+ // check if the ID already exists
+ if (existSourceNameOrID(sourceData.sourceID, sourceData.name))
+ {
+ sourceID = sourceData.sourceID;
+ return (E_ALREADY_EXISTS);
+ }
+ }
+
+ result = insertSourceDB(sourceData, temp_SourceID);
+ if ( false == result )
+ {
+ return (E_UNKNOWN);
+ }
+
+ temp_SourceIndex = temp_SourceID;
}
if ( isFirstStatic )
{
- //if the first static sink is entered, we need to set it onto the boundary if needed
+ // if the first static sink is entered, we need to set it onto the boundary if needed
mFirstStaticSource = false;
}
+
mMappedData.mSourceMap[temp_SourceIndex].sourceID = temp_SourceID;
- sourceID = temp_SourceID;
+ sourceID = temp_SourceID;
logVerbose("DatabaseHandler::enterSourceDB entered new source with name", sourceData.name, "domainID:", sourceData.domainID, "classID:", sourceData.sourceClassID, "visible:", sourceData.visible, "assigned ID:", sourceID);
@@ -1078,169 +1148,177 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData,
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::enterConnectionDB(const am_Connection_s& connection, am_connectionID_t& connectionID)
+am_Error_e CAmDatabaseHandlerMap::enterConnectionDB(const am_Connection_s &connection, am_connectionID_t &connectionID)
{
- if(connection.connectionID!=0)
+ if (connection.connectionID != 0)
{
- logError(__METHOD_NAME__,"connectionID must be 0!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "connectionID must be 0!");
+ return (E_NOT_POSSIBLE);
}
- if(!existSink(connection.sinkID))
+ if (!existSink(connection.sinkID))
{
- logError(__METHOD_NAME__,"sinkID must exist!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkID must exist!");
+ return (E_NOT_POSSIBLE);
}
- if(!existSource(connection.sourceID))
+ if (!existSource(connection.sourceID))
{
- logError(__METHOD_NAME__,"sourceID must exist!");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sourceID must exist!");
+ return (E_NOT_POSSIBLE);
}
- //connection format is not checked, because it's project specific
+
+ // connection format is not checked, because it's project specific
int16_t nextID = 0;
- if(mMappedData.increaseConnectionID(nextID))
- {
- connectionID = nextID;
- mMappedData.mConnectionMap[nextID] = connection;
- mMappedData.mConnectionMap[nextID].connectionID = nextID;
- mMappedData.mConnectionMap[nextID].reserved = true;
- }
- else
- {
- connectionID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (E_UNKNOWN);
- }
+ if (mMappedData.increaseConnectionID(nextID))
+ {
+ connectionID = nextID;
+ mMappedData.mConnectionMap[nextID] = connection;
+ mMappedData.mConnectionMap[nextID].connectionID = nextID;
+ mMappedData.mConnectionMap[nextID].reserved = true;
+ }
+ else
+ {
+ connectionID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (E_UNKNOWN);
+ }
logVerbose("DatabaseHandler::enterConnectionDB entered new connection sinkID=", connection.sinkID, "sourceID=", connection.sourceID, "connectionFormat=", connection.connectionFormat, "assigned ID=", connectionID);
return (E_OK);
}
-bool CAmDatabaseHandlerMap::insertSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
+bool CAmDatabaseHandlerMap::insertSinkClassDB(const am_SinkClass_s &sinkClass, am_sinkClass_t &sinkClassID)
{
int16_t nextID = 0;
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentSinkClassesID, sinkClass.sinkClassID))
- {
- sinkClassID = nextID;
- mMappedData.mSinkClassesMap[nextID] = sinkClass;
- mMappedData.mSinkClassesMap[nextID].sinkClassID = nextID;
- return (true);
- }
- else
- {
- sinkClassID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (false);
- }
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentSinkClassesID, sinkClass.sinkClassID))
+ {
+ sinkClassID = nextID;
+ mMappedData.mSinkClassesMap[nextID] = sinkClass;
+ mMappedData.mSinkClassesMap[nextID].sinkClassID = nextID;
+ return (true);
+ }
+ else
+ {
+ sinkClassID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (false);
+ }
}
-am_Error_e CAmDatabaseHandlerMap::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
+am_Error_e CAmDatabaseHandlerMap::enterSinkClassDB(const am_SinkClass_s &sinkClass, am_sinkClass_t &sinkClassID)
{
- if(sinkClass.sinkClassID>=DYNAMIC_ID_BOUNDARY)
+ if (sinkClass.sinkClassID >= DYNAMIC_ID_BOUNDARY)
{
- logError(__METHOD_NAME__,"sinkClassID must be <",DYNAMIC_ID_BOUNDARY);
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sinkClassID must be <", DYNAMIC_ID_BOUNDARY);
+ return (E_NOT_POSSIBLE);
}
- if(sinkClass.name.empty())
+ if (sinkClass.name.empty())
{
- logError(__METHOD_NAME__,"name must not be empty");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "name must not be empty");
+ return (E_NOT_POSSIBLE);
}
- am_sinkClass_t temp_SinkClassID = 0;
+ am_sinkClass_t temp_SinkClassID = 0;
am_sinkClass_t temp_SinkClassIndex = 0;
- bool result;
- if (sinkClass.sinkClassID != 0 || mFirstStaticSinkClass)
- {
- //check if the ID already exists
- if (existSinkClass(sinkClass.sinkClassID))
- {
- sinkClassID = sinkClass.sinkClassID;
- return (E_ALREADY_EXISTS);
- }
- }
- result = insertSinkClassDB(sinkClass, temp_SinkClassID);
- if( false == result )
- return (E_UNKNOWN);
-
- temp_SinkClassIndex = temp_SinkClassID;
- //if the ID is not created, we add it to the query
- if (sinkClass.sinkClassID == 0 && mFirstStaticSinkClass)
- {
- mFirstStaticSinkClass = false;
- }
- mMappedData.mSinkClassesMap[temp_SinkClassIndex].sinkClassID = temp_SinkClassID;
- sinkClassID = temp_SinkClassID;
-
- //todo:change last_insert implementations for multithreaded usage...
+ bool result;
+ if (sinkClass.sinkClassID != 0 || mFirstStaticSinkClass)
+ {
+ // check if the ID already exists
+ if (existSinkClass(sinkClass.sinkClassID))
+ {
+ sinkClassID = sinkClass.sinkClassID;
+ return (E_ALREADY_EXISTS);
+ }
+ }
+
+ result = insertSinkClassDB(sinkClass, temp_SinkClassID);
+ if ( false == result )
+ {
+ return (E_UNKNOWN);
+ }
+
+ temp_SinkClassIndex = temp_SinkClassID;
+ // if the ID is not created, we add it to the query
+ if (sinkClass.sinkClassID == 0 && mFirstStaticSinkClass)
+ {
+ mFirstStaticSinkClass = false;
+ }
+
+ mMappedData.mSinkClassesMap[temp_SinkClassIndex].sinkClassID = temp_SinkClassID;
+ sinkClassID = temp_SinkClassID;
+
+ // todo:change last_insert implementations for multithreaded usage...
logVerbose("DatabaseHandler::enterSinkClassDB entered new sinkClass");
NOTIFY_OBSERVERS(dboNumberOfSinkClassesChanged)
return (E_OK);
}
-bool CAmDatabaseHandlerMap::insertSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
+bool CAmDatabaseHandlerMap::insertSourceClassDB(am_sourceClass_t &sourceClassID, const am_SourceClass_s &sourceClass)
{
int16_t nextID = 0;
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentSourceClassesID, sourceClass.sourceClassID))
- {
- sourceClassID = nextID;
- mMappedData.mSourceClassesMap[nextID] = sourceClass;
- mMappedData.mSourceClassesMap[nextID].sourceClassID = nextID;
- return (true);
- }
- else
- {
- sourceClassID = 0;
- logVerbose(__METHOD_NAME__,"Max limit reached.");
- return (false);
- }
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentSourceClassesID, sourceClass.sourceClassID))
+ {
+ sourceClassID = nextID;
+ mMappedData.mSourceClassesMap[nextID] = sourceClass;
+ mMappedData.mSourceClassesMap[nextID].sourceClassID = nextID;
+ return (true);
+ }
+ else
+ {
+ sourceClassID = 0;
+ logVerbose(__METHOD_NAME__, "Max limit reached.");
+ return (false);
+ }
}
-am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
+am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t &sourceClassID, const am_SourceClass_s &sourceClass)
{
- if(sourceClass.sourceClassID>=DYNAMIC_ID_BOUNDARY)
+ if (sourceClass.sourceClassID >= DYNAMIC_ID_BOUNDARY)
{
- logError(__METHOD_NAME__,"sourceClassID must be <",DYNAMIC_ID_BOUNDARY);
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "sourceClassID must be <", DYNAMIC_ID_BOUNDARY);
+ return (E_NOT_POSSIBLE);
}
- if(sourceClass.name.empty())
+ if (sourceClass.name.empty())
{
- logError(__METHOD_NAME__,"name must not be empty");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "name must not be empty");
+ return (E_NOT_POSSIBLE);
}
-
- am_sourceClass_t temp_SourceClassID = 0;
+ am_sourceClass_t temp_SourceClassID = 0;
am_sourceClass_t temp_SourceClassIndex = 0;
- bool result;
- if (sourceClass.sourceClassID != 0 || mFirstStaticSourceClass)
- {
- //check if the ID already exists
- if (existSourceClass(sourceClass.sourceClassID))
- {
- sourceClassID = sourceClass.sourceClassID;
- return (E_ALREADY_EXISTS);
- }
- }
- result = insertSourceClassDB(temp_SourceClassID, sourceClass);
- if( false == result )
- return (E_UNKNOWN);
-
- temp_SourceClassIndex = temp_SourceClassID;
- //if the ID is not created, we add it to the query
- if (sourceClass.sourceClassID == 0 && mFirstStaticSourceClass)
- {
- mFirstStaticSinkClass = false;
- }
- mMappedData.mSourceClassesMap[temp_SourceClassIndex].sourceClassID = temp_SourceClassID;
- sourceClassID = temp_SourceClassID;
-
- //todo:change last_insert implementations for multithread usage...
+ bool result;
+ if (sourceClass.sourceClassID != 0 || mFirstStaticSourceClass)
+ {
+ // check if the ID already exists
+ if (existSourceClass(sourceClass.sourceClassID))
+ {
+ sourceClassID = sourceClass.sourceClassID;
+ return (E_ALREADY_EXISTS);
+ }
+ }
+
+ result = insertSourceClassDB(temp_SourceClassID, sourceClass);
+ if ( false == result )
+ {
+ return (E_UNKNOWN);
+ }
+
+ temp_SourceClassIndex = temp_SourceClassID;
+ // if the ID is not created, we add it to the query
+ if (sourceClass.sourceClassID == 0 && mFirstStaticSourceClass)
+ {
+ mFirstStaticSinkClass = false;
+ }
+
+ mMappedData.mSourceClassesMap[temp_SourceClassIndex].sourceClassID = temp_SourceClassID;
+ sourceClassID = temp_SourceClassID;
+
+ // todo:change last_insert implementations for multithread usage...
logVerbose("DatabaseHandler::enterSourceClassDB entered new sourceClass");
@@ -1249,13 +1327,13 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t & sourceCl
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector<am_SystemProperty_s> & listSystemProperties)
+am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector<am_SystemProperty_s> &listSystemProperties)
{
- if(listSystemProperties.empty())
- {
- logError(__METHOD_NAME__,"listSystemProperties must not be empty");
- return (E_NOT_POSSIBLE);
- }
+ if (listSystemProperties.empty())
+ {
+ logError(__METHOD_NAME__, "listSystemProperties must not be empty");
+ return (E_NOT_POSSIBLE);
+ }
mMappedData.mSystemProperties = listSystemProperties;
@@ -1263,27 +1341,29 @@ am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector<am_Sys
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID)
+am_Error_e CAmDatabaseHandlerMap::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t> &listConnectionID)
{
- if(mainconnectionID==0)
+ if (mainconnectionID == 0)
{
- logError(__METHOD_NAME__,"mainconnectionID must not be 0");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "mainconnectionID must not be 0");
+ return (E_NOT_POSSIBLE);
}
if (!existMainConnection(mainconnectionID))
{
- logError(__METHOD_NAME__,"existMainConnection must exist");
+ logError(__METHOD_NAME__, "existMainConnection must exist");
return (E_NON_EXISTENT);
}
int16_t delay = calculateDelayForRoute(listConnectionID);
- //now we replace the data in the main connection object with the new one
+ // now we replace the data in the main connection object with the new one
mMappedData.mMainConnectionMap[mainconnectionID].listConnectionID = listConnectionID;
- if (changeDelayMainConnection(delay,mainconnectionID) == E_NO_CHANGE)
+ if (changeDelayMainConnection(delay, mainconnectionID) == E_NO_CHANGE)
+ {
logError("DatabaseHandler::changeMainConnectionRouteDB error while changing mainConnectionDelay to ", delay);
+ }
logVerbose("DatabaseHandler::changeMainConnectionRouteDB entered new route:", mainconnectionID);
return (E_OK);
@@ -1291,21 +1371,21 @@ am_Error_e CAmDatabaseHandlerMap::changeMainConnectionRouteDB(const am_mainConne
am_Error_e CAmDatabaseHandlerMap::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
{
- if(mainconnectionID==0)
+ if (mainconnectionID == 0)
{
- logError(__METHOD_NAME__,"mainconnectionID must not be 0");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "mainconnectionID must not be 0");
+ return (E_NOT_POSSIBLE);
}
- if(!(connectionState>=CS_UNKNOWN && connectionState<=CS_MAX))
+ if (!(connectionState >= CS_UNKNOWN && connectionState <= CS_MAX))
{
- logError(__METHOD_NAME__,"connectionState must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "connectionState must be valid");
+ return (E_NOT_POSSIBLE);
}
if (!existMainConnection(mainconnectionID))
{
- logError(__METHOD_NAME__,"existMainConnection must exist");
+ logError(__METHOD_NAME__, "existMainConnection must exist");
return (E_NON_EXISTENT);
}
@@ -1320,7 +1400,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMainVolumeDB(const am_mainVolume_t m
{
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must exist");
+ logError(__METHOD_NAME__, "sinkID must exist");
return (E_NON_EXISTENT);
}
@@ -1333,17 +1413,17 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMainVolumeDB(const am_mainVolume_t m
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability_s &availability, const am_sinkID_t sinkID)
{
- if (!(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX))
+ if (!(availability.availability >= A_UNKNOWN && availability.availability <= A_MAX))
{
- logError(__METHOD_NAME__,"availability must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "availability must be valid");
+ return (E_NOT_POSSIBLE);
}
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must exist");
+ logError(__METHOD_NAME__, "sinkID must exist");
return (E_NON_EXISTENT);
}
@@ -1353,23 +1433,24 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability
if (sinkVisible(sinkID))
{
- NOTIFY_OBSERVERS2(dboSinkAvailabilityChanged,sinkID, availability)
+ NOTIFY_OBSERVERS2(dboSinkAvailabilityChanged, sinkID, availability)
}
+
return (E_OK);
}
am_Error_e CAmDatabaseHandlerMap::changeDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
{
- if(!(domainState>=DS_UNKNOWN && domainState<=DS_MAX))
+ if (!(domainState >= DS_UNKNOWN && domainState <= DS_MAX))
{
- logError(__METHOD_NAME__,"domainState must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "domainState must be valid");
+ return (E_NOT_POSSIBLE);
}
if (!existDomain(domainID))
{
- logError(__METHOD_NAME__,"domainID must exist");
+ logError(__METHOD_NAME__, "domainID must exist");
return (E_NON_EXISTENT);
}
@@ -1382,15 +1463,15 @@ am_Error_e CAmDatabaseHandlerMap::changeDomainStateDB(const am_DomainState_e dom
am_Error_e CAmDatabaseHandlerMap::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
{
- if(!(muteState>=MS_UNKNOWN && muteState<=MS_MAX))
+ if (!(muteState >= MS_UNKNOWN && muteState <= MS_MAX))
{
- logError(__METHOD_NAME__,"muteState must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "muteState must be valid");
+ return (E_NOT_POSSIBLE);
}
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must exist");
+ logError(__METHOD_NAME__, "sinkID must exist");
return (E_NON_EXISTENT);
}
@@ -1403,52 +1484,60 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMuteStateDB(const am_MuteState_e mut
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandlerMap::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s &soundProperty, const am_sinkID_t sinkID)
{
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must exist");
+ logError(__METHOD_NAME__, "sinkID must exist");
return (E_NON_EXISTENT);
}
- am_Sink_Database_s & sink = mMappedData.mSinkMap[sinkID];
+
+ am_Sink_Database_s &sink = mMappedData.mSinkMap[sinkID];
std::vector<am_MainSoundProperty_s>::iterator elementIterator = sink.listMainSoundProperties.begin();
- for (;elementIterator != sink.listMainSoundProperties.end(); ++elementIterator)
- {
- if (elementIterator->type == soundProperty.type)
- {
- DB_COND_UPDATE_RIE(elementIterator->value, soundProperty.value);
- if(sink.cacheMainSoundProperties.size())
- sink.cacheMainSoundProperties[soundProperty.type] = soundProperty.value;
- break;
- }
- }
+ for (; elementIterator != sink.listMainSoundProperties.end(); ++elementIterator)
+ {
+ if (elementIterator->type == soundProperty.type)
+ {
+ DB_COND_UPDATE_RIE(elementIterator->value, soundProperty.value);
+ if (sink.cacheMainSoundProperties.size())
+ {
+ sink.cacheMainSoundProperties[soundProperty.type] = soundProperty.value;
+ }
+
+ break;
+ }
+ }
logVerbose("DatabaseHandler::changeMainSinkSoundPropertyDB changed MainSinkSoundProperty of sink:", sinkID, "type:", soundProperty.type, "to:", soundProperty.value);
NOTIFY_OBSERVERS2(dboMainSinkSoundPropertyChanged, sinkID, soundProperty)
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s &soundProperty, const am_sourceID_t sourceID)
{
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must exist");
+ logError(__METHOD_NAME__, "sourceID must exist");
return (E_NON_EXISTENT);
}
- am_Source_Database_s & source = mMappedData.mSourceMap.at(sourceID);
+
+ am_Source_Database_s &source = mMappedData.mSourceMap.at(sourceID);
std::vector<am_MainSoundProperty_s>::iterator elementIterator = source.listMainSoundProperties.begin();
- for (;elementIterator != source.listMainSoundProperties.end(); ++elementIterator)
- {
- if (elementIterator->type == soundProperty.type)
- {
- DB_COND_UPDATE_RIE(elementIterator->value, soundProperty.value);
- if(source.cacheMainSoundProperties.size())
- source.cacheMainSoundProperties[soundProperty.type] = soundProperty.value;
- break;
- }
- }
+ for (; elementIterator != source.listMainSoundProperties.end(); ++elementIterator)
+ {
+ if (elementIterator->type == soundProperty.type)
+ {
+ DB_COND_UPDATE_RIE(elementIterator->value, soundProperty.value);
+ if (source.cacheMainSoundProperties.size())
+ {
+ source.cacheMainSoundProperties[soundProperty.type] = soundProperty.value;
+ }
+
+ break;
+ }
+ }
logVerbose("DatabaseHandler::changeMainSourceSoundPropertyDB changed MainSinkSoundProperty of source:", sourceID, "type:", soundProperty.type, "to:", soundProperty.value);
@@ -1456,17 +1545,17 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainS
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
+am_Error_e CAmDatabaseHandlerMap::changeSourceAvailabilityDB(const am_Availability_s &availability, const am_sourceID_t sourceID)
{
- if(!(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX))
+ if (!(availability.availability >= A_UNKNOWN && availability.availability <= A_MAX))
{
- logError(__METHOD_NAME__,"availability must be valid");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "availability must be valid");
+ return (E_NOT_POSSIBLE);
}
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must exist");
+ logError(__METHOD_NAME__, "sourceID must exist");
return (E_NON_EXISTENT);
}
@@ -1476,19 +1565,22 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceAvailabilityDB(const am_Availabili
if (sourceVisible(sourceID))
{
- NOTIFY_OBSERVERS2(dboSourceAvailabilityChanged, sourceID, availability)
+ NOTIFY_OBSERVERS2(dboSourceAvailabilityChanged, sourceID, availability)
}
+
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeSystemPropertyDB(const am_SystemProperty_s & property)
+am_Error_e CAmDatabaseHandlerMap::changeSystemPropertyDB(const am_SystemProperty_s &property)
{
std::vector<am_SystemProperty_s>::iterator elementIterator = mMappedData.mSystemProperties.begin();
- for (;elementIterator != mMappedData.mSystemProperties.end(); ++elementIterator)
- {
- if (elementIterator->type == property.type)
- DB_COND_UPDATE_RIE(elementIterator->value, property.value);
- }
+ for (; elementIterator != mMappedData.mSystemProperties.end(); ++elementIterator)
+ {
+ if (elementIterator->type == property.type)
+ {
+ DB_COND_UPDATE_RIE(elementIterator->value, property.value);
+ }
+ }
logVerbose("DatabaseHandler::changeSystemPropertyDB changed system property");
@@ -1502,16 +1594,19 @@ am_Error_e CAmDatabaseHandlerMap::removeMainConnectionDB(const am_mainConnection
if (!existMainConnection(mainConnectionID))
{
- logError(__METHOD_NAME__,"mainConnectionID must exist");
+ logError(__METHOD_NAME__, "mainConnectionID must exist");
return (E_NON_EXISTENT);
}
DB_COND_UPDATE_INIT;
DB_COND_UPDATE(mMappedData.mMainConnectionMap[mainConnectionID].mainConnectionID, CS_DISCONNECTED);
if (DB_COND_ISMODIFIED)
+ {
NOTIFY_OBSERVERS2(dboMainConnectionStateChanged, mainConnectionID, CS_DISCONNECTED)
- mMappedData.mMainConnectionMap.erase(mainConnectionID);
+ mMappedData.mMainConnectionMap.erase(mainConnectionID);
+ }
+
logVerbose("DatabaseHandler::removeMainConnectionDB removed:", mainConnectionID);
NOTIFY_OBSERVERS1(dboRemovedMainConnection, mainConnectionID)
@@ -1523,7 +1618,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkDB(const am_sinkID_t sinkID)
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must exist");
+ logError(__METHOD_NAME__, "sinkID must exist");
return (E_NON_EXISTENT);
}
@@ -1531,7 +1626,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkDB(const am_sinkID_t sinkID)
mMappedData.mSinkMap.erase(sinkID);
// todo: Check the tables SinkMainSoundProperty and SinkMainNotificationConfiguration with 'visible' set to true
- //if visible is true then delete SinkMainSoundProperty and SinkMainNotificationConfiguration ????
+ // if visible is true then delete SinkMainSoundProperty and SinkMainNotificationConfiguration ????
logVerbose("DatabaseHandler::removeSinkDB removed:", sinkID);
NOTIFY_OBSERVERS2(dboRemovedSink, sinkID, visible)
@@ -1544,7 +1639,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceDB(const am_sourceID_t sourceID)
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must exist");
+ logError(__METHOD_NAME__, "sourceID must exist");
return (E_NON_EXISTENT);
}
@@ -1553,7 +1648,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceDB(const am_sourceID_t sourceID)
mMappedData.mSourceMap.erase(sourceID);
// todo: Check the tables SourceMainSoundProperty and SourceMainNotificationConfiguration with 'visible' set to true
- //if visible is true then delete SourceMainSoundProperty and SourceMainNotificationConfiguration ????
+ // if visible is true then delete SourceMainSoundProperty and SourceMainNotificationConfiguration ????
logVerbose("DatabaseHandler::removeSourceDB removed:", sourceID);
NOTIFY_OBSERVERS2(dboRemovedSource, sourceID, visible)
@@ -1565,7 +1660,7 @@ am_Error_e CAmDatabaseHandlerMap::removeGatewayDB(const am_gatewayID_t gatewayID
if (!existGateway(gatewayID))
{
- logError(__METHOD_NAME__,"gatewayID must exist");
+ logError(__METHOD_NAME__, "gatewayID must exist");
return (E_NON_EXISTENT);
}
@@ -1581,7 +1676,7 @@ am_Error_e CAmDatabaseHandlerMap::removeConverterDB(const am_converterID_t conve
if (!existConverter(converterID))
{
- logError(__METHOD_NAME__,"converterID must exist");
+ logError(__METHOD_NAME__, "converterID must exist");
return (E_NON_EXISTENT);
}
@@ -1597,9 +1692,10 @@ am_Error_e CAmDatabaseHandlerMap::removeCrossfaderDB(const am_crossfaderID_t cro
if (!existCrossFader(crossfaderID))
{
- logError(__METHOD_NAME__,"crossfaderID must exist");
+ logError(__METHOD_NAME__, "crossfaderID must exist");
return (E_NON_EXISTENT);
}
+
mMappedData.mCrossfaderMap.erase(crossfaderID);
logVerbose("DatabaseHandler::removeCrossfaderDB removed:", crossfaderID);
@@ -1613,9 +1709,10 @@ am_Error_e CAmDatabaseHandlerMap::removeDomainDB(const am_domainID_t domainID)
if (!existDomain(domainID))
{
- logError(__METHOD_NAME__,"domainID must exist");
+ logError(__METHOD_NAME__, "domainID must exist");
return (E_NON_EXISTENT);
}
+
mMappedData.mDomainMap.erase(domainID);
logVerbose("DatabaseHandler::removeDomainDB removed:", domainID);
@@ -1629,7 +1726,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkClassDB(const am_sinkClass_t sinkCla
if (!existSinkClass(sinkClassID))
{
- logError(__METHOD_NAME__,"sinkClassID must exist");
+ logError(__METHOD_NAME__, "sinkClassID must exist");
return (E_NON_EXISTENT);
}
@@ -1645,7 +1742,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceClassDB(const am_sourceClass_t sou
if (!existSourceClass(sourceClassID))
{
- logError(__METHOD_NAME__,"sourceClassID must exist");
+ logError(__METHOD_NAME__, "sourceClassID must exist");
return (E_NON_EXISTENT);
}
@@ -1659,7 +1756,7 @@ am_Error_e CAmDatabaseHandlerMap::removeConnection(const am_connectionID_t conne
{
if (!existConnectionID(connectionID))
{
- logError(__METHOD_NAME__,"connectionID must exist",connectionID);
+ logError(__METHOD_NAME__, "connectionID must exist", connectionID);
return (E_NON_EXISTENT);
}
@@ -1669,87 +1766,95 @@ am_Error_e CAmDatabaseHandlerMap::removeConnection(const am_connectionID_t conne
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
+am_Error_e CAmDatabaseHandlerMap::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s &classInfo) const
{
if (!existSource(sourceID))
{
- logWarning(__METHOD_NAME__,"sourceID must exist");
+ logWarning(__METHOD_NAME__, "sourceID must exist");
return (E_NON_EXISTENT);
}
+
am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID);
- classInfo.sourceClassID = source.sourceClassID;
+ classInfo.sourceClassID = source.sourceClassID;
if (!existSourceClass(classInfo.sourceClassID))
{
return (E_NON_EXISTENT);
}
+
am_SourceClass_s tmpClass = mMappedData.mSourceClassesMap.at(classInfo.sourceClassID);
classInfo = tmpClass;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const
+am_Error_e CAmDatabaseHandlerMap::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s &sinkData) const
{
if (!existSink(sinkID))
{
- logWarning(__METHOD_NAME__,"sinkID",sinkID,"does not exist");
+ logWarning(__METHOD_NAME__, "sinkID", sinkID, "does not exist");
return (E_NON_EXISTENT);
}
am_Sink_Database_s mappedSink = mMappedData.mSinkMap.at(sinkID);
- if( true == mappedSink.reserved )
- return (E_NON_EXISTENT);
- sinkData = mappedSink;
+ if ( true == mappedSink.reserved )
+ {
+ return (E_NON_EXISTENT);
+ }
+
+ sinkData = mappedSink;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const
+am_Error_e CAmDatabaseHandlerMap::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s &sourceData) const
{
if (!existSource(sourceID))
{
- logWarning(__METHOD_NAME__,"sourceID",sourceID,"does not exist");
+ logWarning(__METHOD_NAME__, "sourceID", sourceID, "does not exist");
return (E_NON_EXISTENT);
}
am_Source_Database_s mappedSource = mMappedData.mSourceMap.at(sourceID);
- if( true == mappedSource.reserved )
- return (E_NON_EXISTENT);
+ if ( true == mappedSource.reserved )
+ {
+ return (E_NON_EXISTENT);
+ }
sourceData = mappedSource;
return (E_OK);
}
-am_Error_e am::CAmDatabaseHandlerMap::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const
+am_Error_e am::CAmDatabaseHandlerMap::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s &mainConnectionData) const
{
if (!existMainConnection(mainConnectionID))
{
- logError(__METHOD_NAME__,"mainConnectionID must exist");
+ logError(__METHOD_NAME__, "mainConnectionID must exist");
return (E_NON_EXISTENT);
}
+
am_MainConnection_s temp = mMappedData.mMainConnectionMap.at(mainConnectionID);
mainConnectionData = temp;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s& sinkClass)
+am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s &sinkClass)
{
- if(sinkClass.listClassProperties.empty())
+ if (sinkClass.listClassProperties.empty())
{
- logError(__METHOD_NAME__,"listClassProperties must not be empty");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "listClassProperties must not be empty");
+ return (E_NOT_POSSIBLE);
}
- //check if the ID already exists
+ // check if the ID already exists
if (!existSinkClass(sinkClass.sinkClassID))
{
- logError(__METHOD_NAME__,"sinkClassID must exist");
+ logError(__METHOD_NAME__, "sinkClassID must exist");
return (E_NON_EXISTENT);
}
@@ -1759,18 +1864,18 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s& si
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s& sourceClass)
+am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s &sourceClass)
{
- if(sourceClass.listClassProperties.empty())
+ if (sourceClass.listClassProperties.empty())
{
- logError(__METHOD_NAME__,"listClassProperties must not be empty");
- return (E_NOT_POSSIBLE);
+ logError(__METHOD_NAME__, "listClassProperties must not be empty");
+ return (E_NOT_POSSIBLE);
}
- //check if the ID already exists
+ // check if the ID already exists
if (!existSourceClass(sourceClass.sourceClassID))
{
- logError(__METHOD_NAME__,"sourceClassID must exist");
+ logError(__METHOD_NAME__, "sourceClassID must exist");
return (E_NON_EXISTENT);
}
@@ -1780,33 +1885,35 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
+am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s &sinkClass) const
{
if (!existSink(sinkID))
{
- logWarning(__METHOD_NAME__,"sinkID must exist");
+ logWarning(__METHOD_NAME__, "sinkID must exist");
return (E_NON_EXISTENT);
}
+
am_Sink_Database_s sink = mMappedData.mSinkMap.at(sinkID);
- sinkClass.sinkClassID = sink.sinkClassID;
+ sinkClass.sinkClassID = sink.sinkClassID;
if (!existSinkClass(sinkClass.sinkClassID))
{
- logWarning(__METHOD_NAME__,"sinkClassID must exist");
+ logWarning(__METHOD_NAME__, "sinkClassID must exist");
return (E_NON_EXISTENT);
}
+
am_SinkClass_s tmpSinkClass = mMappedData.mSinkClassesMap.at(sinkClass.sinkClassID);
sinkClass = tmpSinkClass;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
+am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s &gatewayData) const
{
if (!existGateway(gatewayID))
{
- logWarning(__METHOD_NAME__,"gatewayID must exist");
+ logWarning(__METHOD_NAME__, "gatewayID must exist");
return (E_NON_EXISTENT);
}
@@ -1816,11 +1923,11 @@ am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayI
}
-am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s& converterData) const
+am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s &converterData) const
{
if (!existConverter(converterID))
{
- logWarning(__METHOD_NAME__,"converterID must exist");
+ logWarning(__METHOD_NAME__, "converterID must exist");
return (E_NON_EXISTENT);
}
@@ -1830,11 +1937,11 @@ am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t conv
}
-am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
+am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s &crossfaderData) const
{
if (!existCrossFader(crossfaderID))
{
- logWarning(__METHOD_NAME__,"crossfaderID must exist");
+ logWarning(__METHOD_NAME__, "crossfaderID must exist");
return (E_NON_EXISTENT);
}
@@ -1843,411 +1950,442 @@ am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t cr
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
+am_Error_e CAmDatabaseHandlerMap::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> &listSinkID) const
{
listSinkID.clear();
if (!existDomain(domainID))
{
- logWarning(__METHOD_NAME__,"domainID must exist");
+ logWarning(__METHOD_NAME__, "domainID must exist");
return (E_NON_EXISTENT);
}
std::unordered_map<am_sinkID_t, am_Sink_Database_s>::const_iterator elementIterator = mMappedData.mSinkMap.begin();
- for (;elementIterator != mMappedData.mSinkMap.end(); ++elementIterator)
- {
- if (0==elementIterator->second.reserved && domainID==elementIterator->second.domainID)
- listSinkID.push_back(elementIterator->second.sinkID);
- }
+ for (; elementIterator != mMappedData.mSinkMap.end(); ++elementIterator)
+ {
+ if (0 == elementIterator->second.reserved && domainID == elementIterator->second.domainID)
+ {
+ listSinkID.push_back(elementIterator->second.sinkID);
+ }
+ }
+
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
+am_Error_e CAmDatabaseHandlerMap::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> &listSourceID) const
{
listSourceID.clear();
if (!existDomain(domainID))
{
- logWarning(__METHOD_NAME__,"domainID must exist");
+ logWarning(__METHOD_NAME__, "domainID must exist");
return (E_NON_EXISTENT);
}
- AmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin();
- for (;elementIterator != mMappedData.mSourceMap.end(); ++elementIterator)
- {
- if (0==elementIterator->second.reserved && domainID==elementIterator->second.domainID)
- listSourceID.push_back(elementIterator->second.sourceID);
- }
+
+ AmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin();
+ for (; elementIterator != mMappedData.mSourceMap.end(); ++elementIterator)
+ {
+ if (0 == elementIterator->second.reserved && domainID == elementIterator->second.domainID)
+ {
+ listSourceID.push_back(elementIterator->second.sourceID);
+ }
+ }
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listCrossfader) const
+am_Error_e CAmDatabaseHandlerMap::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> &listCrossfader) const
{
listCrossfader.clear();
if (!existDomain(domainID))
{
- logWarning(__METHOD_NAME__,"domainID must exist");
+ logWarning(__METHOD_NAME__, "domainID must exist");
return (E_NON_EXISTENT);
}
AmMapSource::const_iterator sourceIterator = mMappedData.mSourceMap.begin();
- for (;sourceIterator != mMappedData.mSourceMap.end(); ++sourceIterator)
- {
- if (domainID==sourceIterator->second.domainID)
- {
- AmMapCrossfader::const_iterator elementIterator = mMappedData.mCrossfaderMap.begin();
- for (;elementIterator != mMappedData.mCrossfaderMap.end(); ++elementIterator)
- {
- if ( sourceIterator->second.sourceID==elementIterator->second.sourceID )
- listCrossfader.push_back(elementIterator->second.crossfaderID);
- }
- }
- }
+ for (; sourceIterator != mMappedData.mSourceMap.end(); ++sourceIterator)
+ {
+ if (domainID == sourceIterator->second.domainID)
+ {
+ AmMapCrossfader::const_iterator elementIterator = mMappedData.mCrossfaderMap.begin();
+ for (; elementIterator != mMappedData.mCrossfaderMap.end(); ++elementIterator)
+ {
+ if ( sourceIterator->second.sourceID == elementIterator->second.sourceID )
+ {
+ listCrossfader.push_back(elementIterator->second.crossfaderID);
+ }
+ }
+ }
+ }
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
+am_Error_e CAmDatabaseHandlerMap::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> &listGatewaysID) const
{
listGatewaysID.clear();
if (!existDomain(domainID))
{
- logWarning(__METHOD_NAME__,"domainID must exist");
+ logWarning(__METHOD_NAME__, "domainID must exist");
return (E_NON_EXISTENT);
}
AmMapGateway::const_iterator elementIterator = mMappedData.mGatewayMap.begin();
- for (;elementIterator != mMappedData.mGatewayMap.end(); ++elementIterator)
- {
- if (domainID==elementIterator->second.controlDomainID)
- listGatewaysID.push_back(elementIterator->second.gatewayID);
- }
+ for (; elementIterator != mMappedData.mGatewayMap.end(); ++elementIterator)
+ {
+ if (domainID == elementIterator->second.controlDomainID)
+ {
+ listGatewaysID.push_back(elementIterator->second.gatewayID);
+ }
+ }
+
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListConvertersOfDomain(const am_domainID_t domainID, std::vector<am_converterID_t>& listConvertersID) const
+am_Error_e CAmDatabaseHandlerMap::getListConvertersOfDomain(const am_domainID_t domainID, std::vector<am_converterID_t> &listConvertersID) const
{
listConvertersID.clear();
if (!existDomain(domainID))
{
- logWarning(__METHOD_NAME__,"domainID must exist");
+ logWarning(__METHOD_NAME__, "domainID must exist");
return (E_NON_EXISTENT);
}
AmMapConverter::const_iterator elementIterator = mMappedData.mConverterMap.begin();
- for (;elementIterator != mMappedData.mConverterMap.end(); ++elementIterator)
- {
- if (domainID==elementIterator->second.domainID)
- listConvertersID.push_back(elementIterator->second.converterID);
- }
+ for (; elementIterator != mMappedData.mConverterMap.end(); ++elementIterator)
+ {
+ if (domainID == elementIterator->second.domainID)
+ {
+ listConvertersID.push_back(elementIterator->second.converterID);
+ }
+ }
+
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
+am_Error_e CAmDatabaseHandlerMap::getListMainConnections(std::vector<am_MainConnection_s> &listMainConnections) const
{
listMainConnections.clear();
AmMapMainConnection::const_iterator elementIterator = mMappedData.mMainConnectionMap.begin();
- for (;elementIterator != mMappedData.mMainConnectionMap.end(); ++elementIterator)
+ for (; elementIterator != mMappedData.mMainConnectionMap.end(); ++elementIterator)
{
- listMainConnections.push_back(elementIterator->second);
+ listMainConnections.push_back(elementIterator->second);
}
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListDomains(std::vector<am_Domain_s> & listDomains) const
+am_Error_e CAmDatabaseHandlerMap::getListDomains(std::vector<am_Domain_s> &listDomains) const
{
listDomains.clear();
AmMapDomain::const_iterator elementIterator = mMappedData.mDomainMap.begin();
- for (;elementIterator != mMappedData.mDomainMap.end(); ++elementIterator)
- {
- if( 0==elementIterator->second.reserved )
- listDomains.push_back(elementIterator->second);
- }
+ for (; elementIterator != mMappedData.mDomainMap.end(); ++elementIterator)
+ {
+ if ( 0 == elementIterator->second.reserved )
+ {
+ listDomains.push_back(elementIterator->second);
+ }
+ }
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListConnections(std::vector<am_Connection_s> & listConnections) const
+am_Error_e CAmDatabaseHandlerMap::getListConnections(std::vector<am_Connection_s> &listConnections) const
{
listConnections.clear();
AmMapConnection::const_iterator elementIterator = mMappedData.mConnectionMap.begin();
- for (;elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator)
- {
- if( 0==elementIterator->second.reserved )
- listConnections.push_back(elementIterator->second);
- }
+ for (; elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator)
+ {
+ if ( 0 == elementIterator->second.reserved )
+ {
+ listConnections.push_back(elementIterator->second);
+ }
+ }
- return (E_OK);
+ return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListConnectionsReserved(std::vector<am_Connection_s> & listConnections) const
+am_Error_e CAmDatabaseHandlerMap::getListConnectionsReserved(std::vector<am_Connection_s> &listConnections) const
{
listConnections.clear();
AmMapConnection::const_iterator elementIterator = mMappedData.mConnectionMap.begin();
- for (;elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator)
- {
- if( elementIterator->second.reserved )
- listConnections.push_back(elementIterator->second);
- }
+ for (; elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator)
+ {
+ if ( elementIterator->second.reserved )
+ {
+ listConnections.push_back(elementIterator->second);
+ }
+ }
- return (E_OK);
+ return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSinks(std::vector<am_Sink_s> & listSinks) const
+am_Error_e CAmDatabaseHandlerMap::getListSinks(std::vector<am_Sink_s> &listSinks) const
{
listSinks.clear();
- std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair<am_sinkID_t, am_Sink_Database_s>& ref) {
- if( 0==ref.second.reserved )
- listSinks.push_back(ref.second);
- });
+ std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair<am_sinkID_t, am_Sink_Database_s> &ref) {
+ if ( 0 == ref.second.reserved )
+ {
+ listSinks.push_back(ref.second);
+ }
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSources(std::vector<am_Source_s> & listSources) const
+am_Error_e CAmDatabaseHandlerMap::getListSources(std::vector<am_Source_s> &listSources) const
{
listSources.clear();
- std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair<am_sourceID_t, am_Source_Database_s>& ref) {
- if( 0==ref.second.reserved )
- {
- listSources.push_back(ref.second);
- }
- });
+ std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair<am_sourceID_t, am_Source_Database_s> &ref) {
+ if ( 0 == ref.second.reserved )
+ {
+ listSources.push_back(ref.second);
+ }
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
+am_Error_e CAmDatabaseHandlerMap::getListSourceClasses(std::vector<am_SourceClass_s> &listSourceClasses) const
{
listSourceClasses.clear();
- std::for_each(mMappedData.mSourceClassesMap.begin(), mMappedData.mSourceClassesMap.end(), [&](const std::pair<am_sourceClass_t, am_SourceClass_s>& ref) {
- listSourceClasses.push_back(ref.second);
- });
+ std::for_each(mMappedData.mSourceClassesMap.begin(), mMappedData.mSourceClassesMap.end(), [&](const std::pair<am_sourceClass_t, am_SourceClass_s> &ref) {
+ listSourceClasses.push_back(ref.second);
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
+am_Error_e CAmDatabaseHandlerMap::getListCrossfaders(std::vector<am_Crossfader_s> &listCrossfaders) const
{
listCrossfaders.clear();
- std::for_each(mMappedData.mCrossfaderMap.begin(), mMappedData.mCrossfaderMap.end(), [&](const std::pair<am_crossfaderID_t, am_Crossfader_s>& ref) {
- listCrossfaders.push_back(ref.second);
- });
+ std::for_each(mMappedData.mCrossfaderMap.begin(), mMappedData.mCrossfaderMap.end(), [&](const std::pair<am_crossfaderID_t, am_Crossfader_s> &ref) {
+ listCrossfaders.push_back(ref.second);
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListGateways(std::vector<am_Gateway_s> & listGateways) const
+am_Error_e CAmDatabaseHandlerMap::getListGateways(std::vector<am_Gateway_s> &listGateways) const
{
listGateways.clear();
- std::for_each(mMappedData.mGatewayMap.begin(), mMappedData.mGatewayMap.end(), [&](const std::pair<am_gatewayID_t, am_Gateway_s>& ref) {
- listGateways.push_back(ref.second);
- });
+ std::for_each(mMappedData.mGatewayMap.begin(), mMappedData.mGatewayMap.end(), [&](const std::pair<am_gatewayID_t, am_Gateway_s> &ref) {
+ listGateways.push_back(ref.second);
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListConverters(std::vector<am_Converter_s> & listConverters) const
+am_Error_e CAmDatabaseHandlerMap::getListConverters(std::vector<am_Converter_s> &listConverters) const
{
- listConverters.clear();
+ listConverters.clear();
- std::for_each(mMappedData.mConverterMap.begin(), mMappedData.mConverterMap.end(), [&](const std::pair<am_converterID_t, am_Converter_s>& ref) {
- listConverters.push_back(ref.second);
- });
+ std::for_each(mMappedData.mConverterMap.begin(), mMappedData.mConverterMap.end(), [&](const std::pair<am_converterID_t, am_Converter_s> &ref) {
+ listConverters.push_back(ref.second);
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
+am_Error_e CAmDatabaseHandlerMap::getListSinkClasses(std::vector<am_SinkClass_s> &listSinkClasses) const
{
listSinkClasses.clear();
- std::for_each(mMappedData.mSinkClassesMap.begin(), mMappedData.mSinkClassesMap.end(), [&](const std::pair<am_gatewayID_t, am_SinkClass_s>& ref) {
- listSinkClasses.push_back(ref.second);
- });
+ std::for_each(mMappedData.mSinkClassesMap.begin(), mMappedData.mSinkClassesMap.end(), [&](const std::pair<am_gatewayID_t, am_SinkClass_s> &ref) {
+ listSinkClasses.push_back(ref.second);
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListVisibleMainConnections(std::vector<am_MainConnectionType_s> & listConnections) const
+am_Error_e CAmDatabaseHandlerMap::getListVisibleMainConnections(std::vector<am_MainConnectionType_s> &listConnections) const
{
listConnections.clear();
- std::for_each(mMappedData.mMainConnectionMap.begin(), mMappedData.mMainConnectionMap.end(), [&](const std::pair<am_mainConnectionID_t, am_MainConnection_Database_s>& ref) {
- listConnections.emplace_back();
- ref.second.getMainConnectionType(listConnections.back());
- });
+ std::for_each(mMappedData.mMainConnectionMap.begin(), mMappedData.mMainConnectionMap.end(), [&](const std::pair<am_mainConnectionID_t, am_MainConnection_Database_s> &ref) {
+ listConnections.emplace_back();
+ ref.second.getMainConnectionType(listConnections.back());
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListMainSinks(std::vector<am_SinkType_s> & listMainSinks) const
+am_Error_e CAmDatabaseHandlerMap::getListMainSinks(std::vector<am_SinkType_s> &listMainSinks) const
{
listMainSinks.clear();
- std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair<am_sinkID_t, am_Sink_Database_s>& ref) {
- if( 0==ref.second.reserved && 1==ref.second.visible )
- {
- listMainSinks.emplace_back();
- ref.second.getSinkType(listMainSinks.back());
- }
- });
+ std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair<am_sinkID_t, am_Sink_Database_s> &ref) {
+ if ( 0 == ref.second.reserved && 1 == ref.second.visible )
+ {
+ listMainSinks.emplace_back();
+ ref.second.getSinkType(listMainSinks.back());
+ }
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListMainSources(std::vector<am_SourceType_s> & listMainSources) const
+am_Error_e CAmDatabaseHandlerMap::getListMainSources(std::vector<am_SourceType_s> &listMainSources) const
{
listMainSources.clear();
- std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair<am_sourceID_t, am_Source_Database_s>& ref) {
- if( 0==ref.second.reserved && 1==ref.second.visible )
- {
- listMainSources.emplace_back();
- ref.second.getSourceType(listMainSources.back());
- }
- });
+ std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair<am_sourceID_t, am_Source_Database_s> &ref) {
+ if ( 0 == ref.second.reserved && 1 == ref.second.visible )
+ {
+ listMainSources.emplace_back();
+ ref.second.getSourceType(listMainSources.back());
+ }
+ });
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> & listSoundProperties) const
+am_Error_e CAmDatabaseHandlerMap::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> &listSoundProperties) const
{
if (!existSink(sinkID))
{
- logWarning(__METHOD_NAME__,"sinkID must exist");
- return E_NON_EXISTENT;
+ logWarning(__METHOD_NAME__, "sinkID must exist");
+ return E_NON_EXISTENT;
}
- const am_Sink_s & sink = mMappedData.mSinkMap.at(sinkID);
+ const am_Sink_s &sink = mMappedData.mSinkMap.at(sinkID);
listSoundProperties = sink.listMainSoundProperties;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> & listSourceProperties) const
+am_Error_e CAmDatabaseHandlerMap::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> &listSourceProperties) const
{
if (!existSource(sourceID))
{
- logWarning(__METHOD_NAME__,"sourceID must exist");
- return E_NON_EXISTENT;
+ logWarning(__METHOD_NAME__, "sourceID must exist");
+ return E_NON_EXISTENT;
}
- const am_Source_s & source = mMappedData.mSourceMap.at(sourceID);
+
+ const am_Source_s &source = mMappedData.mSourceMap.at(sourceID);
listSourceProperties = source.listMainSoundProperties;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_SoundProperty_s>& listSoundproperties) const
+am_Error_e CAmDatabaseHandlerMap::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_SoundProperty_s> &listSoundproperties) const
{
if (!existSink(sinkID))
{
- logWarning(__METHOD_NAME__,"sinkID must exist");
- return E_NON_EXISTENT;
+ logWarning(__METHOD_NAME__, "sinkID must exist");
+ return E_NON_EXISTENT;
}
- const am_Sink_Database_s & sink = mMappedData.mSinkMap.at(sinkID);
+ const am_Sink_Database_s &sink = mMappedData.mSinkMap.at(sinkID);
listSoundproperties = sink.listSoundProperties;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_SoundProperty_s>& listSoundproperties) const
+am_Error_e CAmDatabaseHandlerMap::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_SoundProperty_s> &listSoundproperties) const
{
- if (!existSource(sourceID))
+ if (!existSource(sourceID))
{
- logWarning(__METHOD_NAME__,"sourceID must exist");
- return E_NON_EXISTENT;
+ logWarning(__METHOD_NAME__, "sourceID must exist");
+ return E_NON_EXISTENT;
}
- const am_Source_Database_s & source = mMappedData.mSourceMap.at(sourceID);
- listSoundproperties = source.listSoundProperties;
+ const am_Source_Database_s &source = mMappedData.mSourceMap.at(sourceID);
+ listSoundproperties = source.listSoundProperties;
- return (E_OK);
+ return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
+am_Error_e CAmDatabaseHandlerMap::getListSystemProperties(std::vector<am_SystemProperty_s> &listSystemProperties) const
{
- listSystemProperties = mMappedData.mSystemProperties;
+ listSystemProperties = mMappedData.mSystemProperties;
return (E_OK);
}
-am_Error_e am::CAmDatabaseHandlerMap::getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector<am_CustomConnectionFormat_t> & listConnectionFormats) const
+am_Error_e am::CAmDatabaseHandlerMap::getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector<am_CustomConnectionFormat_t> &listConnectionFormats) const
{
- if (!existSink(sinkID))
- {
- logWarning(__METHOD_NAME__,"sinkID must exist");
- return E_NON_EXISTENT;
- }
- const am_Sink_s & sink = mMappedData.mSinkMap.at(sinkID);
- listConnectionFormats = sink.listConnectionFormats;
+ if (!existSink(sinkID))
+ {
+ logWarning(__METHOD_NAME__, "sinkID must exist");
+ return E_NON_EXISTENT;
+ }
+
+ const am_Sink_s &sink = mMappedData.mSinkMap.at(sinkID);
+ listConnectionFormats = sink.listConnectionFormats;
return (E_OK);
}
-am_Error_e am::CAmDatabaseHandlerMap::getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector<am_CustomConnectionFormat_t> & listConnectionFormats) const
+am_Error_e am::CAmDatabaseHandlerMap::getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector<am_CustomConnectionFormat_t> &listConnectionFormats) const
{
- if (!existSource(sourceID))
- {
- logWarning(__METHOD_NAME__,"sourceID must exist");
- return E_NON_EXISTENT;
- }
- const am_Source_s & source = mMappedData.mSourceMap.at(sourceID);
+ if (!existSource(sourceID))
+ {
+ logWarning(__METHOD_NAME__, "sourceID must exist");
+ return E_NON_EXISTENT;
+ }
+
+ const am_Source_s &source = mMappedData.mSourceMap.at(sourceID);
listConnectionFormats = source.listConnectionFormats;
return (E_OK);
}
-am_Error_e am::CAmDatabaseHandlerMap::getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector<bool> & listConnectionFormat) const
+am_Error_e am::CAmDatabaseHandlerMap::getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector<bool> &listConnectionFormat) const
{
- if (!existGateway(gatewayID))
- {
- logWarning(__METHOD_NAME__,"gatewayID must exist");
- return E_NON_EXISTENT;
- }
+ if (!existGateway(gatewayID))
+ {
+ logWarning(__METHOD_NAME__, "gatewayID must exist");
+ return E_NON_EXISTENT;
+ }
+
ListConnectionFormat::const_iterator iter = mListConnectionFormat.begin();
iter = mListConnectionFormat.find(gatewayID);
if (iter == mListConnectionFormat.end())
{
- logWarning("DatabaseHandler::getListGatewayConnectionFormats database error with convertionFormat");
+ logWarning("DatabaseHandler::getListGatewayConnectionFormats database error with convertionFormat");
return E_NON_EXISTENT;
}
+
listConnectionFormat = iter->second;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const
+am_Error_e CAmDatabaseHandlerMap::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t &delay) const
{
if (!existMainConnection(mainConnectionID))
{
- logWarning(__METHOD_NAME__,"mainConnectionID must exist");
- return E_NON_EXISTENT;
+ logWarning(__METHOD_NAME__, "mainConnectionID must exist");
+ return E_NON_EXISTENT;
}
+
delay = -1;
- const am_MainConnection_s & mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID);
+ const am_MainConnection_s &mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID);
delay = mainConnection.delay;
if (delay == -1)
+ {
return (E_NOT_POSSIBLE);
+ }
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t & delay, const am_mainConnectionID_t & connectionID)
+am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t &delay, const am_mainConnectionID_t &connectionID)
{
if (!existMainConnection(connectionID))
{
- logError(__METHOD_NAME__,"connectionID must exist");
- return E_NON_EXISTENT;
+ logError(__METHOD_NAME__, "connectionID must exist");
+ return E_NON_EXISTENT;
}
+
DB_COND_UPDATE_RIE(mMappedData.mMainConnectionMap[connectionID].delay, delay);
NOTIFY_OBSERVERS2(dboTimingInformationChanged, connectionID, delay)
return (E_OK);
@@ -2260,7 +2398,7 @@ am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t
*/
bool CAmDatabaseHandlerMap::existMainConnection(const am_mainConnectionID_t mainConnectionID) const
{
- return existsObjectWithKeyInMap(mainConnectionID, mMappedData.mMainConnectionMap);
+ return existsObjectWithKeyInMap(mainConnectionID, mMappedData.mMainConnectionMap);
}
/**
@@ -2270,11 +2408,13 @@ bool CAmDatabaseHandlerMap::existMainConnection(const am_mainConnectionID_t main
*/
bool CAmDatabaseHandlerMap::existSource(const am_sourceID_t sourceID) const
{
- am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
- if( NULL!=source )
- return (0==source->reserved);
+ am_Source_Database_s const *source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+ if ( NULL != source )
+ {
+ return (0 == source->reserved);
+ }
- return false;
+ return false;
}
/**
@@ -2283,7 +2423,7 @@ bool CAmDatabaseHandlerMap::existSource(const am_sourceID_t sourceID) const
* @param name the name
* @return true if it exits
*/
-bool CAmDatabaseHandlerMap::existSourceNameOrID(const am_sourceID_t sourceID, const std::string & name) const
+bool CAmDatabaseHandlerMap::existSourceNameOrID(const am_sourceID_t sourceID, const std::string &name) const
{
return sourceWithNameOrID(sourceID, name);
}
@@ -2293,7 +2433,7 @@ bool CAmDatabaseHandlerMap::existSourceNameOrID(const am_sourceID_t sourceID, co
* @param name the name
* @return true if it exits
*/
-bool CAmDatabaseHandlerMap::existSourceName(const std::string & name) const
+bool CAmDatabaseHandlerMap::existSourceName(const std::string &name) const
{
return existSourceNameOrID(mMappedData.mCurrentSourceID.mMax, name);
}
@@ -2305,17 +2445,18 @@ bool CAmDatabaseHandlerMap::existSourceName(const std::string & name) const
*/
bool CAmDatabaseHandlerMap::existSink(const am_sinkID_t sinkID) const
{
- bool returnVal = false;
- AmMapSink::const_iterator elementIterator = mMappedData.mSinkMap.begin();
- for (;elementIterator != mMappedData.mSinkMap.end(); ++elementIterator)
- {
- if( 0==elementIterator->second.reserved &&
- sinkID==elementIterator->second.sinkID)
- {
- returnVal = true;
- break;
- }
- }
+ bool returnVal = false;
+ AmMapSink::const_iterator elementIterator = mMappedData.mSinkMap.begin();
+ for (; elementIterator != mMappedData.mSinkMap.end(); ++elementIterator)
+ {
+ if ( 0 == elementIterator->second.reserved &&
+ sinkID == elementIterator->second.sinkID)
+ {
+ returnVal = true;
+ break;
+ }
+ }
+
return (returnVal);
}
@@ -2325,13 +2466,13 @@ bool CAmDatabaseHandlerMap::existSink(const am_sinkID_t sinkID) const
* @param name the name
* @return source structure if exists.
*/
-const CAmDatabaseHandlerMap::am_Source_Database_s * CAmDatabaseHandlerMap::sourceWithNameOrID(const am_sourceID_t sourceID, const std::string & name) const
+const CAmDatabaseHandlerMap::am_Source_Database_s *CAmDatabaseHandlerMap::sourceWithNameOrID(const am_sourceID_t sourceID, const std::string &name) const
{
- std::function<bool(const CAmDatabaseHandlerMap::am_Source_Database_s & refObject)> comparator = [&](const CAmDatabaseHandlerMap::am_Source_Database_s & source)->bool{
- return ( 0==source.reserved &&
- (sourceID==source.sourceID || name.compare(source.name)==0));
- };
- return objectMatchingPredicate(mMappedData.mSourceMap, comparator);
+ std::function<bool(const CAmDatabaseHandlerMap::am_Source_Database_s &refObject)> comparator = [&](const CAmDatabaseHandlerMap::am_Source_Database_s &source) -> bool {
+ return (0 == source.reserved &&
+ (sourceID == source.sourceID || name.compare(source.name) == 0));
+ };
+ return objectMatchingPredicate(mMappedData.mSourceMap, comparator);
}
/**
@@ -2340,13 +2481,13 @@ const CAmDatabaseHandlerMap::am_Source_Database_s * CAmDatabaseHandlerMap::sour
* @param name the name
* @return sink structure if exists.
*/
-const CAmDatabaseHandlerMap::am_Sink_Database_s * CAmDatabaseHandlerMap::sinkWithNameOrID(const am_sinkID_t sinkID, const std::string & name) const
+const CAmDatabaseHandlerMap::am_Sink_Database_s *CAmDatabaseHandlerMap::sinkWithNameOrID(const am_sinkID_t sinkID, const std::string &name) const
{
- std::function<bool(const CAmDatabaseHandlerMap::am_Sink_Database_s & refObject)> comparator = [&](const CAmDatabaseHandlerMap::am_Sink_Database_s & sink)->bool{
- return ( 0==sink.reserved &&
- (sinkID==sink.sinkID || name.compare(sink.name)==0));
- };
- return objectMatchingPredicate(mMappedData.mSinkMap, comparator);
+ std::function<bool(const CAmDatabaseHandlerMap::am_Sink_Database_s &refObject)> comparator = [&](const CAmDatabaseHandlerMap::am_Sink_Database_s &sink) -> bool {
+ return (0 == sink.reserved &&
+ (sinkID == sink.sinkID || name.compare(sink.name) == 0));
+ };
+ return objectMatchingPredicate(mMappedData.mSinkMap, comparator);
}
/**
@@ -2355,9 +2496,9 @@ const CAmDatabaseHandlerMap::am_Sink_Database_s * CAmDatabaseHandlerMap::sinkWit
* @param name the name
* @return true if it exists.
*/
-bool CAmDatabaseHandlerMap::existSinkNameOrID(const am_sinkID_t sinkID, const std::string & name) const
+bool CAmDatabaseHandlerMap::existSinkNameOrID(const am_sinkID_t sinkID, const std::string &name) const
{
- return sinkWithNameOrID( sinkID, name)!=NULL;
+ return sinkWithNameOrID(sinkID, name) != NULL;
}
/**
@@ -2365,7 +2506,7 @@ bool CAmDatabaseHandlerMap::existSinkNameOrID(const am_sinkID_t sinkID, const st
* @param name the name
* @return true if it exists
*/
-bool CAmDatabaseHandlerMap::existSinkName(const std::string & name) const
+bool CAmDatabaseHandlerMap::existSinkName(const std::string &name) const
{
return existSinkNameOrID(mMappedData.mCurrentSinkID.mMax, name);
}
@@ -2377,11 +2518,13 @@ bool CAmDatabaseHandlerMap::existSinkName(const std::string & name) const
*/
bool CAmDatabaseHandlerMap::existDomain(const am_domainID_t domainID) const
{
- am_Domain_Database_s const * source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap);
- if( NULL!=source )
- return (0==source->reserved);
+ am_Domain_Database_s const *source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap);
+ if ( NULL != source )
+ {
+ return (0 == source->reserved);
+ }
- return false;
+ return false;
}
/**
@@ -2391,51 +2534,54 @@ bool CAmDatabaseHandlerMap::existDomain(const am_domainID_t domainID) const
*/
bool CAmDatabaseHandlerMap::existGateway(const am_gatewayID_t gatewayID) const
{
- return existsObjectWithKeyInMap(gatewayID, mMappedData.mGatewayMap);
+ return existsObjectWithKeyInMap(gatewayID, mMappedData.mGatewayMap);
}
bool CAmDatabaseHandlerMap::existConverter(const am_converterID_t converterID) const
{
- return existsObjectWithKeyInMap(converterID, mMappedData.mConverterMap);
+ return existsObjectWithKeyInMap(converterID, mMappedData.mConverterMap);
}
-am_Error_e CAmDatabaseHandlerMap::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t & domainID) const
+am_Error_e CAmDatabaseHandlerMap::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t &domainID) const
{
- domainID=0;
+ domainID = 0;
- am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
- if( NULL!=source )
+ am_Source_Database_s const *source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+ if ( NULL != source )
{
- domainID = source->domainID;
- return E_OK;
+ domainID = source->domainID;
+ return E_OK;
}
+
return E_NON_EXISTENT;
}
-am_Error_e am::CAmDatabaseHandlerMap::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t & domainID) const
+am_Error_e am::CAmDatabaseHandlerMap::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t &domainID) const
{
- domainID=0;
+ domainID = 0;
- am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
- if( NULL!=source )
- {
- domainID = source->domainID;
- return E_OK;
- }
- return E_NON_EXISTENT;
+ am_Sink_Database_s const *source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+ if ( NULL != source )
+ {
+ domainID = source->domainID;
+ return E_OK;
+ }
+
+ return E_NON_EXISTENT;
}
-am_Error_e am::CAmDatabaseHandlerMap::getDomainOfCrossfader(const am_converterID_t crossfader, am_domainID_t & domainID) const
+am_Error_e am::CAmDatabaseHandlerMap::getDomainOfCrossfader(const am_converterID_t crossfader, am_domainID_t &domainID) const
{
- domainID=0;
+ domainID = 0;
- am_Crossfader_Database_s const * cross = objectForKeyIfExistsInMap(crossfader, mMappedData.mCrossfaderMap);
- if( NULL!=cross )
- {
- getDomainOfSource(cross->sinkID_A,domainID);
- return E_OK;
- }
- return E_NON_EXISTENT;
+ am_Crossfader_Database_s const *cross = objectForKeyIfExistsInMap(crossfader, mMappedData.mCrossfaderMap);
+ if ( NULL != cross )
+ {
+ getDomainOfSource(cross->sinkID_A, domainID);
+ return E_OK;
+ }
+
+ return E_NON_EXISTENT;
}
/**
@@ -2445,7 +2591,7 @@ am_Error_e am::CAmDatabaseHandlerMap::getDomainOfCrossfader(const am_converterID
*/
bool CAmDatabaseHandlerMap::existSinkClass(const am_sinkClass_t sinkClassID) const
{
- return existsObjectWithKeyInMap(sinkClassID, mMappedData.mSinkClassesMap);
+ return existsObjectWithKeyInMap(sinkClassID, mMappedData.mSinkClassesMap);
}
/**
@@ -2455,27 +2601,27 @@ bool CAmDatabaseHandlerMap::existSinkClass(const am_sinkClass_t sinkClassID) con
*/
bool CAmDatabaseHandlerMap::existSourceClass(const am_sourceClass_t sourceClassID) const
{
- return existsObjectWithKeyInMap(sourceClassID, mMappedData.mSourceClassesMap);
+ return existsObjectWithKeyInMap(sourceClassID, mMappedData.mSourceClassesMap);
}
am_Error_e CAmDatabaseHandlerMap::changeConnectionTimingInformation(const am_connectionID_t connectionID, const am_timeSync_t delay)
{
- if(!existConnectionID(connectionID))
- {
- logError(__METHOD_NAME__,"connectionID must exist");
- return (E_NON_EXISTENT);
- }
+ if (!existConnectionID(connectionID))
+ {
+ logError(__METHOD_NAME__, "connectionID must exist");
+ return (E_NON_EXISTENT);
+ }
mMappedData.mConnectionMap[connectionID].delay = delay;
- //now we need to find all mainConnections that use the changed connection and update their timing
+ // now we need to find all mainConnections that use the changed connection and update their timing
- //first get all route tables for all mainconnections
- am_Error_e error = E_OK;
- AmMapMainConnection::const_iterator iter = mMappedData.mMainConnectionMap.begin();
- for(; iter != mMappedData.mMainConnectionMap.end(); ++iter)
+ // first get all route tables for all mainconnections
+ am_Error_e error = E_OK;
+ AmMapMainConnection::const_iterator iter = mMappedData.mMainConnectionMap.begin();
+ for (; iter != mMappedData.mMainConnectionMap.end(); ++iter)
{
- const am_MainConnection_s & mainConnection = iter->second;
+ const am_MainConnection_s &mainConnection = iter->second;
if (std::find(mainConnection.listConnectionID.begin(), mainConnection.listConnectionID.end(), connectionID) != mainConnection.listConnectionID.end())
{
// Got it.
@@ -2488,31 +2634,36 @@ am_Error_e CAmDatabaseHandlerMap::changeConnectionTimingInformation(const am_con
am_Error_e CAmDatabaseHandlerMap::changeConnectionFinal(const am_connectionID_t connectionID)
{
- am_Connection_Database_s const * connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap);
- if( NULL!=connection )
+ am_Connection_Database_s const *connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap);
+ if ( NULL != connection )
{
- mMappedData.mConnectionMap.at(connectionID).reserved = false;
- return E_OK;
+ mMappedData.mConnectionMap.at(connectionID).reserved = false;
+ return E_OK;
}
- logError(__METHOD_NAME__,"connectionID must exist");
+
+ logError(__METHOD_NAME__, "connectionID must exist");
return (E_NON_EXISTENT);
}
am_timeSync_t CAmDatabaseHandlerMap::calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const
{
if (!existMainConnection(mainConnectionID))
- return -1;
- const am_MainConnection_s & mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID);
- am_timeSync_t delay = 0;
- std::vector<am_connectionID_t>::const_iterator iter = mainConnection.listConnectionID.begin();
- for(;iter<mainConnection.listConnectionID.end(); ++iter)
- {
- am_Connection_Database_s const * source = objectForKeyIfExistsInMap(*iter, mMappedData.mConnectionMap);
- if( NULL!=source )
- {
- delay += std::max(source->delay, static_cast<am_timeSync_t>(0));
- }
- }
+ {
+ return -1;
+ }
+
+ const am_MainConnection_s &mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID);
+ am_timeSync_t delay = 0;
+ std::vector<am_connectionID_t>::const_iterator iter = mainConnection.listConnectionID.begin();
+ for (; iter < mainConnection.listConnectionID.end(); ++iter)
+ {
+ am_Connection_Database_s const *source = objectForKeyIfExistsInMap(*iter, mMappedData.mConnectionMap);
+ if ( NULL != source )
+ {
+ delay += std::max(source->delay, static_cast<am_timeSync_t>(0));
+ }
+ }
+
return (delay == 0 ? -1 : std::min(delay, static_cast<am_timeSync_t>(SHRT_MAX)));
}
@@ -2530,9 +2681,10 @@ bool CAmDatabaseHandlerMap::sourceVisible(const am_sourceID_t sourceID) const
{
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must exist");
- return false;
+ logError(__METHOD_NAME__, "sourceID must exist");
+ return false;
}
+
am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID);
return source.visible;
}
@@ -2544,13 +2696,16 @@ bool CAmDatabaseHandlerMap::sourceVisible(const am_sourceID_t sourceID) const
*/
bool CAmDatabaseHandlerMap::sinkVisible(const am_sinkID_t sinkID) const
{
- am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
- if( NULL!=source )
- {
- if(0==source->reserved)
- return source->visible;
- }
- return false;
+ am_Sink_Database_s const *source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+ if ( NULL != source )
+ {
+ if (0 == source->reserved)
+ {
+ return source->visible;
+ }
+ }
+
+ return false;
}
/**
@@ -2559,15 +2714,15 @@ bool CAmDatabaseHandlerMap::sinkVisible(const am_sinkID_t sinkID) const
* @param connection the connection to be checked
* @return true if connections exists
*/
-bool CAmDatabaseHandlerMap::existConnection(const am_Connection_s & connection) const
+bool CAmDatabaseHandlerMap::existConnection(const am_Connection_s &connection) const
{
- am_Connection_Database_s const * connectionObject = objectMatchingPredicate<am_Connection_Database_s, am_connectionID_t>(mMappedData.mConnectionMap, [&](const am_Connection_Database_s & obj){
- return false==obj.reserved &&
- connection.sinkID == obj.sinkID &&
- connection.sourceID == obj.sourceID &&
- connection.connectionFormat == obj.connectionFormat;
- });
- return ( NULL!=connectionObject );
+ am_Connection_Database_s const *connectionObject = objectMatchingPredicate<am_Connection_Database_s, am_connectionID_t>(mMappedData.mConnectionMap, [&](const am_Connection_Database_s &obj){
+ return false == obj.reserved &&
+ connection.sinkID == obj.sinkID &&
+ connection.sourceID == obj.sourceID &&
+ connection.connectionFormat == obj.connectionFormat;
+ });
+ return (NULL != connectionObject);
}
/**
@@ -2577,12 +2732,13 @@ bool CAmDatabaseHandlerMap::existConnection(const am_Connection_s & connection)
*/
bool CAmDatabaseHandlerMap::existConnectionID(const am_connectionID_t connectionID) const
{
- am_Connection_Database_s const * connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap);
- if( NULL!=connection )
- {
- return (true);
- }
- return false;
+ am_Connection_Database_s const *connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap);
+ if ( NULL != connection )
+ {
+ return (true);
+ }
+
+ return false;
}
/**
@@ -2592,297 +2748,324 @@ bool CAmDatabaseHandlerMap::existConnectionID(const am_connectionID_t connection
*/
bool CAmDatabaseHandlerMap::existCrossFader(const am_crossfaderID_t crossfaderID) const
{
- return existsObjectWithKeyInMap(crossfaderID, mMappedData.mCrossfaderMap);
+ return existsObjectWithKeyInMap(crossfaderID, mMappedData.mCrossfaderMap);
}
-am_Error_e CAmDatabaseHandlerMap::getSoureState(const am_sourceID_t sourceID, am_SourceState_e & sourceState) const
+am_Error_e CAmDatabaseHandlerMap::getSoureState(const am_sourceID_t sourceID, am_SourceState_e &sourceState) const
{
- am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
- if( NULL!=source )
- {
- sourceState = source->sourceState;
- return (E_OK);
- }
- else
- {
- sourceState = SS_UNKNNOWN;
- return (E_NON_EXISTENT);
- }
+ am_Source_Database_s const *source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+ if ( NULL != source )
+ {
+ sourceState = source->sourceState;
+ return (E_OK);
+ }
+ else
+ {
+ sourceState = SS_UNKNNOWN;
+ return (E_NON_EXISTENT);
+ }
}
am_Error_e CAmDatabaseHandlerMap::changeSourceState(const am_sourceID_t sourceID, const am_SourceState_e sourceState)
{
- if(!(sourceState>=SS_UNKNNOWN && sourceState<=SS_MAX))
- {
- logError(__METHOD_NAME__,"sourceState must be valid");
- return (E_NOT_POSSIBLE);
- }
+ if (!(sourceState >= SS_UNKNNOWN && sourceState <= SS_MAX))
+ {
+ logError(__METHOD_NAME__, "sourceState must be valid");
+ return (E_NOT_POSSIBLE);
+ }
- if(existSource(sourceID))
+ if (existSource(sourceID))
{
- mMappedData.mSourceMap.at(sourceID).sourceState = sourceState;
- return (E_OK);
- }
- logError(__METHOD_NAME__,"sourceID must exist");
- return (E_NON_EXISTENT);
+ mMappedData.mSourceMap.at(sourceID).sourceState = sourceState;
+ return (E_OK);
+ }
+
+ logError(__METHOD_NAME__, "sourceID must exist");
+ return (E_NON_EXISTENT);
}
am_Error_e CAmDatabaseHandlerMap::changeSourceInterruptState(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
{
- assert(sourceID!=0);
- assert(interruptState>=IS_UNKNOWN && interruptState<=IS_MAX);
- if(existSource(sourceID))
+ assert(sourceID != 0);
+ assert(interruptState >= IS_UNKNOWN && interruptState <= IS_MAX);
+ if (existSource(sourceID))
{
mMappedData.mSourceMap.at(sourceID).interruptState = interruptState;
return (E_OK);
}
+
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::getSinkMainVolume(const am_sinkID_t sinkID, am_mainVolume_t &mainVolume) const
+{
+
+ am_Sink_Database_s const *source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+ if ( NULL != source )
+ {
+ mainVolume = source->mainVolume;
+ return (E_OK);
+ }
+
+ mainVolume = -1;
+ logWarning(__METHOD_NAME__, "sinkID must be valid");
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::getSinkVolume(const am_sinkID_t sinkID, am_volume_t &volume) const
+{
+
+ am_Sink_Database_s const *source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+ if ( NULL != source )
+ {
+ volume = source->volume;
+ return (E_OK);
+ }
+
+ volume = -1;
+ logWarning(__METHOD_NAME__, "sinkID must be valid");
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::getSourceVolume(const am_sourceID_t sourceID, am_volume_t &volume) const
+{
+ am_Source_Database_s const *source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+ if ( NULL != source )
+ {
+ volume = source->volume;
+ return (E_OK);
+ }
+
+ volume = -1;
+ logWarning(__METHOD_NAME__, "sourceID must be valid");
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t &value) const
+{
+
+ am_Sink_Database_s *pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+ if ( NULL != pObject )
+ {
+ if (pObject->listSoundProperties.size() > 0 && 0 == pObject->cacheSoundProperties.size())
+ {
+ std::vector<am_SoundProperty_s>::const_iterator iter = pObject->listSoundProperties.begin();
+ for (; iter < pObject->listSoundProperties.end(); ++iter)
+ {
+ pObject->cacheSoundProperties[iter->type] = iter->value;
+ }
+ }
+
+ auto it = pObject->cacheSoundProperties.find(propertyType);
+ if (it != pObject->cacheSoundProperties.end())
+ {
+ value = it->second;
+ return (E_OK);
+ }
+ }
+
+ value = -1;
+ logWarning(__METHOD_NAME__, "sinkID must be valid");
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t &value) const
+{
+ am_Source_Database_s *pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+ if ( NULL != pObject )
+ {
+ if (pObject->listSoundProperties.size() > 0 && 0 == pObject->cacheSoundProperties.size())
+ {
+ std::vector<am_SoundProperty_s>::const_iterator iter = pObject->listSoundProperties.begin();
+ for (; iter < pObject->listSoundProperties.end(); ++iter)
+ {
+ pObject->cacheSoundProperties[iter->type] = iter->value;
+ }
+ }
+
+ auto it = pObject->cacheSoundProperties.find(propertyType);
+ if (it != pObject->cacheSoundProperties.end())
+ {
+ value = it->second;
+ return (E_OK);
+ }
+ }
+
+ value = -1;
+ logWarning(__METHOD_NAME__, "sourceID must be valid");
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t &value) const
+{
+ am_Sink_Database_s *pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+ if ( NULL != pObject )
+ {
+ if (pObject->listMainSoundProperties.size() > 0 && 0 == pObject->cacheMainSoundProperties.size())
+ {
+ std::vector<am_MainSoundProperty_s>::const_iterator iter = pObject->listMainSoundProperties.begin();
+ for (; iter < pObject->listMainSoundProperties.end(); ++iter)
+ {
+ pObject->cacheMainSoundProperties[iter->type] = iter->value;
+ }
+ }
+
+ auto it = pObject->cacheMainSoundProperties.find(propertyType);
+ if (it != pObject->cacheMainSoundProperties.end())
+ {
+ value = it->second;
+ return (E_OK);
+ }
+ }
+
+ value = -1;
+ logWarning(__METHOD_NAME__, "sinkID must be valid");
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t &value) const
+{
+
+ am_Source_Database_s *pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+ if ( NULL != pObject )
+ {
+ if (pObject->listMainSoundProperties.size() > 0 && 0 == pObject->cacheMainSoundProperties.size())
+ {
+ std::vector<am_MainSoundProperty_s>::const_iterator iter = pObject->listMainSoundProperties.begin();
+ for (; iter < pObject->listMainSoundProperties.end(); ++iter)
+ {
+ pObject->cacheMainSoundProperties[iter->type] = iter->value;
+ }
+ }
+
+ auto it = pObject->cacheMainSoundProperties.find(propertyType);
+ if (it != pObject->cacheMainSoundProperties.end())
+ {
+ value = it->second;
+ return (E_OK);
+ }
+ }
+
+ value = -1;
+ logWarning(__METHOD_NAME__, "sourceID must be valid");
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::getDomainState(const am_domainID_t domainID, am_DomainState_e &state) const
+{
+
+ am_Domain_Database_s const *source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap);
+ if ( NULL != source )
+ {
+ state = source->state;
+ return (E_OK);
+ }
+
+ state = DS_UNKNOWN;
+ logWarning(__METHOD_NAME__, "domainID must be valid");
return (E_NON_EXISTENT);
}
+am_Error_e CAmDatabaseHandlerMap::peekDomain(const std::string &name, am_domainID_t &domainID)
+{
+ domainID = 0;
-am_Error_e CAmDatabaseHandlerMap::getSinkMainVolume(const am_sinkID_t sinkID, am_mainVolume_t& mainVolume) const {
-
-
- am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
- if( NULL!=source )
- {
- mainVolume = source->mainVolume;
- return (E_OK);
- }
- mainVolume = -1;
- logWarning(__METHOD_NAME__,"sinkID must be valid");
- return (E_NON_EXISTENT);
-}
-
-am_Error_e CAmDatabaseHandlerMap::getSinkVolume(const am_sinkID_t sinkID, am_volume_t & volume) const
-{
-
- am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
- if( NULL!=source )
- {
- volume = source->volume;
- return (E_OK);
- }
- volume = -1;
- logWarning(__METHOD_NAME__,"sinkID must be valid");
- return (E_NON_EXISTENT);
-}
-
-am_Error_e CAmDatabaseHandlerMap::getSourceVolume(const am_sourceID_t sourceID, am_volume_t & volume) const
-{
- am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
- if( NULL!=source )
- {
- volume = source->volume;
- return (E_OK);
- }
- volume = -1;
- logWarning(__METHOD_NAME__,"sourceID must be valid");
- return (E_NON_EXISTENT);
-}
-
-am_Error_e CAmDatabaseHandlerMap::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t & value) const
-{
-
- am_Sink_Database_s * pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
- if( NULL!=pObject )
- {
- if(pObject->listSoundProperties.size()>0 && 0==pObject->cacheSoundProperties.size())
- {
- std::vector<am_SoundProperty_s>::const_iterator iter = pObject->listSoundProperties.begin();
- for(; iter<pObject->listSoundProperties.end(); ++iter)
- pObject->cacheSoundProperties[iter->type] = iter->value;
- }
- auto it = pObject->cacheSoundProperties.find(propertyType);
- if(it!=pObject->cacheSoundProperties.end())
- {
- value = it->second;
- return (E_OK);
- }
- }
- value = -1;
- logWarning(__METHOD_NAME__,"sinkID must be valid");
- return (E_NON_EXISTENT);
-}
-
-am_Error_e CAmDatabaseHandlerMap::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t & value) const
-{
- am_Source_Database_s * pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
- if( NULL!=pObject )
- {
- if(pObject->listSoundProperties.size()>0 && 0==pObject->cacheSoundProperties.size())
- {
- std::vector<am_SoundProperty_s>::const_iterator iter = pObject->listSoundProperties.begin();
- for(; iter<pObject->listSoundProperties.end(); ++iter)
- pObject->cacheSoundProperties[iter->type] = iter->value;
- }
- auto it = pObject->cacheSoundProperties.find(propertyType);
- if(it!=pObject->cacheSoundProperties.end())
- {
- value = it->second;
- return (E_OK);
- }
- }
- value = -1;
- logWarning(__METHOD_NAME__,"sourceID must be valid");
- return (E_NON_EXISTENT);
-}
-
-am_Error_e CAmDatabaseHandlerMap::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const
-{
- am_Sink_Database_s * pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
- if( NULL!=pObject )
- {
- if(pObject->listMainSoundProperties.size()>0 && 0==pObject->cacheMainSoundProperties.size())
- {
- std::vector<am_MainSoundProperty_s>::const_iterator iter = pObject->listMainSoundProperties.begin();
- for(; iter<pObject->listMainSoundProperties.end(); ++iter)
- pObject->cacheMainSoundProperties[iter->type] = iter->value;
- }
- auto it = pObject->cacheMainSoundProperties.find(propertyType);
- if(it!=pObject->cacheMainSoundProperties.end())
- {
- value = it->second;
- return (E_OK);
- }
- }
- value = -1;
- logWarning(__METHOD_NAME__,"sinkID must be valid");
- return (E_NON_EXISTENT);
-}
-
-am_Error_e CAmDatabaseHandlerMap::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const
-{
-
- am_Source_Database_s * pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
- if( NULL!=pObject )
- {
- if(pObject->listMainSoundProperties.size()>0 && 0==pObject->cacheMainSoundProperties.size())
- {
- std::vector<am_MainSoundProperty_s>::const_iterator iter = pObject->listMainSoundProperties.begin();
- for(; iter<pObject->listMainSoundProperties.end(); ++iter)
- pObject->cacheMainSoundProperties[iter->type] = iter->value;
- }
- auto it = pObject->cacheMainSoundProperties.find(propertyType);
- if(it!=pObject->cacheMainSoundProperties.end())
- {
- value = it->second;
- return (E_OK);
- }
- }
-
- value = -1;
- logWarning(__METHOD_NAME__,"sourceID must be valid");
- return (E_NON_EXISTENT);
-}
-
-am_Error_e CAmDatabaseHandlerMap::getDomainState(const am_domainID_t domainID, am_DomainState_e& state) const
-{
-
- am_Domain_Database_s const * source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap);
- if( NULL!=source )
- {
- state = source->state;
- return (E_OK);
- }
- state = DS_UNKNOWN;
- logWarning(__METHOD_NAME__,"domainID must be valid");
- return (E_NON_EXISTENT);
-}
-
-am_Error_e CAmDatabaseHandlerMap::peekDomain(const std::string & name, am_domainID_t & domainID)
-{
- domainID=0;
-
- am_Domain_Database_s const *reservedDomain = objectMatchingPredicate<am_Domain_Database_s, am_domainID_t>(mMappedData.mDomainMap, [&](const am_Domain_Database_s & obj){
- return name.compare(obj.name)==0;
- });
-
- if( NULL != reservedDomain )
- {
- domainID = reservedDomain->domainID;
- return E_OK;
+ am_Domain_Database_s const *reservedDomain = objectMatchingPredicate<am_Domain_Database_s, am_domainID_t>(mMappedData.mDomainMap, [&](const am_Domain_Database_s &obj){
+ return name.compare(obj.name) == 0;
+ });
+
+ if ( NULL != reservedDomain )
+ {
+ domainID = reservedDomain->domainID;
+ return E_OK;
}
else
{
- int16_t nextID = 0;
- if( mMappedData.increaseID( nextID, mMappedData.mCurrentDomainID) )
- {
- domainID = nextID;
- am_Domain_Database_s domain;
- domain.domainID = nextID;
- domain.name = name;
- domain.reserved = 1;
- mMappedData.mDomainMap[nextID] = domain;
- return E_OK;
- }
- return E_UNKNOWN;
+ int16_t nextID = 0;
+ if ( mMappedData.increaseID(nextID, mMappedData.mCurrentDomainID))
+ {
+ domainID = nextID;
+ am_Domain_Database_s domain;
+ domain.domainID = nextID;
+ domain.name = name;
+ domain.reserved = 1;
+ mMappedData.mDomainMap[nextID] = domain;
+ return E_OK;
+ }
+
+ return E_UNKNOWN;
}
+
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::peekSink(const std::string & name, am_sinkID_t & sinkID)
+am_Error_e CAmDatabaseHandlerMap::peekSink(const std::string &name, am_sinkID_t &sinkID)
{
- am_Sink_Database_s const *reservedSink = objectMatchingPredicate<am_Sink_Database_s, am_sinkID_t>(mMappedData.mSinkMap, [&](const am_Sink_Database_s & obj){
- return name.compare(obj.name)==0;
- });
- if( NULL!=reservedSink )
+ am_Sink_Database_s const *reservedSink = objectMatchingPredicate<am_Sink_Database_s, am_sinkID_t>(mMappedData.mSinkMap, [&](const am_Sink_Database_s &obj){
+ return name.compare(obj.name) == 0;
+ });
+ if ( NULL != reservedSink )
{
- sinkID = reservedSink->sinkID;
- return E_OK;
+ sinkID = reservedSink->sinkID;
+ return E_OK;
}
else
{
- int16_t nextID = 0;
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentSinkID))
- {
- if(mFirstStaticSink)
- {
- nextID = DYNAMIC_ID_BOUNDARY;
- mFirstStaticSink = false;
- }
- sinkID = nextID;
- am_Sink_Database_s object;
- object.sinkID = nextID;
- object.name = name;
- object.reserved = 1;
- mMappedData.mSinkMap[nextID] = object;
- return E_OK;
- }
- return E_UNKNOWN;
+ int16_t nextID = 0;
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentSinkID))
+ {
+ if (mFirstStaticSink)
+ {
+ nextID = DYNAMIC_ID_BOUNDARY;
+ mFirstStaticSink = false;
+ }
+
+ sinkID = nextID;
+ am_Sink_Database_s object;
+ object.sinkID = nextID;
+ object.name = name;
+ object.reserved = 1;
+ mMappedData.mSinkMap[nextID] = object;
+ return E_OK;
+ }
+
+ return E_UNKNOWN;
}
}
-am_Error_e CAmDatabaseHandlerMap::peekSource(const std::string & name, am_sourceID_t & sourceID)
+am_Error_e CAmDatabaseHandlerMap::peekSource(const std::string &name, am_sourceID_t &sourceID)
{
- am_Source_Database_s const *reservedSrc = objectMatchingPredicate<am_Source_Database_s, am_sourceID_t>(mMappedData.mSourceMap, [&](const am_Source_Database_s & obj){
- return name.compare(obj.name)==0;
- });
- if( NULL!=reservedSrc )
+ am_Source_Database_s const *reservedSrc = objectMatchingPredicate<am_Source_Database_s, am_sourceID_t>(mMappedData.mSourceMap, [&](const am_Source_Database_s &obj){
+ return name.compare(obj.name) == 0;
+ });
+ if ( NULL != reservedSrc )
{
- sourceID = reservedSrc->sourceID;
- return E_OK;
+ sourceID = reservedSrc->sourceID;
+ return E_OK;
}
else
{
- int16_t nextID = 0;
- if(mMappedData.increaseID(nextID, mMappedData.mCurrentSourceID))
- {
- if(mFirstStaticSource)
- {
-// nextID = DYNAMIC_ID_BOUNDARY;
- mFirstStaticSource = false;
- }
- sourceID = nextID;
- am_Source_Database_s object;
- object.sourceID = nextID;
- object.name = name;
- object.reserved = 1;
- mMappedData.mSourceMap[nextID] = object;
- return E_OK;
- }
- else
- return E_UNKNOWN;
+ int16_t nextID = 0;
+ if (mMappedData.increaseID(nextID, mMappedData.mCurrentSourceID))
+ {
+ if (mFirstStaticSource)
+ {
+// nextID = DYNAMIC_ID_BOUNDARY;
+ mFirstStaticSource = false;
+ }
+
+ sourceID = nextID;
+ am_Source_Database_s object;
+ object.sourceID = nextID;
+ object.name = name;
+ object.reserved = 1;
+ mMappedData.mSourceMap[nextID] = object;
+ return E_OK;
+ }
+ else
+ {
+ return E_UNKNOWN;
+ }
}
}
@@ -2890,7 +3073,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkVolume(const am_sinkID_t sinkID, con
{
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must be valid");
+ logError(__METHOD_NAME__, "sinkID must be valid");
return (E_NON_EXISTENT);
}
@@ -2902,60 +3085,70 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceVolume(const am_sourceID_t sourceI
{
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must be valid");
+ logError(__METHOD_NAME__, "sourceID must be valid");
return (E_NON_EXISTENT);
}
+
mMappedData.mSourceMap[sourceID].volume = volume;
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeSourceSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+am_Error_e CAmDatabaseHandlerMap::changeSourceSoundPropertyDB(const am_SoundProperty_s &soundProperty, const am_sourceID_t sourceID)
{
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must be valid");
+ logError(__METHOD_NAME__, "sourceID must be valid");
return (E_NON_EXISTENT);
}
- am_Source_Database_s & source = mMappedData.mSourceMap[sourceID];
- std::vector<am_SoundProperty_s>::iterator iter = source.listSoundProperties.begin();
- for(; iter<source.listSoundProperties.end(); ++iter)
- {
- if( soundProperty.type == iter->type )
- {
- iter->value = soundProperty.value;
- if(source.cacheSoundProperties.size())
- source.cacheSoundProperties[soundProperty.type] = soundProperty.value;
- return (E_OK);
- }
- }
- logError(__METHOD_NAME__,"soundproperty type must be valid source:",sourceID,"type",soundProperty.type);
- return (E_NON_EXISTENT);
+ am_Source_Database_s &source = mMappedData.mSourceMap[sourceID];
+ std::vector<am_SoundProperty_s>::iterator iter = source.listSoundProperties.begin();
+ for (; iter < source.listSoundProperties.end(); ++iter)
+ {
+ if ( soundProperty.type == iter->type )
+ {
+ iter->value = soundProperty.value;
+ if (source.cacheSoundProperties.size())
+ {
+ source.cacheSoundProperties[soundProperty.type] = soundProperty.value;
+ }
+
+ return (E_OK);
+ }
+ }
+
+ logError(__METHOD_NAME__, "soundproperty type must be valid source:", sourceID, "type", soundProperty.type);
+ return (E_NON_EXISTENT);
}
-am_Error_e CAmDatabaseHandlerMap::changeSinkSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandlerMap::changeSinkSoundPropertyDB(const am_SoundProperty_s &soundProperty, const am_sinkID_t sinkID)
{
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must be valid");
+ logError(__METHOD_NAME__, "sinkID must be valid");
return (E_NON_EXISTENT);
}
- am_Sink_Database_s & sink = mMappedData.mSinkMap[sinkID];
+
+ am_Sink_Database_s &sink = mMappedData.mSinkMap[sinkID];
std::vector<am_SoundProperty_s>::iterator iter = sink.listSoundProperties.begin();
- for(; iter<sink.listSoundProperties.end(); ++iter)
- {
- if( soundProperty.type == iter->type )
- {
- iter->value = soundProperty.value;
- if(sink.cacheSoundProperties.size())
- sink.cacheSoundProperties[soundProperty.type] = soundProperty.value;
- return (E_OK);
- }
- }
- logError(__METHOD_NAME__,"soundproperty type must be valid sinkID:",sinkID,"type",soundProperty.type);
- return (E_NON_EXISTENT);
+ for (; iter < sink.listSoundProperties.end(); ++iter)
+ {
+ if ( soundProperty.type == iter->type )
+ {
+ iter->value = soundProperty.value;
+ if (sink.cacheSoundProperties.size())
+ {
+ sink.cacheSoundProperties[soundProperty.type] = soundProperty.value;
+ }
+
+ return (E_OK);
+ }
+ }
+
+ logError(__METHOD_NAME__, "soundproperty type must be valid sinkID:", sinkID, "type", soundProperty.type);
+ return (E_NON_EXISTENT);
}
am_Error_e CAmDatabaseHandlerMap::changeCrossFaderHotSink(const am_crossfaderID_t crossfaderID, const am_HotSink_e hotsink)
@@ -2963,7 +3156,7 @@ am_Error_e CAmDatabaseHandlerMap::changeCrossFaderHotSink(const am_crossfaderID_
if (!existCrossFader(crossfaderID))
{
- logError(__METHOD_NAME__,"crossfaderID must be valid");
+ logError(__METHOD_NAME__, "crossfaderID must be valid");
return (E_NON_EXISTENT);
}
@@ -2971,67 +3164,74 @@ am_Error_e CAmDatabaseHandlerMap::changeCrossFaderHotSink(const am_crossfaderID_
return (E_OK);
}
-bool CAmDatabaseHandlerMap::isComponentConnected(const am_Gateway_s & gateway) const
+bool CAmDatabaseHandlerMap::isComponentConnected(const am_Gateway_s &gateway) const
{
- bool ret = isConnected(gateway);
- return ret;
+ bool ret = isConnected(gateway);
+ return ret;
}
-bool CAmDatabaseHandlerMap::isComponentConnected(const am_Converter_s & converter) const
+bool CAmDatabaseHandlerMap::isComponentConnected(const am_Converter_s &converter) const
{
- bool ret = isConnected(converter);
- return ret;
+ bool ret = isConnected(converter);
+ return ret;
}
-am_Error_e am::CAmDatabaseHandlerMap::peekSinkClassID(const std::string & name, am_sinkClass_t & sinkClassID)
+am_Error_e am::CAmDatabaseHandlerMap::peekSinkClassID(const std::string &name, am_sinkClass_t &sinkClassID)
{
if (name.empty())
+ {
return (E_NON_EXISTENT);
- am_SinkClass_Database_s const *reserved = objectMatchingPredicate<am_SinkClass_Database_s, am_sinkClass_t>(mMappedData.mSinkClassesMap, [&](const am_SinkClass_Database_s & obj){
- return name.compare(obj.name)==0;
- });
- if( NULL!=reserved )
- {
- sinkClassID = reserved->sinkClassID;
- return E_OK;
- }
- return (E_NON_EXISTENT);
+ }
+
+ am_SinkClass_Database_s const *reserved = objectMatchingPredicate<am_SinkClass_Database_s, am_sinkClass_t>(mMappedData.mSinkClassesMap, [&](const am_SinkClass_Database_s &obj){
+ return name.compare(obj.name) == 0;
+ });
+ if ( NULL != reserved )
+ {
+ sinkClassID = reserved->sinkClassID;
+ return E_OK;
+ }
+
+ return (E_NON_EXISTENT);
}
-am_Error_e am::CAmDatabaseHandlerMap::peekSourceClassID(const std::string & name, am_sourceClass_t & sourceClassID)
+am_Error_e am::CAmDatabaseHandlerMap::peekSourceClassID(const std::string &name, am_sourceClass_t &sourceClassID)
{
if (name.empty())
+ {
return (E_NON_EXISTENT);
- am_SourceClass_Database_s const *ptrSource = objectMatchingPredicate<am_SourceClass_Database_s, am_sourceClass_t>(mMappedData.mSourceClassesMap, [&](const am_SourceClass_Database_s & obj){
- return name.compare(obj.name)==0;
- });
- if( NULL!=ptrSource )
- {
- sourceClassID = ptrSource->sourceClassID;
- return E_OK;
- }
- return (E_NON_EXISTENT);
-}
+ }
+ am_SourceClass_Database_s const *ptrSource = objectMatchingPredicate<am_SourceClass_Database_s, am_sourceClass_t>(mMappedData.mSourceClassesMap, [&](const am_SourceClass_Database_s &obj){
+ return name.compare(obj.name) == 0;
+ });
+ if ( NULL != ptrSource )
+ {
+ sourceClassID = ptrSource->sourceClassID;
+ return E_OK;
+ }
-am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+ return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s> &listSoundProperties, const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must be valid");
+ logError(__METHOD_NAME__, "sourceID must be valid");
return (E_NON_EXISTENT);
}
DB_COND_UPDATE_INIT;
- am_sourceClass_t sourceClassOut(sourceClassID);
+ am_sourceClass_t sourceClassOut(sourceClassID);
std::vector<am_MainSoundProperty_s> listMainSoundPropertiesOut(listMainSoundProperties);
- //check if sinkClass needs to be changed
+ // check if sinkClass needs to be changed
std::unordered_map<am_sourceID_t, am_Source_Database_s>::iterator iter = mMappedData.mSourceMap.begin();
- for(; iter!=mMappedData.mSourceMap.end(); ++iter)
+ for (; iter != mMappedData.mSourceMap.end(); ++iter)
{
- if( iter->second.sourceID == sourceID )
+ if ( iter->second.sourceID == sourceID )
{
if (sourceClassID != 0)
{
@@ -3041,24 +3241,25 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c
{
sourceClassOut = iter->second.sourceClassID;
}
+
break;
}
}
- //check if soundProperties need to be updated
+ // check if soundProperties need to be updated
if (!listSoundProperties.empty())
{
mMappedData.mSourceMap.at(sourceID).listSoundProperties = listSoundProperties;
mMappedData.mSourceMap.at(sourceID).cacheSoundProperties.clear();
}
- //check if we have to update the list of connectionformats
+ // check if we have to update the list of connectionformats
if (!listConnectionFormats.empty())
{
mMappedData.mSourceMap.at(sourceID).listConnectionFormats = listConnectionFormats;
}
- //then we need to check if we need to update the listMainSoundProperties
+ // then we need to check if we need to update the listMainSoundProperties
if (sourceVisible(sourceID))
{
if (!listMainSoundProperties.empty())
@@ -3068,7 +3269,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c
}
else
{
- getListMainSourceSoundProperties(sourceID,listMainSoundPropertiesOut);
+ getListMainSourceSoundProperties(sourceID, listMainSoundPropertiesOut);
}
}
@@ -3076,7 +3277,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c
{
logVerbose("DatabaseHandler::changeSource changed changeSource of source:", sourceID);
- NOTIFY_OBSERVERS4(dboSourceUpdated, sourceID,sourceClassOut,listMainSoundPropertiesOut,sourceVisible(sourceID))
+ NOTIFY_OBSERVERS4(dboSourceUpdated, sourceID, sourceClassOut, listMainSoundPropertiesOut, sourceVisible(sourceID))
}
@@ -3084,21 +3285,21 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c
}
-am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s> &listSoundProperties, const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
DB_COND_UPDATE_INIT;
- am_sinkClass_t sinkClassOut(sinkClassID);
+ am_sinkClass_t sinkClassOut(sinkClassID);
std::vector<am_MainSoundProperty_s> listMainSoundPropertiesOut(listMainSoundProperties);
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must be valid");
+ logError(__METHOD_NAME__, "sinkID must be valid");
return (E_NON_EXISTENT);
}
std::unordered_map<am_sinkID_t, am_Sink_Database_s>::iterator iter = mMappedData.mSinkMap.begin();
- for(; iter!=mMappedData.mSinkMap.end(); ++iter)
+ for (; iter != mMappedData.mSinkMap.end(); ++iter)
{
if (iter->second.sinkID == sinkID)
{
@@ -3110,24 +3311,25 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a
{
sinkClassOut = iter->second.sinkClassID;
}
+
break;
}
}
- //check if soundProperties need to be updated
+ // check if soundProperties need to be updated
if (!listSoundProperties.empty())
{
mMappedData.mSinkMap.at(sinkID).listSoundProperties = listSoundProperties;
mMappedData.mSinkMap.at(sinkID).cacheSoundProperties.clear();
}
- //check if we have to update the list of connectionformats
+ // check if we have to update the list of connectionformats
if (!listConnectionFormats.empty())
{
mMappedData.mSinkMap.at(sinkID).listConnectionFormats = listConnectionFormats;
}
- //then we need to check if we need to update the listMainSoundProperties
+ // then we need to check if we need to update the listMainSoundProperties
if (sinkVisible(sinkID))
{
if (!listMainSoundProperties.empty())
@@ -3135,9 +3337,9 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a
DB_COND_UPDATE(mMappedData.mSinkMap.at(sinkID).listMainSoundProperties, listMainSoundProperties);
mMappedData.mSinkMap.at(sinkID).cacheMainSoundProperties.clear();
}
- else //read out the properties
+ else // read out the properties
{
- getListMainSinkSoundProperties(sinkID,listMainSoundPropertiesOut);
+ getListMainSinkSoundProperties(sinkID, listMainSoundPropertiesOut);
}
}
@@ -3145,33 +3347,34 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a
{
logVerbose("DatabaseHandler::changeSink changed changeSink of sink:", sinkID);
- NOTIFY_OBSERVERS4(dboSinkUpdated, sinkID,sinkClassOut,listMainSoundPropertiesOut,sinkVisible(sinkID))
+ NOTIFY_OBSERVERS4(dboSinkUpdated, sinkID, sinkClassOut, listMainSoundPropertiesOut, sinkVisible(sinkID))
}
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations)
+am_Error_e CAmDatabaseHandlerMap::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector<am_NotificationConfiguration_s> &listMainNotificationConfigurations)
{
if (!existSink(sinkID))
{
- logWarning(__METHOD_NAME__,"sinkID must be valid");
+ logWarning(__METHOD_NAME__, "sinkID must be valid");
return (E_DATABASE_ERROR);
}
+
listMainNotificationConfigurations.clear();
listMainNotificationConfigurations = mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations;
- return (E_OK);
+ return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations)
+am_Error_e CAmDatabaseHandlerMap::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector<am_NotificationConfiguration_s> &listMainNotificationConfigurations)
{
if (!existSource(sourceID))
{
- logWarning(__METHOD_NAME__,"sourceID must be valid");
+ logWarning(__METHOD_NAME__, "sourceID must be valid");
return (E_DATABASE_ERROR);
}
@@ -3180,22 +3383,25 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSourceNotificationConfigurations(co
return (E_OK);
}
-bool changeMainNotificationConfiguration(std::vector<am_NotificationConfiguration_s> & listMainNotificationConfigurations,
- const am_NotificationConfiguration_s & mainNotificationConfiguration)
+bool changeMainNotificationConfiguration(std::vector<am_NotificationConfiguration_s> &listMainNotificationConfigurations,
+ const am_NotificationConfiguration_s &mainNotificationConfiguration)
{
std::vector<am_NotificationConfiguration_s>::iterator iter = listMainNotificationConfigurations.begin();
- for(; iter<listMainNotificationConfigurations.end(); ++iter)
+ for (; iter < listMainNotificationConfigurations.end(); ++iter)
{
- if( mainNotificationConfiguration.type == iter->type )
+ if ( mainNotificationConfiguration.type == iter->type )
{
#ifdef WITH_DATABASE_CHANGE_CHECK
- if( iter->status == mainNotificationConfiguration.status && iter->parameter == mainNotificationConfiguration.parameter )
+ if ( iter->status == mainNotificationConfiguration.status && iter->parameter == mainNotificationConfiguration.parameter )
+ {
return false;
+ }
#endif
*iter = mainNotificationConfiguration;
return true;
}
}
+
return false;
}
@@ -3204,13 +3410,16 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSinkNotificationConfigurationDB(cons
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must be valid");
+ logError(__METHOD_NAME__, "sinkID must be valid");
return (E_NON_EXISTENT);
}
- if(!changeMainNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations, mainNotificationConfiguration))
- return (E_NO_CHANGE);
- logVerbose("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=",mainNotificationConfiguration.parameter);
+ if (!changeMainNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations, mainNotificationConfiguration))
+ {
+ return (E_NO_CHANGE);
+ }
+
+ logVerbose("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=", mainNotificationConfiguration.parameter);
NOTIFY_OBSERVERS2(dboSinkMainNotificationConfigurationChanged, sinkID, mainNotificationConfiguration)
@@ -3222,96 +3431,99 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSourceNotificationConfigurationDB(co
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must be valid");
+ logError(__METHOD_NAME__, "sourceID must be valid");
return (E_NON_EXISTENT);
}
- if(!changeMainNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listMainNotificationConfigurations, mainNotificationConfiguration))
- return (E_NO_CHANGE);
+ if (!changeMainNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listMainNotificationConfigurations, mainNotificationConfiguration))
+ {
+ return (E_NO_CHANGE);
+ }
- logVerbose("DatabaseHandler::changeMainSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=",mainNotificationConfiguration.parameter);
+ logVerbose("DatabaseHandler::changeMainSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=", mainNotificationConfiguration.parameter);
NOTIFY_OBSERVERS2(dboSourceMainNotificationConfigurationChanged, sourceID, mainNotificationConfiguration)
return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix)
+am_Error_e CAmDatabaseHandlerMap::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t> &listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkConnectionFormats, const std::vector<bool> &convertionMatrix)
{
- if (!existGateway(gatewayID))
- {
- logError(__METHOD_NAME__,"gatewayID must be valid");
- return (E_NON_EXISTENT);
- }
+ if (!existGateway(gatewayID))
+ {
+ logError(__METHOD_NAME__, "gatewayID must be valid");
+ return (E_NON_EXISTENT);
+ }
- if (!listSourceConnectionFormats.empty())
- {
- mMappedData.mGatewayMap.at(gatewayID).listSourceFormats = listSourceConnectionFormats;
- }
+ if (!listSourceConnectionFormats.empty())
+ {
+ mMappedData.mGatewayMap.at(gatewayID).listSourceFormats = listSourceConnectionFormats;
+ }
- if (!listSinkConnectionFormats.empty())
- {
- mMappedData.mGatewayMap.at(gatewayID).listSinkFormats = listSinkConnectionFormats;
- }
+ if (!listSinkConnectionFormats.empty())
+ {
+ mMappedData.mGatewayMap.at(gatewayID).listSinkFormats = listSinkConnectionFormats;
+ }
- if (!convertionMatrix.empty())
- {
- mListConnectionFormat.clear();
- mListConnectionFormat.insert(std::make_pair(gatewayID, convertionMatrix));
- }
+ if (!convertionMatrix.empty())
+ {
+ mListConnectionFormat.clear();
+ mListConnectionFormat.insert(std::make_pair(gatewayID, convertionMatrix));
+ }
- logVerbose("DatabaseHandler::changeGatewayDB changed Gateway with ID", gatewayID);
+ logVerbose("DatabaseHandler::changeGatewayDB changed Gateway with ID", gatewayID);
- //todo: check if observer needs to be adopted.
- return (E_OK);
+ // todo: check if observer needs to be adopted.
+ return (E_OK);
}
-am_Error_e CAmDatabaseHandlerMap::changeConverterDB(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix)
+am_Error_e CAmDatabaseHandlerMap::changeConverterDB(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t> &listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkConnectionFormats, const std::vector<bool> &convertionMatrix)
{
- if (!existConverter(converterID))
- {
- logError(__METHOD_NAME__,"converterID must be valid");
- return (E_NON_EXISTENT);
- }
+ if (!existConverter(converterID))
+ {
+ logError(__METHOD_NAME__, "converterID must be valid");
+ return (E_NON_EXISTENT);
+ }
- if (!listSourceConnectionFormats.empty())
- {
- mMappedData.mConverterMap.at(converterID).listSourceFormats = listSourceConnectionFormats;
- }
+ if (!listSourceConnectionFormats.empty())
+ {
+ mMappedData.mConverterMap.at(converterID).listSourceFormats = listSourceConnectionFormats;
+ }
- if (!listSinkConnectionFormats.empty())
- {
- mMappedData.mConverterMap.at(converterID).listSinkFormats = listSinkConnectionFormats;
- }
+ if (!listSinkConnectionFormats.empty())
+ {
+ mMappedData.mConverterMap.at(converterID).listSinkFormats = listSinkConnectionFormats;
+ }
- if (!convertionMatrix.empty())
- {
- mListConnectionFormat.clear();
- mListConnectionFormat.insert(std::make_pair(converterID, convertionMatrix));
- }
+ if (!convertionMatrix.empty())
+ {
+ mListConnectionFormat.clear();
+ mListConnectionFormat.insert(std::make_pair(converterID, convertionMatrix));
+ }
- logVerbose("DatabaseHandler::changeConverterDB changed Gateway with ID", converterID);
+ logVerbose("DatabaseHandler::changeConverterDB changed Gateway with ID", converterID);
- //todo: check if observer needs to be adopted.
- return (E_OK);
+ // todo: check if observer needs to be adopted.
+ return (E_OK);
}
-bool changeNotificationConfiguration(std::vector<am_NotificationConfiguration_s> & listNotificationConfigurations, const am_NotificationConfiguration_s & notificationConfiguration)
+bool changeNotificationConfiguration(std::vector<am_NotificationConfiguration_s> &listNotificationConfigurations, const am_NotificationConfiguration_s &notificationConfiguration)
{
- bool changed = false;
- std::vector<am_NotificationConfiguration_s>::iterator iter = listNotificationConfigurations.begin();
- for(; iter<listNotificationConfigurations.end(); ++iter)
- {
- if( notificationConfiguration.type == iter->type )
- {
- iter->status = notificationConfiguration.status;
- iter->parameter = notificationConfiguration.parameter;
- changed |= true;
- }
- }
- return changed;
+ bool changed = false;
+ std::vector<am_NotificationConfiguration_s>::iterator iter = listNotificationConfigurations.begin();
+ for (; iter < listNotificationConfigurations.end(); ++iter)
+ {
+ if ( notificationConfiguration.type == iter->type )
+ {
+ iter->status = notificationConfiguration.status;
+ iter->parameter = notificationConfiguration.parameter;
+ changed |= true;
+ }
+ }
+
+ return changed;
}
am_Error_e CAmDatabaseHandlerMap::changeSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s notificationConfiguration)
@@ -3319,15 +3531,18 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkNotificationConfigurationDB(const am
if (!existSink(sinkID))
{
- logError(__METHOD_NAME__,"sinkID must be valid");
+ logError(__METHOD_NAME__, "sinkID must be valid");
return (E_NON_EXISTENT);
}
- if(!changeNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listNotificationConfigurations, notificationConfiguration))
- return (E_NO_CHANGE);
- logVerbose("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=",notificationConfiguration.parameter);
+ if (!changeNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listNotificationConfigurations, notificationConfiguration))
+ {
+ return (E_NO_CHANGE);
+ }
+
+ logVerbose("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=", notificationConfiguration.parameter);
- //todo:: inform obsever here...
+ // todo:: inform obsever here...
return (E_NON_EXISTENT);
}
@@ -3336,84 +3551,101 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceNotificationConfigurationDB(const
if (!existSource(sourceID))
{
- logError(__METHOD_NAME__,"sourceID must be valid");
+ logError(__METHOD_NAME__, "sourceID must be valid");
return (E_NON_EXISTENT);
}
- if(!changeNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listNotificationConfigurations, notificationConfiguration))
- return (E_NO_CHANGE);
+ if (!changeNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listNotificationConfigurations, notificationConfiguration))
+ {
+ return (E_NO_CHANGE);
+ }
- logVerbose("DatabaseHandler::changeSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=",notificationConfiguration.parameter);
+ logVerbose("DatabaseHandler::changeSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=", notificationConfiguration.parameter);
- //todo:: implement observer function
+ // todo:: implement observer function
return (E_NON_EXISTENT);
}
-am_Error_e CAmDatabaseHandlerMap::enumerateSources(std::function<void(const am_Source_s & element)> cb) const
+am_Error_e CAmDatabaseHandlerMap::enumerateSources(std::function<void(const am_Source_s &element)> cb) const
{
- for(auto it = mMappedData.mSourceMap.begin(); it!=mMappedData.mSourceMap.end(); it++)
- {
- const am_Source_Database_s *pObject = &it->second;
- if( 0==pObject->reserved )
- cb(*pObject);
- }
- return E_OK;
+ for (auto it = mMappedData.mSourceMap.begin(); it != mMappedData.mSourceMap.end(); it++)
+ {
+ const am_Source_Database_s *pObject = &it->second;
+ if ( 0 == pObject->reserved )
+ {
+ cb(*pObject);
+ }
+ }
+
+ return E_OK;
}
-am_Error_e CAmDatabaseHandlerMap::enumerateSinks(std::function<void(const am_Sink_s & element)> cb) const
+am_Error_e CAmDatabaseHandlerMap::enumerateSinks(std::function<void(const am_Sink_s &element)> cb) const
{
- for(auto it = mMappedData.mSinkMap.begin(); it!=mMappedData.mSinkMap.end(); it++)
- {
- const am_Sink_Database_s *pObject = &it->second;
- if( 0==pObject->reserved )
- cb(*pObject);
- }
- return E_OK;
+ for (auto it = mMappedData.mSinkMap.begin(); it != mMappedData.mSinkMap.end(); it++)
+ {
+ const am_Sink_Database_s *pObject = &it->second;
+ if ( 0 == pObject->reserved )
+ {
+ cb(*pObject);
+ }
+ }
+
+ return E_OK;
}
-am_Error_e CAmDatabaseHandlerMap::enumerateGateways(std::function<void(const am_Gateway_s & element)> cb) const
+am_Error_e CAmDatabaseHandlerMap::enumerateGateways(std::function<void(const am_Gateway_s &element)> cb) const
{
- for(auto it = mMappedData.mGatewayMap.begin(); it!=mMappedData.mGatewayMap.end(); it++)
- {
- const am_Gateway_s *pObject = &it->second;
- cb(*pObject);
- }
- return E_OK;
+ for (auto it = mMappedData.mGatewayMap.begin(); it != mMappedData.mGatewayMap.end(); it++)
+ {
+ const am_Gateway_s *pObject = &it->second;
+ cb(*pObject);
+ }
+
+ return E_OK;
}
-am_Error_e CAmDatabaseHandlerMap::enumerateConverters(std::function<void(const am_Converter_s & element)> cb) const
+am_Error_e CAmDatabaseHandlerMap::enumerateConverters(std::function<void(const am_Converter_s &element)> cb) const
{
- for(auto it = mMappedData.mConverterMap.begin(); it!=mMappedData.mConverterMap.end(); it++)
- {
- const am_Converter_s *pObject = &it->second;
- cb(*pObject);
- }
- return E_OK;
+ for (auto it = mMappedData.mConverterMap.begin(); it != mMappedData.mConverterMap.end(); it++)
+ {
+ const am_Converter_s *pObject = &it->second;
+ cb(*pObject);
+ }
+
+ return E_OK;
}
-bool CAmDatabaseHandlerMap::registerObserver(IAmDatabaseObserver * iObserver) {
- assert(iObserver!=NULL);
- if (std::find(mDatabaseObservers.begin(), mDatabaseObservers.end(), iObserver) == mDatabaseObservers.end())
- {
- mDatabaseObservers.push_back(static_cast<AmDatabaseObserverCallbacks*>(iObserver));
- static_cast<AmDatabaseObserverCallbacks*>(iObserver)->mpDatabaseHandler = this;
- return true;
- }
- return false;
-}
-bool CAmDatabaseHandlerMap::unregisterObserver(IAmDatabaseObserver * iObserver) {
- assert(iObserver!=NULL);
- auto it = std::find(mDatabaseObservers.begin(), mDatabaseObservers.end(), iObserver);
- if (it != mDatabaseObservers.end()) {
- mDatabaseObservers.erase(it);
- static_cast<AmDatabaseObserverCallbacks*>(iObserver)->mpDatabaseHandler = nullptr;
- return true;
- }
- return false;
-}
-
-unsigned CAmDatabaseHandlerMap::countObservers() {
- return mDatabaseObservers.size();
+bool CAmDatabaseHandlerMap::registerObserver(IAmDatabaseObserver *iObserver)
+{
+ assert(iObserver != NULL);
+ if (std::find(mDatabaseObservers.begin(), mDatabaseObservers.end(), iObserver) == mDatabaseObservers.end())
+ {
+ mDatabaseObservers.push_back(static_cast<AmDatabaseObserverCallbacks *>(iObserver));
+ static_cast<AmDatabaseObserverCallbacks *>(iObserver)->mpDatabaseHandler = this;
+ return true;
+ }
+
+ return false;
+}
+
+bool CAmDatabaseHandlerMap::unregisterObserver(IAmDatabaseObserver *iObserver)
+{
+ assert(iObserver != NULL);
+ auto it = std::find(mDatabaseObservers.begin(), mDatabaseObservers.end(), iObserver);
+ if (it != mDatabaseObservers.end())
+ {
+ mDatabaseObservers.erase(it);
+ static_cast<AmDatabaseObserverCallbacks *>(iObserver)->mpDatabaseHandler = nullptr;
+ return true;
+ }
+
+ return false;
+}
+
+unsigned CAmDatabaseHandlerMap::countObservers()
+{
+ return mDatabaseObservers.size();
}
}
diff --git a/AudioManagerCore/src/CAmLog.cpp b/AudioManagerCore/src/CAmLog.cpp
index 5e58f27..6562eed 100644
--- a/AudioManagerCore/src/CAmLog.cpp
+++ b/AudioManagerCore/src/CAmLog.cpp
@@ -23,79 +23,84 @@
#include "CAmLog.h"
-
void CAmLog::CAmFileLogger::generateLogFilename(std::string &result)
{
- static uint32_t logFileID = 1;
- time_t rawtime;
- time (&rawtime);
+ static uint32_t logFileID = 1;
+ time_t rawtime;
+ time(&rawtime);
- std::ostringstream stream;
- stream << DEFAULT_LOG_FOLDER << DEFAULT_LOGFILE_PREFIX << logFileID << "_" << rawtime << DEFAULT_LOGFILE_EXT;
- logFileID++;
- result = stream.str();
+ std::ostringstream stream;
+ stream << DEFAULT_LOG_FOLDER << DEFAULT_LOGFILE_PREFIX << logFileID << "_" << rawtime << DEFAULT_LOGFILE_EXT;
+ logFileID++;
+ result = stream.str();
}
CAmLog::CAmFileLogger::~CAmFileLogger()
{
- if (mOutputStream)
- {
- std::ofstream* of = static_cast<std::ofstream*>(mOutputStream);
- of->close();
- DEL(mOutputStream);
- }
+ if (mOutputStream)
+ {
+ std::ofstream *of = static_cast<std::ofstream *>(mOutputStream);
+ of->close();
+ DEL(mOutputStream);
+ }
}
-CAmLog::CAmLog(const eCAmLogType type ):mLogType(type)
+CAmLog::CAmLog(const eCAmLogType type)
+ : mLogType(type)
{
- instantiateLogger(type);
+ instantiateLogger(type);
}
-CAmLog::CAmLog():mLogType(eCAmLogStdout)
+CAmLog::CAmLog()
+ : mLogType(eCAmLogStdout)
{
- instantiateLogger((const eCAmLogType)eCAmLogStdout);
+ instantiateLogger((const eCAmLogType)eCAmLogStdout);
}
CAmLog::~CAmLog()
{
- releaseLogger();
+ releaseLogger();
}
void CAmLog::releaseLogger()
{
- if(mLogger)
- DEL(mLogger);
+ if (mLogger)
+ {
+ DEL(mLogger);
+ }
}
-void CAmLog::instantiateLogger( const eCAmLogType type)
+void CAmLog::instantiateLogger(const eCAmLogType type)
{
- if( eCAmLogStdout == type )
- mLogger = new CAmStdOutLogger();
- else if( eCAmLogFile == type )
- {
- std::string filename("");
- CAmLog::CAmFileLogger::generateLogFilename(filename);
- mLogger = new CAmFileLogger(filename);
- }
+ if ( eCAmLogStdout == type )
+ {
+ mLogger = new CAmStdOutLogger();
+ }
+ else if ( eCAmLogFile == type )
+ {
+ std::string filename("");
+ CAmLog::CAmFileLogger::generateLogFilename(filename);
+ mLogger = new CAmFileLogger(filename);
+ }
}
CAmLog *CAmLog::getDefaultLog()
{
- static CAmLog theInstance;
- return &theInstance;
+ static CAmLog theInstance;
+ return &theInstance;
}
-void CAmLog::setLogType( const eCAmLogType type)
+void CAmLog::setLogType(const eCAmLogType type)
{
- if(mLogType!=type)
- {
- mLogType = type;
- releaseLogger();
- instantiateLogger(type);
- }
+ if (mLogType != type)
+ {
+ mLogType = type;
+ releaseLogger();
+ instantiateLogger(type);
+ }
}
eCAmLogType CAmLog::getLogType() const
{
- return mLogType;
+ return mLogType;
}
diff --git a/AudioManagerCore/src/CAmRouter.cpp b/AudioManagerCore/src/CAmRouter.cpp
index 3c9bee4..042916d 100644
--- a/AudioManagerCore/src/CAmRouter.cpp
+++ b/AudioManagerCore/src/CAmRouter.cpp
@@ -34,964 +34,1047 @@
namespace am
{
- template<class X> void getMergeConnectionFormats(const X * element, const am_CustomConnectionFormat_t connectionFormat,
- const std::vector<am_CustomConnectionFormat_t> & listConnectionFormats, std::vector<am_CustomConnectionFormat_t> & outListMergeConnectionFormats)
- {
- std::vector<am_CustomConnectionFormat_t> listRestrictedConnectionFormats;
- CAmRouter::getRestrictedOutputFormats(element->convertionMatrix, element->listSourceFormats, element->listSinkFormats, connectionFormat,
- listRestrictedConnectionFormats);
- std::sort(listRestrictedConnectionFormats.begin(), listRestrictedConnectionFormats.end()); //todo: this might be not needed if we use strictly sorted input
- std::insert_iterator<std::vector<am_CustomConnectionFormat_t> > inserter(outListMergeConnectionFormats, outListMergeConnectionFormats.begin());
- set_intersection(listConnectionFormats.begin(), listConnectionFormats.end(), listRestrictedConnectionFormats.begin(),
- listRestrictedConnectionFormats.end(), inserter);
- }
-
- CAmRouter::CAmRouter(IAmDatabaseHandler* iDatabaseHandler, CAmControlSender* iSender) :
- CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks(),
- mpDatabaseHandler(iDatabaseHandler),
- mpControlSender(iSender),
- mUpdateGraphNodesAction(true),
- mMaxAllowedCycles(MAX_ALLOWED_DOMAIN_CYCLES),
- mMaxPathCount(MAX_ROUTING_PATHS),
- mRoutingGraph(),
- mNodeListSources(),
- mNodeListSinks(),
- mNodeListGateways(),
- mNodeListConverters()
- {
- assert(mpDatabaseHandler);
- assert(mpControlSender);
-
- dboNewSink = [&](const am_Sink_s& sink)
- {
+template<class X>
+void getMergeConnectionFormats(const X *element, const am_CustomConnectionFormat_t connectionFormat,
+ const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, std::vector<am_CustomConnectionFormat_t> &outListMergeConnectionFormats)
+{
+ std::vector<am_CustomConnectionFormat_t> listRestrictedConnectionFormats;
+ CAmRouter::getRestrictedOutputFormats(element->convertionMatrix, element->listSourceFormats, element->listSinkFormats, connectionFormat,
+ listRestrictedConnectionFormats);
+ std::sort(listRestrictedConnectionFormats.begin(), listRestrictedConnectionFormats.end()); // todo: this might be not needed if we use strictly sorted input
+ std::insert_iterator<std::vector<am_CustomConnectionFormat_t> > inserter(outListMergeConnectionFormats, outListMergeConnectionFormats.begin());
+ set_intersection(listConnectionFormats.begin(), listConnectionFormats.end(), listRestrictedConnectionFormats.begin(),
+ listRestrictedConnectionFormats.end(), inserter);
+}
+
+CAmRouter::CAmRouter(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iSender)
+ : CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks()
+ , mpDatabaseHandler(iDatabaseHandler)
+ , mpControlSender(iSender)
+ , mUpdateGraphNodesAction(true)
+ , mMaxAllowedCycles(MAX_ALLOWED_DOMAIN_CYCLES)
+ , mMaxPathCount(MAX_ROUTING_PATHS)
+ , mRoutingGraph()
+ , mNodeListSources()
+ , mNodeListSinks()
+ , mNodeListGateways()
+ , mNodeListConverters()
+{
+ assert(mpDatabaseHandler);
+ assert(mpControlSender);
+
+ dboNewSink = [&](const am_Sink_s &sink){
mUpdateGraphNodesAction = true;
};
- dboNewSource = [&](const am_Source_s& source)
- {
- mUpdateGraphNodesAction=true;
+ dboNewSource = [&](const am_Source_s &source){
+ mUpdateGraphNodesAction = true;
};
- dboNewGateway = [&](const am_Gateway_s& gateway)
- {
- mUpdateGraphNodesAction=true;
+ dboNewGateway = [&](const am_Gateway_s &gateway){
+ mUpdateGraphNodesAction = true;
};
- dboNewConverter = [&](const am_Converter_s& coverter)
- {
- mUpdateGraphNodesAction=true;
+ dboNewConverter = [&](const am_Converter_s &coverter){
+ mUpdateGraphNodesAction = true;
};
- dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible)
- {
- mUpdateGraphNodesAction=true;
+ dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible){
+ mUpdateGraphNodesAction = true;
};
- dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible)
- {
- mUpdateGraphNodesAction=true;
+ dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible){
+ mUpdateGraphNodesAction = true;
};
- dboRemoveGateway = [&](const am_gatewayID_t gatewayID)
- {
- mUpdateGraphNodesAction=true;
+ dboRemoveGateway = [&](const am_gatewayID_t gatewayID){
+ mUpdateGraphNodesAction = true;
};
- dboRemoveConverter = [&](const am_converterID_t converterID)
- {
- mUpdateGraphNodesAction=true;
+ dboRemoveConverter = [&](const am_converterID_t converterID){
+ mUpdateGraphNodesAction = true;
};
- }
-
- CAmRouter::~CAmRouter()
- {
- }
+}
- /**
- * returns the best route between a source and a sink
- * @param onlyfree if true only free gateways are used
- * @param sourceID
- * @param sinkID
- * @param returnList this list contains a set of routes
- * @return E_OK in case of success
- */
- am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
- {
- if (mUpdateGraphNodesAction)
- {
- load();
- mUpdateGraphNodesAction = false;
- }
- return getRouteFromLoadedNodes(onlyfree, sourceID, sinkID, returnList);
- }
+CAmRouter::~CAmRouter()
+{
+}
- am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_Source_s & aSource, const am_Sink_s & aSink, std::vector<am_Route_s> & listRoutes)
+/**
+ * returns the best route between a source and a sink
+ * @param onlyfree if true only free gateways are used
+ * @param sourceID
+ * @param sinkID
+ * @param returnList this list contains a set of routes
+ * @return E_OK in case of success
+ */
+am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> &returnList)
+{
+ if (mUpdateGraphNodesAction)
{
- return getRoute(onlyfree, aSource.sourceID, aSink.sinkID, listRoutes);
+ load();
+ mUpdateGraphNodesAction = false;
}
- am_Error_e CAmRouter::getRouteFromLoadedNodes(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID,
- std::vector<am_Route_s> & returnList)
- {
- returnList.clear();
-
- CAmRoutingNode* pRootSource = sourceNodeWithID(sourceID);
- CAmRoutingNode* pRootSink = sinkNodeWithID(sinkID);
+ return getRouteFromLoadedNodes(onlyfree, sourceID, sinkID, returnList);
+}
- if (!pRootSource || !pRootSink)
- return E_NON_EXISTENT;
+am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_Source_s &aSource, const am_Sink_s &aSink, std::vector<am_Route_s> &listRoutes)
+{
+ return getRoute(onlyfree, aSource.sourceID, aSink.sinkID, listRoutes);
+}
- //try to find paths without cycles
- am_Error_e error = getFirstNShortestPaths(onlyfree, 0, mMaxPathCount, *pRootSource, *pRootSink, returnList);
+am_Error_e CAmRouter::getRouteFromLoadedNodes(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID,
+ std::vector<am_Route_s> &returnList)
+{
+ returnList.clear();
- //if no paths have been found, we start a second search with cycles.
- if (!returnList.size() && mMaxAllowedCycles > 0)
- {
- error = getFirstNShortestPaths(onlyfree, mMaxAllowedCycles, mMaxPathCount, *pRootSource, *pRootSink, returnList);
- }
+ CAmRoutingNode *pRootSource = sourceNodeWithID(sourceID);
+ CAmRoutingNode *pRootSink = sinkNodeWithID(sinkID);
- /* For shortest path use the following call:
- *
- * error = getShortestPath(*pRootSource, *pRootSink, listRoutes);
- */
- return error;
+ if (!pRootSource || !pRootSink)
+ {
+ return E_NON_EXISTENT;
}
- am_Error_e CAmRouter::getRouteFromLoadedNodes(const bool onlyfree, const am_Source_s & aSource, const am_Sink_s & aSink,
- std::vector<am_Route_s> & listRoutes)
+ // try to find paths without cycles
+ am_Error_e error = getFirstNShortestPaths(onlyfree, 0, mMaxPathCount, *pRootSource, *pRootSink, returnList);
+
+ // if no paths have been found, we start a second search with cycles.
+ if (!returnList.size() && mMaxAllowedCycles > 0)
{
- return getRouteFromLoadedNodes(onlyfree, aSource.sourceID, aSink.sinkID, listRoutes);
+ error = getFirstNShortestPaths(onlyfree, mMaxAllowedCycles, mMaxPathCount, *pRootSource, *pRootSink, returnList);
}
- void CAmRouter::load()
- {
- clear();
+ /* For shortest path use the following call:
+ *
+ * error = getShortestPath(*pRootSource, *pRootSink, listRoutes);
+ */
+ return error;
+}
- am_RoutingNodeData_s nodeDataSrc;
- nodeDataSrc.type = CAmNodeDataType::SOURCE;
- mpDatabaseHandler->enumerateSources([&](const am_Source_s & obj)
- {
- nodeDataSrc.data.source = (am_Source_s*)&obj;
+am_Error_e CAmRouter::getRouteFromLoadedNodes(const bool onlyfree, const am_Source_s &aSource, const am_Sink_s &aSink,
+ std::vector<am_Route_s> &listRoutes)
+{
+ return getRouteFromLoadedNodes(onlyfree, aSource.sourceID, aSink.sinkID, listRoutes);
+}
+
+void CAmRouter::load()
+{
+ clear();
+
+ am_RoutingNodeData_s nodeDataSrc;
+ nodeDataSrc.type = CAmNodeDataType::SOURCE;
+ mpDatabaseHandler->enumerateSources([&](const am_Source_s &obj){
+ nodeDataSrc.data.source = (am_Source_s *)&obj;
auto node = &mRoutingGraph.addNode(nodeDataSrc);
mNodeListSources[nodeDataSrc.data.source->domainID].push_back(node);
});
- am_RoutingNodeData_s nodeDataSink;
- nodeDataSink.type = CAmNodeDataType::SINK;
- mpDatabaseHandler->enumerateSinks([&](const am_Sink_s & obj)
- {
- nodeDataSink.data.sink = (am_Sink_s*)&obj;
+ am_RoutingNodeData_s nodeDataSink;
+ nodeDataSink.type = CAmNodeDataType::SINK;
+ mpDatabaseHandler->enumerateSinks([&](const am_Sink_s &obj){
+ nodeDataSink.data.sink = (am_Sink_s *)&obj;
auto node = &mRoutingGraph.addNode(nodeDataSink);
mNodeListSinks[nodeDataSink.data.sink->domainID].push_back(node);
});
- am_RoutingNodeData_s nodeDataGateway;
- nodeDataGateway.type = CAmNodeDataType::GATEWAY;
- mpDatabaseHandler->enumerateGateways([&](const am_Gateway_s & obj)
- {
- nodeDataGateway.data.gateway = (am_Gateway_s*)&obj;
+ am_RoutingNodeData_s nodeDataGateway;
+ nodeDataGateway.type = CAmNodeDataType::GATEWAY;
+ mpDatabaseHandler->enumerateGateways([&](const am_Gateway_s &obj){
+ nodeDataGateway.data.gateway = (am_Gateway_s *)&obj;
auto node = &mRoutingGraph.addNode(nodeDataGateway);
mNodeListGateways[nodeDataGateway.data.gateway->controlDomainID].push_back(node);
});
- am_RoutingNodeData_s nodeDataConverter;
- nodeDataConverter.type = CAmNodeDataType::CONVERTER;
- mpDatabaseHandler->enumerateConverters([&](const am_Converter_s & obj)
- {
- nodeDataConverter.data.converter = (am_Converter_s*)&obj;
+ am_RoutingNodeData_s nodeDataConverter;
+ nodeDataConverter.type = CAmNodeDataType::CONVERTER;
+ mpDatabaseHandler->enumerateConverters([&](const am_Converter_s &obj){
+ nodeDataConverter.data.converter = (am_Converter_s *)&obj;
auto node = &mRoutingGraph.addNode(nodeDataConverter);
mNodeListConverters[nodeDataConverter.data.converter->domainID].push_back(node);
});
- constructConverterConnections();
- constructGatewayConnections();
- constructSourceSinkConnections();
+ constructConverterConnections();
+ constructGatewayConnections();
+ constructSourceSinkConnections();
#ifdef TRACE_GRAPH
- mRoutingGraph.trace([&](const CAmRoutingNode & node, const std::vector<CAmVertex<am_RoutingNodeData_s,uint16_t>*> & list)
- {
- std::cout << "Node " << node.getIndex() << ":";
- ((CAmRoutingNode &)node).getData().trace();
- std::cout << "-->[";
- int count = 0;
- std::for_each(list.begin(), list.end(), [&](const CAmVertex<am_RoutingNodeData_s,uint16_t>* refVertex)
- {
- am::CAmNode<am::am_RoutingNodeData_s>* data = refVertex->getNode();
- if(count>0)
- std::cout << ", ";
- std::cout << "Node " << data->getIndex() << ":";
- data->getData().trace();
- count++;
- });
- std::cout << "]" << std::endl;
+ mRoutingGraph.trace([&](const CAmRoutingNode &node, const std::vector<CAmVertex<am_RoutingNodeData_s, uint16_t> *> &list){
+ std::cout << "Node " << node.getIndex() << ":";
+ ((CAmRoutingNode &)node).getData().trace();
+ std::cout << "-->[";
+ int count = 0;
+ std::for_each(list.begin(), list.end(), [&](const CAmVertex<am_RoutingNodeData_s, uint16_t> *refVertex){
+ am::CAmNode<am::am_RoutingNodeData_s> *data = refVertex->getNode();
+ if (count > 0)
+ {
+ std::cout << ", ";
+ }
+
+ std::cout << "Node " << data->getIndex() << ":";
+ data->getData().trace();
+ count++;
});
-#endif
+ std::cout << "]" << std::endl;
+ });
+#endif // ifdef TRACE_GRAPH
- }
+}
- void CAmRouter::clear()
- {
- mRoutingGraph.clear();
- mNodeListSources.clear();
- mNodeListSinks.clear();
- mNodeListGateways.clear();
- mNodeListConverters.clear();
- }
+void CAmRouter::clear()
+{
+ mRoutingGraph.clear();
+ mNodeListSources.clear();
+ mNodeListSinks.clear();
+ mNodeListGateways.clear();
+ mNodeListConverters.clear();
+}
- CAmRoutingNode* CAmRouter::sinkNodeWithID(const am_sinkID_t sinkID)
+CAmRoutingNode *CAmRouter::sinkNodeWithID(const am_sinkID_t sinkID)
+{
+ CAmRoutingNode *result = NULL;
+ for (auto it = mNodeListSinks.begin(); it != mNodeListSinks.end(); it++)
{
- CAmRoutingNode* result = NULL;
- for (auto it = mNodeListSinks.begin(); it != mNodeListSinks.end(); it++)
+ result = sinkNodeWithID(sinkID, it->first);
+ if (result)
{
- result = sinkNodeWithID(sinkID, it->first);
- if (result)
- return result;
+ return result;
}
- return result;
}
- CAmRoutingNode* CAmRouter::sinkNodeWithID(const am_sinkID_t sinkID, const am_domainID_t domainID)
+ return result;
+}
+
+CAmRoutingNode *CAmRouter::sinkNodeWithID(const am_sinkID_t sinkID, const am_domainID_t domainID)
+{
+ CAmRoutingNode *result = NULL;
+ std::vector<CAmRoutingNode *> &value = mNodeListSinks[domainID];
+ auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode *node){
+ return node->getData().data.sink->sinkID == sinkID;
+ });
+ if (iter != value.end())
{
- CAmRoutingNode* result = NULL;
- std::vector<CAmRoutingNode*> & value = mNodeListSinks[domainID];
- auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode* node)
- {
- return node->getData().data.sink->sinkID==sinkID;
- });
- if (iter != value.end())
- result = *iter;
- return result;
+ result = *iter;
}
- CAmRoutingNode* CAmRouter::sourceNodeWithID(const am_sourceID_t sourceID)
+ return result;
+}
+
+CAmRoutingNode *CAmRouter::sourceNodeWithID(const am_sourceID_t sourceID)
+{
+ CAmRoutingNode *result = NULL;
+ for (auto it = mNodeListSources.begin(); it != mNodeListSources.end(); it++)
{
- CAmRoutingNode* result = NULL;
- for (auto it = mNodeListSources.begin(); it != mNodeListSources.end(); it++)
+ result = sourceNodeWithID(sourceID, it->first);
+ if (result)
{
- result = sourceNodeWithID(sourceID, it->first);
- if (result)
- return result;
+ return result;
}
- return result;
}
- CAmRoutingNode* CAmRouter::sourceNodeWithID(const am_sourceID_t sourceID, const am_domainID_t domainID)
+ return result;
+}
+
+CAmRoutingNode *CAmRouter::sourceNodeWithID(const am_sourceID_t sourceID, const am_domainID_t domainID)
+{
+ CAmRoutingNode *result = NULL;
+ std::vector<CAmRoutingNode *> &value = mNodeListSources[domainID];
+ auto iter = std::find_if(value.begin(), value.end(), [sourceID](CAmRoutingNode *node){
+ return node->getData().data.source->sourceID == sourceID;
+ });
+ if (iter != value.end())
{
- CAmRoutingNode* result = NULL;
- std::vector<CAmRoutingNode*> & value = mNodeListSources[domainID];
- auto iter = std::find_if(value.begin(), value.end(), [sourceID](CAmRoutingNode* node)
- {
- return node->getData().data.source->sourceID==sourceID;
- });
- if (iter != value.end())
- result = *iter;
- return result;
+ result = *iter;
}
- CAmRoutingNode* CAmRouter::converterNodeWithSinkID(const am_sinkID_t sinkID, const am_domainID_t domainID)
+ return result;
+}
+
+CAmRoutingNode *CAmRouter::converterNodeWithSinkID(const am_sinkID_t sinkID, const am_domainID_t domainID)
+{
+ CAmRoutingNode *result = NULL;
+ std::vector<CAmRoutingNode *> &value = mNodeListConverters[domainID];
+ auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode *node){
+ return node->getData().data.converter->sinkID == sinkID;
+ });
+ if (iter != value.end())
{
- CAmRoutingNode* result = NULL;
- std::vector<CAmRoutingNode*> & value = mNodeListConverters[domainID];
- auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode* node)
- {
- return node->getData().data.converter->sinkID==sinkID;
- });
- if (iter != value.end())
- result = *iter;
- return result;
+ result = *iter;
}
- CAmRoutingNode* CAmRouter::gatewayNodeWithSinkID(const am_sinkID_t sinkID)
+ return result;
+}
+
+CAmRoutingNode *CAmRouter::gatewayNodeWithSinkID(const am_sinkID_t sinkID)
+{
+ for (auto it = mNodeListGateways.begin(); it != mNodeListGateways.end(); it++)
{
- for (auto it = mNodeListGateways.begin(); it != mNodeListGateways.end(); it++)
+ std::vector<CAmRoutingNode *> &value = it->second;
+ auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode *node){
+ return node->getData().data.gateway->sinkID == sinkID;
+ });
+ if (iter != value.end())
{
- std::vector<CAmRoutingNode*> & value = it->second;
- auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode* node)
- {
- return node->getData().data.gateway->sinkID==sinkID;
- });
- if (iter != value.end())
- return *iter;
+ return *iter;
}
- return NULL;
}
- void CAmRouter::constructSourceSinkConnections()
+ return NULL;
+}
+
+void CAmRouter::constructSourceSinkConnections()
+{
+ std::vector<am_CustomConnectionFormat_t> intersection;
+ for (auto itSrc = mNodeListSources.begin(); itSrc != mNodeListSources.end(); itSrc++)
{
- std::vector<am_CustomConnectionFormat_t> intersection;
- for (auto itSrc = mNodeListSources.begin(); itSrc != mNodeListSources.end(); itSrc++)
+ for (auto it = itSrc->second.begin(); it != itSrc->second.end(); it++)
{
- for (auto it = itSrc->second.begin(); it != itSrc->second.end(); it++)
+ CAmRoutingNode *srcNode = *it;
+ am_RoutingNodeData_s &srcNodeData = srcNode->getData();
+ am_Source_s *source = srcNodeData.data.source;
+ for (auto itSink = mNodeListSinks[itSrc->first].begin(); itSink != mNodeListSinks[itSrc->first].end(); itSink++)
{
- CAmRoutingNode* srcNode = *it;
- am_RoutingNodeData_s & srcNodeData = srcNode->getData();
- am_Source_s * source = srcNodeData.data.source;
- for (auto itSink = mNodeListSinks[itSrc->first].begin(); itSink != mNodeListSinks[itSrc->first].end(); itSink++)
+ CAmRoutingNode *sinkNode = *itSink;
+ am_RoutingNodeData_s &sinkNodeData = sinkNode->getData();
+ am_Sink_s *sink = sinkNodeData.data.sink;
+
+ intersection.clear();
+ // Check whether the hidden sink formats match the source formats...
+ listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, intersection);
+ if (intersection.size() > 0) // OK match source -> sink
{
- CAmRoutingNode* sinkNode = *itSink;
- am_RoutingNodeData_s & sinkNodeData = sinkNode->getData();
- am_Sink_s * sink = sinkNodeData.data.sink;
-
- intersection.clear();
- //Check whether the hidden sink formats match the source formats...
- listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, intersection);
- if (intersection.size() > 0) //OK match source -> sink
- {
- mRoutingGraph.connectNodes(*srcNode, *sinkNode, CF_UNKNOWN, 1);
- }
+ mRoutingGraph.connectNodes(*srcNode, *sinkNode, CF_UNKNOWN, 1);
}
}
}
}
+}
- void CAmRouter::constructGatewayConnections()
+void CAmRouter::constructGatewayConnections()
+{
+ std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
+ for (auto iter = mNodeListGateways.begin(); iter != mNodeListGateways.end(); iter++)
{
- std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
- for (auto iter = mNodeListGateways.begin(); iter != mNodeListGateways.end(); iter++)
+ for (auto it = iter->second.begin(); it != iter->second.end(); it++)
{
- for (auto it = iter->second.begin(); it != iter->second.end(); it++)
+ CAmRoutingNode *gatewayNode = *it;
+ am_RoutingNodeData_s &gatewayNodeData = gatewayNode->getData();
+ am_Gateway_s *gateway = gatewayNodeData.data.gateway;
+ // Get only gateways with end point in current source domain
+
+ // Get the sink connected to the gateway...
+ CAmRoutingNode *gatewaySinkNode = this->sinkNodeWithID(gateway->sinkID, gateway->domainSinkID);
+ if (gatewaySinkNode)
{
- CAmRoutingNode* gatewayNode = *it;
- am_RoutingNodeData_s & gatewayNodeData = gatewayNode->getData();
- am_Gateway_s * gateway = gatewayNodeData.data.gateway;
- //Get only gateways with end point in current source domain
-
- //Get the sink connected to the gateway...
- CAmRoutingNode *gatewaySinkNode = this->sinkNodeWithID(gateway->sinkID, gateway->domainSinkID);
- if (gatewaySinkNode)
+ am_RoutingNodeData_s &gatewaySinkData = gatewaySinkNode->getData();
+ // Check whether the hidden sink formats match the source formats...
+ sourceFormats.clear();
+ sinkFormats.clear();
+ if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats,
+ sinkFormats))
{
- am_RoutingNodeData_s & gatewaySinkData = gatewaySinkNode->getData();
- //Check whether the hidden sink formats match the source formats...
- sourceFormats.clear();
- sinkFormats.clear();
- if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats,
- sinkFormats))
+ CAmRoutingNode *gatewaySourceNode = this->sourceNodeWithID(gateway->sourceID, gateway->domainSourceID);
+ if (gatewaySourceNode)
{
- CAmRoutingNode *gatewaySourceNode = this->sourceNodeWithID(gateway->sourceID, gateway->domainSourceID);
- if (gatewaySourceNode)
- {
- //Connections hidden_sink->gateway->hidden_source
- mRoutingGraph.connectNodes(*gatewaySinkNode, *gatewayNode, CF_UNKNOWN, 1);
- mRoutingGraph.connectNodes(*gatewayNode, *gatewaySourceNode, CF_UNKNOWN, 1);
- }
+ // Connections hidden_sink->gateway->hidden_source
+ mRoutingGraph.connectNodes(*gatewaySinkNode, *gatewayNode, CF_UNKNOWN, 1);
+ mRoutingGraph.connectNodes(*gatewayNode, *gatewaySourceNode, CF_UNKNOWN, 1);
}
}
}
}
}
+}
- void CAmRouter::constructConverterConnections()
- {
- std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
+void CAmRouter::constructConverterConnections()
+{
+ std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
- for (auto iter = mNodeListConverters.begin(); iter != mNodeListConverters.end(); iter++)
+ for (auto iter = mNodeListConverters.begin(); iter != mNodeListConverters.end(); iter++)
+ {
+ for (auto it = iter->second.begin(); it != iter->second.end(); it++)
{
- for (auto it = iter->second.begin(); it != iter->second.end(); it++)
+ CAmRoutingNode *converterNode = *it;
+ am_RoutingNodeData_s &converterNodeData = converterNode->getData();
+ am_Converter_s *converter = converterNodeData.data.converter;
+ // Get only converters with end point in current source domain
+
+ // Get the sink connected to the converter...
+ CAmRoutingNode *converterSinkNode = this->sinkNodeWithID(converter->sinkID, converter->domainID);
+ if (converterSinkNode)
{
- CAmRoutingNode* converterNode = *it;
- am_RoutingNodeData_s & converterNodeData = converterNode->getData();
- am_Converter_s * converter = converterNodeData.data.converter;
- //Get only converters with end point in current source domain
-
- //Get the sink connected to the converter...
- CAmRoutingNode *converterSinkNode = this->sinkNodeWithID(converter->sinkID, converter->domainID);
- if (converterSinkNode)
+ am_RoutingNodeData_s &converterSinkData = converterSinkNode->getData();
+ // Check whether the hidden sink formats match the source formats...
+ sourceFormats.clear();
+ sinkFormats.clear();
+ if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats,
+ sinkFormats))
{
- am_RoutingNodeData_s & converterSinkData = converterSinkNode->getData();
- //Check whether the hidden sink formats match the source formats...
- sourceFormats.clear();
- sinkFormats.clear();
- if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats,
- sinkFormats))
+ CAmRoutingNode *converterSourceNode = this->sourceNodeWithID(converter->sourceID, converter->domainID);
+ if (converterSourceNode)
{
- CAmRoutingNode *converterSourceNode = this->sourceNodeWithID(converter->sourceID, converter->domainID);
- if (converterSourceNode)
- {
- //Connections hidden_sink->converter->hidden_source
- mRoutingGraph.connectNodes(*converterSinkNode, *converterNode, CF_UNKNOWN, 1);
- mRoutingGraph.connectNodes(*converterNode, *converterSourceNode, CF_UNKNOWN, 1);
- }
+ // Connections hidden_sink->converter->hidden_source
+ mRoutingGraph.connectNodes(*converterSinkNode, *converterNode, CF_UNKNOWN, 1);
+ mRoutingGraph.connectNodes(*converterNode, *converterSourceNode, CF_UNKNOWN, 1);
}
}
}
}
}
+}
- void CAmRouter::getVerticesForSource(const CAmRoutingNode & node, CAmRoutingListVertices & list)
+void CAmRouter::getVerticesForSource(const CAmRoutingNode &node, CAmRoutingListVertices &list)
+{
+ am_RoutingNodeData_s &srcNodeData = ((CAmRoutingNode *)&node)->getData();
+ std::vector<am_CustomConnectionFormat_t> intersection;
+ am_Source_s *source = srcNodeData.data.source;
+ std::vector<CAmRoutingNode *> &sinks = mNodeListSinks[source->domainID];
+ for (auto itSink = sinks.begin(); itSink != sinks.end(); itSink++)
{
- am_RoutingNodeData_s & srcNodeData = ((CAmRoutingNode*) &node)->getData();
- std::vector<am_CustomConnectionFormat_t> intersection;
- am_Source_s * source = srcNodeData.data.source;
- std::vector<CAmRoutingNode*> & sinks = mNodeListSinks[source->domainID];
- for (auto itSink = sinks.begin(); itSink != sinks.end(); itSink++)
+ CAmRoutingNode *sinkNode = *itSink;
+ am_RoutingNodeData_s &sinkNodeData = sinkNode->getData();
+ am_Sink_s *sink = sinkNodeData.data.sink;
+
+ intersection.clear();
+ // Check whether the hidden sink formats match the source formats...
+ listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, intersection);
+ if (intersection.size() > 0) // OK match source -> sink
{
- CAmRoutingNode* sinkNode = *itSink;
- am_RoutingNodeData_s & sinkNodeData = sinkNode->getData();
- am_Sink_s * sink = sinkNodeData.data.sink;
-
- intersection.clear();
- //Check whether the hidden sink formats match the source formats...
- listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, intersection);
- if (intersection.size() > 0) //OK match source -> sink
- {
- list.emplace_back(sinkNode, CF_UNKNOWN, 1);
- }
+ list.emplace_back(sinkNode, CF_UNKNOWN, 1);
}
}
+}
- void CAmRouter::getVerticesForSink(const CAmRoutingNode & node, CAmRoutingListVertices & list)
+void CAmRouter::getVerticesForSink(const CAmRoutingNode &node, CAmRoutingListVertices &list)
+{
+ am_RoutingNodeData_s &sinkNodeData = ((CAmRoutingNode *)&node)->getData();
+ std::vector<am_CustomConnectionFormat_t> intersection;
+ am_Sink_s *sink = sinkNodeData.data.sink;
+
+ CAmRoutingNode *converterNode = converterNodeWithSinkID(sink->sinkID, sink->domainID);
+ if (converterNode)
{
- am_RoutingNodeData_s & sinkNodeData = ((CAmRoutingNode*) &node)->getData();
- std::vector<am_CustomConnectionFormat_t> intersection;
- am_Sink_s * sink = sinkNodeData.data.sink;
+ std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
+ am_RoutingNodeData_s &converterData = converterNode->getData();
+ am_Converter_s *converter = converterData.data.converter;
- CAmRoutingNode *converterNode = converterNodeWithSinkID(sink->sinkID, sink->domainID);
- if (converterNode)
+ if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats,
+ sinkFormats))
{
- std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
- am_RoutingNodeData_s & converterData = converterNode->getData();
- am_Converter_s * converter = converterData.data.converter;
-
- if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats,
- sinkFormats))
- list.emplace_back(converterNode, CF_UNKNOWN, 1);
+ list.emplace_back(converterNode, CF_UNKNOWN, 1);
}
- else
+ }
+ else
+ {
+ std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
+ CAmRoutingNode *gatewayNode = gatewayNodeWithSinkID(sink->sinkID);
+ if (gatewayNode)
{
std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
- CAmRoutingNode *gatewayNode = gatewayNodeWithSinkID(sink->sinkID);
- if (gatewayNode)
- {
- std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
- am_RoutingNodeData_s & gatewayData = gatewayNode->getData();
- am_Gateway_s * gateway = gatewayData.data.gateway;
+ am_RoutingNodeData_s &gatewayData = gatewayNode->getData();
+ am_Gateway_s *gateway = gatewayData.data.gateway;
- if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats,
- sinkFormats))
- list.emplace_back(gatewayNode, CF_UNKNOWN, 1);
+ if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats,
+ sinkFormats))
+ {
+ list.emplace_back(gatewayNode, CF_UNKNOWN, 1);
}
}
-
}
+}
- void CAmRouter::getVerticesForConverter(const CAmRoutingNode & node, CAmRoutingListVertices & list)
+void CAmRouter::getVerticesForConverter(const CAmRoutingNode &node, CAmRoutingListVertices &list)
+{
+ std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
+ am_RoutingNodeData_s &converterNodeData = ((CAmRoutingNode *)&node)->getData();
+ am_Converter_s *converter = converterNodeData.data.converter;
+ // Get only converters with end point in current source domain
+ if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats, sinkFormats))
{
- std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
- am_RoutingNodeData_s & converterNodeData = ((CAmRoutingNode*) &node)->getData();
- am_Converter_s * converter = converterNodeData.data.converter;
- //Get only converters with end point in current source domain
- if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats, sinkFormats))
+ CAmRoutingNode *converterSourceNode = this->sourceNodeWithID(converter->sourceID, converter->domainID);
+ if (converterSourceNode)
{
- CAmRoutingNode *converterSourceNode = this->sourceNodeWithID(converter->sourceID, converter->domainID);
- if (converterSourceNode)
- {
- list.emplace_back(converterSourceNode, CF_UNKNOWN, 1);
- }
+ list.emplace_back(converterSourceNode, CF_UNKNOWN, 1);
}
}
+}
- void CAmRouter::getVerticesForGateway(const CAmRoutingNode & node, CAmRoutingListVertices & list)
+void CAmRouter::getVerticesForGateway(const CAmRoutingNode &node, CAmRoutingListVertices &list)
+{
+ am_RoutingNodeData_s &gatewayNodeData = ((CAmRoutingNode *)&node)->getData();
+ std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
+ am_Gateway_s *gateway = gatewayNodeData.data.gateway;
+ if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats, sinkFormats))
{
- am_RoutingNodeData_s & gatewayNodeData = ((CAmRoutingNode*) &node)->getData();
- std::vector<am_CustomConnectionFormat_t> sourceFormats, sinkFormats;
- am_Gateway_s * gateway = gatewayNodeData.data.gateway;
- if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats, sinkFormats))
+ CAmRoutingNode *gatewaySourceNode = this->sourceNodeWithID(gateway->sourceID, gateway->domainSourceID);
+ if (gatewaySourceNode)
{
- CAmRoutingNode *gatewaySourceNode = this->sourceNodeWithID(gateway->sourceID, gateway->domainSourceID);
- if (gatewaySourceNode)
- {
- //Connections hidden_sink->gateway->hidden_source
- list.emplace_back(gatewaySourceNode, CF_UNKNOWN, 1);
- }
+ // Connections hidden_sink->gateway->hidden_source
+ list.emplace_back(gatewaySourceNode, CF_UNKNOWN, 1);
}
}
+}
- void CAmRouter::getVerticesForNode(const CAmRoutingNode & node, CAmRoutingListVertices & list)
+void CAmRouter::getVerticesForNode(const CAmRoutingNode &node, CAmRoutingListVertices &list)
+{
+ am_RoutingNodeData_s &nodeData = ((CAmRoutingNode *)&node)->getData();
+ if (nodeData.type == CAmNodeDataType::SOURCE)
{
- am_RoutingNodeData_s & nodeData = ((CAmRoutingNode*) &node)->getData();
- if (nodeData.type == CAmNodeDataType::SOURCE)
+ getVerticesForSource(node, list);
+ }
+ else if (nodeData.type == CAmNodeDataType::SINK)
+ {
+ getVerticesForSink(node, list);
+ }
+ else if (nodeData.type == CAmNodeDataType::CONVERTER)
+ {
+ getVerticesForConverter(node, list);
+ }
+ else if (nodeData.type == CAmNodeDataType::GATEWAY)
+ {
+ getVerticesForGateway(node, list);
+ }
+}
+
+am_Error_e CAmRouter::determineConnectionFormatsForPath(am_Route_s &routeObjects, std::vector<CAmRoutingNode *> &nodes, std::vector<am_Route_s> &result)
+{
+ std::vector<am_RoutingElement_s>::iterator routingElementIterator = routeObjects.route.begin();
+ std::vector<CAmRoutingNode *>::iterator nodeIterator = nodes.begin();
+ if (routingElementIterator != routeObjects.route.end() && nodeIterator != nodes.end())
+ {
+ return doConnectionFormatsForPath(routeObjects, nodes, routingElementIterator, nodeIterator, result);
+ }
+
+ return E_OK;
+}
+
+am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s &routeObjects, std::vector<CAmRoutingNode *> &nodes,
+ std::vector<am_RoutingElement_s>::iterator routingElementIterator, std::vector<CAmRoutingNode *>::iterator nodeIterator,
+ std::vector<am_Route_s> &result)
+{
+ am_Error_e returnError = E_NOT_POSSIBLE;
+ std::vector<am_CustomConnectionFormat_t> listConnectionFormats;
+ std::vector<am_CustomConnectionFormat_t> listMergeConnectionFormats;
+
+ std::vector<CAmRoutingNode *>::iterator currentNodeIterator = nodeIterator;
+ std::vector<am_RoutingElement_s>::iterator currentRoutingElementIterator = routingElementIterator;
+
+ if (currentRoutingElementIterator != routeObjects.route.begin())
+ {
+ std::vector<am_CustomConnectionFormat_t> listConnectionFormats;
+ std::vector<am_RoutingElement_s>::iterator tempIterator = (currentRoutingElementIterator - 1);
+ CAmRoutingNode *currentNode = *currentNodeIterator;
+ if ((returnError = getSourceSinkPossibleConnectionFormats(currentNodeIterator + 1, currentNodeIterator + 2, listConnectionFormats)) != E_OK)
{
- getVerticesForSource(node, list);
+ return returnError;
}
- else if (nodeData.type == CAmNodeDataType::SINK)
+
+ if (currentNode->getData().type == CAmNodeDataType::GATEWAY)
{
- getVerticesForSink(node, list);
+ am_Gateway_s *gateway = currentNode->getData().data.gateway;
+ getMergeConnectionFormats(gateway, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats);
}
- else if (nodeData.type == CAmNodeDataType::CONVERTER)
+ else if (currentNode->getData().type == CAmNodeDataType::CONVERTER)
{
- getVerticesForConverter(node, list);
+ am_Converter_s *converter = currentNode->getData().data.converter;
+ getMergeConnectionFormats(converter, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats);
}
- else if (nodeData.type == CAmNodeDataType::GATEWAY)
+ else
{
- getVerticesForGateway(node, list);
+ return (E_UNKNOWN);
}
- }
- am_Error_e CAmRouter::determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector<CAmRoutingNode*> & nodes, std::vector<am_Route_s> & result)
- {
- std::vector<am_RoutingElement_s>::iterator routingElementIterator = routeObjects.route.begin();
- std::vector<CAmRoutingNode*>::iterator nodeIterator = nodes.begin();
- if (routingElementIterator != routeObjects.route.end() && nodeIterator != nodes.end())
- return doConnectionFormatsForPath(routeObjects, nodes, routingElementIterator, nodeIterator, result);
- return E_OK;
+ currentNodeIterator += 3;
}
-
- am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s & routeObjects, std::vector<CAmRoutingNode*> & nodes,
- std::vector<am_RoutingElement_s>::iterator routingElementIterator, std::vector<CAmRoutingNode*>::iterator nodeIterator,
- std::vector<am_Route_s> & result)
+ else
{
- am_Error_e returnError = E_NOT_POSSIBLE;
- std::vector<am_CustomConnectionFormat_t> listConnectionFormats;
- std::vector<am_CustomConnectionFormat_t> listMergeConnectionFormats;
+ CAmRoutingNode *currentNode = *currentNodeIterator;
+ if (currentNode->getData().type != CAmNodeDataType::SOURCE)
+ {
+ return (E_UNKNOWN);
+ }
- std::vector<CAmRoutingNode*>::iterator currentNodeIterator = nodeIterator;
- std::vector<am_RoutingElement_s>::iterator currentRoutingElementIterator = routingElementIterator;
+ currentNodeIterator++;
- if (currentRoutingElementIterator != routeObjects.route.begin())
+ if (currentNodeIterator == nodes.end())
{
- std::vector<am_CustomConnectionFormat_t> listConnectionFormats;
- std::vector<am_RoutingElement_s>::iterator tempIterator = (currentRoutingElementIterator - 1);
- CAmRoutingNode * currentNode = *currentNodeIterator;
- if ((returnError = getSourceSinkPossibleConnectionFormats(currentNodeIterator + 1, currentNodeIterator + 2, listConnectionFormats)) != E_OK)
- return returnError;
-
- if (currentNode->getData().type == CAmNodeDataType::GATEWAY)
- {
- am_Gateway_s *gateway = currentNode->getData().data.gateway;
- getMergeConnectionFormats(gateway, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats);
- }
- else if (currentNode->getData().type == CAmNodeDataType::CONVERTER)
- {
- am_Converter_s *converter = currentNode->getData().data.converter;
- getMergeConnectionFormats(converter, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats);
- }
- else
- return (E_UNKNOWN);
- currentNodeIterator += 3;
+ return (E_UNKNOWN);
}
- else
+
+ CAmRoutingNode *nodeSink = *currentNodeIterator;
+ if (nodeSink->getData().type != CAmNodeDataType::SINK)
{
- CAmRoutingNode * currentNode = *currentNodeIterator;
- if (currentNode->getData().type != CAmNodeDataType::SOURCE)
- return (E_UNKNOWN);
- currentNodeIterator++;
-
- if (currentNodeIterator == nodes.end())
- return (E_UNKNOWN);
-
- CAmRoutingNode * nodeSink = *currentNodeIterator;
- if (nodeSink->getData().type != CAmNodeDataType::SINK)
- return (E_UNKNOWN);
-
- am_Source_s *source = currentNode->getData().data.source;
- am_Sink_s *sink = nodeSink->getData().data.sink;
- listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, listMergeConnectionFormats);
- currentNodeIterator += 1; //now we are on the next converter/gateway
+ return (E_UNKNOWN);
}
- //let the controller decide:
- std::vector<am_CustomConnectionFormat_t> listPriorityConnectionFormats;
- if ((returnError = mpControlSender->getConnectionFormatChoice(currentRoutingElementIterator->sourceID, currentRoutingElementIterator->sinkID,
- routeObjects, listMergeConnectionFormats, listPriorityConnectionFormats)) != E_OK)
- return (returnError);
-
- if (listPriorityConnectionFormats.empty())
- return (E_NOT_POSSIBLE);
- //we have the list sorted after priors - now we try one after the other with the next part of the route
- std::vector<am_CustomConnectionFormat_t>::iterator connectionFormatIterator = listPriorityConnectionFormats.begin();
- //here we need to check if we are at the end and stop
- std::vector<am_RoutingElement_s>::iterator nextIterator = currentRoutingElementIterator + 1; //next pair source and sink
- if (nextIterator == routeObjects.route.end())
+
+ am_Source_s *source = currentNode->getData().data.source;
+ am_Sink_s *sink = nodeSink->getData().data.sink;
+ listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, listMergeConnectionFormats);
+ currentNodeIterator += 1; // now we are on the next converter/gateway
+ }
+
+ // let the controller decide:
+ std::vector<am_CustomConnectionFormat_t> listPriorityConnectionFormats;
+ if ((returnError = mpControlSender->getConnectionFormatChoice(currentRoutingElementIterator->sourceID, currentRoutingElementIterator->sinkID,
+ routeObjects, listMergeConnectionFormats, listPriorityConnectionFormats)) != E_OK)
+ {
+ return (returnError);
+ }
+
+ if (listPriorityConnectionFormats.empty())
+ {
+ return (E_NOT_POSSIBLE);
+ }
+
+ // we have the list sorted after priors - now we try one after the other with the next part of the route
+ std::vector<am_CustomConnectionFormat_t>::iterator connectionFormatIterator = listPriorityConnectionFormats.begin();
+ // here we need to check if we are at the end and stop
+ std::vector<am_RoutingElement_s>::iterator nextIterator = currentRoutingElementIterator + 1; // next pair source and sink
+ if (nextIterator == routeObjects.route.end())
+ {
+ for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator)
{
- for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator)
- {
- currentRoutingElementIterator->connectionFormat = *connectionFormatIterator;
- result.push_back(routeObjects);
- }
+ currentRoutingElementIterator->connectionFormat = *connectionFormatIterator;
+ result.push_back(routeObjects);
}
- else
+ }
+ else
+ {
+ for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator)
{
- for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator)
- {
- currentRoutingElementIterator->connectionFormat = *connectionFormatIterator;
- doConnectionFormatsForPath(routeObjects, nodes, nextIterator, currentNodeIterator, result);
- }
+ currentRoutingElementIterator->connectionFormat = *connectionFormatIterator;
+ doConnectionFormatsForPath(routeObjects, nodes, nextIterator, currentNodeIterator, result);
}
- return (E_OK);
}
- am_Error_e CAmRouter::cfPermutationsForPath(am_Route_s shortestRoute, std::vector<CAmRoutingNode*> resultNodesPath, std::vector<am_Route_s>& resultPath)
+ return (E_OK);
+}
+
+am_Error_e CAmRouter::cfPermutationsForPath(am_Route_s shortestRoute, std::vector<CAmRoutingNode *> resultNodesPath, std::vector<am_Route_s> &resultPath)
+{
+ std::vector<am_Route_s> result;
+ am_Error_e err = determineConnectionFormatsForPath(shortestRoute, resultNodesPath, result);
+ if (err != E_UNKNOWN)
{
- std::vector<am_Route_s> result;
- am_Error_e err = determineConnectionFormatsForPath(shortestRoute, resultNodesPath, result);
- if (err != E_UNKNOWN)
- {
- resultPath.insert(resultPath.end(), result.begin(), result.end());
+ resultPath.insert(resultPath.end(), result.begin(), result.end());
#ifdef TRACE_GRAPH
- std::cout
+ std::cout
<< "Determined connection formats for path from source:"
<< shortestRoute.sourceID << " to sink:" << shortestRoute.sinkID
<< "\n";
- for (auto routeConnectionFormats : result)
+ for (auto routeConnectionFormats : result)
+ {
+ std::cout << "[";
+ for (auto it = routeConnectionFormats.route.begin(); it != routeConnectionFormats.route.end(); it++)
{
- std::cout << "[";
- for (auto it = routeConnectionFormats.route.begin();it != routeConnectionFormats.route.end(); it++)
+ am_RoutingElement_s &routingElement = *it;
+ if (it - routeConnectionFormats.route.begin() > 0)
{
- am_RoutingElement_s& routingElement = *it;
- if (it - routeConnectionFormats.route.begin() > 0)
std::cout << " -> ";
-
- std::cout << routingElement.sourceID << ":"
- << routingElement.sinkID << " CF:"
- << routingElement.connectionFormat << " D:"
- << routingElement.domainID;
}
- std::cout << "]\n";
+
+ std::cout << routingElement.sourceID << ":"
+ << routingElement.sinkID << " CF:"
+ << routingElement.connectionFormat << " D:"
+ << routingElement.domainID;
}
-#endif
+
+ std::cout << "]\n";
}
+#endif // ifdef TRACE_GRAPH
+ }
+
#ifdef TRACE_GRAPH
- else
- {
- std::cout
+ else
+ {
+ std::cout
<< "Error by determining connection formats for path from source:"
<< shortestRoute.sourceID << " to sink:" << shortestRoute.sinkID
<< "\n";
- }
-#endif
- return err;
}
+#endif // ifdef TRACE_GRAPH
+ return err;
+}
- am_Error_e CAmRouter::getShortestPath(CAmRoutingNode & aSource, CAmRoutingNode & aSink, std::vector<am_Route_s> & resultPath)
- {
- am_Error_e err = E_OK;
- am_Route_s shortestRoute;
- std::vector<CAmRoutingNode*> resultNodesPath;
- am_RoutingNodeData_s & sinkNodeData = aSink.getData();
- am_RoutingNodeData_s & sourceNodeData = aSource.getData();
- shortestRoute.sinkID = sinkNodeData.data.sink->sinkID;
- shortestRoute.sourceID = sourceNodeData.data.source->sourceID;
-
- mRoutingGraph.getShortestPath(aSource, aSink, [&shortestRoute, &resultNodesPath](const am_GraphPathPosition_e position, CAmRoutingNode & object)
- {
- am_RoutingElement_s * element;
- //reverse order
- resultNodesPath.insert(resultNodesPath.begin(), (CAmRoutingNode*)&object);
- am_RoutingNodeData_s & routingData = object.getData();
- if(routingData.type==CAmNodeDataType::SINK)
- {
- auto iter = shortestRoute.route.emplace(shortestRoute.route.begin());
- element = &(*iter);
- element->domainID = routingData.data.sink->domainID;
- element->sinkID = routingData.data.sink->sinkID;
- element->connectionFormat = CF_UNKNOWN;
- }
- else if(routingData.type==CAmNodeDataType::SOURCE)
- {
- element->domainID = routingData.data.source->domainID;
- element->sourceID = routingData.data.source->sourceID;
- element->connectionFormat = CF_UNKNOWN;
- }
- });
+am_Error_e CAmRouter::getShortestPath(CAmRoutingNode &aSource, CAmRoutingNode &aSink, std::vector<am_Route_s> &resultPath)
+{
+ am_Error_e err = E_OK;
+ am_Route_s shortestRoute;
+ std::vector<CAmRoutingNode *> resultNodesPath;
+ am_RoutingNodeData_s &sinkNodeData = aSink.getData();
+ am_RoutingNodeData_s &sourceNodeData = aSource.getData();
+ shortestRoute.sinkID = sinkNodeData.data.sink->sinkID;
+ shortestRoute.sourceID = sourceNodeData.data.source->sourceID;
+
+ mRoutingGraph.getShortestPath(aSource, aSink, [&shortestRoute, &resultNodesPath](const am_GraphPathPosition_e position, CAmRoutingNode &object){
+ am_RoutingElement_s *element;
+ // reverse order
+ resultNodesPath.insert(resultNodesPath.begin(), (CAmRoutingNode *)&object);
+ am_RoutingNodeData_s &routingData = object.getData();
+ if (routingData.type == CAmNodeDataType::SINK)
+ {
+ auto iter = shortestRoute.route.emplace(shortestRoute.route.begin());
+ element = &(*iter);
+ element->domainID = routingData.data.sink->domainID;
+ element->sinkID = routingData.data.sink->sinkID;
+ element->connectionFormat = CF_UNKNOWN;
+ }
+ else if (routingData.type == CAmNodeDataType::SOURCE)
+ {
+ element->domainID = routingData.data.source->domainID;
+ element->sourceID = routingData.data.source->sourceID;
+ element->connectionFormat = CF_UNKNOWN;
+ }
+ });
- if (shortestRoute.route.size())
- {
- err = cfPermutationsForPath(shortestRoute, resultNodesPath, resultPath);
- }
- return err;
+ if (shortestRoute.route.size())
+ {
+ err = cfPermutationsForPath(shortestRoute, resultNodesPath, resultPath);
}
- int CAmRouter::insertPostion(const std::vector<CAmRoutingNode*>& path, const std::vector<std::vector<CAmRoutingNode*> >& nodes)
+ return err;
+}
+
+int CAmRouter::insertPostion(const std::vector<CAmRoutingNode *> &path, const std::vector<std::vector<CAmRoutingNode *> > &nodes)
+{
+ int index = 0;
+ if (!nodes.empty())
{
- int index = 0;
- if (!nodes.empty())
+ auto itNodes = nodes.begin();
+ for (; itNodes != nodes.end(); itNodes++)
{
- auto itNodes = nodes.begin();
- for (; itNodes != nodes.end(); itNodes++)
+ if (itNodes->size() > path.size())
{
- if (itNodes->size() > path.size())
- break;
+ break;
}
- if (itNodes == nodes.end())
- index = nodes.size();
- else
- index = itNodes - nodes.begin();
}
- return index;
+
+ if (itNodes == nodes.end())
+ {
+ index = nodes.size();
+ }
+ else
+ {
+ index = itNodes - nodes.begin();
+ }
}
- am_Error_e CAmRouter::getFirstNShortestPaths(const bool onlyFree, const unsigned cycles, const unsigned maxPathCount, CAmRoutingNode & aSource,
- CAmRoutingNode & aSink, std::vector<am_Route_s> & resultPath)
+ return index;
+}
+
+am_Error_e CAmRouter::getFirstNShortestPaths(const bool onlyFree, const unsigned cycles, const unsigned maxPathCount, CAmRoutingNode &aSource,
+ CAmRoutingNode &aSink, std::vector<am_Route_s> &resultPath)
+{
+ if (aSource.getData().type != CAmNodeDataType::SOURCE || aSink.getData().type != CAmNodeDataType::SINK)
{
- if (aSource.getData().type != CAmNodeDataType::SOURCE || aSink.getData().type != CAmNodeDataType::SINK)
- return E_NOT_POSSIBLE;
- const am_sinkID_t sinkID = aSink.getData().data.sink->sinkID;
- const am_sourceID_t sourceID = aSource.getData().data.source->sourceID;
- std::vector<am_Route_s> paths;
- std::vector<std::vector<CAmRoutingNode*>> nodes;
- std::vector<am_domainID_t> visitedDomains;
- visitedDomains.push_back(((CAmRoutingNode*) &aSource)->getData().domainID());
+ return E_NOT_POSSIBLE;
+ }
- auto cbShouldVisitNode = [&visitedDomains, &cycles, &onlyFree, this](const CAmRoutingNode * node)->bool
- {
- if(CAmRouter::shouldGoInDomain(visitedDomains, node->getData().domainID(), cycles))
+ const am_sinkID_t sinkID = aSink.getData().data.sink->sinkID;
+ const am_sourceID_t sourceID = aSource.getData().data.source->sourceID;
+ std::vector<am_Route_s> paths;
+ std::vector<std::vector<CAmRoutingNode *> > nodes;
+ std::vector<am_domainID_t> visitedDomains;
+ visitedDomains.push_back(((CAmRoutingNode *)&aSource)->getData().domainID());
+
+ auto cbShouldVisitNode = [&visitedDomains, &cycles, &onlyFree, this](const CAmRoutingNode *node) -> bool {
+ if (CAmRouter::shouldGoInDomain(visitedDomains, node->getData().domainID(), cycles))
{
- const am_RoutingNodeData_s & nodeData = node->getData();
- if(am_RoutingNodeData_s::GATEWAY==nodeData.type)
+ const am_RoutingNodeData_s &nodeData = node->getData();
+ if (am_RoutingNodeData_s::GATEWAY == nodeData.type)
{
- const am_Gateway_s * gateway = nodeData.data.gateway;
+ const am_Gateway_s *gateway = nodeData.data.gateway;
return (!onlyFree || !isComponentConnected(*gateway));
}
- else if(am_RoutingNodeData_s::CONVERTER==nodeData.type)
+ else if (am_RoutingNodeData_s::CONVERTER == nodeData.type)
{
- const am_Converter_s * converter = nodeData.data.converter;
+ const am_Converter_s *converter = nodeData.data.converter;
return (!onlyFree || !isComponentConnected(*converter));
}
+
return true;
}
+
return false;
};
- auto cbWillVisitNode = [&visitedDomains](const CAmRoutingNode * node)
- { visitedDomains.push_back(node->getData().domainID());};
- auto cbDidVisitNode = [&visitedDomains](const CAmRoutingNode * node)
- { visitedDomains.erase(visitedDomains.end()-1);};
- auto cbDidFinish = [&resultPath, &nodes, &paths, &sinkID, &sourceID](const std::vector<CAmRoutingNode*> & path)
- {
+ auto cbWillVisitNode = [&visitedDomains](const CAmRoutingNode *node){
+ visitedDomains.push_back(node->getData().domainID());
+ };
+ auto cbDidVisitNode = [&visitedDomains](const CAmRoutingNode *node){
+ visitedDomains.erase(visitedDomains.end() - 1);
+ };
+ auto cbDidFinish = [&resultPath, &nodes, &paths, &sinkID, &sourceID](const std::vector<CAmRoutingNode *> &path){
int index = CAmRouter::insertPostion(path, nodes);
- nodes.emplace(nodes.begin()+index);
- paths.emplace(paths.begin()+index);
+ nodes.emplace(nodes.begin() + index);
+ paths.emplace(paths.begin() + index);
nodes[index] = path;
- am_Route_s & nextRoute = paths[index];
- nextRoute.sinkID = sinkID;
+ am_Route_s &nextRoute = paths[index];
+ nextRoute.sinkID = sinkID;
nextRoute.sourceID = sourceID;
- am_RoutingElement_s * element;
- for(auto it = path.begin(); it!=path.end(); it++)
+ am_RoutingElement_s *element;
+ for (auto it = path.begin(); it != path.end(); it++)
{
- am_RoutingNodeData_s & routingData = (*it)->getData();
- if(routingData.type==CAmNodeDataType::SOURCE)
+ am_RoutingNodeData_s &routingData = (*it)->getData();
+ if (routingData.type == CAmNodeDataType::SOURCE)
{
auto iter = nextRoute.route.emplace(nextRoute.route.end());
- element = &(*iter);
- element->domainID = routingData.data.source->domainID;
- element->sourceID = routingData.data.source->sourceID;
+ element = &(*iter);
+ element->domainID = routingData.data.source->domainID;
+ element->sourceID = routingData.data.source->sourceID;
element->connectionFormat = CF_UNKNOWN;
}
- else if(routingData.type==CAmNodeDataType::SINK)
+ else if (routingData.type == CAmNodeDataType::SINK)
{
- element->domainID = routingData.data.sink->domainID;
- element->sinkID = routingData.data.sink->sinkID;
+ element->domainID = routingData.data.sink->domainID;
+ element->sinkID = routingData.data.sink->sinkID;
element->connectionFormat = CF_UNKNOWN;
}
}
};
- mRoutingGraph.getAllPaths(aSource, aSink, cbShouldVisitNode, cbWillVisitNode, cbDidVisitNode, cbDidFinish);
- unsigned pathsFound = 0;
- am_Error_e cfError = E_OK;
- for (auto it = paths.begin(); pathsFound < maxPathCount && it != paths.end(); it++)
+ mRoutingGraph.getAllPaths(aSource, aSink, cbShouldVisitNode, cbWillVisitNode, cbDidVisitNode, cbDidFinish);
+ unsigned pathsFound = 0;
+ am_Error_e cfError = E_OK;
+ for (auto it = paths.begin(); pathsFound < maxPathCount && it != paths.end(); it++)
+ {
+ cfError = cfPermutationsForPath(*it, nodes[it - paths.begin()], resultPath);
+ if (E_OK == cfError)
{
- cfError = cfPermutationsForPath(*it, nodes[it - paths.begin()], resultPath);
- if (E_OK == cfError)
- {
- pathsFound += (resultPath.size() > 0);
- }
+ pathsFound += (resultPath.size() > 0);
}
- if (pathsFound)
- return E_OK;
- else
- return E_NOT_POSSIBLE;
}
- bool CAmRouter::shouldGoInDomain(const std::vector<am_domainID_t> & visitedDomains, const am_domainID_t nodeDomainID, const unsigned maxCyclesNumber)
+ if (pathsFound)
+ {
+ return E_OK;
+ }
+ else
{
- unsigned recourseCounter(0);
- if (visitedDomains.size())
+ return E_NOT_POSSIBLE;
+ }
+}
+
+bool CAmRouter::shouldGoInDomain(const std::vector<am_domainID_t> &visitedDomains, const am_domainID_t nodeDomainID, const unsigned maxCyclesNumber)
+{
+ unsigned recourseCounter(0);
+ if (visitedDomains.size())
+ {
+ if (visitedDomains.back() == nodeDomainID)
{
- if (visitedDomains.back() == nodeDomainID)
- return true;
- unsigned count = 0;
- am_domainID_t lastDomain = 0;
- for (auto it = visitedDomains.begin(); it != visitedDomains.end() - 1; it++)
+ return true;
+ }
+
+ unsigned count = 0;
+ am_domainID_t lastDomain = 0;
+ for (auto it = visitedDomains.begin(); it != visitedDomains.end() - 1; it++)
+ {
+ if (lastDomain != *it)
{
- if (lastDomain != *it)
+ if (nodeDomainID == *it)
{
- if (nodeDomainID == *it)
+ recourseCounter++;
+ if (recourseCounter > maxCyclesNumber)
{
- recourseCounter++;
- if (recourseCounter > maxCyclesNumber)
- return false;
+ return false;
}
- lastDomain = *it;
}
+
+ lastDomain = *it;
}
}
- return true;
}
- bool CAmRouter::shouldGoInDomain(const std::vector<am_domainID_t> & visitedDomains, const am_domainID_t nodeDomainID)
+ return true;
+}
+
+bool CAmRouter::shouldGoInDomain(const std::vector<am_domainID_t> &visitedDomains, const am_domainID_t nodeDomainID)
+{
+ return CAmRouter::shouldGoInDomain(visitedDomains, nodeDomainID, mMaxAllowedCycles);
+}
+
+bool CAmRouter::getAllowedFormatsFromConvMatrix(const std::vector<bool> &convertionMatrix,
+ const std::vector<am_CustomConnectionFormat_t> &listSourceFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkFormats,
+ std::vector<am_CustomConnectionFormat_t> &sourceFormats, std::vector<am_CustomConnectionFormat_t> &sinkFormats)
+{
+ const size_t sizeSourceFormats = listSourceFormats.size();
+ const size_t sizeSinkFormats = listSinkFormats.size();
+ const size_t sizeConvertionMatrix = convertionMatrix.size();
+
+ if (sizeSourceFormats == 0 || sizeSinkFormats == 0 || sizeConvertionMatrix == 0 || sizeConvertionMatrix != sizeSinkFormats * sizeSourceFormats)
{
- return CAmRouter::shouldGoInDomain(visitedDomains, nodeDomainID, mMaxAllowedCycles);
+ return false;
}
- bool CAmRouter::getAllowedFormatsFromConvMatrix(const std::vector<bool> & convertionMatrix,
- const std::vector<am_CustomConnectionFormat_t> & listSourceFormats, const std::vector<am_CustomConnectionFormat_t> & listSinkFormats,
- std::vector<am_CustomConnectionFormat_t> & sourceFormats, std::vector<am_CustomConnectionFormat_t> & sinkFormats)
+ std::vector<bool>::const_iterator iterator = convertionMatrix.begin();
+ for (; iterator != convertionMatrix.end(); ++iterator)
{
- const size_t sizeSourceFormats = listSourceFormats.size();
- const size_t sizeSinkFormats = listSinkFormats.size();
- const size_t sizeConvertionMatrix = convertionMatrix.size();
-
- if (sizeSourceFormats == 0 || sizeSinkFormats == 0 || sizeConvertionMatrix == 0 || sizeConvertionMatrix != sizeSinkFormats * sizeSourceFormats)
+ if (true == *iterator)
{
- return false;
+ const size_t index = iterator - convertionMatrix.begin();
+ size_t idx = index % sizeSourceFormats;
+ sourceFormats.push_back(listSourceFormats.at(idx));
+ idx = index / sizeSourceFormats;
+ sinkFormats.push_back(listSinkFormats.at(idx));
}
-
- std::vector<bool>::const_iterator iterator = convertionMatrix.begin();
- for (; iterator != convertionMatrix.end(); ++iterator)
- {
- if (true == *iterator)
- {
- const size_t index = iterator - convertionMatrix.begin();
- size_t idx = index % sizeSourceFormats;
- sourceFormats.push_back(listSourceFormats.at(idx));
- idx = index / sizeSourceFormats;
- sinkFormats.push_back(listSinkFormats.at(idx));
- }
- }
- return sourceFormats.size() > 0;
}
- void CAmRouter::listPossibleConnectionFormats(std::vector<am_CustomConnectionFormat_t> & inListSourceFormats,
- std::vector<am_CustomConnectionFormat_t> & inListSinkFormats, std::vector<am_CustomConnectionFormat_t> & outListFormats)
- {
- std::sort(inListSourceFormats.begin(), inListSourceFormats.end());
- std::sort(inListSinkFormats.begin(), inListSinkFormats.end());
- std::insert_iterator<std::vector<am_CustomConnectionFormat_t> > inserter(outListFormats, outListFormats.begin());
- set_intersection(inListSourceFormats.begin(), inListSourceFormats.end(), inListSinkFormats.begin(), inListSinkFormats.end(), inserter);
- }
+ return sourceFormats.size() > 0;
+}
- bool CAmRouter::getRestrictedOutputFormats(const std::vector<bool> & convertionMatrix, const std::vector<am_CustomConnectionFormat_t> & listSourceFormats,
- const std::vector<am_CustomConnectionFormat_t> & listSinkFormats, const am_CustomConnectionFormat_t connectionFormat,
- std::vector<am_CustomConnectionFormat_t> & listFormats)
- {
- listFormats.clear();
- std::vector<am_CustomConnectionFormat_t>::const_iterator rowSinkIterator = listSinkFormats.begin();
- std::vector<bool>::const_iterator matrixIterator = convertionMatrix.begin();
+void CAmRouter::listPossibleConnectionFormats(std::vector<am_CustomConnectionFormat_t> &inListSourceFormats,
+ std::vector<am_CustomConnectionFormat_t> &inListSinkFormats, std::vector<am_CustomConnectionFormat_t> &outListFormats)
+{
+ std::sort(inListSourceFormats.begin(), inListSourceFormats.end());
+ std::sort(inListSinkFormats.begin(), inListSinkFormats.end());
+ std::insert_iterator<std::vector<am_CustomConnectionFormat_t> > inserter(outListFormats, outListFormats.begin());
+ set_intersection(inListSourceFormats.begin(), inListSourceFormats.end(), inListSinkFormats.begin(), inListSinkFormats.end(), inserter);
+}
+
+bool CAmRouter::getRestrictedOutputFormats(const std::vector<bool> &convertionMatrix, const std::vector<am_CustomConnectionFormat_t> &listSourceFormats,
+ const std::vector<am_CustomConnectionFormat_t> &listSinkFormats, const am_CustomConnectionFormat_t connectionFormat,
+ std::vector<am_CustomConnectionFormat_t> &listFormats)
+{
+ listFormats.clear();
+ std::vector<am_CustomConnectionFormat_t>::const_iterator rowSinkIterator = listSinkFormats.begin();
+ std::vector<bool>::const_iterator matrixIterator = convertionMatrix.begin();
- //find the row number of the sink
- rowSinkIterator = find(listSinkFormats.begin(), listSinkFormats.end(), connectionFormat);
- int rowNumberSink = rowSinkIterator - listSinkFormats.begin();
+ // find the row number of the sink
+ rowSinkIterator = find(listSinkFormats.begin(), listSinkFormats.end(), connectionFormat);
+ int rowNumberSink = rowSinkIterator - listSinkFormats.begin();
- //go through the convertionMatrix and find out if the conversion is possible, if yes, add connectionFormat ...
- std::advance(matrixIterator, rowNumberSink);
+ // go through the convertionMatrix and find out if the conversion is possible, if yes, add connectionFormat ...
+ std::advance(matrixIterator, rowNumberSink);
- //iterate line-wise through the matrix and add more formats
- do
+ // iterate line-wise through the matrix and add more formats
+ do
+ {
+ if (*matrixIterator)
{
- if (*matrixIterator)
- {
- listFormats.push_back(listSourceFormats.at((matrixIterator - convertionMatrix.begin()) / listSinkFormats.size()));
- }
- std::advance(matrixIterator, listSinkFormats.size());
- } while (convertionMatrix.end() - matrixIterator > 0);
+ listFormats.push_back(listSourceFormats.at((matrixIterator - convertionMatrix.begin()) / listSinkFormats.size()));
+ }
+
+ std::advance(matrixIterator, listSinkFormats.size());
+ } while (convertionMatrix.end() - matrixIterator > 0);
+
+ return listFormats.size();
+}
- return listFormats.size();
+am_Error_e CAmRouter::getSourceSinkPossibleConnectionFormats(std::vector<CAmRoutingNode *>::iterator iteratorSource,
+ std::vector<CAmRoutingNode *>::iterator iteratorSink, std::vector<am_CustomConnectionFormat_t> &outConnectionFormats)
+{
+ CAmRoutingNode *nodeSink = *iteratorSink;
+ if (nodeSink->getData().type != CAmNodeDataType::SINK)
+ {
+ return (E_UNKNOWN);
}
- am_Error_e CAmRouter::getSourceSinkPossibleConnectionFormats(std::vector<CAmRoutingNode*>::iterator iteratorSource,
- std::vector<CAmRoutingNode*>::iterator iteratorSink, std::vector<am_CustomConnectionFormat_t> & outConnectionFormats)
+ CAmRoutingNode *nodeSource = *iteratorSource;
+ if (nodeSource->getData().type != CAmNodeDataType::SOURCE)
{
- CAmRoutingNode * nodeSink = *iteratorSink;
- if (nodeSink->getData().type != CAmNodeDataType::SINK)
- return (E_UNKNOWN);
+ return (E_UNKNOWN);
+ }
- CAmRoutingNode * nodeSource = *iteratorSource;
- if (nodeSource->getData().type != CAmNodeDataType::SOURCE)
- return (E_UNKNOWN);
+ am_Source_s *source = nodeSource->getData().data.source;
+ am_Sink_s *sink = nodeSink->getData().data.sink;
+ listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, outConnectionFormats);
+ return (E_OK);
+}
- am_Source_s *source = nodeSource->getData().data.source;
- am_Sink_s *sink = nodeSink->getData().data.sink;
- listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, outConnectionFormats);
- return (E_OK);
- }
+am_Error_e CAmRouter::getAllPaths(CAmRoutingNode &aSource, CAmRoutingNode &aSink, std::vector<am_Route_s> &resultPath,
+ std::vector<std::vector<CAmRoutingNode *> > &resultNodesPath, const bool includeCycles, const bool onlyFree)
+{
- am_Error_e CAmRouter::getAllPaths(CAmRoutingNode & aSource, CAmRoutingNode & aSink, std::vector<am_Route_s> & resultPath,
- std::vector<std::vector<CAmRoutingNode*>> & resultNodesPath, const bool includeCycles, const bool onlyFree)
+ if (aSource.getData().type != CAmNodeDataType::SOURCE || aSink.getData().type != CAmNodeDataType::SINK)
{
+ return E_NOT_POSSIBLE;
+ }
- if (aSource.getData().type != CAmNodeDataType::SOURCE || aSink.getData().type != CAmNodeDataType::SINK)
- return E_NOT_POSSIBLE;
+ unsigned cycles;
+ if (includeCycles)
+ {
+ cycles = UINT_MAX;
+ }
+ else
+ {
+ cycles = 0;
+ }
- unsigned cycles;
- if (includeCycles)
- cycles = UINT_MAX;
- else
- cycles = 0;
-
- uint8_t errorsCount = 0, successCount = 0;
- const am_sinkID_t sinkID = aSink.getData().data.sink->sinkID;
- const am_sourceID_t sourceID = aSource.getData().data.source->sourceID;
- std::vector<am_Route_s> paths;
- std::vector<am_domainID_t> visitedDomains;
- visitedDomains.push_back(((CAmRoutingNode*) &aSource)->getData().domainID());
- mRoutingGraph.getAllPaths(aSource, aSink, [&visitedDomains, &cycles, &onlyFree, this](const CAmRoutingNode * node)->bool
- {
- if(CAmRouter::shouldGoInDomain(visitedDomains, node->getData().domainID(), cycles))
+ uint8_t errorsCount = 0, successCount = 0;
+ const am_sinkID_t sinkID = aSink.getData().data.sink->sinkID;
+ const am_sourceID_t sourceID = aSource.getData().data.source->sourceID;
+ std::vector<am_Route_s> paths;
+ std::vector<am_domainID_t> visitedDomains;
+ visitedDomains.push_back(((CAmRoutingNode *)&aSource)->getData().domainID());
+ mRoutingGraph.getAllPaths(aSource, aSink, [&visitedDomains, &cycles, &onlyFree, this](const CAmRoutingNode *node) -> bool {
+ if (CAmRouter::shouldGoInDomain(visitedDomains, node->getData().domainID(), cycles))
{
- const am_RoutingNodeData_s & nodeData = node->getData();
- if(am_RoutingNodeData_s::GATEWAY==nodeData.type)
+ const am_RoutingNodeData_s &nodeData = node->getData();
+ if (am_RoutingNodeData_s::GATEWAY == nodeData.type)
{
- const am_Gateway_s * gateway = nodeData.data.gateway;
+ const am_Gateway_s *gateway = nodeData.data.gateway;
return (!onlyFree || !isComponentConnected(*gateway));
}
- else if(am_RoutingNodeData_s::CONVERTER==nodeData.type)
+ else if (am_RoutingNodeData_s::CONVERTER == nodeData.type)
{
- const am_Converter_s * converter = nodeData.data.converter;
+ const am_Converter_s *converter = nodeData.data.converter;
return (!onlyFree || !isComponentConnected(*converter));
}
+
return true;
}
+
return false;
- }, [&visitedDomains](const CAmRoutingNode * node)
- {
+ }, [&visitedDomains](const CAmRoutingNode *node){
visitedDomains.push_back(node->getData().domainID());
- }, [&visitedDomains](const CAmRoutingNode * node)
- { visitedDomains.erase(visitedDomains.end()-1);},
- [&resultPath, &resultNodesPath, &paths, &errorsCount, &successCount, &sinkID, &sourceID](const std::vector<CAmRoutingNode*> & path)
+ }, [&visitedDomains](const CAmRoutingNode *node){
+ visitedDomains.erase(visitedDomains.end() - 1);
+ },
+ [&resultPath, &resultNodesPath, &paths, &errorsCount, &successCount, &sinkID, &sourceID](const std::vector<CAmRoutingNode *> &path){
+ int index = CAmRouter::insertPostion(path, resultNodesPath);
+ resultNodesPath.emplace(resultNodesPath.begin() + index);
+ paths.emplace(paths.begin() + index);
+ resultNodesPath[index] = path;
+ am_Route_s &nextRoute = paths[index];
+ nextRoute.sinkID = sinkID;
+ nextRoute.sourceID = sourceID;
+ am_RoutingElement_s *element;
+ for (auto it = path.begin(); it != path.end(); it++)
+ {
+ am_RoutingNodeData_s &routingData = (*it)->getData();
+ if (routingData.type == CAmNodeDataType::SOURCE)
{
- int index = CAmRouter::insertPostion(path, resultNodesPath);
- resultNodesPath.emplace(resultNodesPath.begin()+index);
- paths.emplace(paths.begin()+index);
- resultNodesPath[index] = path;
- am_Route_s & nextRoute = paths[index];
- nextRoute.sinkID = sinkID;
- nextRoute.sourceID = sourceID;
- am_RoutingElement_s * element;
- for(auto it = path.begin(); it!=path.end(); it++)
- {
- am_RoutingNodeData_s & routingData = (*it)->getData();
- if(routingData.type==CAmNodeDataType::SOURCE)
- {
- auto iter = nextRoute.route.emplace(nextRoute.route.end());
- element = &(*iter);
- element->domainID = routingData.data.source->domainID;
- element->sourceID = routingData.data.source->sourceID;
- element->connectionFormat = CF_UNKNOWN;
- }
- else if(routingData.type==CAmNodeDataType::SINK)
- {
- element->domainID = routingData.data.sink->domainID;
- element->sinkID = routingData.data.sink->sinkID;
- element->connectionFormat = CF_UNKNOWN;
- }
- }
- });
+ auto iter = nextRoute.route.emplace(nextRoute.route.end());
+ element = &(*iter);
+ element->domainID = routingData.data.source->domainID;
+ element->sourceID = routingData.data.source->sourceID;
+ element->connectionFormat = CF_UNKNOWN;
+ }
+ else if (routingData.type == CAmNodeDataType::SINK)
+ {
+ element->domainID = routingData.data.sink->domainID;
+ element->sinkID = routingData.data.sink->sinkID;
+ element->connectionFormat = CF_UNKNOWN;
+ }
+ }
+ });
- for (auto it = paths.begin(); successCount < mMaxPathCount && it != paths.end(); it++)
+ for (auto it = paths.begin(); successCount < mMaxPathCount && it != paths.end(); it++)
+ {
+ if (cfPermutationsForPath(*it, resultNodesPath[it - paths.begin()], resultPath) == E_UNKNOWN)
{
- if (cfPermutationsForPath(*it, resultNodesPath[it - paths.begin()], resultPath) == E_UNKNOWN)
- errorsCount++;
- else
- successCount++;
+ errorsCount++;
}
+ else
+ {
+ successCount++;
+ }
+ }
- if (successCount)
- return E_OK;
- if (errorsCount)
- return E_NOT_POSSIBLE;
+ if (successCount)
+ {
return E_OK;
}
+ if (errorsCount)
+ {
+ return E_NOT_POSSIBLE;
+ }
+
+ return E_OK;
+}
+
}
diff --git a/AudioManagerCore/src/CAmRoutingReceiver.cpp b/AudioManagerCore/src/CAmRoutingReceiver.cpp
index b3815cd..f372df9 100644
--- a/AudioManagerCore/src/CAmRoutingReceiver.cpp
+++ b/AudioManagerCore/src/CAmRoutingReceiver.cpp
@@ -30,50 +30,50 @@
#include "CAmDltWrapper.h"
#include "CAmSocketHandler.h"
-#define __METHOD_NAME__ std::string (std::string("CAmRoutingReceiver::") + __func__)
+#define __METHOD_NAME__ std::string(std::string("CAmRoutingReceiver::") + __func__)
namespace am
{
-CAmRoutingReceiver::CAmRoutingReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
- mpDatabaseHandler(iDatabaseHandler),
- mpRoutingSender(iRoutingSender),
- mpControlSender(iControlSender),
- mpSocketHandler(iSocketHandler),
- mpDBusWrapper(NULL),
- mListStartupHandles(),
- mListRundownHandles(),
- handleCount(0),
- mWaitStartup(false),
- mWaitRundown(false),
- mLastStartupError(E_OK),
- mLastRundownError(E_OK)
-{
- assert(mpDatabaseHandler!=NULL);
- assert(mpRoutingSender!=NULL);
- assert(mpControlSender!=NULL);
- assert(mpSocketHandler!=NULL);
-}
-
-CAmRoutingReceiver::CAmRoutingReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
- mpDatabaseHandler(iDatabaseHandler),
- mpRoutingSender(iRoutingSender),
- mpControlSender(iControlSender),
- mpSocketHandler(iSocketHandler),
- mpDBusWrapper(iDBusWrapper),
- mListStartupHandles(),
- mListRundownHandles(),
- handleCount(0),
- mWaitStartup(false),
- mWaitRundown(false),
- mLastStartupError(E_OK),
- mLastRundownError(E_OK)
-{
- assert(mpDatabaseHandler!=NULL);
- assert(mpRoutingSender!=NULL);
- assert(mpControlSender!=NULL);
- assert(mpSocketHandler!=NULL);
- assert(mpDBusWrapper!=NULL);
+CAmRoutingReceiver::CAmRoutingReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler)
+ : mpDatabaseHandler(iDatabaseHandler)
+ , mpRoutingSender(iRoutingSender)
+ , mpControlSender(iControlSender)
+ , mpSocketHandler(iSocketHandler)
+ , mpDBusWrapper(NULL)
+ , mListStartupHandles()
+ , mListRundownHandles()
+ , handleCount(0)
+ , mWaitStartup(false)
+ , mWaitRundown(false)
+ , mLastStartupError(E_OK)
+ , mLastRundownError(E_OK)
+{
+ assert(mpDatabaseHandler != NULL);
+ assert(mpRoutingSender != NULL);
+ assert(mpControlSender != NULL);
+ assert(mpSocketHandler != NULL);
+}
+
+CAmRoutingReceiver::CAmRoutingReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper)
+ : mpDatabaseHandler(iDatabaseHandler)
+ , mpRoutingSender(iRoutingSender)
+ , mpControlSender(iControlSender)
+ , mpSocketHandler(iSocketHandler)
+ , mpDBusWrapper(iDBusWrapper)
+ , mListStartupHandles()
+ , mListRundownHandles()
+ , handleCount(0)
+ , mWaitStartup(false)
+ , mWaitRundown(false)
+ , mLastStartupError(E_OK)
+ , mLastRundownError(E_OK)
+{
+ assert(mpDatabaseHandler != NULL);
+ assert(mpRoutingSender != NULL);
+ assert(mpControlSender != NULL);
+ assert(mpSocketHandler != NULL);
+ assert(mpDBusWrapper != NULL);
}
CAmRoutingReceiver::~CAmRoutingReceiver()
@@ -88,138 +88,142 @@ void CAmRoutingReceiver::handleCallback(const am_Handle_s handle, const am_Error
}
else
{
- mpRoutingSender->removeHandle(handle);
- }
+ mpRoutingSender->removeHandle(handle);
+ }
}
void CAmRoutingReceiver::ackConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"connectionID=",connectionID,"error=",error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "connectionID=", connectionID, "error=", error);
if (error == am_Error_e::E_OK)
{
mpRoutingSender->writeToDatabaseAndRemove(handle);
}
else
{
- //only remove connection of handle was found
- if(mpRoutingSender->removeHandle(handle)==0)
- {
- mpDatabaseHandler->removeConnection(connectionID);
- mpRoutingSender->removeConnectionLookup(connectionID);
- }
+ // only remove connection of handle was found
+ if (mpRoutingSender->removeHandle(handle) == 0)
+ {
+ mpDatabaseHandler->removeConnection(connectionID);
+ mpRoutingSender->removeConnectionLookup(connectionID);
+ }
}
+
mpControlSender->cbAckConnect(handle, error);
}
void CAmRoutingReceiver::ackDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"connectionID=",connectionID,"error=",error);
- //only remove connection of handle was found
- if(mpRoutingSender->removeHandle(handle) == 0)
- {
- mpRoutingSender->removeConnectionLookup(connectionID);
- }
+ logInfo(__METHOD_NAME__, "handle=", handle, "connectionID=", connectionID, "error=", error);
+ // only remove connection of handle was found
+ if (mpRoutingSender->removeHandle(handle) == 0)
+ {
+ mpRoutingSender->removeConnectionLookup(connectionID);
+ }
+
mpControlSender->cbAckDisconnect(handle, error);
}
void CAmRoutingReceiver::ackSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"volume=",volume,"error=",error);
- if(error == E_OK)
+ logInfo(__METHOD_NAME__, "handle=", handle, "volume=", volume, "error=", error);
+ if (error == E_OK)
{
- mpRoutingSender->checkVolume(handle,volume);
- }
-
- if (error== am_Error_e::E_OK || error== am_Error_e::E_ABORTED)
+ mpRoutingSender->checkVolume(handle, volume);
+ }
+
+ if (error == am_Error_e::E_OK || error == am_Error_e::E_ABORTED)
{
- mpRoutingSender->writeToDatabaseAndRemove(handle);
+ mpRoutingSender->writeToDatabaseAndRemove(handle);
}
else
{
- mpRoutingSender->removeHandle(handle);
- }
+ mpRoutingSender->removeHandle(handle);
+ }
+
mpControlSender->cbAckSetSinkVolumeChange(handle, volume, error);
}
void CAmRoutingReceiver::ackSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"volume=",volume,"error=",error);
- if(error == E_OK)
+ logInfo(__METHOD_NAME__, "handle=", handle, "volume=", volume, "error=", error);
+ if (error == E_OK)
{
- mpRoutingSender->checkVolume(handle,volume);
+ mpRoutingSender->checkVolume(handle, volume);
}
- if (error== am_Error_e::E_OK || error== am_Error_e::E_ABORTED)
+ if (error == am_Error_e::E_OK || error == am_Error_e::E_ABORTED)
{
- mpRoutingSender->writeToDatabaseAndRemove(handle);
+ mpRoutingSender->writeToDatabaseAndRemove(handle);
}
else
{
- mpRoutingSender->removeHandle(handle);
- }
+ mpRoutingSender->removeHandle(handle);
+ }
+
mpControlSender->cbAckSetSourceVolumeChange(handle, volume, error);
}
void CAmRoutingReceiver::ackSetSourceState(const am_Handle_s handle, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
- handleCallback(handle,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "error=", error);
+ handleCallback(handle, error);
mpControlSender->cbAckSetSourceState(handle, error);
}
void CAmRoutingReceiver::ackSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
- handleCallback(handle,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "error=", error);
+ handleCallback(handle, error);
mpControlSender->cbAckSetSinkSoundProperty(handle, error);
}
void am::CAmRoutingReceiver::ackSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
- handleCallback(handle,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "error=", error);
+ handleCallback(handle, error);
mpControlSender->cbAckSetSinkSoundProperties(handle, error);
}
void CAmRoutingReceiver::ackSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
- handleCallback(handle,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "error=", error);
+ handleCallback(handle, error);
mpControlSender->cbAckSetSourceSoundProperty(handle, error);
}
void am::CAmRoutingReceiver::ackSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
- handleCallback(handle,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "error=", error);
+ handleCallback(handle, error);
mpControlSender->cbAckSetSourceSoundProperties(handle, error);
}
void CAmRoutingReceiver::ackCrossFading(const am_Handle_s handle, const am_HotSink_e hotSink, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"hotsink=",hotSink,"error=",error);
- handleCallback(handle,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "hotsink=", hotSink, "error=", error);
+ handleCallback(handle, error);
mpControlSender->cbAckCrossFade(handle, hotSink, error);
}
void CAmRoutingReceiver::ackSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"sourceID=",sourceID,"volume=",volume);
+ logInfo(__METHOD_NAME__, "handle=", handle, "sourceID=", sourceID, "volume=", volume);
mpControlSender->hookSystemSourceVolumeTick(handle, sourceID, volume);
}
void CAmRoutingReceiver::ackSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"sinkID=",sinkID,"volume=",volume);
+ logInfo(__METHOD_NAME__, "handle=", handle, "sinkID=", sinkID, "volume=", volume);
mpControlSender->hookSystemSinkVolumeTick(handle, sinkID, volume);
}
-am_Error_e CAmRoutingReceiver::peekDomain(const std::string & name, am_domainID_t & domainID)
-{
+am_Error_e CAmRoutingReceiver::peekDomain(const std::string &name, am_domainID_t &domainID)
+{
return (mpDatabaseHandler->peekDomain(name, domainID));
}
-am_Error_e CAmRoutingReceiver::registerDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
+am_Error_e CAmRoutingReceiver::registerDomain(const am_Domain_s &domainData, am_domainID_t &domainID)
{
return (mpControlSender->hookSystemRegisterDomain(domainData, domainID));
}
@@ -229,14 +233,14 @@ am_Error_e CAmRoutingReceiver::deregisterDomain(const am_domainID_t domainID)
return (mpControlSender->hookSystemDeregisterDomain(domainID));
}
-am_Error_e CAmRoutingReceiver::registerGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+am_Error_e CAmRoutingReceiver::registerGateway(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID)
{
return (mpControlSender->hookSystemRegisterGateway(gatewayData, gatewayID));
}
-am_Error_e CAmRoutingReceiver::registerConverter(const am_Converter_s& converterData, am_converterID_t& converterID)
+am_Error_e CAmRoutingReceiver::registerConverter(const am_Converter_s &converterData, am_converterID_t &converterID)
{
- return (mpControlSender->hookSystemRegisterConverter(converterData, converterID));
+ return (mpControlSender->hookSystemRegisterConverter(converterData, converterID));
}
am_Error_e CAmRoutingReceiver::deregisterGateway(const am_gatewayID_t gatewayID)
@@ -244,17 +248,17 @@ am_Error_e CAmRoutingReceiver::deregisterGateway(const am_gatewayID_t gatewayID)
return (mpControlSender->hookSystemDeregisterGateway(gatewayID));
}
-am_Error_e CAmRoutingReceiver::deregisterConverter(const am_converterID_t converterID)
+am_Error_e CAmRoutingReceiver::deregisterConverter(const am_converterID_t converterID)
{
- return (mpControlSender->hookSystemDeregisterConverter(converterID));
+ return (mpControlSender->hookSystemDeregisterConverter(converterID));
}
-am_Error_e CAmRoutingReceiver::peekSink(const std::string& name, am_sinkID_t & sinkID)
+am_Error_e CAmRoutingReceiver::peekSink(const std::string &name, am_sinkID_t &sinkID)
{
return (mpDatabaseHandler->peekSink(name, sinkID));
}
-am_Error_e CAmRoutingReceiver::registerSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+am_Error_e CAmRoutingReceiver::registerSink(const am_Sink_s &sinkData, am_sinkID_t &sinkID)
{
return (mpControlSender->hookSystemRegisterSink(sinkData, sinkID));
}
@@ -264,12 +268,12 @@ am_Error_e CAmRoutingReceiver::deregisterSink(const am_sinkID_t sinkID)
return (mpControlSender->hookSystemDeregisterSink(sinkID));
}
-am_Error_e CAmRoutingReceiver::peekSource(const std::string & name, am_sourceID_t & sourceID)
+am_Error_e CAmRoutingReceiver::peekSource(const std::string &name, am_sourceID_t &sourceID)
{
return (mpDatabaseHandler->peekSource(name, sourceID));
}
-am_Error_e CAmRoutingReceiver::registerSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+am_Error_e CAmRoutingReceiver::registerSource(const am_Source_s &sourceData, am_sourceID_t &sourceID)
{
return (mpControlSender->hookSystemRegisterSource(sourceData, sourceID));
}
@@ -279,7 +283,7 @@ am_Error_e CAmRoutingReceiver::deregisterSource(const am_sourceID_t sourceID)
return (mpControlSender->hookSystemDeregisterSource(sourceID));
}
-am_Error_e CAmRoutingReceiver::registerCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+am_Error_e CAmRoutingReceiver::registerCrossfader(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID)
{
return (mpControlSender->hookSystemRegisterCrossfader(crossfaderData, crossfaderID));
}
@@ -304,12 +308,12 @@ void CAmRoutingReceiver::hookDomainRegistrationComplete(const am_domainID_t doma
mpControlSender->hookSystemDomainRegistrationComplete(domainID);
}
-void CAmRoutingReceiver::hookSinkAvailablityStatusChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
+void CAmRoutingReceiver::hookSinkAvailablityStatusChange(const am_sinkID_t sinkID, const am_Availability_s &availability)
{
mpControlSender->hookSystemSinkAvailablityStateChange(sinkID, availability);
}
-void CAmRoutingReceiver::hookSourceAvailablityStatusChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
+void CAmRoutingReceiver::hookSourceAvailablityStatusChange(const am_sourceID_t sourceID, const am_Availability_s &availability)
{
mpControlSender->hookSystemSourceAvailablityStateChange(sourceID, availability);
}
@@ -322,157 +326,167 @@ void CAmRoutingReceiver::hookDomainStateChange(const am_domainID_t domainID, con
void CAmRoutingReceiver::hookTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t delay)
{
mpDatabaseHandler->changeConnectionTimingInformation(connectionID, delay);
- mpControlSender->hookSystemSingleTimingInformationChanged(connectionID,delay);
+ mpControlSender->hookSystemSingleTimingInformationChanged(connectionID, delay);
}
-void CAmRoutingReceiver::sendChangedData(const std::vector<am_EarlyData_s> & earlyData)
+void CAmRoutingReceiver::sendChangedData(const std::vector<am_EarlyData_s> &earlyData)
{
mpControlSender->hookSystemReceiveEarlyData(earlyData);
}
-am_Error_e CAmRoutingReceiver::peekSinkClassID(const std::string& name, am_sinkClass_t& sinkClassID)
+am_Error_e CAmRoutingReceiver::peekSinkClassID(const std::string &name, am_sinkClass_t &sinkClassID)
{
return (mpDatabaseHandler->peekSinkClassID(name, sinkClassID));
}
-am_Error_e CAmRoutingReceiver::peekSourceClassID(const std::string& name, am_sourceClass_t& sourceClassID)
+am_Error_e CAmRoutingReceiver::peekSourceClassID(const std::string &name, am_sourceClass_t &sourceClassID)
{
return (mpDatabaseHandler->peekSourceClassID(name, sourceClassID));
}
#ifdef WITH_DBUS_WRAPPER
-am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper *& dbusConnectionWrapper) const
+am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper * &dbusConnectionWrapper) const
{
dbusConnectionWrapper = mpDBusWrapper;
return (E_OK);
#else
-am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper *& ) const
+am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper * &) const
{
return (E_UNKNOWN);
-#endif
+#endif // ifdef WITH_DBUS_WRAPPER
}
-am_Error_e CAmRoutingReceiver::getSocketHandler(CAmSocketHandler *& socketHandler) const
+am_Error_e CAmRoutingReceiver::getSocketHandler(CAmSocketHandler * &socketHandler) const
{
socketHandler = mpSocketHandler;
return (E_OK);
}
-void CAmRoutingReceiver::getInterfaceVersion(std::string & version) const
+void CAmRoutingReceiver::getInterfaceVersion(std::string &version) const
{
version = RoutingVersion;
}
-void CAmRoutingReceiver::confirmRoutingReady(const uint16_t handle, const am_Error_e error)
+void CAmRoutingReceiver::confirmRoutingReady(const uint16_t handle, const am_Error_e error)
{
- if (error!=E_OK)
- mLastStartupError=error;
+ if (error != E_OK)
+ {
+ mLastStartupError = error;
+ }
+
mListStartupHandles.erase(std::remove(mListStartupHandles.begin(), mListStartupHandles.end(), handle), mListStartupHandles.end());
if (mWaitStartup && mListStartupHandles.empty())
+ {
mpControlSender->confirmRoutingReady(mLastStartupError);
+ }
}
void CAmRoutingReceiver::confirmRoutingRundown(const uint16_t handle, const am_Error_e error)
{
- if (error!=E_OK)
- mLastRundownError=error;
+ if (error != E_OK)
+ {
+ mLastRundownError = error;
+ }
+
mListRundownHandles.erase(std::remove(mListRundownHandles.begin(), mListRundownHandles.end(), handle), mListRundownHandles.end());
if (mWaitRundown && mListRundownHandles.empty())
+ {
mpControlSender->confirmRoutingRundown(mLastRundownError);
+ }
}
uint16_t am::CAmRoutingReceiver::getStartupHandle()
{
- uint16_t handle = ++handleCount; //todo: handle overflow
+ uint16_t handle = ++handleCount; // todo: handle overflow
mListStartupHandles.push_back(handle);
return (handle);
}
uint16_t am::CAmRoutingReceiver::getRundownHandle()
{
- uint16_t handle = ++handleCount; //todo: handle overflow
+ uint16_t handle = ++handleCount; // todo: handle overflow
mListRundownHandles.push_back(handle);
return (handle);
}
void am::CAmRoutingReceiver::waitOnStartup(bool startup)
{
- mWaitStartup = startup;
- mLastStartupError=E_OK;
+ mWaitStartup = startup;
+ mLastStartupError = E_OK;
}
void CAmRoutingReceiver::ackSinkNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
- handleCallback(handle,error);
- mpControlSender->cbAckSetSinkNotificationConfiguration(handle,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "error=", error);
+ handleCallback(handle, error);
+ mpControlSender->cbAckSetSinkNotificationConfiguration(handle, error);
}
void CAmRoutingReceiver::ackSourceNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
- handleCallback(handle,error);
- mpControlSender->cbAckSetSourceNotificationConfiguration(handle,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "error=", error);
+ handleCallback(handle, error);
+ mpControlSender->cbAckSetSourceNotificationConfiguration(handle, error);
}
-am_Error_e CAmRoutingReceiver::updateGateway(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t>& listSourceFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkFormats, const std::vector<bool>& convertionMatrix)
+am_Error_e CAmRoutingReceiver::updateGateway(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t> &listSourceFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkFormats, const std::vector<bool> &convertionMatrix)
{
- return (mpControlSender->hookSystemUpdateGateway(gatewayID,listSourceFormats,listSinkFormats,convertionMatrix));
+ return (mpControlSender->hookSystemUpdateGateway(gatewayID, listSourceFormats, listSinkFormats, convertionMatrix));
}
-am_Error_e CAmRoutingReceiver::updateConverter(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t>& listSourceFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkFormats, const std::vector<bool>& convertionMatrix)
+am_Error_e CAmRoutingReceiver::updateConverter(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t> &listSourceFormats, const std::vector<am_CustomConnectionFormat_t> &listSinkFormats, const std::vector<bool> &convertionMatrix)
{
- return (mpControlSender->hookSystemUpdateConverter(converterID,listSourceFormats,listSinkFormats,convertionMatrix));
+ return (mpControlSender->hookSystemUpdateConverter(converterID, listSourceFormats, listSinkFormats, convertionMatrix));
}
-am_Error_e CAmRoutingReceiver::updateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+am_Error_e CAmRoutingReceiver::updateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s> &listSoundProperties, const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
- return (mpControlSender->hookSystemUpdateSink(sinkID,sinkClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties));
+ return (mpControlSender->hookSystemUpdateSink(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties));
}
-am_Error_e CAmRoutingReceiver::updateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+am_Error_e CAmRoutingReceiver::updateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s> &listSoundProperties, const std::vector<am_CustomConnectionFormat_t> &listConnectionFormats, const std::vector<am_MainSoundProperty_s> &listMainSoundProperties)
{
- return (mpControlSender->hookSystemUpdateSource(sourceID,sourceClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties));
+ return (mpControlSender->hookSystemUpdateSource(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties));
}
-void CAmRoutingReceiver::ackSetVolumes(const am_Handle_s handle, const std::vector<am_Volumes_s>& listvolumes, const am_Error_e error)
+void CAmRoutingReceiver::ackSetVolumes(const am_Handle_s handle, const std::vector<am_Volumes_s> &listvolumes, const am_Error_e error)
{
- logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
- handleCallback(handle,error);
- mpControlSender->cbAckSetVolume(handle,listvolumes,error);
+ logInfo(__METHOD_NAME__, "handle=", handle, "error=", error);
+ handleCallback(handle, error);
+ mpControlSender->cbAckSetVolume(handle, listvolumes, error);
}
-void CAmRoutingReceiver::hookSinkNotificationDataChange(const am_sinkID_t sinkID, const am_NotificationPayload_s& payload)
+void CAmRoutingReceiver::hookSinkNotificationDataChange(const am_sinkID_t sinkID, const am_NotificationPayload_s &payload)
{
- logInfo(__METHOD_NAME__,"sinkID=",sinkID,"type=",payload.type,"notificationValue=",payload.value);
- mpControlSender->hookSinkNotificationDataChanged(sinkID,payload);
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "type=", payload.type, "notificationValue=", payload.value);
+ mpControlSender->hookSinkNotificationDataChanged(sinkID, payload);
}
-void CAmRoutingReceiver::hookSourceNotificationDataChange(const am_sourceID_t sourceID, const am_NotificationPayload_s& payload)
+void CAmRoutingReceiver::hookSourceNotificationDataChange(const am_sourceID_t sourceID, const am_NotificationPayload_s &payload)
{
- logInfo(__METHOD_NAME__,"sinkID=",sourceID,"type=",payload.type,"notificationValue=",payload.value);
- mpControlSender->hookSourceNotificationDataChanged(sourceID,payload);
+ logInfo(__METHOD_NAME__, "sinkID=", sourceID, "type=", payload.type, "notificationValue=", payload.value);
+ mpControlSender->hookSourceNotificationDataChanged(sourceID, payload);
}
-am_Error_e CAmRoutingReceiver::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t& domainID) const
+am_Error_e CAmRoutingReceiver::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t &domainID) const
{
- return (mpDatabaseHandler->getDomainOfSink(sinkID,domainID));
+ return (mpDatabaseHandler->getDomainOfSink(sinkID, domainID));
}
-am_Error_e CAmRoutingReceiver::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t& domainID) const
+am_Error_e CAmRoutingReceiver::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t &domainID) const
{
- return (mpDatabaseHandler->getDomainOfSource(sourceID,domainID));
+ return (mpDatabaseHandler->getDomainOfSource(sourceID, domainID));
}
-am_Error_e CAmRoutingReceiver::getDomainOfCrossfader(const am_crossfaderID_t crossfader, am_domainID_t& domainID) const
+am_Error_e CAmRoutingReceiver::getDomainOfCrossfader(const am_crossfaderID_t crossfader, am_domainID_t &domainID) const
{
- return (mpDatabaseHandler->getDomainOfCrossfader(crossfader,domainID));
+ return (mpDatabaseHandler->getDomainOfCrossfader(crossfader, domainID));
}
void CAmRoutingReceiver::waitOnRundown(bool rundown)
{
- mWaitRundown = rundown;
- mLastRundownError=E_OK;
+ mWaitRundown = rundown;
+ mLastRundownError = E_OK;
}
}
diff --git a/AudioManagerCore/src/CAmRoutingSender.cpp b/AudioManagerCore/src/CAmRoutingSender.cpp
index 9c6e658..cb66fe9 100644
--- a/AudioManagerCore/src/CAmRoutingSender.cpp
+++ b/AudioManagerCore/src/CAmRoutingSender.cpp
@@ -40,78 +40,79 @@
namespace am
{
-#define REQUIRED_INTERFACE_VERSION_MAJOR 1 //!< major interface version. All versions smaller than this will be rejected
+#define REQUIRED_INTERFACE_VERSION_MAJOR 1 //!< major interface version. All versions smaller than this will be rejected
#define REQUIRED_INTERFACE_VERSION_MINOR 0 //!< minor interface version. All versions smaller than this will be rejected
-#define __METHOD_NAME__ std::string (std::string("CAmRoutingSender::") + __func__)
+#define __METHOD_NAME__ std::string(std::string("CAmRoutingSender::") + __func__)
CAmRoutingSender::CAmRoutingSender(
- const std::vector<std::string>& listOfPluginDirectories,
- IAmDatabaseHandler* databaseHandler) :
- mHandleCount(0),
- mlistActiveHandles(),
- mListInterfaces(),
- mMapConnectionInterface(),
- mMapCrossfaderInterface(),
- mMapDomainInterface(),
- mMapSinkInterface(),
- mMapSourceInterface(),
- mpRoutingReceiver(),
- mpDatabaseHandler(databaseHandler) {
+ const std::vector<std::string> &listOfPluginDirectories,
+ IAmDatabaseHandler *databaseHandler)
+ : mHandleCount(0)
+ , mlistActiveHandles()
+ , mListInterfaces()
+ , mMapConnectionInterface()
+ , mMapCrossfaderInterface()
+ , mMapDomainInterface()
+ , mMapSinkInterface()
+ , mMapSourceInterface()
+ , mpRoutingReceiver()
+ , mpDatabaseHandler(databaseHandler)
+{
loadPlugins(listOfPluginDirectories);
- dboNewSink = [&](const am_Sink_s& sink) {
- addSinkLookup(sink);
- };
- dboNewSource = [&](const am_Source_s& source) {
- addSourceLookup(source);
- };
- dboNewDomain = [&](const am_Domain_s& domain) {
- addDomainLookup(domain);
- };
- //todo: newGateway implement something
- //todo: newConverter implement something
- dboNewCrossfader = [&](const am_Crossfader_s& crossfader) {
- addCrossfaderLookup(crossfader);
- };
+ dboNewSink = [&](const am_Sink_s &sink) {
+ addSinkLookup(sink);
+ };
+ dboNewSource = [&](const am_Source_s &source) {
+ addSourceLookup(source);
+ };
+ dboNewDomain = [&](const am_Domain_s &domain) {
+ addDomainLookup(domain);
+ };
+ // todo: newGateway implement something
+ // todo: newConverter implement something
+ dboNewCrossfader = [&](const am_Crossfader_s &crossfader) {
+ addCrossfaderLookup(crossfader);
+ };
dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible) {
- removeSinkLookup(sinkID);
- };
+ removeSinkLookup(sinkID);
+ };
dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible) {
- removeSourceLookup(sourceID);
- };
+ removeSourceLookup(sourceID);
+ };
dboRemoveDomain = [&](const am_domainID_t domainID) {
- removeDomainLookup(domainID);
- };
- //todo: removeGateway implement something
- //todo: removeConverter implement something
+ removeDomainLookup(domainID);
+ };
+ // todo: removeGateway implement something
+ // todo: removeConverter implement something
dboRemoveCrossfader = [&](const am_crossfaderID_t crossfaderID) {
- removeCrossfaderLookup(crossfaderID);
- };
+ removeCrossfaderLookup(crossfaderID);
+ };
}
-void CAmRoutingSender::loadPlugins(const std::vector<std::string>& listOfPluginDirectories)
+void CAmRoutingSender::loadPlugins(const std::vector<std::string> &listOfPluginDirectories)
{
if (listOfPluginDirectories.empty())
{
- logError(__METHOD_NAME__,"List of routingplugins is empty");
+ logError(__METHOD_NAME__, "List of routingplugins is empty");
}
- std::vector<std::string> sharedLibraryNameList;
- std::vector<std::string>::const_iterator dirIter = listOfPluginDirectories.begin();
+ std::vector<std::string> sharedLibraryNameList;
+ std::vector<std::string>::const_iterator dirIter = listOfPluginDirectories.begin();
std::vector<std::string>::const_iterator dirIterEnd = listOfPluginDirectories.end();
// search communicator plugins in configured directories
for (; dirIter < dirIterEnd; ++dirIter)
{
- const char* directoryName = dirIter->c_str();
- logInfo(__METHOD_NAME__,"Searching for HookPlugins in", directoryName);
+ const char *directoryName = dirIter->c_str();
+ logInfo(__METHOD_NAME__, "Searching for HookPlugins in", directoryName);
DIR *directory = opendir(directoryName);
if (!directory)
{
- logError(__METHOD_NAME__,"Error opening directory: ", directoryName);
+ logError(__METHOD_NAME__, "Error opening directory: ", directoryName);
continue;
}
@@ -120,10 +121,10 @@ void CAmRoutingSender::loadPlugins(const std::vector<std::string>& listOfPluginD
while ((itemInDirectory = readdir(directory)))
{
unsigned char entryType = itemInDirectory->d_type;
- std::string entryName = itemInDirectory->d_name;
- std::string fullName = *dirIter + "/" + entryName;
+ std::string entryName = itemInDirectory->d_name;
+ std::string fullName = *dirIter + "/" + entryName;
- bool regularFile = (entryType == DT_REG || entryType == DT_LNK);
+ bool regularFile = (entryType == DT_REG || entryType == DT_LNK);
bool sharedLibExtension = ("so" == entryName.substr(entryName.find_last_of(".") + 1));
// Handle cases where readdir() could not determine the file type
@@ -133,7 +134,7 @@ void CAmRoutingSender::loadPlugins(const std::vector<std::string>& listOfPluginD
if (stat(fullName.c_str(), &buf))
{
- logInfo(__METHOD_NAME__,"Failed to stat file: ", entryName, errno);
+ logInfo(__METHOD_NAME__, "Failed to stat file: ", entryName, errno);
continue;
}
@@ -142,7 +143,7 @@ void CAmRoutingSender::loadPlugins(const std::vector<std::string>& listOfPluginD
if (regularFile && sharedLibExtension)
{
- logInfo(__METHOD_NAME__,"adding file: ", entryName);
+ logInfo(__METHOD_NAME__, "adding file: ", entryName);
std::string name(directoryName);
sharedLibraryNameList.push_back(name + "/" + entryName);
}
@@ -156,28 +157,28 @@ void CAmRoutingSender::loadPlugins(const std::vector<std::string>& listOfPluginD
}
// iterate all communicator plugins and start them
- std::vector<std::string>::iterator iter = sharedLibraryNameList.begin();
+ std::vector<std::string>::iterator iter = sharedLibraryNameList.begin();
std::vector<std::string>::iterator iterEnd = sharedLibraryNameList.end();
for (; iter != iterEnd; ++iter)
{
- logInfo(__METHOD_NAME__,"try loading: ", *iter);
+ logInfo(__METHOD_NAME__, "try loading: ", *iter);
- IAmRoutingSend* (*createFunc)();
- void* tempLibHandle = NULL;
- createFunc = getCreateFunction<IAmRoutingSend*()>(*iter, tempLibHandle);
+ IAmRoutingSend *(*createFunc)();
+ void *tempLibHandle = NULL;
+ createFunc = getCreateFunction<IAmRoutingSend *()>(*iter, tempLibHandle);
if (!createFunc)
{
- logError(__METHOD_NAME__,"Entry point of RoutingPlugin not found");
+ logError(__METHOD_NAME__, "Entry point of RoutingPlugin not found");
continue;
}
- IAmRoutingSend* router = createFunc();
+ IAmRoutingSend *router = createFunc();
if (!router)
{
- logError(__METHOD_NAME__,"initialization of plugin ",*iter,"failed. Entry Function not callable");
+ logError(__METHOD_NAME__, "initialization of plugin ", *iter, "failed. Entry Function not callable");
dlclose(tempLibHandle);
continue;
}
@@ -185,7 +186,7 @@ void CAmRoutingSender::loadPlugins(const std::vector<std::string>& listOfPluginD
InterfaceNamePairs routerInterface;
routerInterface.routingInterface = router;
- //check libversion
+ // check libversion
std::string version, cVersion(RoutingVersion);
router->getInterfaceVersion(version);
uint16_t minorVersion, majorVersion, cMinorVersion, cMajorVersion;
@@ -196,12 +197,12 @@ void CAmRoutingSender::loadPlugins(const std::vector<std::string>& listOfPluginD
if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion > cMinorVersion)))
{
- logError(__METHOD_NAME__,"Routing initialization failed. Version of Interface to old");
+ logError(__METHOD_NAME__, "Routing initialization failed. Version of Interface to old");
dlclose(tempLibHandle);
continue;
}
- //here, the busname is saved together with the interface. Later The domains will register with the name and sinks, sources etc with the domain....
+ // here, the busname is saved together with the interface. Later The domains will register with the name and sinks, sources etc with the domain....
router->returnBusName(routerInterface.busName);
assert(!routerInterface.busName.empty());
mListInterfaces.push_back(routerInterface);
@@ -211,13 +212,13 @@ void CAmRoutingSender::loadPlugins(const std::vector<std::string>& listOfPluginD
CAmRoutingSender::~CAmRoutingSender()
{
- //unloadLibraries();
+ // unloadLibraries();
HandlesMap::iterator it = mlistActiveHandles.begin();
- //every open handle is assumed to be an error...
+ // every open handle is assumed to be an error...
for (; it != mlistActiveHandles.end(); ++it)
{
- logError(__METHOD_NAME__,"The action for the handle",it->first,"is still open");
+ logError(__METHOD_NAME__, "The action for the handle", it->first, "is still open");
}
}
@@ -226,7 +227,7 @@ am_Error_e CAmRoutingSender::startupInterfaces(CAmRoutingReceiver *iRoutingRecei
mpRoutingReceiver = iRoutingReceiver;
am_Error_e returnError = E_OK;
- std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
+ std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
std::vector<InterfaceNamePairs>::iterator iterEnd = mListInterfaces.end();
for (; iter < iterEnd; ++iter)
{
@@ -236,410 +237,428 @@ am_Error_e CAmRoutingSender::startupInterfaces(CAmRoutingReceiver *iRoutingRecei
returnError = error;
}
}
+
return (returnError);
}
-am_Error_e CAmRoutingSender::asyncAbort(const am_Handle_s& handle)
+am_Error_e CAmRoutingSender::asyncAbort(const am_Handle_s &handle)
{
- auto iter (mlistActiveHandles.find(handle));
+ auto iter(mlistActiveHandles.find(handle));
if (iter == mlistActiveHandles.end())
{
- logError(__METHOD_NAME__,"Could not find handle",handle);
- return (E_NON_EXISTENT);
+ logError(__METHOD_NAME__, "Could not find handle", handle);
+ return (E_NON_EXISTENT);
}
- logInfo(__METHOD_NAME__," handle", handle);
- return (iter->second->returnInterface()->asyncAbort(handle));
+
+ logInfo(__METHOD_NAME__, " handle", handle);
+ return (iter->second->returnInterface()->asyncAbort(handle));
}
-am_Error_e CAmRoutingSender::asyncConnect(am_Handle_s& handle, am_connectionID_t& connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_CustomConnectionFormat_t connectionFormat)
+am_Error_e CAmRoutingSender::asyncConnect(am_Handle_s &handle, am_connectionID_t &connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_CustomConnectionFormat_t connectionFormat)
{
- auto iter (mMapSinkInterface.find(sinkID));
- if (iter == mMapSinkInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sink",sinkID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_CONNECT)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
-
- am_Connection_s tempConnection;
- tempConnection.sinkID = sinkID;
- tempConnection.sourceID = sourceID;
- tempConnection.connectionFormat = connectionFormat;
- tempConnection.connectionID = 0;
- tempConnection.delay=-1;
-
- am_Error_e connError(mpDatabaseHandler->enterConnectionDB(tempConnection, connectionID));
- if (connError)
- {
- return(connError);
- }
- mMapConnectionInterface.insert(std::make_pair(connectionID, iter->second));
- auto handleData = std::make_shared<handleConnect>(iter->second,connectionID,mpDatabaseHandler);
- handle = createHandle(handleData, am_Handle_e::H_CONNECT);
- }
-
- logInfo(__METHOD_NAME__,"connectionID=",connectionID,"connectionFormat=", connectionFormat, "sourceID=", sourceID, "sinkID=", sinkID,"handle=",handle);
- am_Error_e syncError(iter->second->asyncConnect(handle, connectionID, sourceID, sinkID, connectionFormat));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling connect connectionID:",connectionID,"sourceID:",sourceID,"sinkID:",sinkID,"connectionFormat:",connectionFormat,"handle",handle);
- mpDatabaseHandler->removeConnection(connectionID);
- }
- return(syncError);
+ auto iter(mMapSinkInterface.find(sinkID));
+ if (iter == mMapSinkInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sink", sinkID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_CONNECT)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+
+ am_Connection_s tempConnection;
+ tempConnection.sinkID = sinkID;
+ tempConnection.sourceID = sourceID;
+ tempConnection.connectionFormat = connectionFormat;
+ tempConnection.connectionID = 0;
+ tempConnection.delay = -1;
+
+ am_Error_e connError(mpDatabaseHandler->enterConnectionDB(tempConnection, connectionID));
+ if (connError)
+ {
+ return(connError);
+ }
+
+ mMapConnectionInterface.insert(std::make_pair(connectionID, iter->second));
+ auto handleData = std::make_shared<handleConnect>(iter->second, connectionID, mpDatabaseHandler);
+ handle = createHandle(handleData, am_Handle_e::H_CONNECT);
+ }
+
+ logInfo(__METHOD_NAME__, "connectionID=", connectionID, "connectionFormat=", connectionFormat, "sourceID=", sourceID, "sinkID=", sinkID, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncConnect(handle, connectionID, sourceID, sinkID, connectionFormat));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling connect connectionID:", connectionID, "sourceID:", sourceID, "sinkID:", sinkID, "connectionFormat:", connectionFormat, "handle", handle);
+ mpDatabaseHandler->removeConnection(connectionID);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncDisconnect(am_Handle_s& handle, const am_connectionID_t connectionID)
+am_Error_e CAmRoutingSender::asyncDisconnect(am_Handle_s &handle, const am_connectionID_t connectionID)
{
- auto iter(mMapConnectionInterface.find(connectionID));
- if (iter == mMapConnectionInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find connection",connectionID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_DISCONNECT)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
+ auto iter(mMapConnectionInterface.find(connectionID));
+ if (iter == mMapConnectionInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find connection", connectionID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_DISCONNECT)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
}
else
{
- auto handleData = std::make_shared<handleDisconnect>(iter->second,connectionID,mpDatabaseHandler,this);
- handle = createHandle(handleData, am_Handle_e::H_DISCONNECT);
- }
-
- logInfo(__METHOD_NAME__,"connectionID=", connectionID, "handle=",handle);
- am_Error_e syncError(iter->second->asyncDisconnect(handle, connectionID));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling disconnect connectionID:",connectionID,"handle",handle);
- }
- return(syncError);
+ auto handleData = std::make_shared<handleDisconnect>(iter->second, connectionID, mpDatabaseHandler, this);
+ handle = createHandle(handleData, am_Handle_e::H_DISCONNECT);
+ }
+
+ logInfo(__METHOD_NAME__, "connectionID=", connectionID, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncDisconnect(handle, connectionID));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling disconnect connectionID:", connectionID, "handle", handle);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSinkVolume(am_Handle_s& handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time)
+am_Error_e CAmRoutingSender::asyncSetSinkVolume(am_Handle_s &handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time)
{
- auto iter (mMapSinkInterface.find(sinkID));
- if (iter == mMapSinkInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sink",sinkID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSINKVOLUME)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSinkVolume>(iter->second,sinkID,mpDatabaseHandler,volume);
+ auto iter(mMapSinkInterface.find(sinkID));
+ if (iter == mMapSinkInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sink", sinkID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSINKVOLUME)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSinkVolume>(iter->second, sinkID, mpDatabaseHandler, volume);
handle = createHandle(handleData, H_SETSINKVOLUME);
}
-
- logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volume=", volume, "ramp=", ramp, "time=", time,"handle=",handle);
- am_Error_e syncError(iter->second->asyncSetSinkVolume(handle, sinkID, volume, ramp, time));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSinkVolume sinkID:",sinkID,"handle:",handle,"volume:",volume,"ramp:",ramp,"time:",time);
- }
- return(syncError);
+
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "volume=", volume, "ramp=", ramp, "time=", time, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncSetSinkVolume(handle, sinkID, volume, ramp, time));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSinkVolume sinkID:", sinkID, "handle:", handle, "volume:", volume, "ramp:", ramp, "time:", time);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSourceVolume(am_Handle_s& handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time)
+am_Error_e CAmRoutingSender::asyncSetSourceVolume(am_Handle_s &handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time)
{
- auto iter (mMapSourceInterface.find(sourceID));
- if (iter == mMapSourceInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSOURCEVOLUME)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSourceVolume>(iter->second,sourceID,mpDatabaseHandler,volume);
+ auto iter(mMapSourceInterface.find(sourceID));
+ if (iter == mMapSourceInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sourceID", sourceID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSOURCEVOLUME)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSourceVolume>(iter->second, sourceID, mpDatabaseHandler, volume);
handle = createHandle(handleData, H_SETSOURCEVOLUME);
}
-
- logInfo(__METHOD_NAME__,"sourceID=", sourceID,"volume=", volume, "ramp=", ramp, "time=", time,"handle=",handle);
- am_Error_e syncError(iter->second->asyncSetSourceVolume(handle, sourceID, volume, ramp, time));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSourceVolume sourceID:",sourceID,"handle:",handle,"volume:",volume,"ramp:",ramp,"time:",time);
- }
- return(syncError);
+
+ logInfo(__METHOD_NAME__, "sourceID=", sourceID, "volume=", volume, "ramp=", ramp, "time=", time, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncSetSourceVolume(handle, sourceID, volume, ramp, time));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSourceVolume sourceID:", sourceID, "handle:", handle, "volume:", volume, "ramp:", ramp, "time:", time);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSourceState(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SourceState_e state)
+am_Error_e CAmRoutingSender::asyncSetSourceState(am_Handle_s &handle, const am_sourceID_t sourceID, const am_SourceState_e state)
{
- auto iter (mMapSourceInterface.find(sourceID));
- if (iter == mMapSourceInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSOURCESTATE)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSourceState>(iter->second,sourceID,state,mpDatabaseHandler);
- handle = createHandle(handleData, H_SETSOURCESTATE);
- }
- logInfo(__METHOD_NAME__,"sourceID=", sourceID, "state=", state,"handle=",handle);
- am_Error_e syncError(iter->second->asyncSetSourceState(handle, sourceID, state));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSourceState sourceID:",sourceID,"handle:",handle,"state:",state);
- }
- return(syncError);
+ auto iter(mMapSourceInterface.find(sourceID));
+ if (iter == mMapSourceInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sourceID", sourceID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSOURCESTATE)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSourceState>(iter->second, sourceID, state, mpDatabaseHandler);
+ handle = createHandle(handleData, H_SETSOURCESTATE);
+ }
+
+ logInfo(__METHOD_NAME__, "sourceID=", sourceID, "state=", state, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncSetSourceState(handle, sourceID, state));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSourceState sourceID:", sourceID, "handle:", handle, "state:", state);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSinkSoundProperty(am_Handle_s& handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
+am_Error_e CAmRoutingSender::asyncSetSinkSoundProperty(am_Handle_s &handle, const am_sinkID_t sinkID, const am_SoundProperty_s &soundProperty)
{
- auto iter (mMapSinkInterface.find(sinkID));
- if (iter == mMapSinkInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sink",sinkID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSINKSOUNDPROPERTY)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSinkSoundProperty>(iter->second,sinkID,soundProperty,mpDatabaseHandler);
+ auto iter(mMapSinkInterface.find(sinkID));
+ if (iter == mMapSinkInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sink", sinkID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSINKSOUNDPROPERTY)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSinkSoundProperty>(iter->second, sinkID, soundProperty, mpDatabaseHandler);
handle = createHandle(handleData, H_SETSINKSOUNDPROPERTY);
- }
-
- logInfo(__METHOD_NAME__,"sinkID=", sinkID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value,"handle=",handle);
- am_Error_e syncError(iter->second->asyncSetSinkSoundProperty(handle, sinkID, soundProperty));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSinkSoundProperty sinkID:",sinkID,"handle:",handle,"soundProperty:",soundProperty.type,soundProperty.value);
- }
- return(syncError);
+ }
+
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncSetSinkSoundProperty(handle, sinkID, soundProperty));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSinkSoundProperty sinkID:", sinkID, "handle:", handle, "soundProperty:", soundProperty.type, soundProperty.value);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSourceSoundProperty(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
+am_Error_e CAmRoutingSender::asyncSetSourceSoundProperty(am_Handle_s &handle, const am_sourceID_t sourceID, const am_SoundProperty_s &soundProperty)
{
- auto iter (mMapSourceInterface.find(sourceID));
- if (iter == mMapSourceInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSOURCESOUNDPROPERTY)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSourceSoundProperty>(iter->second,sourceID,soundProperty,mpDatabaseHandler);
+ auto iter(mMapSourceInterface.find(sourceID));
+ if (iter == mMapSourceInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sourceID", sourceID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSOURCESOUNDPROPERTY)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSourceSoundProperty>(iter->second, sourceID, soundProperty, mpDatabaseHandler);
handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTY);
}
- logInfo(__METHOD_NAME__,"sourceID=", sourceID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value,"handle=",handle);
- am_Error_e syncError(iter->second->asyncSetSourceSoundProperty(handle, sourceID, soundProperty));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSourceSoundProperty sourceID:",sourceID,"handle:",handle,"soundProperty:",soundProperty.type,soundProperty.value);
- }
- return(syncError);
+
+ logInfo(__METHOD_NAME__, "sourceID=", sourceID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncSetSourceSoundProperty(handle, sourceID, soundProperty));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSourceSoundProperty sourceID:", sourceID, "handle:", handle, "soundProperty:", soundProperty.type, soundProperty.value);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSourceSoundProperties(am_Handle_s& handle, const std::vector<am_SoundProperty_s> & listSoundProperties, const am_sourceID_t sourceID)
+am_Error_e CAmRoutingSender::asyncSetSourceSoundProperties(am_Handle_s &handle, const std::vector<am_SoundProperty_s> &listSoundProperties, const am_sourceID_t sourceID)
{
- auto iter (mMapSourceInterface.find(sourceID));
- if (iter == mMapSourceInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSOURCESOUNDPROPERTIES)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSourceSoundProperties>(iter->second,sourceID,listSoundProperties,mpDatabaseHandler);
+ auto iter(mMapSourceInterface.find(sourceID));
+ if (iter == mMapSourceInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sourceID", sourceID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSOURCESOUNDPROPERTIES)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSourceSoundProperties>(iter->second, sourceID, listSoundProperties, mpDatabaseHandler);
handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTIES);
}
-
- logInfo(__METHOD_NAME__,"sourceID=", sourceID);
- am_Error_e syncError(iter->second->asyncSetSourceSoundProperties(handle, sourceID, listSoundProperties));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSourceSoundProperties sourceID:",sourceID,"handle:",handle);
- }
- return(syncError);
+
+ logInfo(__METHOD_NAME__, "sourceID=", sourceID);
+ am_Error_e syncError(iter->second->asyncSetSourceSoundProperties(handle, sourceID, listSoundProperties));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSourceSoundProperties sourceID:", sourceID, "handle:", handle);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSinkSoundProperties(am_Handle_s& handle, const std::vector<am_SoundProperty_s> & listSoundProperties, const am_sinkID_t sinkID)
+am_Error_e CAmRoutingSender::asyncSetSinkSoundProperties(am_Handle_s &handle, const std::vector<am_SoundProperty_s> &listSoundProperties, const am_sinkID_t sinkID)
{
- auto iter (mMapSinkInterface.find(sinkID));
- if (iter == mMapSinkInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sink",sinkID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSINKSOUNDPROPERTIES)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSinkSoundProperties>(iter->second,sinkID,listSoundProperties,mpDatabaseHandler);
+ auto iter(mMapSinkInterface.find(sinkID));
+ if (iter == mMapSinkInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sink", sinkID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSINKSOUNDPROPERTIES)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSinkSoundProperties>(iter->second, sinkID, listSoundProperties, mpDatabaseHandler);
handle = createHandle(handleData, H_SETSINKSOUNDPROPERTIES);
}
-
- logInfo(__METHOD_NAME__,"sinkID=", sinkID,"handle=",handle);
- am_Error_e syncError(iter->second->asyncSetSinkSoundProperties(handle, sinkID, listSoundProperties));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSinkSoundProperties sinkID:",sinkID,"handle:",handle);
- }
- return(syncError);
+
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncSetSinkSoundProperties(handle, sinkID, listSoundProperties));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSinkSoundProperties sinkID:", sinkID, "handle:", handle);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s& handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_CustomRampType_t rampType, const am_time_t time)
+am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s &handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_CustomRampType_t rampType, const am_time_t time)
{
- auto iter (mMapCrossfaderInterface.find(crossfaderID));
- if (iter == mMapCrossfaderInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find crossfaderID",crossfaderID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_CROSSFADE)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleCrossFader>(iter->second,crossfaderID,hotSink,mpDatabaseHandler);
+ auto iter(mMapCrossfaderInterface.find(crossfaderID));
+ if (iter == mMapCrossfaderInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find crossfaderID", crossfaderID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_CROSSFADE)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleCrossFader>(iter->second, crossfaderID, hotSink, mpDatabaseHandler);
handle = createHandle(handleData, H_CROSSFADE);
- }
-
- logInfo(__METHOD_NAME__,"hotSource=", hotSink, "crossfaderID=", crossfaderID, "rampType=", rampType, "rampTime=", time,"handle=",handle);
- am_Error_e syncError(iter->second->asyncCrossFade(handle, crossfaderID, hotSink, rampType, time));
- if (syncError)
- {
- removeHandle(handle);
- }
- return(syncError);
+ }
+
+ logInfo(__METHOD_NAME__, "hotSource=", hotSink, "crossfaderID=", crossfaderID, "rampType=", rampType, "rampTime=", time, "handle=", handle);
+ am_Error_e syncError(iter->second->asyncCrossFade(handle, crossfaderID, hotSink, rampType, time));
+ if (syncError)
+ {
+ removeHandle(handle);
+ }
+
+ return(syncError);
}
am_Error_e CAmRoutingSender::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
{
- logInfo(__METHOD_NAME__,"domainID=", domainID, "domainState=", domainState);
+ logInfo(__METHOD_NAME__, "domainID=", domainID, "domainState=", domainState);
DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
iter = mMapDomainInterface.find(domainID);
if (iter != mMapDomainInterface.end())
+ {
return (iter->second->setDomainState(domainID, domainState));
+ }
+
return (E_NON_EXISTENT);
}
@@ -648,9 +667,9 @@ am_Error_e CAmRoutingSender::setDomainState(const am_domainID_t domainID, const
* this adds the domain to the lookup table of the Router. The data is used to have a quick lookup of the correct pluginInterface.
* This must be done whenever a domain is registered.
*/
-am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s& domainData)
+am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s &domainData)
{
- std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
+ std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
std::vector<InterfaceNamePairs>::iterator iterEnd = mListInterfaces.end();
for (; iter < iterEnd; ++iter)
{
@@ -660,7 +679,8 @@ am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s& domainData)
return (E_OK);
}
}
- logError(__PRETTY_FUNCTION__," Could not find busname for bus",domainData.busname);
+
+ logError(__PRETTY_FUNCTION__, " Could not find busname for bus", domainData.busname);
return (E_UNKNOWN);
}
@@ -669,7 +689,7 @@ am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s& domainData)
* this adds the Source to the lookup table of the Router. The data is used to have a quick lookup of the correct pluginInterface.
* This must be done whenever a Source is registered.
*/
-am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s& sourceData)
+am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s &sourceData)
{
DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
iter = mMapDomainInterface.find(sourceData.domainID);
@@ -678,7 +698,8 @@ am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s& sourceData)
mMapSourceInterface.insert(std::make_pair(sourceData.sourceID, iter->second));
return (E_OK);
}
- logError(__PRETTY_FUNCTION__," Could not find domainInterface for domainID",sourceData.domainID);
+
+ logError(__PRETTY_FUNCTION__, " Could not find domainInterface for domainID", sourceData.domainID);
return (E_UNKNOWN);
}
@@ -687,7 +708,7 @@ am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s& sourceData)
* this adds the Sink to the lookup table of the Router. The data is used to have a quick lookup of the correct pluginInterface.
* This must be done whenever a Sink is registered.
*/
-am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s& sinkData)
+am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s &sinkData)
{
DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
iter = mMapDomainInterface.find(sinkData.domainID);
@@ -696,7 +717,8 @@ am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s& sinkData)
mMapSinkInterface.insert(std::make_pair(sinkData.sinkID, iter->second));
return (E_OK);
}
- logError(__PRETTY_FUNCTION__,"Could not find domainInterface for domainID",sinkData.domainID);
+
+ logError(__PRETTY_FUNCTION__, "Could not find domainInterface for domainID", sinkData.domainID);
return (E_UNKNOWN);
}
@@ -705,7 +727,7 @@ am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s& sinkData)
* this adds the Crossfader to the lookup table of the Router. The data is used to have a quick lookup of the correct pluginInterface.
* This must be done whenever a Crossfader is registered.
*/
-am_Error_e CAmRoutingSender::addCrossfaderLookup(const am_Crossfader_s& crossfaderData)
+am_Error_e CAmRoutingSender::addCrossfaderLookup(const am_Crossfader_s &crossfaderData)
{
DomainInterfaceMap::iterator iter = mMapSourceInterface.begin();
iter = mMapSourceInterface.find(crossfaderData.sourceID);
@@ -714,7 +736,8 @@ am_Error_e CAmRoutingSender::addCrossfaderLookup(const am_Crossfader_s& crossfad
mMapSourceInterface.insert(std::make_pair(crossfaderData.crossfaderID, iter->second));
return (E_OK);
}
- logError(__PRETTY_FUNCTION__," Could not find sourceInterface for source",crossfaderData.sourceID);
+
+ logError(__PRETTY_FUNCTION__, " Could not find sourceInterface for source", crossfaderData.sourceID);
return (E_UNKNOWN);
}
@@ -791,17 +814,18 @@ am_Error_e CAmRoutingSender::removeCrossfaderLookup(const am_crossfaderID_t cros
* @param handle to be removed
* @return E_OK in case of success
*/
-am_Error_e CAmRoutingSender::removeHandle(const am_Handle_s& handle)
+am_Error_e CAmRoutingSender::removeHandle(const am_Handle_s &handle)
{
if (mlistActiveHandles.erase(handle))
{
return (E_OK);
}
- logError(__METHOD_NAME__,"Could not remove handle",handle.handle);
+
+ logError(__METHOD_NAME__, "Could not remove handle", handle.handle);
return (E_NON_EXISTENT);
}
-am_Error_e CAmRoutingSender::getListHandles(std::vector<am_Handle_s> & listHandles) const
+am_Error_e CAmRoutingSender::getListHandles(std::vector<am_Handle_s> &listHandles) const
{
listHandles.clear();
HandlesMap::const_iterator it = mlistActiveHandles.begin();
@@ -809,6 +833,7 @@ am_Error_e CAmRoutingSender::getListHandles(std::vector<am_Handle_s> & listHandl
{
listHandles.push_back(it->first);
}
+
return (E_OK);
}
@@ -822,30 +847,32 @@ am_Handle_s CAmRoutingSender::createHandle(std::shared_ptr<handleDataBase> handl
{
am_Handle_s handle;
handle.handleType = type;
-
- for (int checkOverflow=0;checkOverflow<1024;checkOverflow++)
- {
- if (++mHandleCount>=1024) //defined by 10 bit (out if structure!)
- {
- mHandleCount=1;
- }
- handle.handle = mHandleCount;
-
- if ( mlistActiveHandles.find(handle) == mlistActiveHandles.end() )
- {
- mlistActiveHandles.insert(std::make_pair(handle, handleData));
- if (mlistActiveHandles.size()>100)
- {
- logWarning(__METHOD_NAME__,"too many open handles, number of handles: ", mlistActiveHandles.size());
- }
- logInfo(__METHOD_NAME__,handle.handle, handle.handleType);
- return (handle);
- }
- }
-
- logError(__METHOD_NAME__,"could not create new handle, all handles in use!");
- handle.handle=0;
-
+
+ for (int checkOverflow = 0; checkOverflow < 1024; checkOverflow++)
+ {
+ if (++mHandleCount >= 1024) // defined by 10 bit (out if structure!)
+ {
+ mHandleCount = 1;
+ }
+
+ handle.handle = mHandleCount;
+
+ if ( mlistActiveHandles.find(handle) == mlistActiveHandles.end())
+ {
+ mlistActiveHandles.insert(std::make_pair(handle, handleData));
+ if (mlistActiveHandles.size() > 100)
+ {
+ logWarning(__METHOD_NAME__, "too many open handles, number of handles: ", mlistActiveHandles.size());
+ }
+
+ logInfo(__METHOD_NAME__, handle.handle, handle.handleType);
+ return (handle);
+ }
+ }
+
+ logError(__METHOD_NAME__, "could not create new handle, all handles in use!");
+ handle.handle = 0;
+
return(handle);
}
@@ -853,19 +880,19 @@ void CAmRoutingSender::setRoutingReady()
{
mpRoutingReceiver->waitOnStartup(false);
- //create a list of handles
+ // create a list of handles
std::vector<uint16_t> listStartupHandles;
for (size_t i = 0; i < mListInterfaces.size(); i++)
{
listStartupHandles.push_back(mpRoutingReceiver->getStartupHandle());
}
- //set the receiver ready to wait for replies
+ // set the receiver ready to wait for replies
mpRoutingReceiver->waitOnStartup(true);
- std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
+ std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
std::vector<InterfaceNamePairs>::iterator iterEnd = mListInterfaces.end();
- std::vector<uint16_t>::const_iterator handleIter(listStartupHandles.begin());
+ std::vector<uint16_t>::const_iterator handleIter(listStartupHandles.begin());
for (; iter < iterEnd; ++iter)
{
(*iter).routingInterface->setRoutingReady(*(handleIter++));
@@ -875,301 +902,328 @@ void CAmRoutingSender::setRoutingReady()
void CAmRoutingSender::setRoutingRundown()
{
mpRoutingReceiver->waitOnRundown(false);
- //create a list of handles
+ // create a list of handles
std::vector<uint16_t> listStartupHandles;
for (size_t i = 0; i < mListInterfaces.size(); i++)
{
listStartupHandles.push_back(mpRoutingReceiver->getRundownHandle());
}
- //set the receiver ready to wait for replies
+ // set the receiver ready to wait for replies
mpRoutingReceiver->waitOnRundown(true);
- std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
+ std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
std::vector<InterfaceNamePairs>::iterator iterEnd = mListInterfaces.end();
- std::vector<uint16_t>::const_iterator handleIter(listStartupHandles.begin());
+ std::vector<uint16_t>::const_iterator handleIter(listStartupHandles.begin());
for (; iter < iterEnd; ++iter)
{
(*iter).routingInterface->setRoutingRundown(*(handleIter++));
}
}
-am_Error_e CAmRoutingSender::asyncSetVolumes(am_Handle_s& handle, const std::vector<am_Volumes_s>& listVolumes)
+am_Error_e CAmRoutingSender::asyncSetVolumes(am_Handle_s &handle, const std::vector<am_Volumes_s> &listVolumes)
{
- IAmRoutingSend* pRoutingInterface(NULL);
+ IAmRoutingSend *pRoutingInterface(NULL);
if (listVolumes.empty())
+ {
return (E_NOT_POSSIBLE);
+ }
- //we need an interface so lets get either the sink or source ID from the first entry in the listVolumes
- if (listVolumes[0].volumeType==VT_SINK)
+ // we need an interface so lets get either the sink or source ID from the first entry in the listVolumes
+ if (listVolumes[0].volumeType == VT_SINK)
{
- am_sinkID_t sinkID=listVolumes[0].volumeID.sink;
- SinkInterfaceMap::iterator iter = mMapSinkInterface.begin();
+ am_sinkID_t sinkID = listVolumes[0].volumeID.sink;
+ SinkInterfaceMap::iterator iter = mMapSinkInterface.begin();
iter = mMapSinkInterface.find(sinkID);
- if(iter!=mMapSinkInterface.end())
- pRoutingInterface=iter->second;
+ if (iter != mMapSinkInterface.end())
+ {
+ pRoutingInterface = iter->second;
+ }
else
+ {
return(E_NON_EXISTENT);
+ }
}
-
- else if (listVolumes[0].volumeType==VT_SOURCE)
+ else if (listVolumes[0].volumeType == VT_SOURCE)
{
- am_sourceID_t sourceID=listVolumes[0].volumeID.source;
- SourceInterfaceMap::iterator iter = mMapSourceInterface.begin();
+ am_sourceID_t sourceID = listVolumes[0].volumeID.source;
+ SourceInterfaceMap::iterator iter = mMapSourceInterface.begin();
iter = mMapSourceInterface.find(sourceID);
- if (iter!=mMapSourceInterface.end())
- pRoutingInterface=iter->second;
+ if (iter != mMapSourceInterface.end())
+ {
+ pRoutingInterface = iter->second;
+ }
else
+ {
return(E_NON_EXISTENT);
+ }
}
else
+ {
return (E_NON_EXISTENT);
+ }
- auto handleData = std::make_shared<handleSetVolumes>(pRoutingInterface,listVolumes,mpDatabaseHandler);
+ auto handleData = std::make_shared<handleSetVolumes>(pRoutingInterface, listVolumes, mpDatabaseHandler);
handle = createHandle(handleData, H_SETVOLUMES);
logInfo(__METHOD_NAME__, "handle=", handle);
am_Error_e syncError(pRoutingInterface->asyncSetVolumes(handle, listVolumes));
if (syncError)
- {
- removeHandle(handle);
- }
- return(syncError);
+ {
+ removeHandle(handle);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSinkNotificationConfiguration(am_Handle_s& handle, const am_sinkID_t sinkID, const am_NotificationConfiguration_s& notificationConfiguration)
+am_Error_e CAmRoutingSender::asyncSetSinkNotificationConfiguration(am_Handle_s &handle, const am_sinkID_t sinkID, const am_NotificationConfiguration_s &notificationConfiguration)
{
- auto iter (mMapSinkInterface.find(sinkID));
- if (iter == mMapSinkInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sink",sinkID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSINKNOTIFICATION)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSetSinkNotificationConfiguration>(iter->second,sinkID,notificationConfiguration,mpDatabaseHandler);
+ auto iter(mMapSinkInterface.find(sinkID));
+ if (iter == mMapSinkInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sink", sinkID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSINKNOTIFICATION)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSetSinkNotificationConfiguration>(iter->second, sinkID, notificationConfiguration, mpDatabaseHandler);
handle = createHandle(handleData, H_SETSINKNOTIFICATION);
}
- logInfo(__METHOD_NAME__,"sinkID=",sinkID,"notificationConfiguration.type=",notificationConfiguration.type,"notificationConfiguration.status",notificationConfiguration.status,"notificationConfiguration.parameter",notificationConfiguration.parameter);
- am_Error_e syncError(iter->second->asyncSetSinkNotificationConfiguration(handle, sinkID, notificationConfiguration));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSinkNotificationConfiguration sinkID:",sinkID,"handle:",handle);
- }
- return(syncError);
+ logInfo(__METHOD_NAME__, "sinkID=", sinkID, "notificationConfiguration.type=", notificationConfiguration.type, "notificationConfiguration.status", notificationConfiguration.status, "notificationConfiguration.parameter", notificationConfiguration.parameter);
+ am_Error_e syncError(iter->second->asyncSetSinkNotificationConfiguration(handle, sinkID, notificationConfiguration));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSinkNotificationConfiguration sinkID:", sinkID, "handle:", handle);
+ }
+
+ return(syncError);
}
-am_Error_e CAmRoutingSender::asyncSetSourceNotificationConfiguration(am_Handle_s& handle, const am_sourceID_t sourceID, const am_NotificationConfiguration_s& notificationConfiguration)
+am_Error_e CAmRoutingSender::asyncSetSourceNotificationConfiguration(am_Handle_s &handle, const am_sourceID_t sourceID, const am_NotificationConfiguration_s &notificationConfiguration)
{
- auto iter (mMapSourceInterface.find(sourceID));
- if (iter == mMapSourceInterface.end())
- {
- logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
- return (E_NON_EXISTENT);
- }
-
- if(handleExists(handle))
- {
- if (handle.handleType==am_Handle_e::H_SETSOURCENOTIFICATION)
- {
- logInfo(__METHOD_NAME__,"Resending for handle",handle);
- }
- else
- {
- logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
- return(E_UNKNOWN);
- }
- }
- else
- {
- auto handleData = std::make_shared<handleSetSourceNotificationConfiguration>(iter->second,sourceID,notificationConfiguration,mpDatabaseHandler);
+ auto iter(mMapSourceInterface.find(sourceID));
+ if (iter == mMapSourceInterface.end())
+ {
+ logError(__METHOD_NAME__, "Could not find sourceID", sourceID);
+ return (E_NON_EXISTENT);
+ }
+
+ if (handleExists(handle))
+ {
+ if (handle.handleType == am_Handle_e::H_SETSOURCENOTIFICATION)
+ {
+ logInfo(__METHOD_NAME__, "Resending for handle", handle);
+ }
+ else
+ {
+ logError(__METHOD_NAME__, "Handle exists but wrong type", handle);
+ return(E_UNKNOWN);
+ }
+ }
+ else
+ {
+ auto handleData = std::make_shared<handleSetSourceNotificationConfiguration>(iter->second, sourceID, notificationConfiguration, mpDatabaseHandler);
handle = createHandle(handleData, H_SETSOURCENOTIFICATION);
}
- logInfo(__METHOD_NAME__,"sourceID=",sourceID,"notificationConfiguration.type=",notificationConfiguration.type,"notificationConfiguration.status",notificationConfiguration.status,"notificationConfiguration.parameter",notificationConfiguration.parameter);
- am_Error_e syncError(iter->second->asyncSetSourceNotificationConfiguration(handle, sourceID, notificationConfiguration));
- if (syncError)
- {
- removeHandle(handle);
- logError(__METHOD_NAME__,"Error while calling asyncSetSourceNotificationConfiguration sourceID:",sourceID,"handle:",handle);
- }
- return(syncError);
+ logInfo(__METHOD_NAME__, "sourceID=", sourceID, "notificationConfiguration.type=", notificationConfiguration.type, "notificationConfiguration.status", notificationConfiguration.status, "notificationConfiguration.parameter", notificationConfiguration.parameter);
+ am_Error_e syncError(iter->second->asyncSetSourceNotificationConfiguration(handle, sourceID, notificationConfiguration));
+ if (syncError)
+ {
+ removeHandle(handle);
+ logError(__METHOD_NAME__, "Error while calling asyncSetSourceNotificationConfiguration sourceID:", sourceID, "handle:", handle);
+ }
+
+ return(syncError);
}
void CAmRoutingSender::unloadLibraries(void)
{
- std::vector<void*>::iterator iterator = mListLibraryHandles.begin();
+ std::vector<void *>::iterator iterator = mListLibraryHandles.begin();
for (; iterator < mListLibraryHandles.end(); ++iterator)
{
dlclose(*iterator);
}
+
mListLibraryHandles.clear();
}
-am_Error_e CAmRoutingSender::getListPlugins(std::vector<std::string>& interfaces) const
+am_Error_e CAmRoutingSender::getListPlugins(std::vector<std::string> &interfaces) const
{
std::vector<InterfaceNamePairs>::const_iterator it = mListInterfaces.begin();
for (; it != mListInterfaces.end(); ++it)
{
interfaces.push_back(it->busName);
}
+
return (E_OK);
}
-void CAmRoutingSender::getInterfaceVersion(std::string & version) const
+void CAmRoutingSender::getInterfaceVersion(std::string &version) const
{
version = RoutingVersion;
}
-am_Error_e CAmRoutingSender::resyncConnectionState(const am_domainID_t domainID,std::vector<am_Connection_s>& listOfExistingConnections)
+
+am_Error_e CAmRoutingSender::resyncConnectionState(const am_domainID_t domainID, std::vector<am_Connection_s> &listOfExistingConnections)
{
DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
iter = mMapDomainInterface.find(domainID);
if (iter != mMapDomainInterface.end())
+ {
return (iter->second->resyncConnectionState(domainID, listOfExistingConnections));
+ }
+
return (E_NON_EXISTENT);
}
am_Error_e CAmRoutingSender::writeToDatabaseAndRemove(const am_Handle_s handle)
{
auto it(mlistActiveHandles.find(handle));
- if (it!=mlistActiveHandles.end())
+ if (it != mlistActiveHandles.end())
{
- am_Error_e error(it->second->writeDataToDatabase());
- mlistActiveHandles.erase(handle);
+ am_Error_e error(it->second->writeDataToDatabase());
+ mlistActiveHandles.erase(handle);
return (error);
}
- logError(__METHOD_NAME__,"could not find handle data for handle",handle);
- return (am_Error_e::E_NON_EXISTENT);
+
+ logError(__METHOD_NAME__, "could not find handle data for handle", handle);
+ return (am_Error_e::E_NON_EXISTENT);
}
void CAmRoutingSender::checkVolume(const am_Handle_s handle, const am_volume_t volume)
{
auto it(mlistActiveHandles.find(handle));
- if (it!=mlistActiveHandles.end())
+ if (it != mlistActiveHandles.end())
{
- handleVolumeBase* basePtr = static_cast<handleVolumeBase*>(it->second.get());
- if (basePtr->returnVolume()!=volume)
- {
- logError(__METHOD_NAME__,"volume returned for handle does not match: ",volume,"expected:",basePtr->returnVolume());
- }
- return;
+ handleVolumeBase *basePtr = static_cast<handleVolumeBase *>(it->second.get());
+ if (basePtr->returnVolume() != volume)
+ {
+ logError(__METHOD_NAME__, "volume returned for handle does not match: ", volume, "expected:", basePtr->returnVolume());
+ }
+
+ return;
}
- logError(__METHOD_NAME__,"could not find handle data for handle",handle);
+
+ logError(__METHOD_NAME__, "could not find handle data for handle", handle);
}
bool CAmRoutingSender::handleExists(const am_Handle_s handle)
{
auto iter(mlistActiveHandles.find(handle));
- if (iter!=mlistActiveHandles.end())
+ if (iter != mlistActiveHandles.end())
{
- return (true);
- }
- return (false);
+ return (true);
+ }
+
+ return (false);
}
am_Error_e CAmRoutingSender::handleSinkSoundProperty::writeDataToDatabase()
{
- return (mpDatabaseHandler->changeSinkSoundPropertyDB(mSoundProperty,mSinkID));
+ return (mpDatabaseHandler->changeSinkSoundPropertyDB(mSoundProperty, mSinkID));
}
am_Error_e CAmRoutingSender::handleSinkSoundProperties::writeDataToDatabase()
{
- std::vector<am_SoundProperty_s>::const_iterator it = mlistSoundProperties.begin();
- for (; it != mlistSoundProperties.end(); ++it)
- {
- mpDatabaseHandler->changeSinkSoundPropertyDB(*it, mSinkID);
- }
- return (am_Error_e::E_OK);
+ std::vector<am_SoundProperty_s>::const_iterator it = mlistSoundProperties.begin();
+ for (; it != mlistSoundProperties.end(); ++it)
+ {
+ mpDatabaseHandler->changeSinkSoundPropertyDB(*it, mSinkID);
+ }
+
+ return (am_Error_e::E_OK);
}
am_Error_e CAmRoutingSender::handleSourceSoundProperty::writeDataToDatabase()
{
- return (mpDatabaseHandler->changeSourceSoundPropertyDB(mSoundProperty,mSourceID));
+ return (mpDatabaseHandler->changeSourceSoundPropertyDB(mSoundProperty, mSourceID));
}
am_Error_e CAmRoutingSender::handleSourceSoundProperties::writeDataToDatabase()
{
- std::vector<am_SoundProperty_s>::const_iterator it = mlistSoundProperties.begin();
- for (; it != mlistSoundProperties.end(); ++it)
- {
- mpDatabaseHandler->changeSourceSoundPropertyDB(*it, mSourceID);
- }
- return (am_Error_e::E_OK);
+ std::vector<am_SoundProperty_s>::const_iterator it = mlistSoundProperties.begin();
+ for (; it != mlistSoundProperties.end(); ++it)
+ {
+ mpDatabaseHandler->changeSourceSoundPropertyDB(*it, mSourceID);
+ }
+
+ return (am_Error_e::E_OK);
}
am_Error_e CAmRoutingSender::handleSourceState::writeDataToDatabase()
{
- return (mpDatabaseHandler->changeSourceState(mSourceID,mSourceState));
+ return (mpDatabaseHandler->changeSourceState(mSourceID, mSourceState));
}
am_Error_e CAmRoutingSender::handleSourceVolume::writeDataToDatabase()
{
- return (mpDatabaseHandler->changeSourceVolume(mSourceID,returnVolume()));
+ return (mpDatabaseHandler->changeSourceVolume(mSourceID, returnVolume()));
}
am_Error_e CAmRoutingSender::handleSinkVolume::writeDataToDatabase()
{
- return (mpDatabaseHandler->changeSinkVolume(mSinkID,returnVolume()));
+ return (mpDatabaseHandler->changeSinkVolume(mSinkID, returnVolume()));
}
am_Error_e CAmRoutingSender::handleCrossFader::writeDataToDatabase()
{
- return (mpDatabaseHandler->changeCrossFaderHotSink(mCrossfaderID, mHotSink));
+ return (mpDatabaseHandler->changeCrossFaderHotSink(mCrossfaderID, mHotSink));
}
am_Error_e CAmRoutingSender::handleConnect::writeDataToDatabase()
{
- mConnectionPending = false;
- return (mpDatabaseHandler->changeConnectionFinal(mConnectionID));
+ mConnectionPending = false;
+ return (mpDatabaseHandler->changeConnectionFinal(mConnectionID));
}
am_Error_e CAmRoutingSender::handleDisconnect::writeDataToDatabase()
{
- return E_OK;
+ return E_OK;
}
am_Error_e CAmRoutingSender::handleSetVolumes::writeDataToDatabase()
{
- std::vector<am_Volumes_s>::const_iterator iterator (mlistVolumes.begin());
-
- for (;iterator!=mlistVolumes.end();++iterator)
- {
- if (iterator->volumeType==VT_SINK)
- {
- return (mpDatabaseHandler->changeSinkVolume(iterator->volumeID.sink,iterator->volume));
- }
- else if (iterator->volumeType==VT_SOURCE)
- {
- return (mpDatabaseHandler->changeSourceVolume(iterator->volumeID.source,iterator->volume));
- }
- }
- return (am_Error_e::E_WRONG_FORMAT);
+ std::vector<am_Volumes_s>::const_iterator iterator(mlistVolumes.begin());
+
+ for (; iterator != mlistVolumes.end(); ++iterator)
+ {
+ if (iterator->volumeType == VT_SINK)
+ {
+ return (mpDatabaseHandler->changeSinkVolume(iterator->volumeID.sink, iterator->volume));
+ }
+ else if (iterator->volumeType == VT_SOURCE)
+ {
+ return (mpDatabaseHandler->changeSourceVolume(iterator->volumeID.source, iterator->volume));
+ }
+ }
+
+ return (am_Error_e::E_WRONG_FORMAT);
}
am_Error_e CAmRoutingSender::handleSetSinkNotificationConfiguration::writeDataToDatabase()
{
- return (mpDatabaseHandler->changeSinkNotificationConfigurationDB(mSinkID,mNotificationConfiguration));
+ return (mpDatabaseHandler->changeSinkNotificationConfigurationDB(mSinkID, mNotificationConfiguration));
}
am_Error_e CAmRoutingSender::handleSetSourceNotificationConfiguration::writeDataToDatabase()
{
- return (mpDatabaseHandler->changeSourceNotificationConfigurationDB(mSourceID,mNotificationConfiguration));
+ return (mpDatabaseHandler->changeSourceNotificationConfigurationDB(mSourceID, mNotificationConfiguration));
}
am_Error_e CAmRoutingSender::removeConnectionLookup(const am_connectionID_t connectionID)
@@ -1181,21 +1235,21 @@ am_Error_e CAmRoutingSender::removeConnectionLookup(const am_connectionID_t conn
mMapConnectionInterface.erase(iter);
return (E_OK);
}
+
return (E_UNKNOWN);
}
CAmRoutingSender::handleConnect::~handleConnect()
{
- if (mConnectionPending)
- {
- mpDatabaseHandler->removeConnection(mConnectionID);
- }
+ if (mConnectionPending)
+ {
+ mpDatabaseHandler->removeConnection(mConnectionID);
+ }
}
CAmRoutingSender::handleDisconnect::~handleDisconnect()
{
- mpDatabaseHandler->removeConnection(mConnectionID);
+ mpDatabaseHandler->removeConnection(mConnectionID);
}
}
-
View Lorry Controller Status