From b9e6974c8eabafa9d80ce235c6fbadfac9c8d8a6 Mon Sep 17 00:00:00 2001
From: Tom Henderson <tomh@tomh.org>
Date: Mon, 19 Mar 2007 22:19:38 -0700
Subject: [PATCH] Add static node factory methods to class Node

---
 SConstruct       |  2 ++
 src/node/node.cc | 70 +++++++++++++++++++++++++++++++++++++++++++++---
 src/node/node.h  | 37 +++++++++++++++++++++++--
 3 files changed, 104 insertions(+), 5 deletions(-)

diff --git a/SConstruct b/SConstruct
index 8b7bc5bf1..e938e91c6 100644
--- a/SConstruct
+++ b/SConstruct
@@ -175,6 +175,8 @@ common.add_inst_headers([
     'array-trace-resolver.h',
     'trace-root.h',
     'terminal-trace-resolver.h',
+    'smartvector.h',
+    'smartset.h',
     ])
 
 node = build.Ns3Module ('node', 'src/node')
diff --git a/src/node/node.cc b/src/node/node.cc
index 50cfe9c07..e912055c0 100644
--- a/src/node/node.cc
+++ b/src/node/node.cc
@@ -23,15 +23,24 @@
 // George F. Riley, Georgia Tech, Fall 2006
 
 #include "node.h"
+#include "internet-node.h"
 
 namespace ns3{
 
-uint32_t Node::m_nodeId = 0;
+uint32_t Node::g_nextId = 0;
+Node::SmartNodeVec_t Node::g_prototypes;  // The node prototypes stack
+Node::SmartNodeVec_t Node::g_nodes;       // All nodes
 
 Node::Node()
-  : m_id(m_nodeId), m_sid(0)
+  : m_id(g_nextId), m_sid(0)
 {
-  m_nodeId++;
+  g_nextId++;
+}
+
+Node::Node(uint32_t sid)
+  : m_id(g_nextId), m_sid(sid)
+{ 
+  g_nextId++;
 }
   
 Node::~Node ()
@@ -55,6 +64,61 @@ Node::SetSystemId(uint32_t s )
   m_sid = s;
 }
 
+// Node stack creation and management routines.
+Node* Node::Create()
+{
+  if (g_prototypes.Empty()) CreateDefaultPrototype();
+  Node* n = g_prototypes.Back()->Copy(); // Copy the top of the stack
+  n->m_id = g_nextId++;                  // Set unique node id
+  g_nodes.Add(n);                        // Add to list of known nodes
+  return n;
+}
+
+Node* Node::Create(uint32_t sid)
+{ // Create with distributed simulation systemid
+  // ! Need to check if sid matches DistributedSimulator system id,
+  // and create an empty (ghost) node if so.  Code this later
+  Node* n = Create(sid);
+  return n;
+}
+
+Node* Node::GetNodePrototype()
+{ // Get node* to top of prototypes stack
+  if (g_prototypes.Empty()) CreateDefaultPrototype();
+  return g_prototypes.Back();
+}
+
+Node* Node::PushNodePrototype(const Node& n)
+{ // Add a new node to the top of the prototypes stack
+  g_prototypes.Add(n.Copy());
+  return g_prototypes.Back();
+}
+
+Node* Node::PushNodePrototype() 
+{ // Replicate the top of the prototype stack
+  if (g_prototypes.Empty()) CreateDefaultPrototype();
+  g_prototypes.Add(GetNodePrototype()->Copy());
+  return g_prototypes.Back();
+}
+
+void Node::PopNodePrototype()
+{ 
+  if (!g_prototypes.Empty()) g_prototypes.Remove();
+}
+
+void Node::ClearAll()
+{ // Delete all nodes for memory leak checking, including prototypes
+  g_nodes.Clear();
+  g_prototypes.Clear();
+}
+
+// Private method to ceate a reasonable default if stack is empty
+void Node::CreateDefaultPrototype()
+{
+  Node* n = new InternetNode();
+  g_prototypes.Add(n);
+}
+
 L3Demux*
 Node::GetL3Demux() const
 {
diff --git a/src/node/node.h b/src/node/node.h
index b8ef6278e..20be77afc 100644
--- a/src/node/node.h
+++ b/src/node/node.h
@@ -91,6 +91,8 @@
 #include <vector>
 #include <list>
 
+#include "ns3/smartvector.h"
+
 namespace ns3 {
 
 class L3Demux;
@@ -104,8 +106,9 @@ class TraceResolver;
 
 class Node {
 public:
-
+  typedef SmartVector<Node*> SmartNodeVec_t;
   Node();
+  Node(uint32_t); // Specify which system for a distributed simulation
   virtual ~Node();
   virtual Node* Copy() const = 0;// Make a copy of this node
 
@@ -115,6 +118,36 @@ public:
   uint32_t GetSystemId (void) const;
   void SetSystemId(uint32_t s);
 
+  // Static methods for creating nodes and managing the node stack
+
+  // Create a new node.  The node will be a copy of the top of the
+  // node prototype list
+  static Node* Create();
+  // Create with a uint32_t is used by distributed simulations to
+  // indicate system ownership of the new node.
+  static Node* Create(uint32_t);
+  static Node* GetNodePrototype(); // Get the current node prototype
+  // Specifies the type of node to be returned by Create()
+  // This version specifies a pre-configured node to use as the prototype
+  // Of course the passed object can be any subclass of Node.
+  static Node* PushNodePrototype(const Node&); 
+  // THis version replicates the top of the prototype stack
+  static Node* PushNodePrototype();
+  // Remove the top of the prototype stack
+  static void PopNodePrototype();
+  // Node access
+  static const SmartNodeVec_t& Nodes(); // Get a vector of all nodes
+  static void  ClearAll();          // Delete all nodes for memory leak checking
+  static void  ClearAllPrototypes();// Delete the prototype stack
+private: 
+  static void  CreateDefaultPrototype(); // Create a "typical" prototype node
+  // Global static variables
+private: 
+  static uint32_t       g_nextId;     // Next available ID
+  static SmartNodeVec_t g_nodes;      // Vector of all nodes created
+  static SmartNodeVec_t g_prototypes; // Node prototype stack
+
+public:
   // Virtual "Getters" for each capability.
   // These exist to allow owners of a generic Node pointer to get
   // a pointer to the underlying capability, a pointer to a "NULL"
@@ -135,5 +168,5 @@ private:
   uint32_t    m_sid;        // System id for this node
 };
 
-}; //namespace ns3
+} //namespace ns3
 #endif