mipcomponentchain.h

Go to the documentation of this file.

/*
    
  This file is a part of EMIPLIB, the EDM Media over IP Library.
  
  Copyright (C) 2006-2011  Hasselt University - Expertise Centre for
                      Digital Media (EDM) (http://www.edm.uhasselt.be)

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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 for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  
  USA

*/

#ifndef MIPCOMPONENTCHAIN_H

#define MIPCOMPONENTCHAIN_H

#include "mipconfig.h"
#include "miperrorbase.h"
#include "mipmessage.h"
#include <jthread/jthread.h>
#include <string>
#include <list>

class MIPComponent;

class EMIPLIB_IMPORTEXPORT MIPComponentChain : private jthread::JThread, public MIPErrorBase
{
public:
        MIPComponentChain(const std::string &chainName);
        virtual ~MIPComponentChain();

        bool start();

        bool stop();

        bool clearChain();

        bool setChainStart(MIPComponent *pStartComponent);

        bool addConnection(MIPComponent *pPullComponent, MIPComponent *pPushCompontent, bool feedback = false,
                          uint32_t allowedMessageTypes = MIPMESSAGE_TYPE_ALL, 
                          uint32_t allowedSubmessageTypes = MIPMESSAGE_TYPE_ALL);

        bool deleteConnection(MIPComponent *pPullComponent, MIPComponent *pPushCompontent, bool feedback = false,
                          uint32_t allowedMessageTypes = MIPMESSAGE_TYPE_ALL, 
                          uint32_t allowedSubmessageTypes = MIPMESSAGE_TYPE_ALL);

        std::string getName() const                                                                     { return m_chainName; }
        
        bool rebuild();
protected:
        virtual void onThreadExit(bool error, const std::string &errorComponent,
                                  const std::string &errorDescription)                                  { }
private:
        class MIPConnection
        {
        public:
                MIPConnection(MIPComponent *pPull, MIPComponent *pPush, bool feedback, uint32_t mask1,
                              uint32_t mask2)                                                           { m_mask1 = mask1; m_mask2 = mask2; m_pPull = pPull; m_pPush = pPush; m_marked = false; m_feedback = feedback; }
                MIPComponent *getPullComponent() const                                                  { return m_pPull; }
                MIPComponent *getPushComponent() const                                                  { return m_pPush; }
                bool isMarked() const                                                                   { return m_marked; }
                void setMark(bool v)                                                                    { m_marked = v; }
                uint32_t getMask1() const                                                               { return m_mask1; }
                uint32_t getMask2() const                                                               { return m_mask2; }
                bool giveFeedback() const                                                               { return m_feedback; }
                bool operator==(const MIPConnection &c) const                                           { if (m_pPull == c.m_pPull && m_pPush == c.m_pPush && m_mask1 == c.m_mask1 && m_mask2 == c.m_mask2 && m_feedback == c.m_feedback) return true; return false; }
        private:
                MIPComponent *m_pPull, *m_pPush;
                uint32_t m_mask1;
                uint32_t m_mask2;
                bool m_marked;
                bool m_feedback;
        };

        void *Thread();
        bool orderConnections(std::list<MIPConnection> &orderedConnections);
        bool buildFeedbackList(std::list<MIPConnection> &orderedList, std::list<MIPComponent *> &feedbackChain);
        void copyConnectionInfo(const std::list<MIPConnection> &orderedList, const std::list<MIPComponent *> &feedbackChain);
        
        std::string m_chainName;
        std::list<MIPConnection> m_inputConnections;
        std::list<MIPConnection> m_orderedConnections;
        std::list<MIPComponent *> m_feedbackChain;
        MIPComponent *m_pInputChainStart;       
        MIPComponent *m_pInternalChainStart;

        jthread::JMutex m_loopMutex;
        jthread::JMutex m_chainMutex;
        bool m_stopLoop;
};

#endif // MIPCOMPONENTCHAIN_H