AudioManagerDaemon/src/Router.cpp

   1 /**
   2  * Copyright (C) 2011, BMW AG
   3  *
   4  * GeniviAudioMananger AudioManagerDaemon
   5  *
   6  * \file Router.cpp
   7  *
   8  * \date 20-Oct-2011 3:42:04 PM
   9  * \author Christian Mueller (christian.ei.mueller@bmw.de)
  10  *
  11  * \section License
  12  * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
  13  * Copyright (C) 2011, BMW AG Christian Mueller  Christian.ei.mueller@bmw.de
  14  *
  15  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
  16  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License, version 2.1, for more details.
  17  * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
  18  * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
  19  * Linking AudioManager statically or dynamically with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
  20  * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
  21  * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
  22  *
  23  */
  24
  25 #include "Router.h"
  26 #include "DatabaseHandler.h"
  27 #include "ControlSender.h"
  28 #include <assert.h>
  29 #include <algorithm>
  30 #include <vector>
  31 #include <iterator>
  32
  33 using namespace am;
  34
  35 Router::Router(DatabaseHandler* iDatabaseHandler, ControlSender* iSender) :
  36         mDatabaseHandler(iDatabaseHandler), //
  37         mControlSender(iSender)
  38 {
  39     assert(mDatabaseHandler);
  40     assert(mControlSender);
  41 }
  42
  43 am_Error_e Router::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
  44 {
  45     //first find out in which domains the source and sink are
  46     am_domainID_t sourceDomainID;
  47     am_domainID_t sinkDomainID;
  48     if (mDatabaseHandler->getDomainOfSource(sourceID, sourceDomainID) != E_OK)
  49         return (E_NON_EXISTENT);
  50     if (mDatabaseHandler->getDomainOfSink(sinkID, sinkDomainID) != E_OK)
  51         return (E_NON_EXISTENT);
  52
  53     RoutingTree routingtree(sourceDomainID); //Build up a Tree from the Source_Domain to every other domain.
  54     std::vector<RoutingTreeItem*> flattree; //This list is the flat tree
  55     std::vector<RoutingTreeItem*> matchtree;
  56     std::vector<am_gatewayID_t> listGatewayID; //holds all gateway ids of the route
  57     am_RoutingElement_s routingElement;
  58     std::vector<am_RoutingElement_s> actualRoutingElement; //intermediate list of current routing pairs
  59     am_Route_s actualRoute; //holds the actual Route
  60     am_sourceID_t lastSource = 0;
  61
  62     //TODO: kind of unclean. The separation between database and router could be better.
  63     mDatabaseHandler->getRoutingTree(onlyfree, routingtree, flattree); //Build up the tree out of the database as
  64
  65     //we go through the returned flattree and look for our sink, after that flattree holds only treeItems that match
  66     std::vector<RoutingTreeItem*>::iterator iterator = flattree.begin();
  67     for (; iterator != flattree.end(); ++iterator)
  68     {
  69         if ((*iterator)->returnDomainID() == sinkDomainID)
  70         {
  71             matchtree.push_back(*iterator);
  72         }
  73     }
  74
  75     //No we need to trace back the routes for each entry in matchtree
  76     iterator = matchtree.begin();
  77     for (; iterator != matchtree.end(); ++iterator)
  78     {
  79         //getting the route for the actual item
  80         routingtree.getRoute(*iterator, listGatewayID); //This gives only the Gateway IDs we need more
  81
  82         //go throught the gatewayids and get more information
  83         std::vector<am_gatewayID_t>::iterator gatewayIterator = listGatewayID.begin();
  84         for (; gatewayIterator != listGatewayID.end(); ++gatewayIterator)
  85         {
  86             am_Gateway_s gatewayData;
  87             if (mDatabaseHandler->getGatewayInfoDB(*gatewayIterator, gatewayData) != E_OK)
  88                 return (E_UNKNOWN);
  89
  90             //at the beginning of the route, we connect first the source to the first gateway
  91             if (gatewayIterator == listGatewayID.begin())
  92             {
  93                 routingElement.sourceID = sourceID;
  94                 routingElement.domainID = sourceDomainID;
  95             }
  96             else
  97             {
  98                 routingElement.sourceID = lastSource;
  99                 routingElement.domainID = gatewayData.domainSinkID;
 100             }
 101             routingElement.sinkID = gatewayData.sinkID;
 102             actualRoutingElement.push_back(routingElement);
 103             lastSource = gatewayData.sourceID;
 104         }
 105         //at the end of the route, connect to the sink !
 106         routingElement.sourceID = lastSource;
 107         routingElement.sinkID = sinkID;
 108         routingElement.domainID = sinkDomainID;
 109         actualRoutingElement.push_back(routingElement);
 110
 111         //So now we got the route, what is missing are the connectionFormats...
 112
 113         //Step through the routes and try to use always the best connectionFormat
 114         std::vector<am_RoutingElement_s>::iterator routingInterator = actualRoutingElement.begin();
 115         gatewayIterator = listGatewayID.begin();
 116         if (findBestWay(actualRoutingElement, routingInterator, gatewayIterator) != E_OK)
 117         {
 118             continue;
 119         }
 120
 121         //add the route to the list of routes...
 122         actualRoute.sourceID = sourceID;
 123         actualRoute.sinkID = sinkID;
 124         actualRoute.route = actualRoutingElement;
 125         returnList.push_back(actualRoute);
 126     }
 127     return (E_OK);
 128 }
 129
 130 void Router::listPossibleConnectionFormats(const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e>& listFormats) const
 131 {
 132     std::vector<am_ConnectionFormat_e> listSourceFormats;
 133     std::vector<am_ConnectionFormat_e> listSinkFormats;
 134     mDatabaseHandler->getListSinkConnectionFormats(sinkID, listSinkFormats);
 135     mDatabaseHandler->getListSourceConnectionFormats(sourceID, listSourceFormats);
 136     std::insert_iterator<std::vector<am_ConnectionFormat_e> > inserter(listFormats, listFormats.begin());
 137     set_intersection(listSourceFormats.begin(), listSourceFormats.end(), listSinkFormats.begin(), listSinkFormats.end(), inserter);
 138     std::vector<am_ConnectionFormat_e>::iterator it = listSourceFormats.begin();
 139 }
 140
 141 am_Error_e Router::findBestWay(std::vector<am_RoutingElement_s> & listRoute, std::vector<am_RoutingElement_s>::iterator routeIterator, std::vector<am_gatewayID_t>::iterator gatewayIterator)
 142 {
 143     am_Error_e returnError = E_NOT_POSSIBLE;
 144     std::vector<am_ConnectionFormat_e> listConnectionFormats;
 145     std::vector<am_ConnectionFormat_e> listMergeConnectionFormats;
 146     std::vector<am_ConnectionFormat_e> listPriorityConnectionFormats;
 147     std::vector<am_RoutingElement_s>::iterator nextIterator = routeIterator + 1;
 148     //get best connection format
 149     listPossibleConnectionFormats(routeIterator->sourceID, routeIterator->sinkID, listConnectionFormats);
 150
 151     //if we have not just started, we need to take care about the gateways...
 152     if (routeIterator != listRoute.begin())
 153     {
 154         //since we have to deal with Gateways, there are restrictions what connectionFormat we can take. So we need to take the subset of connections that are restricted:
 155         std::vector<am_ConnectionFormat_e> listRestrictedConnectionFormats;
 156         std::insert_iterator<std::vector<am_ConnectionFormat_e> > inserter(listMergeConnectionFormats, listMergeConnectionFormats.begin());
 157         std::vector<am_RoutingElement_s>::iterator tempIterator(routeIterator);
 158         tempIterator--;
 159         listRestrictedOutputFormatsGateways(*gatewayIterator, (tempIterator)->connectionFormat, listRestrictedConnectionFormats);
 160         set_intersection(listConnectionFormats.begin(), listConnectionFormats.end(), listRestrictedConnectionFormats.begin(), listRestrictedConnectionFormats.end(), inserter);
 161         gatewayIterator++;
 162     }
 163     else
 164     {
 165         listMergeConnectionFormats = listConnectionFormats;
 166     }
 167
 168     //let the controller decide:
 169     mControlSender->getConnectionFormatChoice(routeIterator->sourceID, routeIterator->sinkID, listMergeConnectionFormats, listPriorityConnectionFormats);
 170
 171     //we have the list sorted after prios - now we try one after the other with the next part of the route
 172     std::vector<am_ConnectionFormat_e>::iterator connectionFormatIterator = listPriorityConnectionFormats.begin();
 173
 174     //here we need to check if we are at the end and stop
 175     if (nextIterator == listRoute.end())
 176     {
 177         if (!listPriorityConnectionFormats.empty())
 178         {
 179             routeIterator->connectionFormat = listPriorityConnectionFormats.front();
 180             return E_OK;
 181         }
 182         else
 183             return E_NOT_POSSIBLE;
 184     }
 185
 186     for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator)
 187     {
 188         routeIterator->connectionFormat = *connectionFormatIterator;
 189         if ((returnError = findBestWay(listRoute, nextIterator, gatewayIterator)) == E_OK)
 190         {
 191             break;
 192         }
 193     }
 194
 195     return (returnError);
 196 }
 197
 198 void Router::listRestrictedOutputFormatsGateways(const am_gatewayID_t gatewayID, const am_ConnectionFormat_e sinkConnectionFormat, std::vector<am_ConnectionFormat_e> & listFormats) const
 199 {
 200     listFormats.clear();
 201     am_Gateway_s gatewayData;
 202     mDatabaseHandler->getGatewayInfoDB(gatewayID, gatewayData);
 203     std::vector<am_ConnectionFormat_e>::const_iterator rowSinkIterator = gatewayData.listSinkFormats.begin();
 204     std::vector<bool>::const_iterator matrixIterator = gatewayData.convertionMatrix.begin();
 205
 206     //find the row number of the sink
 207     rowSinkIterator = find(gatewayData.listSinkFormats.begin(), gatewayData.listSinkFormats.end(), sinkConnectionFormat);
 208     int rowNumberSink = rowSinkIterator - gatewayData.listSinkFormats.begin();
 209
 210     //go through the convertionMatrix and find out if the conversion is possible, if yes, add connectionFormat ...
 211     matrixIterator + rowNumberSink;
 212
 213     //iterate line-wise through the matrix and add more formats
 214     do
 215     {
 216         if (*matrixIterator)
 217         {
 218             listFormats.push_back(gatewayData.listSourceFormats.at(matrixIterator - gatewayData.convertionMatrix.begin()));
 219         }
 220         matrixIterator += gatewayData.listSinkFormats.size();
 221     } while (matrixIterator - gatewayData.convertionMatrix.begin() < (int) gatewayData.listSourceFormats.size());
 222 }
 223
 224 Router::~Router()
 225 {
 226 }
 227
 228 RoutingTreeItem::RoutingTreeItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent) :
 229         mDomainID(domainID), //
 230         mGatewayID(gatewayID), //
 231         mParentItem(parent)
 232 {
 233     assert(mDomainID!=0);
 234 }
 235
 236 void RoutingTreeItem::appendChild(RoutingTreeItem *newChild)
 237 {
 238     assert(newChild);
 239     mListChildItems.push_back(newChild);
 240 }
 241
 242 void RoutingTreeItem::returnChildItems(std::vector<RoutingTreeItem*> listChildItems)
 243 {
 244     listChildItems = mListChildItems;
 245 }
 246
 247 am_domainID_t RoutingTreeItem::returnDomainID() const
 248 {
 249     return (mDomainID);
 250 }
 251
 252 am_gatewayID_t RoutingTreeItem::returnGatewayID() const
 253 {
 254     return (mGatewayID);
 255 }
 256
 257 RoutingTreeItem* RoutingTreeItem::returnParent() const
 258 {
 259     return (mParentItem);
 260 }
 261
 262 RoutingTreeItem::~RoutingTreeItem()
 263 {
 264 }
 265
 266 RoutingTree::RoutingTree(const am_domainID_t rootDomainID) :
 267         mRootItem(RoutingTreeItem(rootDomainID))
 268 {
 269     assert(rootDomainID!=0);
 270 }
 271
 272 RoutingTreeItem *RoutingTree::insertItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent)
 273 {
 274     RoutingTreeItem *newTree = new RoutingTreeItem(domainID, gatewayID, parent);
 275     parent->appendChild(newTree);
 276     mListChild.push_back(newTree);
 277     return newTree;
 278 }
 279
 280 void RoutingTree::getRoute(RoutingTreeItem *targetItem, std::vector<am_gatewayID_t>& listGateways)
 281 {
 282     listGateways.clear();
 283     RoutingTreeItem *parentItem = targetItem;
 284     while (parentItem != &mRootItem)
 285     {
 286         listGateways.push_back(parentItem->returnGatewayID());
 287         parentItem = parentItem->returnParent();
 288     }
 289     std::reverse(listGateways.begin(), listGateways.end());
 290 }
 291
 292 am_domainID_t RoutingTree::returnRootDomainID() const
 293 {
 294     return (mRootItem.returnDomainID());
 295 }
 296
 297 RoutingTreeItem *RoutingTree::returnRootItem()
 298 {
 299     return (&mRootItem);
 300 }
 301
 302 RoutingTree::~RoutingTree()
 303 {
 304     std::vector<RoutingTreeItem*>::iterator it = mListChild.begin();
 305     for (; it != mListChild.end(); ++it)
 306     {
 307         delete *it;
 308     }
 309 }
 310