FsfSystem.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_SYSTEM_H
#define FSF_SYSTEM_H

#include "Fsf.h"
#include "FsfClassFactories.h"

#include "FsfCell.h"

#include <string>
#include <map>

#include <sys/timeb.h>
#include <sys/time.h>


namespace fsf
{
    // number of clocks per sec is usually less than one per nanosec
    // so the conversion with integers only involves a multiplication...
    // NANOSEC_FACTOR is really 1/CLOCKS_PER_NANOSEC, which is more likely to be an integer
    const double CLOCK_FACTOR=1000000000.0/CLOCKS_PER_SEC;

    class CSystem{

    private:
        typedef std::map<std::string,CNodeFactoryBase*> NodeFactoryMap;
        typedef std::map<std::string,CCellFactoryBase*> CellFactoryMap;

        static CSystem *m_pSingle; 
        CSystem(); 


        // Class factories
        NodeFactoryMap m_mapNodeFactories; 
        CellFactoryMap m_mapCellFactories; // A list (really a map) of cell factories registered with this system

        // Maps should be made thread-safe with critical sections.
        // However, for now they are set at start time and never modified...
        // Critical sections would not hurt anyways, since the map access
        // is not a highly time critical operation

    public:



        static CSystem* getInstance(){
            if(m_pSingle!=NULL)
                return m_pSingle;
            else
                return (m_pSingle=new CSystem);
        }
      
        static void deleteInstance(){
            if(m_pSingle!=NULL){
                delete m_pSingle;
                m_pSingle=NULL;
            }
        }

        ~CSystem(); 



#ifdef _WINDOWS
        Time getTime() { return (clock()*CLOCK_FACTOR); }
#else
        Time getTime(){
            timeval now;
            gettimeofday(&now,NULL);
            return (now.tv_sec*1000000000.0+now.tv_usec*1000.0);
        }
#endif




        void registerNodeFactory(const std::string &strID, CNodeFactoryBase *pNodeFactory){
            m_mapNodeFactories[strID]=pNodeFactory;
        }
        CNodeFactoryBase *getNodeFactory(const std::string &strID){
            return m_mapNodeFactories[strID];
        }

        void registerCellFactory(const std::string &strID, CCellFactoryBase *pCellFactory){
            m_mapCellFactories[strID]=pCellFactory;
        }
        CCellFactoryBase *getCellFactory(const std::string &strID){
            return m_mapCellFactories[strID];
        }



        static CCell *createCell(const std::string &strID);
        static CNode *createNode(const std::string &strID, fsf::CNode *pParent=NULL);
        template <class N>
        static CPassiveFilter<N> *createPassiveFilter(const std::string &strName){
            return new CPassiveFilter<N>(strName);
        }

    };

} // namespace fsf

#endif // FSF_SYSTEM_H

---