CAmRouter.h

Go to the documentation of this file.

#ifndef ROUTER_H_
#define ROUTER_H_

#include <assert.h>
#include <vector>
#include <iomanip>
#include <functional>
#include "audiomanagertypes.h"
#include "CAmGraph.h"
#include "CAmDatabaseHandlerMap.h"

namespace am
{

#undef TRACE_GRAPH

#ifndef MAX_ROUTING_PATHS
#define MAX_ROUTING_PATHS 5
#endif

#ifndef MAX_ALLOWED_DOMAIN_CYCLES
#define MAX_ALLOWED_DOMAIN_CYCLES 1
#endif

    class CAmRouter;

    struct am_RoutingNodeData_s
    {
        typedef enum
            :int
            {   SINK, SOURCE, GATEWAY, CONVERTER
        } am_NodeDataType_e;
        am_NodeDataType_e type;                                     
        union
        {
            am_Source_s *source;
            am_Sink_s *sink;
            am_Gateway_s *gateway;
            am_Converter_s *converter;
        } data;                                                 

        am_RoutingNodeData_s() :
                type(SINK)
        {
        }

        bool operator==(const am_RoutingNodeData_s & anotherObject) const
        {
            bool result = false;
            if (type == anotherObject.type)
            {
                result = true;
                if (type == SINK)
                    result &= (data.sink->sinkID == anotherObject.data.sink->sinkID);
                else if (type == SOURCE)
                    result &= (data.source->sourceID == anotherObject.data.source->sourceID);
                else if (type == GATEWAY)
                    result &= (data.gateway->gatewayID == anotherObject.data.gateway->gatewayID);
                else if (type == CONVERTER)
                    result &= (data.converter->converterID == anotherObject.data.converter->converterID);
            }
            return result;
        }
        ;

#ifdef TRACE_GRAPH
#define COUT_NODE(HEAD, NAME, ID) \
    std::cout << HEAD << "(" << std::setfill('0') << std::setw(4) << ID << " " << NAME << ")";

        void trace() const
        {
            if(type==SINK)
            COUT_NODE("SI", data.sink->name, data.sink->sinkID )
            else if(type==SOURCE)
            COUT_NODE("SO", data.source->name, data.source->sourceID )
            else if(type==GATEWAY)
            COUT_NODE("GA", data.gateway->name, data.gateway->gatewayID )
            else if(type==CONVERTER)
            COUT_NODE("CO", data.converter->name, data.converter->converterID )
        };
#endif

        am_domainID_t domainID() const
        {
            if (type == SINK)
                return data.sink->domainID;
            else if (type == SOURCE)
                return data.source->domainID;
            else if (type == GATEWAY)
                return data.gateway->controlDomainID;
            else if (type == CONVERTER)
                return data.converter->domainID;
            return 0;
        }
        ;
    };

    typedef am_RoutingNodeData_s::am_NodeDataType_e CAmNodeDataType;
    typedef CAmNode<am_RoutingNodeData_s> CAmRoutingNode;
    typedef CAmGraph<am_RoutingNodeData_s, uint16_t> CAmRoutingGraph;
    typedef CAmVertex<am_RoutingNodeData_s, uint16_t> CAmRoutingVertex;
    typedef std::list<CAmRoutingVertex> CAmRoutingListVertices;
    typedef std::vector<CAmRoutingListVertices*> CAmRoutingVertexReferenceList;

    class CAmControlSender;

    class CAmRouter: public CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks
    {
        IAmDatabaseHandler* mpDatabaseHandler;                                      
        CAmControlSender* mpControlSender;                                          
        bool mUpdateGraphNodesAction;                                               
        unsigned mMaxAllowedCycles;                                                 
        unsigned mMaxPathCount;                                                     
        CAmRoutingGraph mRoutingGraph;                                              
        std::map<am_domainID_t, std::vector<CAmRoutingNode*>> mNodeListSources;     
        std::map<am_domainID_t, std::vector<CAmRoutingNode*>> mNodeListSinks;       
        std::map<am_domainID_t, std::vector<CAmRoutingNode*>> mNodeListGateways;    
        std::map<am_domainID_t, std::vector<CAmRoutingNode*>> mNodeListConverters;  

        template<class Component> bool isComponentConnected(const Component & comp)
        {
            return mpDatabaseHandler->isComponentConnected(comp);
        }

        void constructConverterConnections();

        void constructGatewayConnections();

        void constructSourceSinkConnections();

        void getVerticesForNode(const CAmRoutingNode & node, CAmRoutingListVertices & list);

        void getVerticesForSource(const CAmRoutingNode & node, CAmRoutingListVertices & list);

        void getVerticesForSink(const CAmRoutingNode & node, CAmRoutingListVertices & list);

        void getVerticesForConverter(const CAmRoutingNode & node, CAmRoutingListVertices & list);

        void getVerticesForGateway(const CAmRoutingNode & node, CAmRoutingListVertices & list);

        am_Error_e determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector<CAmRoutingNode*> & nodes, std::vector<am_Route_s> & result);
        am_Error_e doConnectionFormatsForPath(am_Route_s & routeObjects, std::vector<CAmRoutingNode*> & route,
                std::vector<am_RoutingElement_s>::iterator routingElementIterator, std::vector<CAmRoutingNode*>::iterator routeIterator,
                std::vector<am_Route_s> & result);
        am_Error_e cfPermutationsForPath(am_Route_s shortestRoute, std::vector<CAmRoutingNode*> resultNodesPath, std::vector<am_Route_s>& resultPath);

        static int insertPostion(const std::vector<CAmRoutingNode*>& path, const std::vector<std::vector<CAmRoutingNode*> >& nodes);

    public:
        CAmRouter(IAmDatabaseHandler* iDatabaseHandler, CAmControlSender* iSender);
        ~CAmRouter();

        unsigned getMaxAllowedCycles()
        {
            return mMaxAllowedCycles;
        }
        void setMaxAllowedCycles(unsigned count)
        {
            mMaxAllowedCycles = count;
        }

        unsigned getMaxPathCount()
        {
            return mMaxPathCount;
        }
        void setMaxPathCount(unsigned count)
        {
            mMaxPathCount = count;
        }

        bool getUpdateGraphNodesAction()
        {
            return mUpdateGraphNodesAction;
        }

        am_Error_e getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList);
        am_Error_e getRoute(const bool onlyfree, const am_Source_s & source, const am_Sink_s & sink, std::vector<am_Route_s> & listRoutes);

        am_Error_e getRouteFromLoadedNodes(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList);
        am_Error_e getRouteFromLoadedNodes(const bool onlyfree, const am_Source_s & aSource, const am_Sink_s & aSink, std::vector<am_Route_s> & listRoutes);

        am_Error_e getFirstNShortestPaths(const bool onlyfree, const unsigned cycles, const unsigned maxPathCount, CAmRoutingNode & source,
                CAmRoutingNode & sink, std::vector<am_Route_s> & resultPath);

        am_Error_e getShortestPath(CAmRoutingNode & source, CAmRoutingNode & sink, std::vector<am_Route_s> & resultPath);

        static bool 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);
        static void listPossibleConnectionFormats(std::vector<am_CustomConnectionFormat_t> & inListSourceFormats,
                std::vector<am_CustomConnectionFormat_t> & inListSinkFormats, std::vector<am_CustomConnectionFormat_t> & outListFormats);
        static bool 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);
        static am_Error_e getSourceSinkPossibleConnectionFormats(std::vector<CAmRoutingNode*>::iterator iteratorSource,
                std::vector<CAmRoutingNode*>::iterator iteratorSink, std::vector<am_CustomConnectionFormat_t> & outConnectionFormats);

        static bool shouldGoInDomain(const std::vector<am_domainID_t> & visitedDomains, const am_domainID_t nodeDomainID, const unsigned maxCyclesNumber);
        bool shouldGoInDomain(const std::vector<am_domainID_t> & visitedDomains, const am_domainID_t nodeDomainID);
        CAmRoutingNode* sinkNodeWithID(const am_sinkID_t sinkID);
        CAmRoutingNode* sinkNodeWithID(const am_sinkID_t sinkID, const am_domainID_t domainID);

        CAmRoutingNode* sourceNodeWithID(const am_sourceID_t sourceID);
        CAmRoutingNode* sourceNodeWithID(const am_sourceID_t sourceID, const am_domainID_t domainID);

        CAmRoutingNode* converterNodeWithSinkID(const am_sinkID_t sinkID, const am_domainID_t domainID);

        CAmRoutingNode* gatewayNodeWithSinkID(const am_sinkID_t sinkID);

        void load();
        void clear();

    public:
        am_Error_e getAllPaths(CAmRoutingNode & aSource, CAmRoutingNode & aSink, std::vector<am_Route_s> & resultPath,
                std::vector<std::vector<CAmRoutingNode*>> & resultNodesPath, const bool includeCycles = false,
                const bool onlyFree = false)
                        __attribute__((deprecated("You should use am_Error_e getFirstNShortestPaths(const bool onlyFree, CAmRoutingNode &, CAmRoutingNode &, std::vector<am_Route_s> &) instead!")));
    };
} /* namespace am */
#endif /* ROUTER_H_ */