NodeBase.h

Go to the documentation of this file.

//=============================================================================
//  Computational Process Networks class library
//  Copyright (C) 1997-2006  Gregory E. Allen and The University of Texas
//
//  This library is free software; you can redistribute it and/or modify it
//  under the terms of the GNU Library General Public License as published
//  by the Free Software Foundation; either version 2 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
//  Library General Public License for more details.
//
//  The GNU Public License is available in the file LICENSE, or you
//  can write to the Free Software Foundation, Inc., 59 Temple Place -
//  Suite 330, Boston, MA 02111-1307, USA, or you can find it on the
//  World Wide Web at http://www.fsf.org.
//=============================================================================
#ifndef CPN_NODEBASE_H
#define CPN_NODEBASE_H
#pragma once
#include <cpn/common.h>
#include <cpn/NodeAttr.h>
#include <cpn/NodeFactory.h>
#include <cpn/bits/PseudoNode.h>
#include <cpn/utils/ParseBool.h>
#include <sstream>
#include <map>
#include <string>
#include <stdexcept>

class Pthread;

namespace CPN {

    namespace NodeBasePrivate {
        template<typename T>
        struct CoerceParam {
            static T Coerce(const std::string& key, const std::string &param) {
                std::istringstream iss(param);
                T ret;
                if (iss >> ret) {
                    return ret;
                }
                throw std::invalid_argument("Unable to convert parameter \"" + key + "\": \"" + param + "\"");
            }
        };
        template<>
        struct CoerceParam<bool> {
            static bool Coerce(const std::string &, const std::string &param) {
                return ParseBool(param);
            }
        };
    }

    class CPN_API NodeBase : public PseudoNode {
    public:
        NodeBase(Kernel &ker, const NodeAttr &attr);

        virtual ~NodeBase();

        const std::string &GetTypeName() const { return type; }

        Kernel *GetKernel() { return &kernel; }

        std::string GetParam(const std::string &key) const;

        bool HasParam(const std::string &key) const;

        template<typename T>
        T GetParam(const std::string &key) const {
            return NodeBasePrivate::CoerceParam<T>::Coerce(key, GetParam(key));
        }

        template<typename T>
        T GetParam(const std::string &key, T def) const {
            if (HasParam(key)) {
                return GetParam<T>(key);
            }
            return def;
        }

        void Start();

        void Shutdown();

        bool IsPurePseudo();

        void LogState();
    protected:

        virtual void Process() = 0;

        Kernel &kernel;
    private:
        void* EntryPoint();

        const std::string type;
        auto_ptr<Pthread> thread;
        std::map<std::string, std::string> params;
    };

}

#define CPN_DECLARE_NODE_FACTORY(type, klass) class type ## Factory : public CPN::NodeFactory {\
    public: type ## Factory() : CPN::NodeFactory(#type) {}\
    CPN::shared_ptr<CPN::NodeBase> Create(CPN::Kernel &ker, const CPN::NodeAttr &attr) { return CPN::shared_ptr<CPN::NodeBase>(new klass(ker, attr)); }};\
extern "C" CPN::shared_ptr<CPN::NodeFactory> cpninit ## type (void);\
CPN::shared_ptr<CPN::NodeFactory> cpninit ## type (void) { return CPN::shared_ptr<CPN::NodeFactory>(new type ## Factory); }

#define CPN_DECLARE_NODE_AND_FACTORY(type,klass) class klass : public CPN::NodeBase { \
    public : klass(CPN::Kernel &kern, const CPN::NodeAttr& attr) : CPN::NodeBase(kern,attr) {} \
    private: void Process(); }; \
CPN_DECLARE_NODE_FACTORY(type,klass)

#endif