1 #ifndef OBJECT_VECTOR_H

     2 #define OBJECT_VECTOR_H

     3 

     4 #include <vector>

     5 #include "object.h"

     6 #include "ptr.h"

     7 #include "value.h"

     8 

     9 namespace ns3 {

    10 

    11 class ObjectVector

    12 {

    13 public:

    14   typedef std::vector<Ptr<Object> >::const_iterator Iterator;

    15 

    16   ObjectVector ();

    17 

    18   Iterator Begin (void) const;

    19   Iterator End (void) const;

    20   uint32_t GetN (void) const;

    21   Ptr<Object> Get (uint32_t i) const;

    22 

    23   ObjectVector (PValue value);

    24 private:

    25   friend class ObjectVectorParamSpec;

    26   std::vector<Ptr<Object> > m_objects;

    27 };

    28 

    29 template <typename T, typename U>

    30 Ptr<ParamSpec>

    31 MakeObjectVectorParamSpec (U T::*memberVector);

    32 

    33 template <typename T, typename U, typename INDEX>

    34 Ptr<ParamSpec>

    35 MakeObjectVectorParamSpec (Ptr<U> (T::*get) (INDEX) const,

    36 			   INDEX (T::*getN) (void) const);

    37 

    38 template <typename T, typename U, typename INDEX>

    39 Ptr<ParamSpec>

    40 MakeObjectVectorParamSpec (INDEX (T::*getN) (void) const,

    41 			   Ptr<U> (T::*get) (INDEX) const);

    42 

    43 

    44 } // namespace ns3

    45 

    46 namespace ns3 {

    47 

    48 class ObjectVectorValue : public Value

    49 {

    50 public:

    51   ObjectVectorValue ();

    52   ObjectVectorValue (const ObjectVector &vector);

    53 

    54   ObjectVector Get (void) const;

    55 

    56   virtual PValue Copy (void) const;

    57   virtual std::string SerializeToString (Ptr<const ParamSpec> spec) const;

    58   virtual bool DeserializeFromString (std::string value, Ptr<const ParamSpec> spec);

    59 

    60 private:

    61   friend class ObjectVectorParamSpec;

    62   ObjectVector m_vector;

    63 };

    64 

    65 class ObjectVectorParamSpec : public ParamSpec

    66 {

    67 public:

    68   virtual bool Set (ObjectBase * object, PValue value) const;

    69   virtual bool Get (const ObjectBase * object, PValue value) const;

    70   virtual bool Check (PValue value) const;

    71   virtual PValue GetInitialValue (void) const;

    72   virtual PValue CreateValue (void) const;

    73 private:

    74   virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const = 0;

    75   virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i) const = 0;

    76 };

    77 

    78 template <typename T, typename U>

    79 Ptr<ParamSpec>

    80 MakeObjectVectorParamSpec (U T::*memberVector)

    81 {

    82   struct MemberStdContainer : public ObjectVectorParamSpec

    83   {

    84     virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {

    85       const T *obj = dynamic_cast<const T *> (object);

    86       if (obj == 0)

    87 	{

    88 	  return false;

    89 	}

    90       *n = (obj->*m_memberVector).size ();

    91       return true;

    92     }

    93     virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i) const {

    94       const T *obj = static_cast<const T *> (object);

    95       return (obj->*m_memberVector)[i];

    96     }

    97     U T::*m_memberVector;

    98   } *spec = new MemberStdContainer ();

    99   spec->m_memberVector = memberVector;

   100   return Ptr<ParamSpec> (spec, false);

   101 }

   102 

   103 template <typename T, typename U, typename INDEX>

   104 Ptr<ParamSpec>

   105 MakeObjectVectorParamSpec (Ptr<U> (T::*get) (INDEX) const,

   106 			   INDEX (T::*getN) (void) const)

   107 {

   108   struct MemberGetters : public ObjectVectorParamSpec

   109   {

   110     virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {

   111       const T *obj = dynamic_cast<const T *> (object);

   112       if (obj == 0)

   113 	{

   114 	  return false;

   115 	}

   116       *n = (obj->*m_getN) ();

   117       return true;

   118     }

   119     virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i) const {

   120       const T *obj = static_cast<const T *> (object);

   121       return (obj->*m_get) (i);

   122     }

   123     Ptr<U> (T::*m_get) (INDEX) const;

   124     INDEX (T::*m_getN) (void) const;

   125   } *spec = new MemberGetters ();

   126   spec->m_get = get;

   127   spec->m_getN = getN;

   128   return Ptr<ParamSpec> (spec, false);

   129 }

   130 

   131 template <typename T, typename U, typename INDEX>

   132 Ptr<ParamSpec>

   133 MakeObjectVectorParamSpec (INDEX (T::*getN) (void) const,

   134 			   Ptr<U> (T::*get) (INDEX) const)

   135 {

   136   return MakeObjectVectorParamSpec (get, getN);

   137 }

   138 

   139 } // namespace ns3

   140 

   141 #endif /* OBJECT_VECTOR_H */