F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Piles o' doxygen

Browse Source
This commit is contained in:
Craig Dowell
2009-10-04 21:46:30 -07:00
parent dae80627ee
commit 4f45471b71
10 changed files with 377 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/helper/application-container.h
View File

@@ -37,7 +37,6 @@ namespace ns3 {
* add a Ptr<Application> to that application into a Container for use
* by the caller. This is that container used to hold the Ptr<Application>
* which are instantiated by the Application helper.
*
*/
class ApplicationContainer
{
@@ -52,16 +51,16 @@ public:
* been previously instantiated. The single application is specified
* by a smart pointer.
*
* \param application The application to add to the container.
* \param application The Ptr<Application> to add to the container.
*/
ApplicationContainer (Ptr<Application> application);
/**
* Create an ApplicationContainer with exactly one application which has
* been previously instantiated and assigned a name using the Object name
* service. This Application is specified by its assigned name.
* been previously instantiated and assigned a name using the Object Name
* Service. This Application is then specified by its assigned name.
*
* \param name The name of the application object to add to the container.
* \param name The name of the Application Object to add to the container.
*/
ApplicationContainer (std::string name);
@@ -89,7 +88,7 @@ public:
Iterator Begin (void) const;
/**
* \brief Get an iterator which indicates to the last Application in the
* \brief Get an iterator which indicates past-the-last Application in the
* container.
*
* Applications can be retrieved from the container in two ways. First,
@@ -141,10 +140,10 @@ public:
* indexed Ptr<Appliation>.
*
* \code
* uint32_t nApplications = continer.GetN ();
* uint32_t nApplications = container.GetN ();
* for (uint32_t i = 0 i < nApplications; ++i)
* {
* Ptr<Application> p = continer.Get (i)
* Ptr<Application> p = container.Get (i)
* i->method (); // some Application method
* }
* \endcode
@@ -163,7 +162,7 @@ public:
void Add (ApplicationContainer other);
/**
* \brief Append the single Ptr<Application> to this container.
* \brief Append a single Ptr<Application> to this container.
*
* \param application The Ptr<Application> to append.
*/
@@ -173,7 +172,7 @@ public:
* \brief Append to this container the single Ptr<Application> referred to
* via its object name service registered name.
*
* \param name The name of the application object to add to the container.
* \param name The name of the Application Object to add to the container.
*/
void Add (std::string name);

4
src/helper/ipv4-list-routing-helper.h
View File

@@ -42,8 +42,8 @@ public:
Ipv4ListRoutingHelper ();
/*
* Construct an Ipv4ListRoutingHelper used to make installing routing
* protocols easier.
* \internal
* Destroy an Ipv4ListRoutingHelper.
*/
virtual ~Ipv4ListRoutingHelper ();

1
src/helper/ipv4-static-routing-helper.h
View File

@@ -162,7 +162,6 @@ private:
* assignment and prevent the compiler from happily inserting its own.
*/
Ipv4StaticRoutingHelper &operator = (const Ipv4StaticRoutingHelper &o);
};
} // namespace ns3

20
src/helper/ipv6-list-routing-helper.h
View File

@@ -37,9 +37,24 @@ namespace ns3 {
class Ipv6ListRoutingHelper : public Ipv6RoutingHelper
{
public:
/**
* Construct an Ipv6 Ipv6ListRoutingHelper which is used to make life easier
* for people wanting to configure routing using Ipv6.
*/
Ipv6ListRoutingHelper ();
/**
* \internal
* Destroy an Ipv6 Ipv6ListRoutingHelper.
*/
virtual ~Ipv6ListRoutingHelper ();
/**
* \brief Construct an Ipv6ListRoutingHelper from another previously
* initialized instance (Copy Constructor).
*/
Ipv6ListRoutingHelper (const Ipv6ListRoutingHelper &);
/**
* \returns pointer to clone of this Ipv6ListRoutingHelper
*
@@ -67,6 +82,11 @@ public:
*/
virtual Ptr<Ipv6RoutingProtocol> Create (Ptr<Node> node) const;
private:
/**
* \internal
* \brief Assignment operator declared private and not implemented to disallow
* assignment and prevent the compiler from happily inserting its own.
*/
Ipv6ListRoutingHelper &operator = (const Ipv6ListRoutingHelper &o);
std::list<std::pair<const Ipv6RoutingHelper *,int16_t> > m_list;

5
src/helper/ipv6-routing-helper.h
View File

@@ -40,6 +40,11 @@ class Node;
class Ipv6RoutingHelper
{
public:
/**
* \internal
* Destroy an Ipv6 Ipv6RoutingHelper.
*/
virtual ~Ipv6RoutingHelper ();
/**

35
src/helper/ipv6-static-routing-helper.h
View File

@@ -45,8 +45,15 @@ public:
* \brief Constructor.
*/
Ipv6StaticRoutingHelper ();
Ipv6StaticRoutingHelper (const Ipv6StaticRoutingHelper &);
/**
* \brief Construct an Ipv6ListRoutingHelper from another previously
* initialized instance (Copy Constructor).
*/
Ipv6StaticRoutingHelper (const Ipv6StaticRoutingHelper &);
/**
* \internal
* \returns pointer to clone of this Ipv6StaticRoutingHelper
*
* This method is mainly for internal use by the other helpers;
@@ -69,12 +76,33 @@ public:
*/
Ptr<Ipv6StaticRouting> GetStaticRouting (Ptr<Ipv6> ipv6) const;
/**
* \brief Add a multicast route to a node and net device using explicit
* Ptr<Node> and Ptr<NetDevice>
*/
void AddMulticastRoute (Ptr<Node> n, Ipv6Address source, Ipv6Address group,
Ptr<NetDevice> input, NetDeviceContainer output);
/**
* \brief Add a multicast route to a node and device using a name string
* previously associated to the node using the Object Name Service and a
* Ptr<NetDevice>
*/
void AddMulticastRoute (std::string n, Ipv6Address source, Ipv6Address group,
Ptr<NetDevice> input, NetDeviceContainer output);
/**
* \brief Add a multicast route to a node and device using a Ptr<Node> and a
* name string previously associated to the device using the Object Name Service.
*/
void AddMulticastRoute (Ptr<Node> n, Ipv6Address source, Ipv6Address group,
std::string inputName, NetDeviceContainer output);
/**
* \brief Add a multicast route to a node and device using name strings
* previously associated to both the node and device using the Object Name
* Service.
*/
void AddMulticastRoute (std::string nName, Ipv6Address source, Ipv6Address group,
std::string inputName, NetDeviceContainer output);
@@ -89,6 +117,11 @@ public:
void SetDefaultMulticastRoute (std::string nName, std::string ndName);
#endif
private:
/**
* \internal
* \brief Assignment operator declared private and not implemented to disallow
* assignment and prevent the compiler from happily inserting its own.
*/
Ipv6StaticRoutingHelper &operator = (const Ipv6StaticRoutingHelper &o);
};

25
src/helper/mesh-helper.h
View File

@@ -38,9 +38,17 @@ class WifiChannel;
class MeshHelper
{
public:
/**
* Construct a MeshHelper used to make life easier when creating 802.11s networks.
*/
MeshHelper ();
static MeshHelper
Default ();
/**
* \brief Set the helper to the default values for the MAC type, remote
* station manager and channel policy.
*/
static MeshHelper Default ();
/**
* \param n0 the name of the attribute to set
* \param v0 the value of the attribute to set
@@ -118,6 +126,10 @@ public:
SPREAD_CHANNELS,
ZERO_CHANNEL
};
/**
* \brief set the channel policy
*/
void SetSpreadInterfaceChannels (ChannelPolicy);
/**
* \brief Set a number of interfaces in a mesh network
@@ -163,10 +175,19 @@ public:
std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ());
/**
* \brief Print statistics.
*/
void Report (const ns3::Ptr<ns3::NetDevice>&, std::ostream&);
/**
* \brief Reset statistics.
*/
void ResetStats (const ns3::Ptr<ns3::NetDevice>&);
private:
/**
* \internal
* \returns a WifiNetDevice with ready-to-use interface
*/
Ptr<WifiNetDevice> CreateInterface (const WifiPhyHelper &phyHelper, Ptr<Node> node, uint16_t channelId) const;

12
src/helper/mobility-helper.h
View File

@@ -40,7 +40,16 @@ class MobilityModel;
class MobilityHelper
{
public:
/**
* Construct a Mobility Helper which is used to make life easier when working
* with mobility models.
*/
MobilityHelper ();
/**
* \internal
* Destroy a Mobility Helper
*/
~MobilityHelper ();
/**
@@ -241,6 +250,9 @@ public:
static void EnableAsciiAll (std::ostream &os);
private:
/**
* \internal
*/
static void CourseChanged (std::ostream *os, Ptr<const MobilityModel> mobility);
std::vector<Ptr<MobilityModel> > m_mobilityStack;
ObjectFactory m_mobility;

114
src/helper/net-device-container.h
View File

@@ -29,6 +29,14 @@ namespace ns3 {
/**
* \brief holds a vector of ns3::NetDevice pointers
*
* Typically ns-3 NetDevices are installed on nodes using a net device
* helper. The helper Install method takes a NodeContainer which holds
* some number of Ptr<Node>. For each of the Nodes in the NodeContainer
* the helper will instantiate a net device, add a MAC address and a queue
* to the device and install it to the node. For each of the devices, the
* helper also adds the device into a Container for later use by the caller.
* This is that container used to hold the Ptr<NetDevice> which are
* instantiated by the device helper.
*/
class NetDeviceContainer
{
@@ -39,18 +47,26 @@ public:
* Create an empty NetDeviceContainer.
*/
NetDeviceContainer ();
/**
* \param dev a device to add to the container
*
* Create a NetDeviceContainer with exactly one device
* Create a NetDeviceContainer with exactly one net device that has previously
* been instantiated
*/
NetDeviceContainer (Ptr<NetDevice> dev);
/**
* \param devName The name of a device to add to the container
* Create a NetDeviceContainer with exactly one device which has been
* previously instantiated and assigned a name using the Object name
* service. This NetDevice is specified by its assigned name.
*
* \param devName The name of the device to add to the container
*
* Create a NetDeviceContainer with exactly one device
*/
NetDeviceContainer (std::string devName);
/**
* \param a a device container
* \param b another device container
@@ -69,40 +85,112 @@ public:
NetDeviceContainer (const NetDeviceContainer &a, const NetDeviceContainer &b);
/**
* \returns an iterator which points to the start of the array of pointers.
* \brief Get an iterator which refers to the first NetDevice in the
* container.
*
* NetDevices can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the iterator method and is typically used in a
* for-loop to run through the NetDevices
*
* \code
* NetDeviceContainer::Iterator i;
* for (i = container.Begin (); i != container.End (); ++i)
* {
* (*i)->method (); // some NetDevice method
* }
* \endcode
*
* \returns an iterator which refers to the first NetDevice in the container.
*/
Iterator Begin (void) const;
/**
* \returns an iterator which points to the end of the array of pointers.
* \brief Get an iterator which indicates past-the-last NetDevice in the
* container.
*
* NetDevices can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the iterator method and is typically used in a
* for-loop to run through the NetDevices
*
* \code
* NetDeviceContainer::Iterator i;
* for (i = container.Begin (); i != container.End (); ++i)
* {
* (*i)->method (); // some NetDevice method
* }
* \endcode
*
* \returns an iterator which indicates an ending condition for a loop.
*/
Iterator End (void) const;
/**
* \returns the number of netdevice pointers stored in this container.
* \brief Get the number of Ptr<NetDevice> stored in this container.
*
* NetDevices can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the direct method and is typically used to
* define an ending condition in a for-loop that runs through the stored
* NetDevices
*
* \code
* uint32_t nDevices = container.GetN ();
* for (uint32_t i = 0 i < nDevices; ++i)
* {
* Ptr<NetDevice> p = container.Get (i)
* i->method (); // some NetDevice method
* }
* \endcode
*
* \returns the number of Ptr<NetDevice> stored in this container.
*/
uint32_t GetN (void) const;
/**
* \param i the index of the requested netdevice pointer.
* \returns the requested netdevice pointer.
* \brief Get the Ptr<NetDevice> stored in this container at a given
* index.
*
* NetDevices can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the direct method and is used to retrieve the
* indexed Ptr<NetDevice>.
*
* \code
* uint32_t nDevices = container.GetN ();
* for (uint32_t i = 0 i < nDevices; ++i)
* {
* Ptr<NetDevice> p = container.Get (i)
* i->method (); // some NetDevice method
* }
* \endcode
*
* \param i the index of the requested device pointer.
* \returns the requested device pointer.
*/
Ptr<NetDevice> Get (uint32_t i) const;
/**
* \param other another netdevice container
* \brief Append the contents of another NetDeviceContainer to the end of
* this container.
*
* Append to the end of this container the other input container.
* \param The NetDeviceContainer to append.
*/
void Add (NetDeviceContainer other);
/**
* \param device another netdevice pointer.
* \brief Append a single Ptr<NetDevice> to this container.
*
* Append to the end of this container the input netdevice pointer.
* \param application The Ptr<NetDevice> to append.
*/
void Add (Ptr<NetDevice> device);
/**
* \param deviceName The name of another netdevice to add.
* \brief Append to this container the single Ptr<NetDevice> referred to
* via its object name service registered name.
*
* Append to the end of this container the input netdevice pointer.
* \param name The name of the NetDevice Object to add to the container.
*/
void Add (std::string deviceName);

194
src/helper/node-container.h
View File

@@ -29,6 +29,11 @@ namespace ns3 {
/**
* \brief keep track of a set of node pointers.
*
* Typically ns-3 helpers operate on more than one node at a time. For example
* a device helper may want to install devices on a large number of similar
* nodes. The helper Install methods usually take a NodeContainer as a
* parameter. NodeContainers hold the multiple Ptr<Node> which are used
* to refer to the nodes.
*/
class NodeContainer
{
@@ -39,25 +44,31 @@ public:
* Create an empty NodeContainer.
*/
NodeContainer ();
/**
* \param node a node to add to the container
* Create a NodeContainer with exactly one node which has been previously
* instantiated. The single Node is specified by a smart pointer.
*
* Create a NodeContainer with exactly one node.
* \param node The Ptr<Node> to add to the container.
*/
NodeContainer (Ptr<Node> node);
/**
* \param nodeName The name of a node to add to the container
* Create a NodeContainer with exactly one node which has been previously
* instantiated and assigned a name using the Object Name Service. This
* Node is then specified by its assigned name.
*
* Create a NodeContainer with exactly one node.
* \param name The name of the Node Object to add to the container.
*/
NodeContainer (std::string nodeName);
/**
* \param a a node container
* \param b another node container
*
* Create a node container which is a concatenation of the two input
* Create a node container which is a concatenation of two input
* NodeContainers.
*
* \param a The first NodeContainer
* \param b The second NodeContainer
*
* \note A frequently seen idiom that uses these constructors involves the
* implicit conversion by constructor of Ptr<Node>. When used, two
* Ptr<Node> will be passed to this constructor instead of NodeContainer&.
@@ -68,60 +79,197 @@ public:
*/
NodeContainer (const NodeContainer &a, const NodeContainer &b);
/**
* Create a node container which is a concatenation of three input
* NodeContainers.
*
* \param a The first NodeContainer
* \param b The second NodeContainer
* \param c The third NodeContainer
*
* \note A frequently seen idiom that uses these constructors involves the
* implicit conversion by constructor of Ptr<Node>. When used, two
* Ptr<Node> will be passed to this constructor instead of NodeContainer&.
* C++ will notice the implicit conversion path that goes through the
* NodeContainer (Ptr<Node> node) constructor above. Using this conversion
* one may provide optionally provide arguments of Ptr<Node> to these
* constructors.
*/
NodeContainer (const NodeContainer &a, const NodeContainer &b, const NodeContainer &c);
/**
* Create a node container which is a concatenation of four input
* NodeContainers.
*
* \param a The first NodeContainer
* \param b The second NodeContainer
* \param c The third NodeContainer
* \param d The fourth NodeContainer
*
* \note A frequently seen idiom that uses these constructors involves the
* implicit conversion by constructor of Ptr<Node>. When used, two
* Ptr<Node> will be passed to this constructor instead of NodeContainer&.
* C++ will notice the implicit conversion path that goes through the
* NodeContainer (Ptr<Node> node) constructor above. Using this conversion
* one may provide optionally provide arguments of Ptr<Node> to these
* constructors.
*/
NodeContainer (const NodeContainer &a, const NodeContainer &b, const NodeContainer &c, const NodeContainer &d);
/**
* Create a node container which is a concatenation of five input
* NodeContainers.
*
* \param a The first NodeContainer
* \param b The second NodeContainer
* \param c The third NodeContainer
* \param d The fourth NodeContainer
* \param e The fifth NodeContainer
*
* \note A frequently seen idiom that uses these constructors involves the
* implicit conversion by constructor of Ptr<Node>. When used, two
* Ptr<Node> will be passed to this constructor instead of NodeContainer&.
* C++ will notice the implicit conversion path that goes through the
* NodeContainer (Ptr<Node> node) constructor above. Using this conversion
* one may provide optionally provide arguments of Ptr<Node> to these
* constructors.
*/
NodeContainer (const NodeContainer &a, const NodeContainer &b, const NodeContainer &c, const NodeContainer &d,
const NodeContainer &e);
/**
* \returns an iterator to the start of the vector of node pointers.
* \brief Get an iterator which refers to the first Node in the
* container.
*
* Nodes can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the iterator method and is typically used in a
* for-loop to run through the Nodes
*
* \code
* NodeContainer::Iterator i;
* for (i = container.Begin (); i != container.End (); ++i)
* {
* (*i)->method (); // some Node method
* }
* \endcode
*
* \returns an iterator which refers to the first Node in the container.
*/
Iterator Begin (void) const;
/**
* \returns an iterator to the end of the vector of node pointers.
* \brief Get an iterator which indicates past-the-last Node in the
* container.
*
* Nodes can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the iterator method and is typically used in a
* for-loop to run through the Nodes
*
* \code
* NodeContainer::Iterator i;
* for (i = container.Begin (); i != container.End (); ++i)
* {
* (*i)->method (); // some Node method
* }
* \endcode
*
* \returns an iterator which indicates an ending condition for a loop.
*/
Iterator End (void) const;
/**
* \returns the number of node pointers stored in this NodeContainer.
* \brief Get the number of Ptr<Node> stored in this container.
*
* Nodes can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the direct method and is typically used to
* define an ending condition in a for-loop that runs through the stored
* Nodes
*
* \code
* uint32_t nNodes = continer.GetN ();
* for (uint32_t i = 0 i < nNodes; ++i)
* {
* Ptr<Node> p = continer.Get (i)
* i->method (); // some Node method
* }
* \endcode
*
* \returns the number of Ptr<Node> stored in this container.
*/
uint32_t GetN (void) const;
/**
* \brief Get the Ptr<Node> stored in this container at a given
* index.
*
* Nodes can be retrieved from the container in two ways. First,
* directly by an index into the container, and second, using an iterator.
* This method is used in the direct method and is used to retrieve the
* indexed Ptr<Appliation>.
*
* \code
* uint32_t nNodes = container.GetN ();
* for (uint32_t i = 0 i < nNodes; ++i)
* {
* Ptr<Node> p = container.Get (i)
* i->method (); // some Node method
* }
* \endcode
*
* \param i the index of the requested node pointer.
* \returns the requested node pointer.
*/
Ptr<Node> Get (uint32_t i) const;
/**
* \param n the number of nodes to create
* \brief Create n nodes and append pointers to them to the end of this
* NodeContainer.
*
* Create n nodes and append pointers to them to the end of this NodeContainer.
* Nodes are at the heart of any ns-3 simulation. One of the first tasks that
* any simulation needs to do is to create a number of nodes. This method
* automates that task.
*
* \param n The number of Nodes to create
*/
void Create (uint32_t n);
/**
* \param other another NodeContainer
* \brief Append the contents of another NodeContainer to the end of
* this container.
*
* Append the node pointers from the input NodeContainer at the end
* of this NodeContainer.
* \param The NodeContainer to append.
*/
void Add (NodeContainer other);
/**
* \param node a node pointer
* \brief Append a single Ptr<Node> to this container.
*
* Append the input node pointer at the end of this NodeContainer.
* \param node The Ptr<Node> to append.
*/
void Add (Ptr<Node> node);
/**
* \param nodeName The name of a node
* \brief Append to this container the single Ptr<Node> referred to
* via its object name service registered name.
*
* Append the input node pointer at the end of this NodeContainer.
* \param nodeName The name of the Node Object to add to the container.
*/
void Add (std::string nodeName);
/**
* \returns a container which contains a list of _all_ nodes
* created through NodeContainer::Create and stored
* in ns3::NodeList.
* \brief Create a NodeContainer that contains a list of _all_ nodes
* created through NodeContainer::Create() and stored in the
* ns3::NodeList.
*
* Whenever a Node is created, a Ptr<Node> is added to a global list of all
* nodes in the system. It is sometimes useful to be able to get to all
* nodes in one place. This method creates a NodeContainer that is
* initialized to contain all of the simulation nodes,
*
* \returns a NoceContainer which contains a list of all Nodes.
*/
static NodeContainer GetGlobal (void);