CPN::NodeBase Class Reference

The definition common to all nodes in the process network. More...

#include <NodeBase.h>

Inheritance diagram for CPN::NodeBase:

Collaboration diagram for CPN::NodeBase:

Public Member Functions
	NodeBase (Kernel &ker, const NodeAttr &attr)
virtual	~NodeBase ()
const std::string &	GetTypeName () const
Kernel *	GetKernel ()
	Return a pointer to the kernel that his node is running under. More...
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
template<typename T >
T	GetParam (const std::string &key, T def) const
void	Start ()
	For use by the CPN::Kernel to start the node. More...
void	Shutdown ()
	Perform actions (like joining a thread) before destruction. More...
bool	IsPurePseudo ()
void	LogState ()
	For debugging ONLY! More...
const std::string &	GetName () const
Key_t	GetKey () const
shared_ptr< QueueReader >	GetIQueue (const std::string &portname)
	This method is for use by the user to aquire a reader endpoint. This function blocks until the CPN::Kernel hands this node the queue associated with the endpoint. More...
shared_ptr< QueueWriter >	GetOQueue (const std::string &portname)
	This method is for use by the user to aquire a writer endpoint. This function blocks until the CPN::Kernel hands this node the queue associated with the endpoint. More...
void	CreateReader (shared_ptr< QueueBase > q)
	for use by the CPN::Kernel to create a new read endpoint. More...
void	CreateWriter (shared_ptr< QueueBase > q)
	for use by the CPN::Kernel to create a new writer endpoint. More...
void	NotifyTerminate ()
	Called by the kernel when it is shutting down. More...

Protected Member Functions
virtual void	Process ()=0
	Override this method to implement a node. More...

Protected Attributes
Kernel &	kernel
Logger	logger

Private Member Functions
void *	EntryPoint ()

Private Attributes
const std::string	type
auto_ptr< Pthread >	thread
std::map< std::string, std::string >	params

Detailed Description

The definition common to all nodes in the process network.

A node is a thread of execution which lasts the lifetime of the node object.

Definition at line 69 of file NodeBase.h.

Constructor & Destructor Documentation

CPN::NodeBase::NodeBase	(	Kernel &	ker,
		const NodeAttr &	attr
	)

Definition at line 35 of file NodeBase.cc.

References CreatePthreadFunctional(), EntryPoint(), and thread.

    :   PseudoNode(attr.GetName(), attr.GetKey(), ker.GetContext()),
        kernel(ker),
        type(attr.GetTypeName()),
        params(attr.GetParams())
    {
        thread.reset(CreatePthreadFunctional(this, &NodeBase::EntryPoint));
    }

Here is the call graph for this function:

CPN::NodeBase::~NodeBase ( )

virtual

Definition at line 44 of file NodeBase.cc.

                        {
    }

Member Function Documentation

void CPN::PseudoNode::CreateReader ( shared_ptr< QueueBase >  q )

inherited

for use by the CPN::Kernel to create a new read endpoint.

Definition at line 55 of file PseudoNode.cc.

References ASSERT, CPN::PseudoNode::cond, CPN::PseudoNode::d4rnode, CPN::PseudoNode::lock, CPN::PseudoNode::readermap, and Sync::ReentrantCondition::Signal().

                                                         {
        Sync::AutoReentrantLock arl(lock);
        Key_t readerkey = q->GetReaderKey();
        d4rnode->AddReader(q);
        q->SetReaderNode(d4rnode);
        q->SignalReaderTagChanged();
        ASSERT(readermap.find(readerkey) == readermap.end(), "The reader already exists");
        shared_ptr<QueueReader> reader;
        reader = shared_ptr<QueueReader>(new QueueReader(this, q));
        readermap.insert(std::make_pair(readerkey, reader));
        cond.Signal();
    }

Here is the call graph for this function:

void CPN::PseudoNode::CreateWriter ( shared_ptr< QueueBase >  q )

inherited

for use by the CPN::Kernel to create a new writer endpoint.

Definition at line 68 of file PseudoNode.cc.

References ASSERT, CPN::PseudoNode::cond, CPN::PseudoNode::d4rnode, CPN::PseudoNode::lock, Sync::ReentrantCondition::Signal(), and CPN::PseudoNode::writermap.

                                                         {
        Sync::AutoReentrantLock arl(lock);
        Key_t writerkey = q->GetWriterKey();
        d4rnode->AddWriter(q);
        q->SetWriterNode(d4rnode);
        q->SignalWriterTagChanged();
        ASSERT(writermap.find(writerkey) == writermap.end(), "The writer already exists.");
        shared_ptr<QueueWriter> writer;
        writer = shared_ptr<QueueWriter>(new QueueWriter(this, q));
        writermap.insert(std::make_pair(writerkey, writer));
        cond.Signal();
    }

Here is the call graph for this function:

void * CPN::NodeBase::EntryPoint ( )

private

Definition at line 72 of file NodeBase.cc.

References Logger::ERROR, CPN::Kernel::GetContext(), CPN::PseudoNode::GetKey(), CPN::PseudoNode::GetName(), Logger::Info(), kernel, CPN::PseudoNode::logger, Logger::Name(), CPN::Kernel::NodeTerminated(), Process(), and CPN::Kernel::SwallowBrokenQueueExceptions().

Referenced by NodeBase().

                               {
        try {
            kernel.GetContext()->SignalNodeStart(GetKey());
            Process();
        } catch (const CPN::ShutdownException &e) {
            // Forced shutdown
        } catch (const CPN::BrokenQueueException &e) {
            if (!kernel.SwallowBrokenQueueExceptions()) {
                throw;
            }
        } catch (const D4R::DeadlockException &e) {
            // A true deadlock was detected, die
            Logger logger(kernel.GetContext().get(), Logger::ERROR);
            logger.Name(GetName().c_str());
            logger.Info("DEADLOCK detected at %s\n", GetName().c_str());
        }
        kernel.NodeTerminated(GetKey());
        return 0;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

shared_ptr< QueueReader > CPN::PseudoNode::GetIQueue ( const std::string &  portname )

inherited

This method is for use by the user to aquire a reader endpoint. This function blocks until the CPN::Kernel hands this node the queue associated with the endpoint.

Parameters

portname

the port name of the reader to get.

Returns

a shared pointer to a reader for he given endpoint name

Definition at line 43 of file PseudoNode.cc.

References CPN::PseudoNode::context, CPN::PseudoNode::GetReader(), and CPN::PseudoNode::nodekey.

                                                                           {
        context->CheckTerminated();
        Key_t ekey = context->GetCreateReaderKey(nodekey, portname);
        return GetReader(ekey);
    }

Here is the call graph for this function:

Kernel* CPN::NodeBase::GetKernel ( )

inline

Return a pointer to the kernel that his node is running under.

Definition at line 82 of file NodeBase.h.

{ return &kernel; }

Key_t CPN::PseudoNode::GetKey ( ) const

inlineinherited

Returns

the process network wide unique id for this node

Definition at line 43 of file PseudoNode.h.

Referenced by EntryPoint().

{ return nodekey; }

Here is the caller graph for this function:

const std::string& CPN::PseudoNode::GetName ( ) const

inlineinherited

Returns

the unique name of this node

Definition at line 40 of file PseudoNode.h.

Referenced by EntryPoint(), and GetParam().

{ return name; }

Here is the caller graph for this function:

shared_ptr< QueueWriter > CPN::PseudoNode::GetOQueue ( const std::string &  portname )

inherited

This method is for use by the user to aquire a writer endpoint. This function blocks until the CPN::Kernel hands this node the queue associated with the endpoint.

Parameters

portname

the port name fo the writer to get.

Returns

a shared pointer to a writer for the given endpoint name.

Definition at line 49 of file PseudoNode.cc.

References CPN::PseudoNode::context, CPN::PseudoNode::GetWriter(), and CPN::PseudoNode::nodekey.

                                                                           {
        context->CheckTerminated();
        Key_t ekey = context->GetCreateWriterKey(nodekey, portname);
        return GetWriter(ekey);
    }

Here is the call graph for this function:

std::string CPN::NodeBase::GetParam

(

const std::string &

key

)

const

Definition at line 47 of file NodeBase.cc.

References CPN::PseudoNode::GetName(), and params.

                                                           {
        std::map<std::string, std::string>::const_iterator entry =
            params.find(key);
        if (entry == params.end()) {
            throw std::invalid_argument("Required parameter \"" + key + "\" missing"
                    " for node \"" + GetName() + "\"");
        }
        return entry->second;
    }

Here is the call graph for this function:

template<typename T >

T CPN::NodeBase::GetParam ( const std::string &  key ) const

inline

Definition at line 89 of file NodeBase.h.

References CPN::NodeBasePrivate::CoerceParam< T >::Coerce().

                                               {
            return NodeBasePrivate::CoerceParam<T>::Coerce(key, GetParam(key));
        }

Here is the call graph for this function:

template<typename T >

T CPN::NodeBase::GetParam ( const std::string &  key, T  def  ) const

inline

Definition at line 94 of file NodeBase.h.

                                                      {
            if (HasParam(key)) {
                return GetParam<T>(key);
            }
            return def;
        }

const std::string& CPN::NodeBase::GetTypeName ( ) const

inline

Returns

the type id of this node

Definition at line 78 of file NodeBase.h.

{ return type; }

bool CPN::NodeBase::HasParam

(

const std::string &

key

)

const

Definition at line 57 of file NodeBase.cc.

References params.

                                                      {
        std::map<std::string, std::string>::const_iterator entry =
            params.find(key);
        return entry != params.end();
    }

bool CPN::NodeBase::IsPurePseudo ( )

virtual

Reimplemented from CPN::PseudoNode.

Definition at line 93 of file NodeBase.cc.

                                {
        return false;
    }

void CPN::NodeBase::LogState ( )

virtual

For debugging ONLY!

Reimplemented from CPN::PseudoNode.

Definition at line 97 of file NodeBase.cc.

References Logger::Error(), CPN::PseudoNode::logger, CPN::PseudoNode::LogState(), and thread.

                            {
        PseudoNode::LogState();
        logger.Error("Thread id: %llu, %s", (unsigned long long)((pthread_t)(*thread.get())),
                (thread->Done() ? "done" : "running"));
    }

Here is the call graph for this function:

void CPN::PseudoNode::NotifyTerminate ( )

inherited

Called by the kernel when it is shutting down.

Definition at line 123 of file PseudoNode.cc.

References CPN::PseudoNode::cond, CPN::PseudoNode::lock, CPN::PseudoNode::readermap, Sync::ReentrantCondition::Signal(), and CPN::PseudoNode::writermap.

                                     {
        Sync::AutoReentrantLock arl(lock);
        cond.Signal();
        WriterMap::iterator witr = writermap.begin();
        while (witr != writermap.end()) { (witr++)->second->NotifyTerminate(); }
        ReaderMap::iterator ritr = readermap.begin();
        while (ritr != readermap.end()) { (ritr++)->second->NotifyTerminate(); }
    }

Here is the call graph for this function:

virtual void CPN::NodeBase::Process ( )

protectedpure virtual

Override this method to implement a node.

Referenced by EntryPoint().

Here is the caller graph for this function:

void CPN::NodeBase::Shutdown ( )

virtual

Perform actions (like joining a thread) before destruction.

Reimplemented from CPN::PseudoNode.

Definition at line 67 of file NodeBase.cc.

References CPN::PseudoNode::Shutdown(), and thread.

                            {
        thread->Join();
        PseudoNode::Shutdown();
    }

Here is the call graph for this function:

void CPN::NodeBase::Start

(

)

For use by the CPN::Kernel to start the node.

Definition at line 63 of file NodeBase.cc.

References thread.

                         {
        thread->Start();
    }

Member Data Documentation

Kernel& CPN::NodeBase::kernel

protected

Definition at line 117 of file NodeBase.h.

Referenced by EntryPoint().

Logger CPN::PseudoNode::logger

protectedinherited

Definition at line 76 of file PseudoNode.h.

Referenced by EntryPoint(), CPN::PseudoNode::LogState(), and LogState().

std::map<std::string, std::string> CPN::NodeBase::params

private

Definition at line 123 of file NodeBase.h.

Referenced by GetParam(), and HasParam().

auto_ptr<Pthread> CPN::NodeBase::thread

private

Definition at line 122 of file NodeBase.h.

Referenced by LogState(), NodeBase(), Shutdown(), and Start().

const std::string CPN::NodeBase::type

private

Definition at line 121 of file NodeBase.h.

---

The documentation for this class was generated from the following files:

• include/cpn/NodeBase.h
• lib/NodeBase.cc