FsfPulse.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_PULSE_H
#define FSF_PULSE_H

#include "FsfNode.h"

namespace fsf{

    class CPulse : public CNode {
    public:



        CPulse()
            : CNode() {}
        CPulse(const std::string &strName, Time tTime=0)
            : CNode(strName,NULL,tTime) {}
        CPulse(const CPulse& rhs)
            : CNode(rhs) {}
        // virtual ~CPulse(); ///< Virual destructor inherited from CNode
        
        CPulse& operator=(const CPulse& rhs);
        
        virtual CNode *clone() { return new CPulse(*this); }
        

        virtual void getTypeID(std::string &str) { str.assign("FSF_PULSE"); }
        
        virtual CPulse *getPulse() { return this; }
    };
    
    class CPassivePulse : public CPulse {
    public:
        


        CPassivePulse()
            : CPulse() {}
        CPassivePulse(const std::string &strName, Time tTime=0)
            : CPulse(strName,tTime) {}
        CPassivePulse(const CPassivePulse& rhs)
            : CPulse(rhs) {}
        // virtual ~CPassivePulse();
        
        CPassivePulse& operator=(const CPassivePulse& rhs);
        
        virtual CNode *clone() { return new CPassivePulse(*this); }
        



        virtual void getTypeID(std::string &str) { str.assign("FSF_PASSIVE_PULSE"); }
        



        // not sure why locking was removed?
//      void detachComponents(std::list<CNode*> &listComponents) {
//          m_csComponents.lock();
//          listComponents.assign(m_listComponents.begin(),m_listComponents.end());
//          m_listComponents.erase(m_listComponents.begin(),m_listComponents.end());
//          m_csComponents.unlock();
//      }

        void detachComponents(std::list<CNode*> &listComponents) {
            listComponents.assign(getListComponents().begin(),getListComponents().end());
            getListComponents().erase(getListComponents().begin(),getListComponents().end());
        }
        
        void cleanUpComponents();
    };
    
    class CActivePulse : public CPulse {
    protected:
        CMutex m_csNbPaths; 
        int m_nNbPaths; 
    public:

        


        CActivePulse()
            : CPulse(), m_nNbPaths(1) {}
        CActivePulse(const std::string &strName, Time tTime=0)
            : CPulse(strName,tTime), m_nNbPaths(1) {}
        CActivePulse(const CActivePulse& rhs)
            : CPulse(rhs), m_nNbPaths(1) {}
        // virtual ~CActivePulse();
        
        CActivePulse& operator=(const CActivePulse& rhs);
        
        virtual CNode *clone() { return new CActivePulse(*this); }
        




        virtual void getTypeID(std::string &str) { str.assign("FSF_ACTIVE_PULSE"); }
        int getNbPaths() { m_csNbPaths.lock(); int r=m_nNbPaths; m_csNbPaths.unlock(); return r;}
        


        int incNbPaths(int nNbPaths=1) { m_csNbPaths.lock(); int r=(m_nNbPaths+=nNbPaths); m_csNbPaths.unlock(); return r;}
        int decNbPaths() { m_csNbPaths.lock(); int r=(--m_nNbPaths); m_csNbPaths.unlock(); return r; }


    };
    
} // namespace fsf

#endif // FSF_PULSE_H

---