FsfNode.h

Go to the documentation of this file.

/*
  FSF: Flow Scheduling Framework library

  Version 1.0 Copyright (C) 2010 Alexandre R.J. Francois

  Previous versions Copyright (C) 2001-2005 University of Southern California

  Author: Alexandre R.J. Francois - alexandrefrancois@yahoo.com
  www.alexandrefrancois.org

  Modular Flow Scheduling Middleware
  mfsm.sourceForge.net

  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef FSF_NODE_H
#define FSF_NODE_H

#include "Fsf.h"

#include <string>
#include <list>


namespace fsf{
    
    


    class CPulse;
    template <class T> class CPassiveFilter;
    class CPassiveHandle;
        

    class CNode{
    private:
        CNode *m_pParent; 
        // Local data
        Time m_tTime; 
        Time m_tDuration; 
        
        CMutex m_csName; 
        std::string m_strName; 
                
        bool m_bNotDeleted; 
        bool m_bNoDelete; 

        // reference counting using mutex
        CMutex m_csHandleRefs; 
        long m_nNbHandleRefs; 
 
        CMutex m_csComponents; 
        std::list<CNode*> m_listComponents; 
        

        bool wildcardMatch(const std::string &strWildcard, const std::string &strTest) const;
        bool wildcardMatch(const char *wildcard, const char *test) const;
        bool set (const char **wildcard, const char **test) const;
        bool star (const char **wildcard, const char **test) const;

    protected:
        std::list<CNode*> &getListComponents() { return m_listComponents; }

    public:



        CNode()
            : m_pParent(NULL), m_tTime(0), m_tDuration(0),
            m_bNotDeleted(true), m_bNoDelete(false), m_nNbHandleRefs(0) {}
        CNode(CNode *pParent, Time tTime=0)
            : m_pParent(pParent), m_tTime(tTime), m_tDuration(0),
            m_bNotDeleted(true), m_bNoDelete(false), m_nNbHandleRefs(0) {}
        CNode(const std::string &strName, CNode *pParent=NULL, Time tTime=0)
            : m_pParent(pParent), m_tTime(tTime), m_tDuration(0),
            m_strName(strName), m_bNotDeleted(true), m_bNoDelete(false), m_nNbHandleRefs(0) {}
        CNode(const CNode& rhs)
            : m_pParent(NULL), m_tTime(rhs.m_tTime), m_tDuration(rhs.m_tDuration),
            m_strName(rhs.m_strName), m_bNotDeleted(rhs.m_bNotDeleted), m_bNoDelete(rhs.m_bNoDelete),
            m_nNbHandleRefs(0) {}
        virtual ~CNode();
        virtual CNode *clone() const { return new CNode(*this); }



        CNode& operator=(const CNode& rhs){
            m_tTime=rhs.m_tTime;
            m_tDuration=rhs.m_tDuration;
            m_strName=rhs.m_strName;
            m_bNotDeleted=rhs.m_bNotDeleted;
            m_bNoDelete=rhs.m_bNoDelete;
            m_nNbHandleRefs=0; return *this;
        }

        void setTime(Time tTime) { m_tTime=tTime; }
        void setDuration(Time tDuration) { m_tDuration=tDuration; }
        void setName(const std::string &strName){
            m_csName.lock();
            m_strName.assign(strName);
            m_csName.unlock();
        }
        void setParent(CNode *pParent) { m_pParent=pParent; }
        void setDeleted() { m_bNotDeleted=false; }
        void setNoDelete(bool bNoDelete=true) { m_bNoDelete=bNoDelete; }

        virtual bool deleteNode(bool bForce=false);

        virtual void addComponent(CNode *pNode){
            m_csComponents.lock();
            m_listComponents.push_front(pNode);
            m_csComponents.unlock();
        }
        
        virtual void addComponent(CNode *pNode, int nMode, CNode *pReference=NULL);
        virtual bool removeComponent(CNode *pNode);
        
        virtual void cleanUpComponents(std::list<CNode*> &listNodes);


        virtual void generateChildrenList(std::list<CNode*> &listNode);
        virtual void generateChildrenHandleList(std::list<CPassiveHandle*> &listHandles);


        void getName(std::string &strName){
            m_csName.lock();
            strName.assign(m_strName);
            m_csName.unlock();
        }
        virtual CPulse *getPulse() { return (m_pParent!=NULL)?(m_pParent->getPulse()):(NULL); }





        virtual void getTypeID(std::string &str) const { str.assign("FSF_NODE"); }
        
        Time getTime() const { return m_tTime; }
        Time getDuration() const { return m_tDuration; }

        CNode *getParent() const {  return m_pParent; }
        bool isNotDeleted() const { return m_bNotDeleted; }
        bool canDelete() const { return (m_bNoDelete==false); }





        std::string& name() { return m_strName; }
        bool testNameExact(const std::string &str) const { return str==m_strName; }
        bool testNameWildcard(const std::string &str) const { return wildcardMatch(str,m_strName); }
        void incNbHandleRefs() { m_csHandleRefs.lock(); m_nNbHandleRefs++; m_csHandleRefs.unlock(); }
        void decNbHandleRefs() { m_csHandleRefs.lock(); m_nNbHandleRefs--; m_csHandleRefs.unlock(); }

    };

} // namespace fsf

#endif // FSF_NODE_H

---