#include <PseudoNode.h>

Inheritance diagram for CPN::PseudoNode:

Collaboration diagram for CPN::PseudoNode:

Public Member Functions
	PseudoNode (const std::string &name_, Key_t k, shared_ptr< Context > ctx)

virtual	~PseudoNode ()

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...

virtual void	Shutdown ()
	Perform actions (like joining a thread) before destruction. More...

virtual bool	IsPurePseudo ()

virtual void	LogState ()
	For debugging ONLY! More...

Protected Attributes
Logger	logger

Private Types
typedef std::map< Key_t, shared_ptr< QueueReader > >	ReaderMap

typedef std::map< Key_t, shared_ptr< QueueWriter > >	WriterMap

Private Member Functions
	PseudoNode (const PseudoNode &)

void	ReleaseReader (Key_t ekey)

void	ReleaseWriter (Key_t ekey)

shared_ptr< QueueReader >	GetReader (Key_t ekey)

shared_ptr< QueueWriter >	GetWriter (Key_t ekey)

Private Attributes
Sync::ReentrantLock	lock

Sync::ReentrantCondition	cond

const std::string	name

const Key_t	nodekey

shared_ptr< D4R::Node >	d4rnode

ReaderMap	readermap

WriterMap	writermap

shared_ptr< Context >	context

Detailed Description

Definition at line 34 of file PseudoNode.h.

Member Typedef Documentation

typedef std::map<Key_t, shared_ptr<QueueReader> > CPN::PseudoNode::ReaderMap

private

Definition at line 91 of file PseudoNode.h.

typedef std::map<Key_t, shared_ptr<QueueWriter> > CPN::PseudoNode::WriterMap

private

Definition at line 92 of file PseudoNode.h.

Constructor & Destructor Documentation

CPN::PseudoNode::PseudoNode	(	const std::string &	name_,
		Key_t	k,
		shared_ptr< Context >	ctx
	)

Definition at line 31 of file PseudoNode.cc.

         : logger(ctx.get(), Logger::WARNING, n),
         name(n),
         nodekey(k),
         d4rnode(new D4R::Node(k)),
         context(ctx)
     {
     }

CPN::PseudoNode::~PseudoNode ( )

virtual

Definition at line 40 of file PseudoNode.cc.

40 {

41 }

CPN::PseudoNode::PseudoNode ( const PseudoNode & )

private

Member Function Documentation

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

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

Definition at line 55 of file PseudoNode.cc.

References ASSERT, cond, d4rnode, lock, 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 )

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

Definition at line 68 of file PseudoNode.cc.

References ASSERT, cond, d4rnode, lock, Sync::ReentrantCondition::Signal(), and 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:

shared_ptr< QueueReader > CPN::PseudoNode::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.

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 context, GetReader(), and nodekey.

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

Here is the call graph for this function:

Key_t CPN::PseudoNode::GetKey ( ) const

inline

Returns: the process network wide unique id for this node

Definition at line 43 of file PseudoNode.h.

Referenced by CPN::NodeBase::EntryPoint().

43 { return nodekey; }

CPN::PseudoNode::nodekey

const Key_t nodekey

Definition: PseudoNode.h:88

Here is the caller graph for this function:

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

inline

Returns: the unique name of this node

Definition at line 40 of file PseudoNode.h.

Referenced by CPN::NodeBase::EntryPoint(), and CPN::NodeBase::GetParam().

40 { return name; }

CPN::PseudoNode::name

const std::string name

Definition: PseudoNode.h:87

Here is the caller graph for this function:

shared_ptr< QueueWriter > CPN::PseudoNode::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.

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 context, GetWriter(), and nodekey.

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

Here is the call graph for this function:

shared_ptr< QueueReader > CPN::PseudoNode::GetReader ( Key_t ekey )

private

Definition at line 132 of file PseudoNode.cc.

References cond, context, lock, readermap, and Sync::ReentrantCondition::Wait().

Referenced by GetIQueue().

                                                             {
         Sync::AutoReentrantLock arl(lock);
         shared_ptr<QueueReader> reader;
         while (!reader) {
             ReaderMap::iterator entry = readermap.find(ekey);
             if (entry == readermap.end()) {
                 context->CheckTerminated();
                 cond.Wait(lock);
             } else {
                 reader = shared_ptr<QueueReader>(entry->second);
             }
         }
         return reader;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

shared_ptr< QueueWriter > CPN::PseudoNode::GetWriter ( Key_t ekey )

private

Definition at line 147 of file PseudoNode.cc.

References cond, context, lock, Sync::ReentrantCondition::Wait(), and writermap.

Referenced by GetOQueue().

                                                             {
         Sync::AutoReentrantLock arl(lock);
         shared_ptr<QueueWriter> writer;
         while (!writer) {
             WriterMap::iterator entry = writermap.find(ekey);
             if (entry == writermap.end()) {
                 context->CheckTerminated();
                 cond.Wait(lock);
             } else {
                 writer = shared_ptr<QueueWriter>(entry->second);
             }
         }
         return writer;
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::PseudoNode::IsPurePseudo ( )

virtual

Reimplemented in CPN::NodeBase.

Definition at line 163 of file PseudoNode.cc.

                                   {
         return true;
     }

void CPN::PseudoNode::LogState ( )

virtual

For debugging ONLY!

Reimplemented in CPN::NodeBase.

Definition at line 167 of file PseudoNode.cc.

References D4R::Tag::Count(), d4rnode, Logger::Error(), D4R::Tag::Key(), logger, nodekey, D4R::Tag::QueueKey(), D4R::Tag::QueueSize(), readermap, and writermap.

Referenced by CPN::NodeBase::LogState().

                               {
         logger.Error("Logging (key: %llu), %u readers, %u writers",
                 nodekey, readermap.size(), writermap.size());
         D4R::Tag tag = d4rnode->GetPrivateTag();
         logger.Error("Private key: (%llu, %llu, %llu, %llu)", tag.Count(), tag.Key(), tag.QueueSize(), tag.QueueKey());
         tag = d4rnode->GetPublicTag();
         logger.Error("Public key: (%llu, %llu, %llu, %llu)", tag.Count(), tag.Key(), tag.QueueSize(), tag.QueueKey());
         ReaderMap::iterator r = readermap.begin();
         while (r != readermap.end()) {
             r->second->GetQueue()->LogState();
             ++r;
         }
         WriterMap::iterator w = writermap.begin();
         while (w != writermap.end()) {
             w->second->GetQueue()->LogState();
             ++w;
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::PseudoNode::NotifyTerminate ( )

Called by the kernel when it is shutting down.

Definition at line 123 of file PseudoNode.cc.

References cond, lock, readermap, Sync::ReentrantCondition::Signal(), and 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:

void CPN::PseudoNode::ReleaseReader ( Key_t ekey )

privatevirtual

Implements CPN::QueueReleaser.

Definition at line 99 of file PseudoNode.cc.

References lock, readermap, and AutoLock< Lockable >::Unlock().

                                              {
         shared_ptr<QueueReader> reader;
         Sync::AutoReentrantLock arl(lock);
         ReaderMap::iterator entry = readermap.find(ekey);
         if (entry != readermap.end()) {
             reader = entry->second;
             readermap.erase(entry);
         }
         arl.Unlock();
         reader.reset();
     }

Here is the call graph for this function:

void CPN::PseudoNode::ReleaseWriter ( Key_t ekey )

privatevirtual

Implements CPN::QueueReleaser.

Definition at line 111 of file PseudoNode.cc.

References lock, AutoLock< Lockable >::Unlock(), and writermap.

                                              {
         shared_ptr<QueueWriter> writer;
         Sync::AutoReentrantLock arl(lock);
         WriterMap::iterator entry = writermap.find(ekey);
         if (entry != writermap.end()) {
             writer = entry->second;
             writermap.erase(entry);
         }
         arl.Unlock();
         writer.reset();
     }

Here is the call graph for this function:

void CPN::PseudoNode::Shutdown ( )

virtual

Perform actions (like joining a thread) before destruction.

Reimplemented in CPN::NodeBase.

Definition at line 81 of file PseudoNode.cc.

References lock, readermap, AutoLock< Lockable >::Unlock(), and writermap.

Referenced by CPN::NodeBase::Shutdown().

                               {
         Sync::AutoReentrantLock arl(lock);
         ReaderMap readers;
         readers.swap(readermap);
         WriterMap writers;
         writers.swap(writermap);
         arl.Unlock();
         for (ReaderMap::iterator i = readers.begin(); i != readers.end(); ++i) {
             i->second->GetQueue()->ShutdownReader();
         }
         for (WriterMap::iterator i = writers.begin(); i != writers.end(); ++i) {
             i->second->GetQueue()->ShutdownWriter();
         }
         readers.clear();
         writers.clear();
 
     }