FsfTypeNode.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_TYPE_NODE_H
#define FSF_TYPE_NODE_H

#include "FsfNode.h"

namespace fsf {
    
    class CTypeNodeBase : public CNode {
    public:



        CTypeNodeBase() : CNode() {}
        CTypeNodeBase(CNode *pParent, Time tTime=0)
            : CNode(pParent,tTime) {}
        CTypeNodeBase(const std::string &strName,CNode *pParent=NULL, Time tTime=0)
            : CNode(strName,pParent,tTime) {}
        CTypeNodeBase(const CTypeNodeBase& rhs)
            : CNode(rhs) {}
        virtual CNode *clone() const { return new CTypeNodeBase(*this); }       



        CTypeNodeBase& operator=(const CTypeNodeBase& rhs);



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

    template <typename Type> class CTypeNode : public CTypeNodeBase {
    private:
        Type m_tData; 
    public:


        CTypeNode() : CTypeNodeBase() {}
        CTypeNode(CNode *pParent, Time tTime=0)
            : CTypeNodeBase(pParent,tTime) {}
        CTypeNode(const std::string &strName,CNode *pParent=NULL, Time tTime=0)
            : CTypeNodeBase(strName,pParent,tTime) {}
        CTypeNode(const Type &val, const std::string &strName, CNode *pParent=NULL, Time tTime=0)
            : CTypeNodeBase(strName,pParent,tTime), m_tData(val) {}
        CTypeNode(const CTypeNode& rhs)
            : CTypeNodeBase(rhs), m_tData(rhs.m_tData) {}
        virtual CNode *clone() const { return new CTypeNode<Type>(*this); }



        virtual void getTypeID(std::string &str) const { str.assign("FSF_TYPE_NODE"); } 
        void getData(Type &val) const { val=m_tData; }
        const Type& getData() const { return m_tData; }



        CTypeNode& operator=(const CTypeNode& rhs);
        void setData(const Type &val) { m_tData=val; }
    };
    


    typedef CTypeNode<long int> Int32Node;
    template<> inline void Int32Node::getTypeID(std::string &str) const { str.assign("FSF_INT32_NODE"); }
   
    typedef CTypeNode<long long int> Int64Node;
    template<> inline void Int64Node::getTypeID(std::string &str) const { str.assign("FSF_INT64_NODE"); }
    
    typedef CTypeNode<float> Float32Node;
    template<> inline void Float32Node::getTypeID(std::string &str) const { str.assign("FSF_FLOAT32_NODE"); }
    
    typedef CTypeNode<double> Float64Node;
    template<> inline void Float64Node::getTypeID(std::string &str) const { str.assign("FSF_FLOAT64_NODE"); }
    
    typedef CTypeNode<bool> BoolNode;
    template<> inline void BoolNode::getTypeID(std::string &str) const { str.assign("FSF_BOOL_NODE"); }
    
    typedef CTypeNode<std::string> StringNode;
    template<> inline void StringNode::getTypeID(std::string &str) const { str.assign("FSF_STRING_NODE"); }
    
} // namespace fsf

#endif // FSF_TYPE_NODE_H

---