This file is indexed.

/usr/include/ns3.26/ns3/net-device-container.h is in libns3-dev 3.26+dfsg-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#ifndef NET_DEVICE_CONTAINER_H
#define NET_DEVICE_CONTAINER_H

#include <stdint.h>
#include <vector>
#include "ns3/net-device.h"

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
{
public:
  /// NetDevice container iterator
  typedef std::vector<Ptr<NetDevice> >::const_iterator Iterator;

  /**
   * Create an empty NetDeviceContainer.
   */
  NetDeviceContainer ();

  /**
   * \param dev a device to add to the container
   *
   * Create a NetDeviceContainer with exactly one net device that has previously
   * been instantiated
   */
  NetDeviceContainer (Ptr<NetDevice> dev);

  /**
   * 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
   *
   * Create a device container which is a concatenation of the two input
   * NetDeviceContainers.
   *
   * \note A frequently seen idiom that uses these constructors involves the
   * implicit conversion by constructor of Ptr<NetDevice>.  When used, two 
   * Ptr<NetDevice> will be passed to this constructor instead of NetDeviceContainer&.
   * C++ will notice the implicit conversion path that goes through the 
   * NetDeviceContainer (Ptr<NetDevice> dev) constructor above.  Using this conversion
   * one may provide optionally provide arguments of Ptr<NetDevice> to these 
   * constructors.
   */
  NetDeviceContainer (const NetDeviceContainer &a, const NetDeviceContainer &b);

  /**
   * \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;

  /**
   * \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;

  /**
   * \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;

  /**
   * \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;

  /**
   * \brief Append the contents of another NetDeviceContainer to the end of
   * this container.
   *
   * \param other The NetDeviceContainer to append.
   */
  void Add (NetDeviceContainer other);

  /**
   * \brief Append a single Ptr<NetDevice> to this container.
   *
   * \param device The Ptr<NetDevice> to append.
   */
  void Add (Ptr<NetDevice> device);

  /**
   * \brief Append to this container the single Ptr<NetDevice> referred to
   * via its object name service registered name.
   *
   * \param deviceName The name of the NetDevice Object to add to the container.
   */
  void Add (std::string deviceName);

private:
  std::vector<Ptr<NetDevice> > m_devices; //!< NetDevices smart pointers
};

} // namespace ns3

#endif /* NET_DEVICE_CONTAINER_H */