FsfClassFactories.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_CLASS_FACTORIES_H
#define FSF_CLASS_FACTORIES_H

#include <string>

// These classes do not use cell or node types at all
// probably not-so-good design!
// #include "FsfNode.h"
// #include "FsfCell.h"

#include "FsfFilter.h"

namespace fsf{

    class CClassFactoryBase{
    private:
        std::string m_strName; 
        std::string m_strAuthor; 
        std::string m_strThanks; 
    public:


        CClassFactoryBase() {}
        CClassFactoryBase(const std::string& strName) { m_strName=strName; }
        CClassFactoryBase(const std::string& strName, const std::string& strAuthor) { m_strName=strName; m_strAuthor=strAuthor; }
        CClassFactoryBase(const std::string& strName, const std::string& strAuthor, const std::string& strThanks) { m_strName=strName; m_strAuthor=strAuthor; m_strThanks=strThanks; }
        CClassFactoryBase(const CClassFactoryBase &rhs) { m_strName=rhs.m_strName; m_strAuthor=rhs.m_strAuthor; m_strThanks=rhs.m_strThanks; }
        virtual ~CClassFactoryBase() {}
        


        void getName(std::string &str) const { str.assign(m_strName); }
        void getAuthor(std::string &str) const { str.assign(m_strAuthor); }
        void getThanks(std::string &str) const { str.assign(m_strThanks); }





        virtual void *instantiate()=0;
    };
    
    class CNodeFactoryBase : public CClassFactoryBase {
    public:


        CNodeFactoryBase() : CClassFactoryBase() {}
        CNodeFactoryBase(const std::string& strName) : CClassFactoryBase(strName) {}
        CNodeFactoryBase(const std::string& strName, const std::string& strAuthor) : CClassFactoryBase(strName,strAuthor) {}
        CNodeFactoryBase(const std::string& strName, const std::string& strAuthor, const std::string& strThanks) : CClassFactoryBase(strName,strAuthor,strThanks) {}
        CNodeFactoryBase(const CNodeFactoryBase &rhs) : CClassFactoryBase(rhs) {}




        virtual CPassiveFilterBase* makePassiveFilter(const std::string &str)=0;
        virtual CActiveFilterBase* makeActiveFilter(const std::string &str)=0;
    };
    

    template <class N> class CNodeFactory : public CNodeFactoryBase {
    public:


        CNodeFactory() : CNodeFactoryBase() {}
        CNodeFactory(const std::string& strName) : CNodeFactoryBase(strName) {}
        CNodeFactory(const std::string& strName, const std::string& strAuthor) : CNodeFactoryBase(strName,strAuthor) {}
        CNodeFactory(const std::string& strName, const std::string& strAuthor, const std::string& strThanks) : CNodeFactoryBase(strName,strAuthor,strThanks) {}
        CNodeFactory(const CNodeFactory &rhs) : CNodeFactoryBase(rhs) {}



        virtual void* instantiate() { return new N; }
        virtual CPassiveFilterBase* makePassiveFilter(const std::string &str) { return new CPassiveFilter<N>(str); }
        virtual CActiveFilterBase* makeActiveFilter(const std::string &str)  { return new CActiveFilter<N>(str); }
    };
    
    class CCellFactoryBase : public CClassFactoryBase {
    public:


        CCellFactoryBase() : CClassFactoryBase() {}
        CCellFactoryBase(const std::string& strName) : CClassFactoryBase(strName) {}
        CCellFactoryBase(const std::string& strName, const std::string& strAuthor) : CClassFactoryBase(strName,strAuthor) {}
        CCellFactoryBase(const std::string& strName, const std::string& strAuthor, const std::string& strThanks) : CClassFactoryBase(strName,strAuthor,strThanks) {}
        CCellFactoryBase(const CCellFactoryBase &rhs) : CClassFactoryBase(rhs) {}
    };
    
    template <class C> class CCellFactory : public CCellFactoryBase {
    public:

        CCellFactory() : CCellFactoryBase() {}
        CCellFactory(const std::string& strName) : CCellFactoryBase(strName) {}
        CCellFactory(const std::string& strName, const std::string& strAuthor) : CCellFactoryBase(strName,strAuthor) {}
        CCellFactory(const std::string& strName, const std::string& strAuthor, const std::string& strThanks) : CCellFactoryBase(strName,strAuthor,strThanks) {}
        CCellFactory(const CCellFactory &rhs) : CCellFactoryBase(rhs) {} // Copy constructor



        virtual void* instantiate() { return new C; }
    };
    
} // namespace fsf

#endif // FSF_CLASS_FACTORIES_H

---