This file is indexed.

/usr/include/ns3.26/ns3/building-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
205
206
207
208
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008 INRIA
 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
 *
 * 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> (original node-container.h)
 *         Nicola Baldo (wrote building-container.h based on node-container.h)
 */
#ifndef BUILDING_CONTAINER_H
#define BUILDING_CONTAINER_H

#include <stdint.h>
#include <vector>
#include <ns3/building.h>

namespace ns3 {

/**
 * \brief keep track of a set of building pointers.
 *
 * Some ns-3 helpers operate on more than one building at a time.  For example
 * a PositionAllocator may want to position nodes on a set of buildings.
 * The helper methods will then usually take a BuildingContainer as a
 * parameter.  BuildingContainers hold the multiple Ptr<Building> which are used
 * to refer to the buildings.
 */
class BuildingContainer
{
public:
  typedef std::vector<Ptr<Building> >::const_iterator Iterator;

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

  /**
   * Create a BuildingContainer with exactly one building which has been previously
   * instantiated.  The single Building is specified by a smart pointer.
   *
   * \param building The Ptr<Building> to add to the container.
   */
  BuildingContainer (Ptr<Building> building);

  /**
   * Create a BuildingContainer with exactly one building which has been previously 
   * instantiated and assigned a name using the Object Name Service.  This 
   * Building is then specified by its assigned name. 
   *
   * \param buildingName The name of the Building Object to add to the container.
   */
  BuildingContainer (std::string buildingName);

  /**
   * \brief Get an iterator which refers to the first Building in the 
   * container.
   *
   * Buildings 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 Buildings
   *
   * \code
   *   BuildingContainer::Iterator i;
   *   for (i = container.Begin (); i != container.End (); ++i)
   *     {
   *       (*i)->method ();  // some Building method
   *     }
   * \endcode
   *
   * \returns an iterator which refers to the first Building in the container.
   */
  Iterator Begin (void) const;

  /**
   * \brief Get an iterator which indicates past-the-last Building in the 
   * container.
   *
   * Buildings 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 Buildings
   *
   * \code
   *   BuildingContainer::Iterator i;
   *   for (i = container.Begin (); i != container.End (); ++i)
   *     {
   *       (*i)->method ();  // some Building method
   *     }
   * \endcode
   *
   * \returns an iterator which indicates an ending condition for a loop.
   */
  Iterator End (void) const;

  /**
   * \brief Get the number of Ptr<Building> stored in this container.
   *
   * Buildings 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
   * Buildings
   *
   * \code
   *   uint32_t nBuildings = container.GetN ();
   *   for (uint32_t i = 0 i < nBuildings; ++i)
   *     {
   *       Ptr<Building> p = container.Get (i)
   *       i->method ();  // some Building method
   *     }
   * \endcode
   *
   * \returns the number of Ptr<Building> stored in this container.
   */
  uint32_t GetN (void) const;

  /**
   * \brief Get the Ptr<Building> stored in this container at a given
   * index.
   *
   * Buildings 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 nBuildings = container.GetN ();
   *   for (uint32_t i = 0 i < nBuildings; ++i)
   *     {
   *       Ptr<Building> p = container.Get (i)
   *       i->method ();  // some Building method
   *     }
   * \endcode
   *
   * \param i the index of the requested building pointer.
   * \returns the requested building pointer.
   */
  Ptr<Building> Get (uint32_t i) const;

  /**
   * \brief Create n buildings and append pointers to them to the end of this 
   * BuildingContainer.
   *
   * Buildings 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 buildings.  This method
   * automates that task.
   *
   * \param n The number of Buildings to create
   */
  void Create (uint32_t n);

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

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

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

  /**
   * \brief Create a BuildingContainer that contains a list of _all_ buildings
   * stored in the ns3::BuildingList.
   *
   * Whenever a Building is created, a Ptr<Building> is added to a global list of all
   * buildings in the system.  It is sometimes useful to be able to get to all
   * buildings in one place.  This method creates a BuildingContainer that is 
   * initialized to contain all of the simulation buildings,
   *
   * \returns a BuildingContainer which contains a list of all Buildings.
   */
  static BuildingContainer GetGlobal (void);

private:
  std::vector<Ptr<Building> > m_buildings;
};

} // namespace ns3

#endif /* BUILDING_CONTAINER_H */