#include <VariantCPNLoader.h>

Collaboration diagram for CPN::VariantCPNLoader:

Public Member Functions
	VariantCPNLoader ()

	VariantCPNLoader (Variant conf)

	~VariantCPNLoader ()

Variant &	GetConfig ()

void	MergeConfig (Variant v)

void	KernelName (const std::string &name)

void	KernelHost (const std::string &host)

void	KernelPort (const std::string &port)

void	AddLib (const std::string &filename)

void	AddLibList (const std::string &filename)

void	AddLibPath (const std::string &path)

void	UseD4R (bool value)

void	GrowQueueMaxThreshold (bool value)

void	SwallowBrokenQueueExceptions (bool value)

void	LogLevel (int i)

void	ContextHost (const std::string &host)

void	ContextPort (const std::string &port)

void	AddNode (Variant v)

void	AddQueue (Variant v)

void	AddNodeMapping (const std::string &noden, const std::string &kernn)

std::pair< bool, std::string >	Validate ()

CPN::KernelAttr	GetKernelAttr ()

void	Setup (CPN::Kernel *kernel)

Static Public Member Functions
static CPN::shared_ptr < CPN::Context >	LoadContext (Variant v)

static CPN::KernelAttr	GetKernelAttr (Variant args)

static void	Setup (CPN::Kernel *kernel, Variant args)

static void	LoadNodes (CPN::Kernel *kernel, Variant nodelist, Variant nodemap)

static void	LoadNode (CPN::Kernel *kernel, Variant attr, Variant nodemap)

static void	LoadQueues (CPN::Kernel *kernel, Variant queuelist)

static void	LoadQueue (CPN::Kernel *kernel, Variant attr)

static std::pair< bool, std::string >	Validate (Variant conf)

Private Attributes
Variant	config

Detailed Description

Load a CPN network from a specially defined Variant

Definition at line 36 of file VariantCPNLoader.h.

Constructor & Destructor Documentation

CPN::VariantCPNLoader::VariantCPNLoader ( )

Definition at line 37 of file VariantCPNLoader.cc.

37 { }

CPN::VariantCPNLoader::VariantCPNLoader ( Variant conf )

Definition at line 38 of file VariantCPNLoader.cc.

38 : config(conf) { }

CPN::VariantCPNLoader::config

Variant config

Definition: VariantCPNLoader.h:82

CPN::VariantCPNLoader::~VariantCPNLoader ( )

Definition at line 39 of file VariantCPNLoader.cc.

39 { }

Member Function Documentation

void CPN::VariantCPNLoader::AddLib ( const std::string & filename )

Definition at line 53 of file VariantCPNLoader.cc.

References config.

                                                            {
         config["libs"].Append(filename);
     }

void CPN::VariantCPNLoader::AddLibList ( const std::string & filename )

Definition at line 57 of file VariantCPNLoader.cc.

References config.

                                                                {
         config["liblist"].Append(filename);
     }

void CPN::VariantCPNLoader::AddLibPath ( const std::string & path )

Definition at line 61 of file VariantCPNLoader.cc.

References config.

                                                            {
         config["libpaths"].Append(path);
     }

void CPN::VariantCPNLoader::AddNode ( Variant v )

Definition at line 102 of file VariantCPNLoader.cc.

References config.

Referenced by MergeConfig().

                                             {
         if (!config.Contains("nodes")) {
             config["nodes"] = Variant::ListType;
         }
         Variant nodes = config["nodes"];
         Variant::ListIterator itr = nodes.ListBegin(), end = nodes.ListEnd();
         for (; itr != end; ++itr) {
             if (v["name"] == itr->At("name")) {
                 for (Variant::MapIterator mitr = v.MapBegin(),
                         mend = v.MapEnd(); mitr != mend; ++mitr) {
                     itr->At(mitr->first) = mitr->second.Copy();
                 }
                 return;
             }
         }
         nodes.Append(v.Copy());
     }

Here is the caller graph for this function:

void CPN::VariantCPNLoader::AddNodeMapping	(	const std::string &	noden,
		const std::string &	kernn
	)

Definition at line 147 of file VariantCPNLoader.cc.

References config.

                                                                                         {
         config.At("nodemap", Variant::MapType).Set(noden, kernn);
     }

void CPN::VariantCPNLoader::AddQueue ( Variant v )

Definition at line 120 of file VariantCPNLoader.cc.

References config.

Referenced by MergeConfig().

                                              {
         if (!config.Contains("queues")) {
             config["queues"] = Variant::ListType;
         }
         Variant queues = config["queues"];
         Variant::ListIterator qitr = queues.ListBegin(), qend = queues.ListEnd();
         for (;qitr != qend; ++qitr) {
             if (
                     (
                      v["readernode"] == qitr->At("readernode") &&
                      v["readerport"] == qitr->At("readerport")
                     ) ||
                     (
                      v["writernode"] == qitr->At("writernode") &&
                      v["writerport"] == qitr->At("writerport")
                     )
                ) {
                 for (Variant::MapIterator mitr = v.MapBegin(),
                         mend = v.MapEnd(); mitr != mend; ++mitr) {
                     qitr->At(mitr->first) = mitr->second.Copy();
                 }
                 return;
             }
         }
         queues.Append(v.Copy());
     }

Here is the caller graph for this function:

void CPN::VariantCPNLoader::ContextHost ( const std::string & host )

Definition at line 65 of file VariantCPNLoader.cc.

References config.

                                                             {
         config["context"]["host"] = host;
     }

void CPN::VariantCPNLoader::ContextPort ( const std::string & port )

Definition at line 69 of file VariantCPNLoader.cc.

References config.

                                                             {
         config["context"]["port"] = port;
     }

Variant& CPN::VariantCPNLoader::GetConfig ( )

inline

Definition at line 42 of file VariantCPNLoader.h.

References config.

42 { return config; }

CPN::VariantCPNLoader::config

Variant config

Definition: VariantCPNLoader.h:82

CPN::KernelAttr CPN::VariantCPNLoader::GetKernelAttr ( )

inline

Definition at line 66 of file VariantCPNLoader.h.

References config, and GetKernelAttr().

Referenced by GetKernelAttr().

66 { return GetKernelAttr(config); }

CPN::VariantCPNLoader::config

Variant config

Definition: VariantCPNLoader.h:82

CPN::VariantCPNLoader::GetKernelAttr

CPN::KernelAttr GetKernelAttr()

Definition: VariantCPNLoader.h:66

Here is the call graph for this function:

Here is the caller graph for this function:

CPN::KernelAttr CPN::VariantCPNLoader::GetKernelAttr ( Variant args )

static

Definition at line 186 of file VariantCPNLoader.cc.

References CPN::KernelAttr::AddNodeList(), CPN::KernelAttr::AddNodeSearchPath(), CPN::KernelAttr::AddSharedLib(), CPN::KernelAttr::GrowQueueMaxThreshold(), LoadContext(), CPN::KernelAttr::SetContext(), CPN::KernelAttr::SetHostName(), CPN::KernelAttr::SetServName(), CPN::KernelAttr::SwallowBrokenQueueExceptions(), and CPN::KernelAttr::UseD4R().

                                                               {
         CPN::KernelAttr attr(args["name"].AsString());
         if (args.Contains("context")) {
             attr.SetContext(LoadContext(args["context"]));
         }
         if (args.Contains("host")) {
             attr.SetHostName(args["host"].AsString());
         }
         if (args.Contains("port")) {
             attr.SetServName(args["port"].AsString());
         }
 
         if (args.Contains("d4r")) {
             attr.UseD4R(args["d4r"].AsBool());
         }
         if (args.Contains("swallow-broken-queue-exceptions")) {
             attr.SwallowBrokenQueueExceptions(args["swallow-broken-queue-exceptions"].AsBool());
         }
         if (args.Contains("grow-queue-max-threshold")) {
             attr.GrowQueueMaxThreshold(args["grow-queue-max-threshold"].AsBool());
         }
         if (args.Contains("libs") && args["libs"].IsList()) {
             for (Variant::ListIterator itr = args["libs"].ListBegin(); itr != args["libs"].ListEnd(); ++itr) {
                 attr.AddSharedLib(itr->AsString());
             }
         }
         if (args.Contains("liblist") && args["liblist"].IsList()) {
             for (Variant::ListIterator itr = args["liblist"].ListBegin(); itr != args["liblist"].ListEnd(); ++itr) {
                 attr.AddNodeList(itr->AsString());
             }
         }
         if (args.Contains("libpaths") && args["libpaths"].IsList()) {
             for (Variant::ListIterator itr = args["libpaths"].ListBegin(); itr != args["libpaths"].ListEnd(); ++itr) {
                 attr.AddNodeSearchPath(itr->AsString());
             }
         }
         return attr;
     }

Here is the call graph for this function:

void CPN::VariantCPNLoader::GrowQueueMaxThreshold ( bool value )

Definition at line 45 of file VariantCPNLoader.cc.

References config.

                                                            {
         config["grow-queue-max-threshold"] = value;
     }

void CPN::VariantCPNLoader::KernelHost ( const std::string & host )

Definition at line 178 of file VariantCPNLoader.cc.

References config.

                                                            {
         config["host"] = host;
     }

void CPN::VariantCPNLoader::KernelName ( const std::string & name )

Definition at line 174 of file VariantCPNLoader.cc.

References config.

                                                            {
         config["name"] = name;
     }

void CPN::VariantCPNLoader::KernelPort ( const std::string & port )

Definition at line 182 of file VariantCPNLoader.cc.

References config.

                                                            {
         config["port"] = port;
     }

shared_ptr< Context > CPN::VariantCPNLoader::LoadContext ( Variant v )

static

Definition at line 151 of file VariantCPNLoader.cc.

References SocketAddress::CreateIP(), and CPN::Context::Local().

Referenced by GetKernelAttr().

                                                                {
         shared_ptr<Context> context;
         if (v.IsNull()) {
             context = Context::Local();
         } else {
             if (!v.Contains("host") && !v.Contains("port")) {
                 context = Context::Local();
             } else {
                 SockAddrList addrs = SocketAddress::CreateIP(
                         v["host"].AsString(),
                         v["port"].AsString()
                         );
                 shared_ptr<RemoteContext> ctx = shared_ptr<RemoteContext>(new RemoteContext(addrs));
                 context = ctx;
             }
 
             if (v.Contains("loglevel")) {
                 context->LogLevel(v["loglevel"].AsInt());
             }
         }
         return context;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::VariantCPNLoader::LoadNode	(	CPN::Kernel *	kernel,
		Variant	attr,
		Variant	nodemap
	)

static

Definition at line 245 of file VariantCPNLoader.cc.

References CPN::Kernel::CreateNode(), CPN::NodeAttr::GetName(), CPN::NodeAttr::SetKernel(), and CPN::NodeAttr::SetParam().

Referenced by LoadNodes().

                                                                                     {
         CPN::NodeAttr nattr(attr["name"].AsString(), attr["type"].AsString());
         if (nodemap.IsMap() && nodemap.Contains(nattr.GetName())) {
             nattr.SetKernel(nodemap.At(nattr.GetName()).AsString());
         } else if (attr.Contains("kernel")) {
             nattr.SetKernel(attr["kernel"].AsString());
         }
         Variant param = attr["param"];
         if (param.IsMap()) {
             for (Variant::MapIterator i = param.MapBegin(), e = param.MapEnd();
                     i != e; ++i)
             {
                 nattr.SetParam(i->first, i->second.AsString());
             }
         }
         kernel->CreateNode(nattr);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::VariantCPNLoader::LoadNodes	(	CPN::Kernel *	kernel,
		Variant	nodelist,
		Variant	nodemap
	)

static

Definition at line 230 of file VariantCPNLoader.cc.

References LoadNode().

Referenced by Setup().

                                                                                          {
         if (!nodelist.IsList()) {
             return;
         }
         Variant::ConstListIterator itr, end;
         itr = nodelist.ListBegin();
         end = nodelist.ListEnd();
         while (itr != end) {
             if (itr->IsMap()) {
                 LoadNode(kernel, *itr, nodemap);
             }
             ++itr;
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::VariantCPNLoader::LoadQueue	(	CPN::Kernel *	kernel,
		Variant	attr
	)

static

Definition at line 278 of file VariantCPNLoader.cc.

References CPN::Kernel::CreateQueue(), CPN::QueueAttr::SetAlpha(), CPN::QueueAttr::SetDatatype(), CPN::QueueAttr::SetHint(), CPN::QueueAttr::SetMaxWriteThreshold(), CPN::QueueAttr::SetName(), CPN::QueueAttr::SetNumChannels(), CPN::QueueAttr::SetReader(), and CPN::QueueAttr::SetWriter().

Referenced by LoadQueues().

                                                                     {
         CPN::QueueAttr qattr(attr["size"].AsUnsigned(), attr["threshold"].AsUnsigned());
         qattr.SetReader(attr["readernode"].AsString(), attr["readerport"].AsString());
         qattr.SetWriter(attr["writernode"].AsString(), attr["writerport"].AsString());
         if (attr.Contains("type")) {
             qattr.SetHint(attr["type"].AsString());
         }
         if (attr.Contains("datatype")) {
             qattr.SetDatatype(attr["datatype"].AsString());
         }
         if (attr.Contains("numchannels")) {
             qattr.SetNumChannels(attr["numchannels"].AsUnsigned());
         }
         if (attr.Contains("alpha")) {
             qattr.SetAlpha(attr["alpha"].AsDouble());
         }
         if (attr.Contains("name")) {
             qattr.SetName(attr["name"].AsString());
         }
         if (attr.Contains("maxwritethreshold")) {
             qattr.SetMaxWriteThreshold(attr["maxwritethreshold"].AsUnsigned());
         }
         kernel->CreateQueue(qattr);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::VariantCPNLoader::LoadQueues	(	CPN::Kernel *	kernel,
		Variant	queuelist
	)

static

Definition at line 263 of file VariantCPNLoader.cc.

References LoadQueue().

Referenced by Setup().

                                                                           {
         if (!queuelist.IsList()) {
             return;
         }
         Variant::ConstListIterator itr, end;
         itr = queuelist.ListBegin();
         end = queuelist.ListEnd();
         while (itr != end) {
             if (itr->IsMap()) {
                 LoadQueue(kernel, *itr);
             }
             ++itr;
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::VariantCPNLoader::LogLevel ( int i )

Definition at line 73 of file VariantCPNLoader.cc.

References config.

                                          {
         config["context"]["loglevel"] = i;
     }

void CPN::VariantCPNLoader::MergeConfig ( Variant v )

Definition at line 77 of file VariantCPNLoader.cc.

References AddNode(), AddQueue(), and config.

                                                 {
         Variant::MapIterator topitr = v.MapBegin(), topend = v.MapEnd();
         for (;topitr != topend; ++topitr) {
             if (topitr->first == "context") {
                 Variant::MapIterator mitr = v["context"].MapBegin(), mend = v["context"].MapEnd();
                 for (;mitr != mend; ++mitr) {
                     config["context"][mitr->first] = mitr->second;
                 }
             } else if (topitr->first == "nodes") {
                 Variant::ListIterator litr = v["nodes"].ListBegin(), lend = v["nodes"].ListEnd();
                 for (;litr != lend; ++litr) {
                     AddNode(*litr);
                 }
             } else if (topitr->first == "queues") {
                 Variant::ListIterator litr = v["queues"].ListBegin(), lend = v["queues"].ListEnd();
                 for (;litr != lend; ++litr) {
                     AddQueue(*litr);
                 }
             } else {
                 config[topitr->first] = topitr->second;
             }
         }
     }

Here is the call graph for this function:

void CPN::VariantCPNLoader::Setup ( CPN::Kernel * kernel )

inline

Definition at line 67 of file VariantCPNLoader.h.

References config, and Setup().

Referenced by Setup().

67 { Setup(kernel, config); }

CPN::VariantCPNLoader::config

Variant config

Definition: VariantCPNLoader.h:82

CPN::VariantCPNLoader::Setup

void Setup(CPN::Kernel *kernel)

Definition: VariantCPNLoader.h:67

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::VariantCPNLoader::Setup	(	CPN::Kernel *	kernel,
		Variant	args
	)

static

Definition at line 225 of file VariantCPNLoader.cc.

References LoadNodes(), and LoadQueues().

                                                                 {
         LoadNodes(kernel, args.Get("nodes", Variant::ListType), args.Get("nodemap", Variant::MapType));
         LoadQueues(kernel, args.Get("queues", Variant::ListType));
     }

Here is the call graph for this function:

void CPN::VariantCPNLoader::SwallowBrokenQueueExceptions ( bool value )

Definition at line 49 of file VariantCPNLoader.cc.

References config.

                                                                   {
         config["swallow-broken-queue-exceptions"] = value;
     }

void CPN::VariantCPNLoader::UseD4R ( bool value )

Definition at line 41 of file VariantCPNLoader.cc.

References config.

                                             {
         config["d4r"] = value;
     }

std::pair<bool, std::string> CPN::VariantCPNLoader::Validate ( )

inline

Definition at line 64 of file VariantCPNLoader.h.

References config, and Validate().

Referenced by Validate().

64 { return Validate(config); }

CPN::VariantCPNLoader::config

Variant config

Definition: VariantCPNLoader.h:82

CPN::VariantCPNLoader::Validate

std::pair< bool, std::string > Validate()

Definition: VariantCPNLoader.h:64

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< bool, std::string > CPN::VariantCPNLoader::Validate ( Variant conf )

static

Definition at line 303 of file VariantCPNLoader.cc.

                                                                     {
         set<string> nodeset;
         if (!conf.Contains("name")) {
             return make_pair(false, "Kernels must have a name.");
         }
 
         if (conf.Contains("nodes")) {
             Variant nodes = conf["nodes"];
             Variant::ListIterator nitr = nodes.ListBegin(), nend = nodes.ListEnd();
             for (; nitr != nend; ++nitr) {
                 if (!nitr->Contains("name")) {
                     return make_pair(false, "Nodes must have a name");
                 }
                 if (!nitr->Contains("type")) {
                     return make_pair(false, "Nodes must have a type");
                 }
                 if (!nodeset.insert(nitr->At("name").AsString()).second) {
                     return make_pair(false, "Duplicate node");
                 }
             }
         }
         if (conf.Contains("queues")) {
             map<string, set<string> > readports, writeports;
             Variant queues = conf["queues"];
             Variant::ListIterator qitr = queues.ListBegin(), qend = queues.ListEnd();
             for (;qitr != qend; ++qitr) {
                 if (!qitr->Contains("size")) {
                     return make_pair(false, "Queues must have a size");
                 }
                 if (!qitr->Contains("threshold")) {
                     return make_pair(false, "Queues must have a threshold");
                 }
                 if (!qitr->Contains("readernode")) {
                     return make_pair(false, "Queues must have a readernode");
                 }
                 if (!qitr->Contains("readerport")) {
                     return make_pair(false, "Queues must have a readerport");
                 }
                 if (!readports[qitr->At("readernode").AsString()].insert(qitr->At("readerport").AsString()).second) {
                     return make_pair(false, "Two queues connected to the same reader port.");
                 }
                 if (!qitr->Contains("writernode")) {
                     return make_pair(false, "Queues must have a writernode");
                 }
                 if (!qitr->Contains("writerport")) {
                     return make_pair(false, "Queues must have a writerport");
                 }
                 if (!writeports[qitr->At("writernode").AsString()].insert(qitr->At("writerport").AsString()).second) {
                     return make_pair(false, "Two queues connected to the same writer port.");
                 }
             }
         }
         return make_pair(true, "");
     }

Member Data Documentation

Variant CPN::VariantCPNLoader::config

private

Definition at line 82 of file VariantCPNLoader.h.

Referenced by AddLib(), AddLibList(), AddLibPath(), AddNode(), AddNodeMapping(), AddQueue(), ContextHost(), ContextPort(), GetConfig(), GetKernelAttr(), GrowQueueMaxThreshold(), KernelHost(), KernelName(), KernelPort(), LogLevel(), MergeConfig(), Setup(), SwallowBrokenQueueExceptions(), UseD4R(), and Validate().

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

include/cpn/VariantCPNLoader.h
lib/VariantCPNLoader.cc

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation