CAmRouter.h

Go to the documentation of this file.

#ifndef ROUTER_H_
#define ROUTER_H_

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


namespace am
{
#define ROUTING_BUILD_CONNECTIONS 1

#if !defined(ROUTING_BUILD_CONNECTIONS)
    #undef TRACE_GRAPH
#endif

#if !defined(ROUTING_BUILD_CONNECTIONS)
    #undef ROUTING_BUILD_CONNECTIONS
#endif

#if defined(TRACE_GRAPH)
#if !defined(ROUTING_BUILD_CONNECTIONS)
#warning "You should define ROUTING_BUILD_CONNECTIONS in order to be able to see the connections in the trace."
#endif
#endif

class CAmRouter;

struct am_RoutingNodeData_s
{
    typedef enum:uint8_t {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
    void trace() const
    {
        if(type==SINK)
            std::cout << "[SINK:" << data.sink->sinkID << ":" << data.sink->name << "(" << data.sink->domainID << ")"
            << "]";
        else if(type==SOURCE)
            std::cout << "[SOUR:" << data.source->sourceID << ":" << data.source->name << "(" << data.source->domainID << ")"
            << "]";
        else if(type==GATEWAY)
            std::cout << "[GATE:" << data.gateway->gatewayID << ":" << data.gateway->name << "(" << data.gateway->controlDomainID << ")"
            << "]";
        else if(type==CONVERTER)
            std::cout << "[CONV:" << data.converter->converterID << ":" << data.converter->name << "(" << data.converter->domainID << ")"
            << "]";
    };
#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
{
    IAmDatabaseHandler* mpDatabaseHandler;                          
    CAmControlSender* mpControlSender;                              
    bool mOnlyFreeConversionNodes;                                  
    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;

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


    template <class Component> bool isComponentConnected(const Component & comp)
    {
        return mpDatabaseHandler->isComponentConnected(comp);
    }
    void generateAllPaths(const CAmRoutingNode & src,
            const CAmRoutingNode & dst,
            const bool includeCycles,
            std::function<void(const std::vector<CAmRoutingNode*> & path)> cb);
    void goThroughAllPaths(const CAmRoutingNode & dst,
            std::vector<CAmRoutingNode*> & visited,
            std::vector<am_domainID_t> & visitedDomains,
            std::function<void(const std::vector<CAmRoutingNode*> & path)> cb);

#ifdef ROUTING_BUILD_CONNECTIONS

    void constructConverterConnections();

    void constructGatewayConnections();

    void constructSourceSinkConnections();
#else

    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);
#endif

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

    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 & aSource, const am_Sink_s & aSink, std::vector<am_Route_s> & listRoutes);

    am_Error_e getAllPaths(CAmRoutingNode & aSource, CAmRoutingNode & aSink,
            std::vector<am_Route_s> & resultPath, std::vector<std::vector<CAmRoutingNode*>> & resultNodesPath,
#if !defined(ROUTING_BUILD_CONNECTIONS)
            __attribute__((unused))
#endif
            const bool includeCycles = false);
#ifdef ROUTING_BUILD_CONNECTIONS
    void getShortestPath(const CAmRoutingNode & source, const CAmRoutingNode & destination, std::vector<CAmRoutingNode*> & resultPath);
    void getShortestPath(CAmRoutingNode & aSource, CAmRoutingNode & aSink, am_Route_s & resultPath, std::vector<CAmRoutingNode*> & resultNodesPath);
#endif

    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 void 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);

    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(const bool onlyFree);
    void clear();
};
} /* namespace am */
#endif /* ROUTER_H_ */