Attachment #2911 for bug #2780

View | Details | Raw Unified | Return to bug 2780
Collapse All | Expand All

(-)a/src/core/model/object-factory.cc (-1 / +1 lines)

Lines 61-67 ObjectFactory::SetTypeId (const char *tid)	Link Here

  m_tid = TypeId::LookupByName (tid);

  m_tid = TypeId::LookupByName (tid);

void

void

ObjectFactory::Set (std::string name, const AttributeValue &value)

ObjectFactory::DoSet (std::string name, const AttributeValue &value)

  NS_LOG_FUNCTION (this << name << &value);

  NS_LOG_FUNCTION (this << name << &value);

  if (name == "")

  if (name == "")

(-)a/src/core/model/object-factory.h (-53 / +61 lines)

Lines 23-28	Link Here

#include "attribute-construction-list.h"

#include "attribute-construction-list.h"

#include "object.h"

#include "object.h"

#include "type-id.h"

#include "type-id.h"

#include <map>

#include <functional>

/**

/**

 * \file

 * \file

Lines 75-84 public:	Link Here

/**

/**

   * Set an attribute to be set during construction.

   * Set an attribute to be set during construction.

   * \param [in] name The name of the attribute to set.

   * \param [in] args A sequence of name-value pairs of the attributes to set.

   * \param [in] value The value of the attribute to set.

   * The args sequence can be made of any number of pairs, each consisting of a

   * name (of std::string type) followed by a value (of const AttributeValue & type).

*/

*/

  void Set (std::string name, const AttributeValue &value);

  template <typename... Args>

  void Set (Args&&... args);

/**

/**

   * Get the TypeId which will be created by this ObjectFactory.

   * Get the TypeId which will be created by this ObjectFactory.

Lines 106-111 public:	Link Here

106

  Ptr<T> Create (void) const;

111

  Ptr<T> Create (void) const;

107

112

108

private:

113

private:

114

  template <std::size_t...> struct index_sequence {};

115

116

  template <std::size_t N, std::size_t... Is>

117

  struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};

118

119

  template <std::size_t... Is>

120

  struct make_index_sequence<0u, Is...> : index_sequence<Is...> { using type = index_sequence<Is...>; };

121

122

/**

123

   * Set an attribute to be set during construction.

124

125

   * \param [in] name The name of the attribute to set.

126

   * \param [in] value The value of the attribute to set.

127

*/

128

  void DoSet (std::string name, const AttributeValue &value);

129

/**

130

   * Set all the attributes whose name-value pairs are stored in a tuple.

131

132

   * \param [in] seq A sequence of values from 0 to (size_of_tuple/2)-1.

133

   * \param [in] tuple Tuple containing name-value pairs of the attributes to set.

134

*/

135

  template <std::size_t... Is, typename Tuple>

136

  void SetImpl (index_sequence<Is...> seq, Tuple tuple);

109

/**

137

/**

110

   * Print the factory configuration on an output stream.

138

   * Print the factory configuration on an output stream.

111

139

Lines 147-185 std::istream & operator >> (std::istream &is, ObjectFactory &factory);	Link Here

147

 * Allocate an Object on the heap and initialize with a set of attributes.

175

 * Allocate an Object on the heap and initialize with a set of attributes.

148

176

149

 * \tparam T \explicit The requested Object type.

177

 * \tparam T \explicit The requested Object type.

150

 * \param [in] n1 Name of attribute

178

 * \param [in] args A sequence of name-value pairs of the attributes to set.

151

 * \param [in] v1 Value of attribute

152

 * \param [in] n2 Name of attribute

153

 * \param [in] v2 Value of attribute

154

 * \param [in] n3 Name of attribute

155

 * \param [in] v3 Value of attribute

156

 * \param [in] n4 Name of attribute

157

 * \param [in] v4 Value of attribute

158

 * \param [in] n5 Name of attribute

159

 * \param [in] v5 Value of attribute

160

 * \param [in] n6 Name of attribute

161

 * \param [in] v6 Value of attribute

162

 * \param [in] n7 Name of attribute

163

 * \param [in] v7 Value of attribute

164

 * \param [in] n8 Name of attribute

165

 * \param [in] v8 Value of attribute

166

 * \param [in] n9 Name of attribute

167

 * \param [in] v9 Value of attribute

168

 * \returns A pointer to a newly allocated object.

179

 * \returns A pointer to a newly allocated object.

180

181

 * The args sequence can be made of any number of pairs, each consisting of a

182

 * name (of std::string type) followed by a value (of const AttributeValue & type).

169

*/

183

*/

170

template <typename T>

184

template <typename T, typename... Args>

171

Ptr<T>

185

Ptr<T>

172

CreateObjectWithAttributes

186

CreateObjectWithAttributes (Args... args);

173

  (std::string n1 = "", const AttributeValue & v1 = EmptyAttributeValue (),

174

   std::string n2 = "", const AttributeValue & v2 = EmptyAttributeValue (),

175

   std::string n3 = "", const AttributeValue & v3 = EmptyAttributeValue (),

176

   std::string n4 = "", const AttributeValue & v4 = EmptyAttributeValue (),

177

   std::string n5 = "", const AttributeValue & v5 = EmptyAttributeValue (),

178

   std::string n6 = "", const AttributeValue & v6 = EmptyAttributeValue (),

179

   std::string n7 = "", const AttributeValue & v7 = EmptyAttributeValue (),

180

   std::string n8 = "", const AttributeValue & v8 = EmptyAttributeValue (),

181

   std::string n9 = "", const AttributeValue & v9 = EmptyAttributeValue ()

182

);

183

187

184

188

185

ATTRIBUTE_HELPER_HEADER (ObjectFactory);

189

ATTRIBUTE_HELPER_HEADER (ObjectFactory);

Lines 201-233 ObjectFactory::Create (void) const	Link Here

201

  return object->GetObject<T> ();

205

  return object->GetObject<T> ();

202

206

203

207

204

template <typename T>

208

template <std::size_t... Is, typename Tuple>

209

void

210

ObjectFactory::SetImpl (index_sequence<Is...>, Tuple tuple)

211

212

  std::map<std::string, const AttributeValue &> m {

213

        std::make_pair (std::get<2*Is> (tuple), std::cref (std::get<2*Is+1> (tuple)))...

214

};

215

  for (auto p : m)

216

217

      DoSet (p.first, p.second);

218

219

220

221

template <typename... Args>

222

void

223

ObjectFactory::Set (Args&&... args)

224

225

  static_assert (sizeof...(args) % 2 == 0, "ObjectFactory::Set requires an even number of arguments");

226

  SetImpl (make_index_sequence<sizeof...(args)/2>{}, std::forward_as_tuple (args...));

227

228

229

template <typename T, typename... Args>

205

Ptr<T>

230

Ptr<T>

206

CreateObjectWithAttributes (std::string n1, const AttributeValue & v1,

231

CreateObjectWithAttributes (Args... args)

207

                            std::string n2, const AttributeValue & v2,

208

                            std::string n3, const AttributeValue & v3,

209

                            std::string n4, const AttributeValue & v4,

210

                            std::string n5, const AttributeValue & v5,

211

                            std::string n6, const AttributeValue & v6,

212

                            std::string n7, const AttributeValue & v7,

213

                            std::string n8, const AttributeValue & v8,

214

                            std::string n9, const AttributeValue & v9)

215

232

216

  ObjectFactory factory;

233

  ObjectFactory factory;

217

  factory.SetTypeId (T::GetTypeId ());

234

  factory.SetTypeId (T::GetTypeId ());

218

  factory.Set(n1, v1);

235

  factory.Set (args...);

219

  factory.Set(n2, v2);

220

  factory.Set(n3, v3);

221

  factory.Set(n4, v4);

222

  factory.Set(n5, v5);

223

  factory.Set(n6, v6);

224

  factory.Set(n7, v7);

225

  factory.Set(n8, v8);

226

  factory.Set(n9, v9);

227

  return factory.Create<T> ();

236

  return factory.Create<T> ();

228

237

229

238

230

231

} // namespace ns3

239

} // namespace ns3

232

240

233

#endif /* OBJECT_FACTORY_H */

241

#endif /* OBJECT_FACTORY_H */




#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/queue-limits.h"
#include "ns3/queue.h"
#include "ns3/net-device-queue-interface.h"
#include "ns3/uinteger.h"
#include "ns3/pointer.h"

  return helper;
}

uint16_t
TrafficControlHelper::SetRootQueueDisc (std::string type,
                                        std::string n01, const AttributeValue& v01,
                                        std::string n02, const AttributeValue& v02,
                                        std::string n03, const AttributeValue& v03,
                                        std::string n04, const AttributeValue& v04,
                                        std::string n05, const AttributeValue& v05,
                                        std::string n06, const AttributeValue& v06,
                                        std::string n07, const AttributeValue& v07,
                                        std::string n08, const AttributeValue& v08,
                                        std::string n09, const AttributeValue& v09,
                                        std::string n10, const AttributeValue& v10,
                                        std::string n11, const AttributeValue& v11,
                                        std::string n12, const AttributeValue& v12,
                                        std::string n13, const AttributeValue& v13,
                                        std::string n14, const AttributeValue& v14,
                                        std::string n15, const AttributeValue& v15)
{
  NS_ABORT_MSG_UNLESS (m_queueDiscFactory.empty (), "A root queue disc has been already added to this factory");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (n01, v01);
  factory.Set (n02, v02);
  factory.Set (n03, v03);
  factory.Set (n04, v04);
  factory.Set (n05, v05);
  factory.Set (n06, v06);
  factory.Set (n07, v07);
  factory.Set (n08, v08);
  factory.Set (n09, v09);
  factory.Set (n10, v10);
  factory.Set (n11, v11);
  factory.Set (n12, v12);
  factory.Set (n13, v13);
  factory.Set (n14, v14);
  factory.Set (n15, v15);

  m_queueDiscFactory.push_back (QueueDiscFactory (factory));
  return 0;
}

void
TrafficControlHelper::AddInternalQueues (uint16_t handle, uint16_t count, std::string type,
                                         std::string n01, const AttributeValue& v01,
                                         std::string n02, const AttributeValue& v02,
                                         std::string n03, const AttributeValue& v03,
                                         std::string n04, const AttributeValue& v04,
                                         std::string n05, const AttributeValue& v05,
                                         std::string n06, const AttributeValue& v06,
                                         std::string n07, const AttributeValue& v07,
                                         std::string n08, const AttributeValue& v08)
{
  NS_ABORT_MSG_IF (handle >= m_queueDiscFactory.size (), "A queue disc with handle "
                   << handle << " does not exist");

  QueueBase::AppendItemTypeIfNotPresent (type, "QueueDiscItem");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (n01, v01);
  factory.Set (n02, v02);
  factory.Set (n03, v03);
  factory.Set (n04, v04);
  factory.Set (n05, v05);
  factory.Set (n06, v06);
  factory.Set (n07, v07);
  factory.Set (n08, v08);

  for (int i = 0; i < count; i++)
    {
      m_queueDiscFactory[handle].AddInternalQueue (factory);
    }
}

void
TrafficControlHelper::AddPacketFilter (uint16_t handle, std::string type,
                                       std::string n01, const AttributeValue& v01,
                                       std::string n02, const AttributeValue& v02,
                                       std::string n03, const AttributeValue& v03,
                                       std::string n04, const AttributeValue& v04,
                                       std::string n05, const AttributeValue& v05,
                                       std::string n06, const AttributeValue& v06,
                                       std::string n07, const AttributeValue& v07,
                                       std::string n08, const AttributeValue& v08)
{
  NS_ABORT_MSG_IF (handle >= m_queueDiscFactory.size (), "A queue disc with handle "
                   << handle << " does not exist");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (n01, v01);
  factory.Set (n02, v02);
  factory.Set (n03, v03);
  factory.Set (n04, v04);
  factory.Set (n05, v05);
  factory.Set (n06, v06);
  factory.Set (n07, v07);
  factory.Set (n08, v08);

  m_queueDiscFactory[handle].AddPacketFilter (factory);
}

TrafficControlHelper::ClassIdList
TrafficControlHelper::AddQueueDiscClasses (uint16_t handle, uint16_t count, std::string type,
                                           std::string n01, const AttributeValue& v01,
                                           std::string n02, const AttributeValue& v02,
                                           std::string n03, const AttributeValue& v03,
                                           std::string n04, const AttributeValue& v04,
                                           std::string n05, const AttributeValue& v05,
                                           std::string n06, const AttributeValue& v06,
                                           std::string n07, const AttributeValue& v07,
                                           std::string n08, const AttributeValue& v08)
{
  NS_ABORT_MSG_IF (handle >= m_queueDiscFactory.size (), "A queue disc with handle "
                   << handle << " does not exist");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (n01, v01);
  factory.Set (n02, v02);
  factory.Set (n03, v03);
  factory.Set (n04, v04);
  factory.Set (n05, v05);
  factory.Set (n06, v06);
  factory.Set (n07, v07);
  factory.Set (n08, v08);

  ClassIdList list;
  uint16_t classId;

  for (int i = 0; i < count; i++)
    {
      classId = m_queueDiscFactory[handle].AddQueueDiscClass (factory);
      list.push_back (classId);
    }
  return list;
}

uint16_t
TrafficControlHelper::AddChildQueueDisc (uint16_t handle, uint16_t classId, std::string type,
                                         std::string n01, const AttributeValue& v01,
                                         std::string n02, const AttributeValue& v02,
                                         std::string n03, const AttributeValue& v03,
                                         std::string n04, const AttributeValue& v04,
                                         std::string n05, const AttributeValue& v05,
                                         std::string n06, const AttributeValue& v06,
                                         std::string n07, const AttributeValue& v07,
                                         std::string n08, const AttributeValue& v08,
                                         std::string n09, const AttributeValue& v09,
                                         std::string n10, const AttributeValue& v10,
                                         std::string n11, const AttributeValue& v11,
                                         std::string n12, const AttributeValue& v12,
                                         std::string n13, const AttributeValue& v13,
                                         std::string n14, const AttributeValue& v14,
                                         std::string n15, const AttributeValue& v15)
{
  NS_ABORT_MSG_IF (handle >= m_queueDiscFactory.size (), "A queue disc with handle "
                   << handle << " does not exist");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (n01, v01);
  factory.Set (n02, v02);
  factory.Set (n03, v03);
  factory.Set (n04, v04);
  factory.Set (n05, v05);
  factory.Set (n06, v06);
  factory.Set (n07, v07);
  factory.Set (n08, v08);
  factory.Set (n09, v09);
  factory.Set (n10, v10);
  factory.Set (n11, v11);
  factory.Set (n12, v12);
  factory.Set (n13, v13);
  factory.Set (n14, v14);
  factory.Set (n15, v15);

  uint16_t childHandle = m_queueDiscFactory.size ();
  m_queueDiscFactory.push_back (QueueDiscFactory (factory));
  m_queueDiscFactory[handle].SetChildQueueDisc (classId, childHandle);

  return childHandle;
}

TrafficControlHelper::HandleList
TrafficControlHelper::AddChildQueueDiscs (uint16_t handle, const TrafficControlHelper::ClassIdList &classes,
                                          std::string type,
                                          std::string n01, const AttributeValue& v01,
                                          std::string n02, const AttributeValue& v02,
                                          std::string n03, const AttributeValue& v03,
                                          std::string n04, const AttributeValue& v04,
                                          std::string n05, const AttributeValue& v05,
                                          std::string n06, const AttributeValue& v06,
                                          std::string n07, const AttributeValue& v07,
                                          std::string n08, const AttributeValue& v08,
                                          std::string n09, const AttributeValue& v09,
                                          std::string n10, const AttributeValue& v10,
                                          std::string n11, const AttributeValue& v11,
                                          std::string n12, const AttributeValue& v12,
                                          std::string n13, const AttributeValue& v13,
                                          std::string n14, const AttributeValue& v14,
                                          std::string n15, const AttributeValue& v15)
{
  HandleList list;
  for (ClassIdList::const_iterator c = classes.begin (); c != classes.end (); c++)
    {
      uint16_t childHandle = AddChildQueueDisc (handle, *c, type, n01, v01, n02, v02, n03, v03,
                                                n04, v04, n05, v05, n06, v06, n07, v07, n08, v08, n09, v09,
                                                n10, v10, n11, v11, n12, v12, n13, v13, n14, v14, n15, v15);
      list.push_back (childHandle);
    }
  return list;
}

void
TrafficControlHelper::SetQueueLimits (std::string type,
                                      std::string n01, const AttributeValue& v01,
                                      std::string n02, const AttributeValue& v02,
                                      std::string n03, const AttributeValue& v03,
                                      std::string n04, const AttributeValue& v04,
                                      std::string n05, const AttributeValue& v05,
                                      std::string n06, const AttributeValue& v06,
                                      std::string n07, const AttributeValue& v07,
                                      std::string n08, const AttributeValue& v08)
{
  m_queueLimitsFactory.SetTypeId (type);
  m_queueLimitsFactory.Set (n01, v01);
  m_queueLimitsFactory.Set (n02, v02);
  m_queueLimitsFactory.Set (n03, v03);
  m_queueLimitsFactory.Set (n04, v04);
  m_queueLimitsFactory.Set (n05, v05);
  m_queueLimitsFactory.Set (n06, v06);
  m_queueLimitsFactory.Set (n07, v07);
  m_queueLimitsFactory.Set (n08, v08);
}

QueueDiscContainer
TrafficControlHelper::Install (Ptr<NetDevice> d)
{




#include "ns3/object-factory.h"
#include "ns3/net-device-container.h"
#include "ns3/queue-disc-container.h"
#include "ns3/queue.h"

namespace ns3 {


   * attributes, use the AddInternalQueue, AddPacketFilter and AddChildQueueDisc methods.
   *
   * \param type the type of queue disc
   * \param n01 the name of the attribute to set on the queue disc
   * \param v01 the value of the attribute to set on the queue disc
   * \param n02 the name of the attribute to set on the queue disc
   * \param v02 the value of the attribute to set on the queue disc
   * \param n03 the name of the attribute to set on the queue disc
   * \param v03 the value of the attribute to set on the queue disc
   * \param n04 the name of the attribute to set on the queue disc
   * \param v04 the value of the attribute to set on the queue disc
   * \param n05 the name of the attribute to set on the queue disc
   * \param v05 the value of the attribute to set on the queue disc
   * \param n06 the name of the attribute to set on the queue disc
   * \param v06 the value of the attribute to set on the queue disc
   * \param n07 the name of the attribute to set on the queue disc
   * \param v07 the value of the attribute to set on the queue disc
   * \param n08 the name of the attribute to set on the queue disc
   * \param v08 the value of the attribute to set on the queue disc
   * \param n09 the name of the attribute to set on the queue disc
   * \param v09 the value of the attribute to set on the queue disc
   * \param n10 the name of the attribute to set on the queue disc
   * \param v10 the value of the attribute to set on the queue disc
   * \param n11 the name of the attribute to set on the queue disc
   * \param v11 the value of the attribute to set on the queue disc
   * \param n12 the name of the attribute to set on the queue disc
   * \param v12 the value of the attribute to set on the queue disc
   * \param n13 the name of the attribute to set on the queue disc
   * \param v13 the value of the attribute to set on the queue disc
   * \param n14 the name of the attribute to set on the queue disc
   * \param v14 the value of the attribute to set on the queue disc
   * \param n15 the name of the attribute to set on the queue disc
   * \param v15 the value of the attribute to set on the queue disc
   * \return the handle of the root queue disc (zero)
   */
  template <typename... Args>
  uint16_t SetRootQueueDisc (std::string type, Args... args);
                             std::string n02 = "", const AttributeValue &v02 = EmptyAttributeValue (),
                             std::string n03 = "", const AttributeValue &v03 = EmptyAttributeValue (),
                             std::string n04 = "", const AttributeValue &v04 = EmptyAttributeValue (),
                             std::string n05 = "", const AttributeValue &v05 = EmptyAttributeValue (),
                             std::string n06 = "", const AttributeValue &v06 = EmptyAttributeValue (),
                             std::string n07 = "", const AttributeValue &v07 = EmptyAttributeValue (),
                             std::string n08 = "", const AttributeValue &v08 = EmptyAttributeValue (),
                             std::string n09 = "", const AttributeValue &v09 = EmptyAttributeValue (),
                             std::string n10 = "", const AttributeValue &v10 = EmptyAttributeValue (),
                             std::string n11 = "", const AttributeValue &v11 = EmptyAttributeValue (),
                             std::string n12 = "", const AttributeValue &v12 = EmptyAttributeValue (),
                             std::string n13 = "", const AttributeValue &v13 = EmptyAttributeValue (),
                             std::string n14 = "", const AttributeValue &v14 = EmptyAttributeValue (),
                             std::string n15 = "", const AttributeValue &v15 = EmptyAttributeValue ());

  /**
   * Helper function used to add the given number of internal queues (of the given

   * \param count the number of queues to add
   * \param type the type of queue
   * \param n01 the name of the attribute to set on the queue
   * \param v01 the value of the attribute to set on the queue
   * \param n02 the name of the attribute to set on the queue
   * \param v02 the value of the attribute to set on the queue
   * \param n03 the name of the attribute to set on the queue
   * \param v03 the value of the attribute to set on the queue
   * \param n04 the name of the attribute to set on the queue
   * \param v04 the value of the attribute to set on the queue
   * \param n05 the name of the attribute to set on the queue
   * \param v05 the value of the attribute to set on the queue
   * \param n06 the name of the attribute to set on the queue
   * \param v06 the value of the attribute to set on the queue
   * \param n07 the name of the attribute to set on the queue
   * \param v07 the value of the attribute to set on the queue
   * \param n08 the name of the attribute to set on the queue
   * \param v08 the value of the attribute to set on the queue
   */
  template <typename... Args>
  void AddInternalQueues (uint16_t handle, uint16_t count, std::string type, Args... args);
                          std::string n02 = "", const AttributeValue &v02 = EmptyAttributeValue (),
                          std::string n03 = "", const AttributeValue &v03 = EmptyAttributeValue (),
                          std::string n04 = "", const AttributeValue &v04 = EmptyAttributeValue (),
                          std::string n05 = "", const AttributeValue &v05 = EmptyAttributeValue (),
                          std::string n06 = "", const AttributeValue &v06 = EmptyAttributeValue (),
                          std::string n07 = "", const AttributeValue &v07 = EmptyAttributeValue (),
                          std::string n08 = "", const AttributeValue &v08 = EmptyAttributeValue ());

  /**
   * Helper function used to add a packet filter (of the given type and with

   * \param handle the handle of the parent queue disc
   * \param type the type of packet filter
   * \param n01 the name of the attribute to set on the packet filter
   * \param v01 the value of the attribute to set on the packet filter
   * \param n02 the name of the attribute to set on the packet filter
   * \param v02 the value of the attribute to set on the packet filter
   * \param n03 the name of the attribute to set on the packet filter
   * \param v03 the value of the attribute to set on the packet filter
   * \param n04 the name of the attribute to set on the packet filter
   * \param v04 the value of the attribute to set on the packet filter
   * \param n05 the name of the attribute to set on the packet filter
   * \param v05 the value of the attribute to set on the packet filter
   * \param n06 the name of the attribute to set on the packet filter
   * \param v06 the value of the attribute to set on the packet filter
   * \param n07 the name of the attribute to set on the packet filter
   * \param v07 the value of the attribute to set on the packet filter
   * \param n08 the name of the attribute to set on the packet filter
   * \param v08 the value of the attribute to set on the packet filter
   */
  template <typename... Args>
  void AddPacketFilter (uint16_t handle, std::string type, Args... args);
                        std::string n02 = "", const AttributeValue &v02 = EmptyAttributeValue (),
                        std::string n03 = "", const AttributeValue &v03 = EmptyAttributeValue (),
                        std::string n04 = "", const AttributeValue &v04 = EmptyAttributeValue (),
                        std::string n05 = "", const AttributeValue &v05 = EmptyAttributeValue (),
                        std::string n06 = "", const AttributeValue &v06 = EmptyAttributeValue (),
                        std::string n07 = "", const AttributeValue &v07 = EmptyAttributeValue (),
                        std::string n08 = "", const AttributeValue &v08 = EmptyAttributeValue ());

  /**
   * Container type for Class IDs

   * \param count the number of queue disc classes to add
   * \param type the type of queue disc class
   * \param n01 the name of the attribute to set on the queue disc class
   * \param v01 the value of the attribute to set on the queue disc class
   * \param n02 the name of the attribute to set on the queue disc class
   * \param v02 the value of the attribute to set on the queue disc class
   * \param n03 the name of the attribute to set on the queue disc class
   * \param v03 the value of the attribute to set on the queue disc class
   * \param n04 the name of the attribute to set on the queue disc class
   * \param v04 the value of the attribute to set on the queue disc class
   * \param n05 the name of the attribute to set on the queue disc class
   * \param v05 the value of the attribute to set on the queue disc class
   * \param n06 the name of the attribute to set on the queue disc class
   * \param v06 the value of the attribute to set on the queue disc class
   * \param n07 the name of the attribute to set on the queue disc class
   * \param v07 the value of the attribute to set on the queue disc class
   * \param n08 the name of the attribute to set on the queue disc class
   * \param v08 the value of the attribute to set on the queue disc class
   * \return the list of class IDs
   */
  template <typename... Args>
  ClassIdList AddQueueDiscClasses (uint16_t handle, uint16_t count, std::string type, Args... args);
                                   std::string n02 = "", const AttributeValue &v02 = EmptyAttributeValue (),
                                   std::string n03 = "", const AttributeValue &v03 = EmptyAttributeValue (),
                                   std::string n04 = "", const AttributeValue &v04 = EmptyAttributeValue (),
                                   std::string n05 = "", const AttributeValue &v05 = EmptyAttributeValue (),
                                   std::string n06 = "", const AttributeValue &v06 = EmptyAttributeValue (),
                                   std::string n07 = "", const AttributeValue &v07 = EmptyAttributeValue (),
                                   std::string n08 = "", const AttributeValue &v08 = EmptyAttributeValue ());

  /**
   * Helper function used to attach a child queue disc (of the given type and with

   * \param classId the class ID of the class to attach the queue disc to
   * \param type the type of queue disc
   * \param n01 the name of the attribute to set on the queue disc
   * \param v01 the value of the attribute to set on the queue disc
   * \param n02 the name of the attribute to set on the queue disc
   * \param v02 the value of the attribute to set on the queue disc
   * \param n03 the name of the attribute to set on the queue disc
   * \param v03 the value of the attribute to set on the queue disc
   * \param n04 the name of the attribute to set on the queue disc
   * \param v04 the value of the attribute to set on the queue disc
   * \param n05 the name of the attribute to set on the queue disc
   * \param v05 the value of the attribute to set on the queue disc
   * \param n06 the name of the attribute to set on the queue disc
   * \param v06 the value of the attribute to set on the queue disc
   * \param n07 the name of the attribute to set on the queue disc
   * \param v07 the value of the attribute to set on the queue disc
   * \param n08 the name of the attribute to set on the queue disc
   * \param v08 the value of the attribute to set on the queue disc
   * \param n09 the name of the attribute to set on the queue disc
   * \param v09 the value of the attribute to set on the queue disc
   * \param n10 the name of the attribute to set on the queue disc
   * \param v10 the value of the attribute to set on the queue disc
   * \param n11 the name of the attribute to set on the queue disc
   * \param v11 the value of the attribute to set on the queue disc
   * \param n12 the name of the attribute to set on the queue disc
   * \param v12 the value of the attribute to set on the queue disc
   * \param n13 the name of the attribute to set on the queue disc
   * \param v13 the value of the attribute to set on the queue disc
   * \param n14 the name of the attribute to set on the queue disc
   * \param v14 the value of the attribute to set on the queue disc
   * \param n15 the name of the attribute to set on the queue disc
   * \param v15 the value of the attribute to set on the queue disc
   * \return the handle of the created child queue disc
   */
  template <typename... Args>
  uint16_t AddChildQueueDisc (uint16_t handle, uint16_t classId, std::string type, Args... args);
                              std::string n02 = "", const AttributeValue &v02 = EmptyAttributeValue (),
                              std::string n03 = "", const AttributeValue &v03 = EmptyAttributeValue (),
                              std::string n04 = "", const AttributeValue &v04 = EmptyAttributeValue (),
                              std::string n05 = "", const AttributeValue &v05 = EmptyAttributeValue (),
                              std::string n06 = "", const AttributeValue &v06 = EmptyAttributeValue (),
                              std::string n07 = "", const AttributeValue &v07 = EmptyAttributeValue (),
                              std::string n08 = "", const AttributeValue &v08 = EmptyAttributeValue (),
                              std::string n09 = "", const AttributeValue &v09 = EmptyAttributeValue (),
                              std::string n10 = "", const AttributeValue &v10 = EmptyAttributeValue (),
                              std::string n11 = "", const AttributeValue &v11 = EmptyAttributeValue (),
                              std::string n12 = "", const AttributeValue &v12 = EmptyAttributeValue (),
                              std::string n13 = "", const AttributeValue &v13 = EmptyAttributeValue (),
                              std::string n14 = "", const AttributeValue &v14 = EmptyAttributeValue (),
                              std::string n15 = "", const AttributeValue &v15 = EmptyAttributeValue ());

  /**
   * Container type for Handlers

   * \param classes the class IDs of the classes to attach a queue disc to
   * \param type the type of queue disc
   * \param n01 the name of the attribute to set on the queue disc
   * \param v01 the value of the attribute to set on the queue disc
   * \param n02 the name of the attribute to set on the queue disc
   * \param v02 the value of the attribute to set on the queue disc
   * \param n03 the name of the attribute to set on the queue disc
   * \param v03 the value of the attribute to set on the queue disc
   * \param n04 the name of the attribute to set on the queue disc
   * \param v04 the value of the attribute to set on the queue disc
   * \param n05 the name of the attribute to set on the queue disc
   * \param v05 the value of the attribute to set on the queue disc
   * \param n06 the name of the attribute to set on the queue disc
   * \param v06 the value of the attribute to set on the queue disc
   * \param n07 the name of the attribute to set on the queue disc
   * \param v07 the value of the attribute to set on the queue disc
   * \param n08 the name of the attribute to set on the queue disc
   * \param v08 the value of the attribute to set on the queue disc
   * \param n09 the name of the attribute to set on the queue disc
   * \param v09 the value of the attribute to set on the queue disc
   * \param n10 the name of the attribute to set on the queue disc
   * \param v10 the value of the attribute to set on the queue disc
   * \param n11 the name of the attribute to set on the queue disc
   * \param v11 the value of the attribute to set on the queue disc
   * \param n12 the name of the attribute to set on the queue disc
   * \param v12 the value of the attribute to set on the queue disc
   * \param n13 the name of the attribute to set on the queue disc
   * \param v13 the value of the attribute to set on the queue disc
   * \param n14 the name of the attribute to set on the queue disc
   * \param v14 the value of the attribute to set on the queue disc
   * \param n15 the name of the attribute to set on the queue disc
   * \param v15 the value of the attribute to set on the queue disc
   * \return the list of handles of the created child queue discs
   */
  template <typename... Args>
  HandleList AddChildQueueDiscs (uint16_t handle, const ClassIdList &classes, std::string type, Args... args);
                                 std::string n02 = "", const AttributeValue &v02 = EmptyAttributeValue (),
                                 std::string n03 = "", const AttributeValue &v03 = EmptyAttributeValue (),
                                 std::string n04 = "", const AttributeValue &v04 = EmptyAttributeValue (),
                                 std::string n05 = "", const AttributeValue &v05 = EmptyAttributeValue (),
                                 std::string n06 = "", const AttributeValue &v06 = EmptyAttributeValue (),
                                 std::string n07 = "", const AttributeValue &v07 = EmptyAttributeValue (),
                                 std::string n08 = "", const AttributeValue &v08 = EmptyAttributeValue (),
                                 std::string n09 = "", const AttributeValue &v09 = EmptyAttributeValue (),
                                 std::string n10 = "", const AttributeValue &v10 = EmptyAttributeValue (),
                                 std::string n11 = "", const AttributeValue &v11 = EmptyAttributeValue (),
                                 std::string n12 = "", const AttributeValue &v12 = EmptyAttributeValue (),
                                 std::string n13 = "", const AttributeValue &v13 = EmptyAttributeValue (),
                                 std::string n14 = "", const AttributeValue &v14 = EmptyAttributeValue (),
                                 std::string n15 = "", const AttributeValue &v15 = EmptyAttributeValue ());

  /**
   * Helper function used to add a queue limits object to the transmission

   *
   * \param type the type of queue
   * \param n01 the name of the attribute to set on the queue limits object
   * \param v01 the value of the attribute to set on the queue limits object
   * \param n02 the name of the attribute to set on the queue limits object
   * \param v02 the value of the attribute to set on the queue limits object
   * \param n03 the name of the attribute to set on the queue limits object
   * \param v03 the value of the attribute to set on the queue limits object
   * \param n04 the name of the attribute to set on the queue limits object
   * \param v04 the value of the attribute to set on the queue limits object
   * \param n05 the name of the attribute to set on the queue limits object
   * \param v05 the value of the attribute to set on the queue limits object
   * \param n06 the name of the attribute to set on the queue limits object
   * \param v06 the value of the attribute to set on the queue limits object
   * \param n07 the name of the attribute to set on the queue limits object
   * \param v07 the value of the attribute to set on the queue limits object
   * \param n08 the name of the attribute to set on the queue limits object
   * \param v08 the value of the attribute to set on the queue limits object
   */
  template <typename... Args>
  void SetQueueLimits (std::string type, Args... args);
                       std::string n02 = "", const AttributeValue &v02 = EmptyAttributeValue (),
                       std::string n03 = "", const AttributeValue &v03 = EmptyAttributeValue (),
                       std::string n04 = "", const AttributeValue &v04 = EmptyAttributeValue (),
                       std::string n05 = "", const AttributeValue &v05 = EmptyAttributeValue (),
                       std::string n06 = "", const AttributeValue &v06 = EmptyAttributeValue (),
                       std::string n07 = "", const AttributeValue &v07 = EmptyAttributeValue (),
                       std::string n08 = "", const AttributeValue &v08 = EmptyAttributeValue ());

  /**
   * \param c set of devices

  ObjectFactory m_queueLimitsFactory;
};

} // namespace ns3


/***************************************************************
 *  Implementation of the templates declared above.
 ***************************************************************/

namespace ns3 {

template <typename... Args>
uint16_t
TrafficControlHelper::SetRootQueueDisc (std::string type, Args... args)
{
  NS_ABORT_MSG_UNLESS (m_queueDiscFactory.empty (), "A root queue disc has been already added to this factory");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (args...);

  m_queueDiscFactory.push_back (QueueDiscFactory (factory));
  return 0;
}

template <typename... Args>
void
TrafficControlHelper::AddInternalQueues (uint16_t handle, uint16_t count, std::string type, Args... args)
{
  NS_ABORT_MSG_IF (handle >= m_queueDiscFactory.size (), "A queue disc with handle "
                   << handle << " does not exist");

  QueueBase::AppendItemTypeIfNotPresent (type, "QueueDiscItem");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (args...);

  for (int i = 0; i < count; i++)
    {
      m_queueDiscFactory[handle].AddInternalQueue (factory);
    }
}

template <typename... Args>
void
TrafficControlHelper::AddPacketFilter (uint16_t handle, std::string type, Args... args)
{
  NS_ABORT_MSG_IF (handle >= m_queueDiscFactory.size (), "A queue disc with handle "
                   << handle << " does not exist");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (args...);

  m_queueDiscFactory[handle].AddPacketFilter (factory);
}

template <typename... Args>
TrafficControlHelper::ClassIdList
TrafficControlHelper::AddQueueDiscClasses (uint16_t handle, uint16_t count, std::string type, Args... args)
{
  NS_ABORT_MSG_IF (handle >= m_queueDiscFactory.size (), "A queue disc with handle "
                   << handle << " does not exist");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (args...);

  ClassIdList list;
  uint16_t classId;

  for (int i = 0; i < count; i++)
    {
      classId = m_queueDiscFactory[handle].AddQueueDiscClass (factory);
      list.push_back (classId);
    }
  return list;
}

template <typename... Args>
uint16_t
TrafficControlHelper::AddChildQueueDisc (uint16_t handle, uint16_t classId, std::string type, Args... args)
{
  NS_ABORT_MSG_IF (handle >= m_queueDiscFactory.size (), "A queue disc with handle "
                   << handle << " does not exist");

  ObjectFactory factory;
  factory.SetTypeId (type);
  factory.Set (args...);

  uint16_t childHandle = m_queueDiscFactory.size ();
  m_queueDiscFactory.push_back (QueueDiscFactory (factory));
  m_queueDiscFactory[handle].SetChildQueueDisc (classId, childHandle);

  return childHandle;
}

template <typename... Args>
TrafficControlHelper::HandleList
TrafficControlHelper::AddChildQueueDiscs (uint16_t handle, const TrafficControlHelper::ClassIdList &classes,
                                          std::string type, Args... args)
{
  HandleList list;
  for (ClassIdList::const_iterator c = classes.begin (); c != classes.end (); c++)
    {
      uint16_t childHandle = AddChildQueueDisc (handle, *c, type, args...);
      list.push_back (childHandle);
    }
  return list;
}

template <typename... Args>
void
TrafficControlHelper::SetQueueLimits (std::string type, Args... args)
{
  m_queueLimitsFactory.SetTypeId (type);
  m_queueLimitsFactory.Set (args...);
}


} // namespace ns3

#endif /* TRAFFIC_CONTROL_HELPER_H */

Return to bug 2780