Attachment #1317 for bug #1352

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




#include "ns3/pointer.h"
#include "ns3/global-value.h"
#include "ns3/string.h"
#include "ns3/object-ptr-vector.h"
#include "ns3/object-ptr-map.h"

namespace ns3
{

              //No value, check next attribute
              continue;
            }
          Ptr<const ObjectPtrVectorValue> vector = DynamicCast<const ObjectPtrVectorValue> (info.initialValue);
          if (vector != 0)
            {
              //a vector value, won't take it
              continue;
            }
          Ptr<const ObjectPtrMapValue> map = DynamicCast<const ObjectPtrMapValue> (info.initialValue);
          if (map != 0)
            {
              //a map value, won't take it
              continue;
            }
          Ptr<const PointerValue> pointer = DynamicCast<const PointerValue> (info.initialValue);
          if (pointer != 0)
            {
              //pointer value, won't take it
              continue;
            }
          //We take only values, no pointers or vectors or maps
          if (!calledStart)
            {
              StartVisitTypeId (tid.GetName ());




namespace ns3 {


  AttributeIterator::AttributeIterator ()
  {
  }

  AttributeIterator::~AttributeIterator ()
  {
  }

  void
  AttributeIterator::Iterate (void)
  {
    for (uint32_t i = 0; i < Config::GetRootNamespaceObjectN (); ++i)
      {
        Ptr<Object> object = Config::GetRootNamespaceObject (i);
        StartVisitObject (object);
        DoIterate (object);
        EndVisitObject ();
      }
    NS_ASSERT (m_currentPath.empty ());
    NS_ASSERT (m_examined.empty ());
  }

  bool
  AttributeIterator::IsExamined (Ptr<const Object> object)
  {
    for (uint32_t i = 0; i < m_examined.size (); ++i)
      {
        if (object == m_examined[i])
          {
            return true;
          }
      }
    return false;
  }


  std::string
  AttributeIterator::GetCurrentPath (std::string attr) const
  {
    std::ostringstream oss;
    for (uint32_t i = 0; i < m_currentPath.size (); ++i)
      {
        oss << "/" << m_currentPath[i];
      }
    if (attr != "")
      {
        oss << "/" << attr;
      }
    return oss.str ();
  }

  std::string
  AttributeIterator::GetCurrentPath (void) const
  {
    std::ostringstream oss;
    for (uint32_t i = 0; i < m_currentPath.size (); ++i)
      {
        oss << "/" << m_currentPath[i];
      }
    return oss.str ();
  }

  void
  AttributeIterator::DoStartVisitObject (Ptr<Object> object)
  {
  }
  void
  AttributeIterator::DoEndVisitObject (void)
  {
  }
  void
  AttributeIterator::DoStartVisitPointerAttribute (Ptr<Object> object, std::string name, Ptr<Object> item)
  {
  }
  void
  AttributeIterator::DoEndVisitPointerAttribute (void)
  {
  }
  void
  AttributeIterator::DoStartVisitArrayAttribute (Ptr<Object> object,
                                                 std::string name, const ObjectPtrVectorValue &vector)
  {
  }
  void
  AttributeIterator::DoEndVisitArrayAttribute (void)
  {
  }
  void
  AttributeIterator::DoStartVisitArrayItem (const ObjectPtrVectorValue &vector,
                                            uint32_t index, Ptr<Object> item)
  {
  }
  void
  AttributeIterator::DoEndVisitArrayItem (void)
  {
  }

  void
  AttributeIterator::DoStartVisitMapAttribute (Ptr<Object> object,
                                               std::string name, const ObjectPtrMapValue &map)
  {
  DoVisitAttribute (object, name);
  m_currentPath.pop_back ();
}

  }
  void
  AttributeIterator::DoEndVisitMapAttribute (void)
  {
  DoStartVisitObject (object);
}
void 
AttributeIterator::EndVisitObject (void)
{
  m_currentPath.pop_back ();
  DoEndVisitObject ();
}
void 
AttributeIterator::StartVisitPointerAttribute (Ptr<Object> object, std::string name, Ptr<Object> value)
{
  m_currentPath.push_back (name);
  m_currentPath.push_back ("$" + value->GetInstanceTypeId ().GetName ());
  DoStartVisitPointerAttribute (object, name, value);
}
void 
AttributeIterator::EndVisitPointerAttribute (void)
{
  m_currentPath.pop_back ();
  m_currentPath.pop_back ();
  DoEndVisitPointerAttribute ();
}
void 
AttributeIterator::StartVisitArrayAttribute (Ptr<Object> object, std::string name, const ObjectPtrContainerValue &vector)
{
  m_currentPath.push_back (name);
  DoStartVisitArrayAttribute (object, name, vector);
}
void 
AttributeIterator::EndVisitArrayAttribute (void)
{
  m_currentPath.pop_back ();
  DoEndVisitArrayAttribute ();
}

  }
AttributeIterator::StartVisitArrayItem (const ObjectPtrContainerValue &vector, uint32_t index, Ptr<Object> item)
{
  std::ostringstream oss;
  oss << index;
  m_currentPath.push_back (oss.str ());
  m_currentPath.push_back ("$" + item->GetInstanceTypeId ().GetName ());
  DoStartVisitArrayItem (vector, index, item);
}
void 
AttributeIterator::EndVisitArrayItem (void)
{
  m_currentPath.pop_back ();
  m_currentPath.pop_back ();
  DoEndVisitArrayItem ();
}

  void
  AttributeIterator::DoStartVisitMapItem (const ObjectPtrMapValue &vector,
                                          uint32_t index, Ptr<Object> item)
  {

  }
AttributeIterator::DoIterate (Ptr<Object> object)
{
  if (IsExamined (object))
    {
      return;
    }
  TypeId tid;
  for (tid = object->GetInstanceTypeId (); tid.HasParent (); tid = tid.GetParent ())
    {
      NS_LOG_DEBUG ("store " << tid.GetName ());
      for (uint32_t i = 0; i < tid.GetAttributeN (); ++i)
        {
          struct TypeId::AttributeInformation info = tid.GetAttribute(i);
          const PointerChecker *ptrChecker = dynamic_cast<const PointerChecker *> (PeekPointer (info.checker));
          if (ptrChecker != 0)
            {
              NS_LOG_DEBUG ("pointer attribute " << info.name);
              PointerValue ptr;
              object->GetAttribute (info.name, ptr);
              Ptr<Object> tmp = ptr.Get<Object> ();
              if (tmp != 0)
                {
                  StartVisitPointerAttribute (object, info.name,
                                              tmp);
                  m_examined.push_back (object);
                  DoIterate (tmp);
                  m_examined.pop_back ();
                  EndVisitPointerAttribute ();
                }
              continue;
            }
          // attempt to cast to an object vector.
          const ObjectPtrContainerChecker *vectorChecker = dynamic_cast<const ObjectPtrContainerChecker *> (PeekPointer (info.checker));
          if (vectorChecker != 0)
            {
              NS_LOG_DEBUG ("vector attribute " << info.name);
              ObjectPtrContainerValue vector;
              object->GetAttribute (info.name, vector);
              StartVisitArrayAttribute (object, info.name, vector);
              for (uint32_t j = 0; j < vector.GetN (); ++j)
                {
                  NS_LOG_DEBUG ("vector attribute item " << j);
                  Ptr<Object> tmp = vector.Get (j);
                  StartVisitArrayItem (vector, j, tmp);
                  m_examined.push_back (object);
                  DoIterate (tmp);
                  m_examined.pop_back ();
                  EndVisitArrayItem ();
                }
              EndVisitArrayAttribute ();
              continue;
            }
          if ((info.flags & TypeId::ATTR_GET) && info.accessor->HasGetter () && 
              (info.flags & TypeId::ATTR_SET) && info.accessor->HasSetter ())
            {
              VisitAttribute (object, info.name);
            }
          else
            {
              NS_LOG_DEBUG ("could not store " << info.name);
            }
        }
    }
  Object::AggregateIterator iter = object->GetAggregateIterator ();
  bool recursiveAggregate = false;
  while (iter.HasNext ())
    {
      Ptr<const Object> tmp = iter.Next ();
      if (IsExamined (tmp))
        {
          recursiveAggregate = true;
        }
    }
  if (!recursiveAggregate)
    {
      iter = object->GetAggregateIterator ();
      while (iter.HasNext ())
        {
          Ptr<Object> tmp = const_cast<Object *> (PeekPointer (iter.Next ()));
          StartVisitObject (tmp);
          m_examined.push_back (object);
          DoIterate (tmp);
          m_examined.pop_back ();
          EndVisitObject ();
        }
    }
}

  void
  AttributeIterator::DoEndVisitMapItem (void)
  {

  }

  void
  AttributeIterator::VisitAttribute (Ptr<Object> object, std::string name)
  {
    m_currentPath.push_back (name);
    DoVisitAttribute (object, name);
    m_currentPath.pop_back ();
  }

  void
  AttributeIterator::StartVisitObject (Ptr<Object> object)
  {
    m_currentPath.push_back ("$" + object->GetInstanceTypeId ().GetName ());
    DoStartVisitObject (object);
  }
  void
  AttributeIterator::EndVisitObject (void)
  {
    m_currentPath.pop_back ();
    DoEndVisitObject ();
  }
  void
  AttributeIterator::StartVisitPointerAttribute (Ptr<Object> object, std::string name, Ptr<Object> value)
  {
    m_currentPath.push_back (name);
    m_currentPath.push_back ("$" + value->GetInstanceTypeId ().GetName ());
    DoStartVisitPointerAttribute (object, name, value);
  }
  void
  AttributeIterator::EndVisitPointerAttribute (void)
  {
    m_currentPath.pop_back ();
    m_currentPath.pop_back ();
    DoEndVisitPointerAttribute ();
  }
  void
  AttributeIterator::StartVisitArrayAttribute (Ptr<Object> object,
                                               std::string name, const ObjectPtrVectorValue &vector)
  {
    m_currentPath.push_back (name);
    DoStartVisitArrayAttribute (object, name, vector);
  }
  void
  AttributeIterator::EndVisitArrayAttribute (void)
  {
    m_currentPath.pop_back ();
    DoEndVisitArrayAttribute ();
  }

  void
  AttributeIterator::StartVisitArrayItem (const ObjectPtrVectorValue &vector,
                                          uint32_t index, Ptr<Object> item)
  {
    std::ostringstream oss;
    oss << index;
    m_currentPath.push_back (oss.str ());
    m_currentPath.push_back ("$" + item->GetInstanceTypeId ().GetName ());
    DoStartVisitArrayItem (vector, index, item);
  }
  void
  AttributeIterator::EndVisitArrayItem (void)
  {
    m_currentPath.pop_back ();
    m_currentPath.pop_back ();
    DoEndVisitArrayItem ();
  }

  void
  AttributeIterator::StartVisitMapAttribute (Ptr<Object> object,
                                             std::string name, const ObjectPtrMapValue &map)
  {
    m_currentPath.push_back (name);
    DoStartVisitMapAttribute (object, name, map);
    NS_LOG_INFO (this << GetCurrentPath ());
  }

  void
  AttributeIterator::EndVisitMapAttribute (void)
  {
    m_currentPath.pop_back ();
    DoEndVisitMapAttribute ();
  }

  void
  AttributeIterator::StartVisitMapItem (const ObjectPtrMapValue &map,
                                        uint32_t index, Ptr<Object> item)
  {
    std::ostringstream oss;
    oss << index;
    m_currentPath.push_back (oss.str ());
    m_currentPath.push_back ("$" + item->GetInstanceTypeId ().GetName ());
    DoStartVisitMapItem (map, index, item);
    NS_LOG_INFO (this << GetCurrentPath ());
  }

  void
  AttributeIterator::EndVisitMapItem (void)
  {
    m_currentPath.pop_back ();
    m_currentPath.pop_back ();
    DoEndVisitMapItem ();
  }

  void
  AttributeIterator::DoIterate (Ptr<Object> object)
  {
    if (IsExamined (object))
      {
        return;
      }
    TypeId tid;
    for (tid = object->GetInstanceTypeId (); tid.HasParent (); tid
           = tid.GetParent ())
      {
        NS_LOG_DEBUG ("store " << tid.GetName ());
        for (uint32_t i = 0; i < tid.GetAttributeN (); ++i)
          {
            struct TypeId::AttributeInformation info = tid.GetAttribute (i);
            const PointerChecker *ptrChecker =
              dynamic_cast<const PointerChecker *> (PeekPointer (info.checker));
            if (ptrChecker != 0)
              {
                NS_LOG_DEBUG ("pointer attribute " << info.name);
                PointerValue ptr;
                object->GetAttribute (info.name, ptr);
                Ptr < Object > tmp = ptr.Get<Object> ();
                if (tmp != 0)
                  {
                    StartVisitPointerAttribute (object, info.name, tmp);
                    m_examined.push_back (object);
                    DoIterate ( tmp);
                    m_examined.pop_back ();
                    EndVisitPointerAttribute ();
                  }
                continue;
              }
            // attempt to cast to an object vector.
            const ObjectPtrVectorChecker *vectorChecker =dynamic_cast<const ObjectPtrVectorChecker *> (PeekPointer (
                                                                                                         info.checker));
            if (vectorChecker != 0)
              {
                NS_LOG_DEBUG ("vector attribute " << info.name);
                ObjectPtrVectorValue vector;
                object->GetAttribute (info.name, vector);
                StartVisitArrayAttribute (object, info.name, vector);
                for (uint32_t j = 0; j < vector.GetN (); ++j)
                  {
                    NS_LOG_DEBUG ("vector attribute item " << j);
                    Ptr < Object > tmp = vector.Get (j);
                    StartVisitArrayItem (vector, j, tmp);
                    m_examined.push_back (object);
                    DoIterate ( tmp);
                    m_examined.pop_back ();
                    EndVisitArrayItem ();
                  }
                EndVisitArrayAttribute ();
                continue;
              }
            // attempt to cast to an object map.
            const ObjectPtrMapChecker *mapChecker = dynamic_cast<const ObjectPtrMapChecker *> (PeekPointer (info.checker));
            if (mapChecker != 0)
              {
                ObjectPtrMapValue map;
                object->GetAttribute (info.name, map);
                StartVisitMapAttribute (object, info.name, map);
                for (ObjectPtrMapValue::Iterator it = map.Begin (); it != map.End (); it++)
                  {
                    NS_LOG_DEBUG ("map attribute index " << (*it).first <<  " item " << (*it).second);
                    StartVisitMapItem (map, (*it).first, (*it).second);
                    m_examined.push_back (object);
                    DoIterate ((*it).second);
                    m_examined.pop_back ();
                    EndVisitMapItem ();
                  }
                EndVisitMapAttribute ();
                continue;
              }
            if ((info.flags & TypeId::ATTR_GET) && info.accessor->HasGetter ()
                && (info.flags & TypeId::ATTR_SET) && info.accessor->HasSetter ())
              {
                VisitAttribute (object, info.name);
              }
            else
              {
                NS_LOG_DEBUG ("could not store " << info.name);
              }
          }
        Object::AggregateIterator iter = object->GetAggregateIterator ();
        bool recursiveAggregate = false;
        while (iter.HasNext ())
          {
            Ptr<const Object> tmp = iter.Next ();
            if (IsExamined (tmp))
              {
                recursiveAggregate = true;
              }
          }
        if (!recursiveAggregate)
          {
            iter = object->GetAggregateIterator ();
            while (iter.HasNext ())
              {
                Ptr<Object> tmp = const_cast<Object *> (PeekPointer (iter.Next ()));
                StartVisitObject (tmp);
                m_examined.push_back (object);
                DoIterate (tmp);
                m_examined.pop_back ();
                EndVisitObject ();
              }
          }
      }


  } // namespace ns3

(-)a/src/config-store/model/attribute-iterator.h (-6 / +14 lines)

Lines 21-27	Link Here

#include "ns3/ptr.h"

#include "ns3/ptr.h"

#include "ns3/object.h"

#include "ns3/object.h"

#include "ns3/object-ptr-container.h"

#include "ns3/object-ptr-vector.h"

#include "ns3/object-ptr-map.h"

#include <vector>

#include <vector>

namespace ns3 {

namespace ns3 {

Lines 46-55	Link Here

  virtual void DoEndVisitObject (void);

  virtual void DoEndVisitObject (void);

  virtual void DoStartVisitPointerAttribute (Ptr<Object> object, std::string name, Ptr<Object> value);

  virtual void DoStartVisitPointerAttribute (Ptr<Object> object, std::string name, Ptr<Object> value);

  virtual void DoEndVisitPointerAttribute (void);

  virtual void DoEndVisitPointerAttribute (void);

  virtual void DoStartVisitArrayAttribute (Ptr<Object> object, std::string name, const ObjectPtrContainerValue &vector);

  virtual void DoStartVisitArrayAttribute (Ptr<Object> object, std::string name, const ObjectPtrVectorValue &vector);

  virtual void DoEndVisitArrayAttribute (void);

  virtual void DoEndVisitArrayAttribute (void);

  virtual void DoStartVisitArrayItem (const ObjectPtrContainerValue &vector, uint32_t index, Ptr<Object> item);

  virtual void DoStartVisitArrayItem (const ObjectPtrVectorValue &vector, uint32_t index, Ptr<Object> item);

  virtual void DoEndVisitArrayItem (void);

  virtual void DoEndVisitArrayItem (void);

  virtual void DoStartVisitMapAttribute (Ptr<Object> object, std::string name, const ObjectPtrMapValue &map);

  virtual void DoEndVisitMapAttribute (void);

  virtual void DoStartVisitMapItem (const ObjectPtrMapValue &vector, uint32_t index, Ptr<Object> item);

  virtual void DoEndVisitMapItem (void);

  void DoIterate (Ptr<Object> object);

  void DoIterate (Ptr<Object> object);

  bool IsExamined (Ptr<const Object> object);

  bool IsExamined (Ptr<const Object> object);

Lines 60-70	Link Here

  void EndVisitObject (void);

  void EndVisitObject (void);

  void StartVisitPointerAttribute (Ptr<Object> object, std::string name, Ptr<Object> value);

  void StartVisitPointerAttribute (Ptr<Object> object, std::string name, Ptr<Object> value);

  void EndVisitPointerAttribute (void);

  void EndVisitPointerAttribute (void);

  void StartVisitArrayAttribute (Ptr<Object> object, std::string name, const ObjectPtrContainerValue &vector);

  void StartVisitArrayAttribute (Ptr<Object> object, std::string name, const ObjectPtrVectorValue &vector);

  void EndVisitArrayAttribute (void);

  void EndVisitArrayAttribute (void);

  void StartVisitArrayItem (const ObjectPtrContainerValue &vector, uint32_t index, Ptr<Object> item);

  void StartVisitArrayItem (const ObjectPtrVectorValue &vector, uint32_t index, Ptr<Object> item);

  void EndVisitArrayItem (void);

  void EndVisitArrayItem (void);

  void StartVisitMapAttribute (Ptr<Object> object, std::string name, const ObjectPtrMapValue &map);

  void EndVisitMapAttribute (void);

  void StartVisitMapItem (const ObjectPtrMapValue &vector, uint32_t index, Ptr<Object> item);

  void EndVisitMapItem (void);

  std::vector<Ptr<Object> > m_examined;

  std::vector<Ptr<Object> > m_examined;

  std::vector<std::string> m_currentPath;

  std::vector<std::string> m_currentPath;




{
  Remove ();
}
void
ModelCreator::DoStartVisitArrayAttribute (Ptr<Object> object, std::string name,
                                          const ObjectPtrVectorValue &vector)
{
  ModelNode *node = new ModelNode ();
  node->type = ModelNode::NODE_VECTOR;

{
  Remove ();
}
void
ModelCreator::DoStartVisitArrayItem (const ObjectPtrVectorValue &vector,
                                     uint32_t index, Ptr<Object> item)
{
  GtkTreeIter *parent = m_iters.back ();
  GtkTreeIter *current = g_new (GtkTreeIter, 1);

  g_free (iter);
  m_iters.pop_back ();
}

void
ModelCreator::DoStartVisitMapAttribute (Ptr<Object> object, std::string name,
                                        const ObjectPtrMapValue &map)
{
  ModelNode *node = new ModelNode ();
  node->type = ModelNode::NODE_VECTOR;
  node->object = object;
  node->name = name;
  Add (node);
}
void
ModelCreator::DoEndVisitMapAttribute (void)
{
  Remove ();
}
void
ModelCreator::DoStartVisitMapItem (const ObjectPtrMapValue &map, uint32_t index,
                                   Ptr<Object> item)
{
  GtkTreeIter *parent = m_iters.back ();
  GtkTreeIter *current = g_new (GtkTreeIter, 1);
  ModelNode *node = new ModelNode ();
  node->type = ModelNode::NODE_VECTOR_ITEM;
  node->object = item;
  node->index = index;
  gtk_tree_store_append (m_treestore, current, parent);
  gtk_tree_store_set (m_treestore, current, COL_NODE, node, -1);
  m_iters.push_back (current);
}

void
ModelCreator::DoEndVisitMapItem (void)
{
  GtkTreeIter *iter = m_iters.back ();
  g_free (iter);
  m_iters.pop_back ();
}

} //end namespace ns3





  void Build (GtkTreeStore *treestore);
private:
  virtual void
  DoVisitAttribute (Ptr<Object> object, std::string name);
  virtual void
  DoStartVisitObject (Ptr<Object> object);
  virtual void
  DoEndVisitObject (void);
  virtual void
  DoStartVisitPointerAttribute (Ptr<Object> object, std::string name,
                                Ptr<Object> value);
  virtual void
  DoEndVisitPointerAttribute (void);
  virtual void
  DoStartVisitArrayAttribute (Ptr<Object> object, std::string name,
                              const ObjectPtrVectorValue &vector);
  virtual void
  DoEndVisitArrayAttribute (void);
  virtual void
  DoStartVisitArrayItem (const ObjectPtrVectorValue &vector, uint32_t index,
                         Ptr<Object> item);
  virtual void
  DoEndVisitArrayItem (void);
  virtual void
  DoStartVisitMapAttribute (Ptr<Object> object, std::string name,
                            const ObjectPtrMapValue &map);
  virtual void
  DoEndVisitMapAttribute (void);
  virtual void
  DoStartVisitMapItem (const ObjectPtrMapValue &vector, uint32_t index,
                       Ptr<Object> item);
  virtual void
  DoEndVisitMapItem (void);

  void
  Add (ModelNode *node);
  void
  Remove (void);

  GtkTreeStore *m_treestore;
  std::vector<GtkTreeIter *> m_iters;




#include "singleton.h"
#include "object.h"
#include "global-value.h"
#include "object-ptr-vector.h"
#include "object-ptr-map.h"
#include "names.h"
#include "pointer.h"
#include "log.h"

private:
  void Canonicalize (void);
  void DoResolve (std::string path, Ptr<Object> root);
  void DoArrayResolve (std::string path, const ObjectPtrVectorValue &vector);
  void DoMapResolve (std::string path, const ObjectPtrMapValue &map);
  void DoResolveOne (Ptr<Object> object);
  std::string GetResolvedPath (void) const;
  virtual void DoOne (Ptr<Object> object, std::string path) = 0;

          m_workStack.pop_back ();
        }
      // attempt to cast to an object vector.
      const ObjectPtrVectorChecker *vectorChecker = dynamic_cast<const ObjectPtrVectorChecker *> (PeekPointer (info.checker));
      if (vectorChecker != 0)
        {
          NS_LOG_DEBUG ("GetAttribute(vector)="<<item<<" on path="<<GetResolvedPath ());
          ObjectPtrVectorValue vector;
          root->GetAttribute (item, vector);
          m_workStack.push_back (item);
          DoArrayResolve (pathLeft, vector);
          m_workStack.pop_back ();
        }
      // attempt to cast to an object map.
      const ObjectPtrMapChecker *mapChecker = dynamic_cast<const ObjectPtrMapChecker *> (PeekPointer (info.checker));
      if (mapChecker != 0)
        {
          NS_LOG_DEBUG ("GetAttribute(map)="<<item<<" on path="<<GetResolvedPath ());
          ObjectPtrMapValue map;
          root->GetAttribute (item, map);
          m_workStack.push_back (item);
          DoMapResolve (pathLeft, map);
          m_workStack.pop_back ();
        }
      // this could be anything else and we don't know what to do with it.
      // So, we just ignore it.
    }
}

void 
Resolver::DoArrayResolve (std::string path, const ObjectPtrVectorValue &vector)
{
  NS_ASSERT (path != "");
  NS_ASSERT ((path.find ("/")) == 0);

    }
}

void
Resolver::DoMapResolve (std::string path, const ObjectPtrMapValue &map)
{
  NS_ASSERT (path != "");
  NS_ASSERT ((path.find ("/")) == 0);
  std::string::size_type next = path.find ("/", 1);
  if (next == std::string::npos)
    {
      NS_FATAL_ERROR ("map path includes no index data on path=\""<<path<<"\"");
    }
  std::string item = path.substr (1, next-1);
  std::string pathLeft = path.substr (next, path.size ()-next);

  ArrayMatcher matcher = ArrayMatcher (item);
  ObjectPtrMapValue::Iterator it;
  for (it =  map.Begin (); it != map.End ();  ++it)
    {
      if (matcher.Matches ((*it).first))
        {
          std::ostringstream oss;
          oss << (*it).first;
          m_workStack.push_back (oss.str ());
          DoResolve (pathLeft, (*it).second);
          m_workStack.pop_back ();
        }
    }
}


class ConfigImpl 
{

}
void SetDefault (std::string name, const AttributeValue &value)
{
  if (!SetDefaultFailSafe (name, value))
    {
      NS_FATAL_ERROR ("Could not set default value for " << name);
    }

    }
  for (uint32_t j = 0; j < tid.GetAttributeN (); j++)
    {
      struct TypeId::AttributeInformation tmp = tid.GetAttribute (j);
      if (tmp.name == paramName)
        {
          Ptr<AttributeValue> v = tmp.checker->CreateValidValue (value);




#ifndef OBJECT_MAP_H
#define OBJECT_MAP_H

#include <map>
#include "object.h"
#include "ptr.h"
#include "attribute.h"
#include "object-ptr-map.h"

namespace ns3 {

typedef ObjectPtrMapValue ObjectMapValue;

template <typename T, typename U>
Ptr<const AttributeAccessor>


template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectMapAccessor (Ptr<U> (T::*get)(INDEX) const,
                          INDEX (T::*getN)(void) const);

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectMapAccessor (INDEX (T::*getN)(void) const,
                          Ptr<U> (T::*get)(INDEX) const);

} // namespace ns3


template <typename T, typename U>
Ptr<const AttributeAccessor>
MakeObjectMapAccessor (U T::*memberMap)
{
  struct MemberStdContainer : public ObjectPtrMapAccessor
  {
    virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {
      const T *obj = dynamic_cast<const T *> (object);

        {
          return false;
        }

      *n = (obj->*m_memberMap).size ();
      return true;
    }
    virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i, uint32_t *index) const {
      const T *obj = static_cast<const T *> (object);
      typename U::const_iterator begin = (obj->*m_memberMap).begin ();
      typename U::const_iterator end = (obj->*m_memberMap).end ();
      uint32_t k = 0;
      for (typename U::const_iterator j = begin; j != end; j++, k++)
        {
          if (k == i)
            {
              *index = (*j).first;
              return (*j).second;
              break;
            }

      // quiet compiler.
      return 0;
    }
    U T::*m_memberMap;
  } *spec = new MemberStdContainer ();
  spec->m_memberMap = memberMap;
  return Ptr<const AttributeAccessor> (spec, false);
}

template <typename T>
Ptr<const AttributeChecker> MakeObjectMapChecker (void)
{
  return MakeObjectPtrMapChecker<T> ();
}

template <typename T, typename U, typename INDEX>

MakeObjectMapAccessor (Ptr<U> (T::*get)(INDEX) const,
		       INDEX (T::*getN)(void) const)
{
  return MakeObjectPtrMapAccessor<T,U,INDEX>(get, getN);
}

template <typename T, typename U, typename INDEX>

MakeObjectMapAccessor (INDEX (T::*getN)(void) const,
		       Ptr<U> (T::*get)(INDEX) const)
{
  return MakeObjectPtrMapAccessor<T,U,INDEX>(get, getN);
}






/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2007 INRIA, Mathieu Lacage
 *
 * 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
 *
 * Authors: Jaume Nin <jaume.nin@cttc.cat>,  Mathieu Lacage <mathieu.lacage@gmail.com>
 */
#include "object-ptr-map.h"

namespace ns3
{

ObjectPtrMapValue::ObjectPtrMapValue ()
{
}

ObjectPtrMapValue::Iterator
ObjectPtrMapValue::Begin (void) const
{
  return m_objects.begin ();
}
ObjectPtrMapValue::Iterator
ObjectPtrMapValue::End (void) const
{
  return m_objects.end ();
}
uint32_t
ObjectPtrMapValue::GetN (void) const
{
  return m_objects.size ();
}
Ptr<Object>
ObjectPtrMapValue::Get (uint32_t i) const
{
  return m_objects.find (i)->second;
}

Ptr<AttributeValue>
ObjectPtrMapValue::Copy (void) const
{
  return ns3::Create<ObjectPtrMapValue>(*this);
}
std::string
ObjectPtrMapValue::SerializeToString (Ptr<const AttributeChecker> checker) const
{
  std::ostringstream oss;
  Iterator it;
  for (it = m_objects.begin (); it != m_objects.end (); ++it)
    {
      oss << (*it).second;
      if (it != m_objects.end ())
        {
          oss << " ";
        }
    }
  return oss.str ();
}

bool
ObjectPtrMapValue::DeserializeFromString (std::string value,
                                          Ptr<const AttributeChecker> checker)
{
  NS_FATAL_ERROR ("cannot deserialize a map of object pointers.");
  return true;
}

bool
ObjectPtrMapAccessor::Set (ObjectBase * object, const AttributeValue & value) const
{
  // not allowed.
  return false;
}
bool
ObjectPtrMapAccessor::Get (const ObjectBase * object, AttributeValue &value) const
{
  ObjectPtrMapValue *v = dynamic_cast<ObjectPtrMapValue *> (&value);
  if (v == 0)
    {
      return false;
    }
  v->m_objects.clear ();
  uint32_t n;
  bool ok = DoGetN (object, &n);
  if (!ok)
    {
      return false;
    }
  for (uint32_t i = 0; i < n; i++)
    {

      uint32_t k;
      Ptr < Object > element = DoGet (object, i, &k);
      v->m_objects.insert (std::pair<uint32_t, Ptr<Object> >(k, element));
    }
  return true;
}

bool
ObjectPtrMapAccessor::HasGetter (void) const
{
  return true;
}
bool
ObjectPtrMapAccessor::HasSetter (void) const
{
  return false;
}

} // name




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2007 INRIA, Mathieu Lacage
 *
 * 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
 *
 * Authors: Mathieu Lacage <mathieu.lacage@gmail.com>
 */
#ifndef OBJECT_PTR_MAP_H
#define OBJECT_PTR_MAP_H

#include <map>
#include "object.h"
#include "ptr.h"
#include "attribute.h"

namespace ns3 {

/**
 * \ingroup object
 * 
 * \brief contain a map of ns3::Object pointers.
 *
 * This class it used to get attribute access to an array of
 * ns3::Object pointers.
 */
class ObjectPtrMapValue : public AttributeValue
{
public:
  typedef std::map<uint32_t, Ptr<Object> >::const_iterator Iterator;

  ObjectPtrMapValue ();

  /**
   * \returns an iterator to the first object contained in this map
   */
  Iterator Begin (void) const;
  /**
   * \returns an iterator to the last object contained in this map
   */
  Iterator End (void) const;
  /**
   * \returns the number of objects contained in this map.
   */
  uint32_t GetN (void) const;
  /**
   * \param i the index of the requested object.
   * \returns the requested object
   */
  Ptr<Object> Get (uint32_t i) const;

  virtual Ptr<AttributeValue> Copy (void) const;
  virtual std::string SerializeToString (Ptr<const AttributeChecker> checker) const;
  virtual bool DeserializeFromString (std::string value, Ptr<const AttributeChecker> checker);

private:
  friend class ObjectPtrMapAccessor;
  std::map<uint32_t, Ptr<Object> > m_objects;
};


template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectPtrMapAccessor (Ptr<U> (T::*get)(INDEX) const,
                          INDEX (T::*getN)(void) const);

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectPtrMapAccessor (INDEX (T::*getN)(void) const,
                          Ptr<U> (T::*get)(INDEX) const);

class ObjectPtrMapChecker : public AttributeChecker
{
public:
  virtual TypeId GetItemTypeId (void) const = 0;
};

template <typename T>
Ptr<const AttributeChecker> MakeObjectPtrMapChecker (void);

} // namespace ns3

namespace ns3 {

namespace internal {

template <typename T>
class AnObjectPtrMapChecker : public ObjectPtrMapChecker
{
public:
  virtual TypeId GetItemTypeId (void) const {
    return T::GetTypeId ();
  }
  virtual bool Check (const AttributeValue &value) const {
    return dynamic_cast<const ObjectPtrMapValue *> (&value) != 0;
  }
  virtual std::string GetValueTypeName (void) const {
    return "ns3::ObjectPtrMapValue";
  }
  virtual bool HasUnderlyingTypeInformation (void) const {
    return true;
  }
  virtual std::string GetUnderlyingTypeInformation (void) const {
    return "ns3::Ptr< " + T::GetTypeId ().GetName () + " >";
  }
  virtual Ptr<AttributeValue> Create (void) const {
    return ns3::Create<ObjectPtrMapValue> ();
  }
  virtual bool Copy (const AttributeValue &source, AttributeValue &destination) const {
    const ObjectPtrMapValue *src = dynamic_cast<const ObjectPtrMapValue *> (&source);
    ObjectPtrMapValue *dst = dynamic_cast<ObjectPtrMapValue *> (&destination);
    if (src == 0 || dst == 0)
      {
        return false;
      }
    *dst = *src;
    return true;
  }
};

} // namespace internal


class ObjectPtrMapAccessor : public AttributeAccessor
{
public:
  virtual bool Set (ObjectBase * object, const AttributeValue &value) const;
  virtual bool Get (const ObjectBase * object, AttributeValue &value) const;
  virtual bool HasGetter (void) const;
  virtual bool HasSetter (void) const;
private:
  virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const = 0;
  virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i, uint32_t *index) const = 0;
};

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectPtrMapAccessor (Ptr<U> (T::*get)(INDEX) const,
                          INDEX (T::*getN)(void) const)
{
  struct MemberGetters : public ObjectPtrMapAccessor
  {
    virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {
      const T *obj = dynamic_cast<const T *> (object);
      if (obj == 0)
        {
          return false;
        }
      *n = (obj->*m_getN)();
      return true;
    }
    virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i, uint32_t *index) const {
      const T *obj = static_cast<const T *> (object);
      return (obj->*m_get)(i);
    }
    Ptr<U> (T::*m_get)(INDEX) const;
    INDEX (T::*m_getN)(void) const;
  } *spec = new MemberGetters ();
  spec->m_get = get;
  spec->m_getN = getN;
  return Ptr<const AttributeAccessor> (spec, false);
}

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectPtrMapAccessor (INDEX (T::*getN)(void) const,
                          Ptr<U> (T::*get)(INDEX) const)
{
  return MakeObjectPtrMapAccessor (get, getN);
}

template <typename T>
Ptr<const AttributeChecker> MakeObjectPtrMapChecker (void)
{
  return Create<internal::AnObjectPtrMapChecker<T> > ();
}


} // namespace ns3

#endif /* OBJECT_PTR_MAP_H */




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2007 INRIA, Mathieu Lacage
 *
 * 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
 *
 * Authors: Mathieu Lacage <mathieu.lacage@gmail.com>
 */
#include "object-ptr-vector.h"

namespace ns3 {

ObjectPtrVectorValue::ObjectPtrVectorValue ()
{
}

ObjectPtrVectorValue::Iterator
ObjectPtrVectorValue::Begin (void) const
{
  return m_objects.begin ();
}
ObjectPtrVectorValue::Iterator
ObjectPtrVectorValue::End (void) const
{
  return m_objects.end ();
}
uint32_t
ObjectPtrVectorValue::GetN (void) const
{
  return m_objects.size ();
}
Ptr<Object>
ObjectPtrVectorValue::Get (uint32_t i) const
{
  return m_objects[i];
}

Ptr<AttributeValue>
ObjectPtrVectorValue::Copy (void) const
{
  return ns3::Create<ObjectPtrVectorValue> (*this);
}
std::string 
ObjectPtrVectorValue::SerializeToString (Ptr<const AttributeChecker> checker) const
{
  std::ostringstream oss;
  for (uint32_t i = 0; i < m_objects.size (); ++i)
    {
      oss << m_objects[i];
      if (i != m_objects.size () - 1)
        {
          oss << " ";
        }
    }
  return oss.str ();
}
bool 
ObjectPtrVectorValue::DeserializeFromString (std::string value, Ptr<const AttributeChecker> checker)
{
  NS_FATAL_ERROR ("cannot deserialize a vector of object pointers.");
  return true;
}

bool 
ObjectPtrVectorAccessor::Set (ObjectBase * object, const AttributeValue & value) const
{
  // not allowed.
  return false;
}
bool 
ObjectPtrVectorAccessor::Get (const ObjectBase * object, AttributeValue &value) const
{
  ObjectPtrVectorValue *v = dynamic_cast<ObjectPtrVectorValue *> (&value);
  if (v == 0)
    {
      return false;
    }
  v->m_objects.clear ();
  uint32_t n;
  bool ok = DoGetN (object, &n);
  if (!ok)
    {
      return false;
    }
  for (uint32_t i = 0; i < n; i++)
    {
      Ptr<Object> o = DoGet (object, i);
      v->m_objects.push_back (o);
    }
  return true;
}
bool 
ObjectPtrVectorAccessor::HasGetter (void) const
{
  return true;
}
bool 
ObjectPtrVectorAccessor::HasSetter (void) const
{
  return false;
}

} // name




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2007 INRIA, Mathieu Lacage
 *
 * 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
 *
 * Authors: Mathieu Lacage <mathieu.lacage@gmail.com>
 */
#ifndef OBJECT_PTR_VECTOR_H
#define OBJECT_PTR_VECTOR_H

#include <vector>
#include "object.h"
#include "ptr.h"
#include "attribute.h"

namespace ns3 {

/**
 * \ingroup object
 * 
 * \brief contain a vector of ns3::Object pointers.
 *
 * This class it used to get attribute access to an array of
 * ns3::Object pointers.
 */
class ObjectPtrVectorValue : public AttributeValue
{
public:
  typedef std::vector<Ptr<Object> >::const_iterator Iterator;

  ObjectPtrVectorValue ();

  /**
   * \returns an iterator to the first object contained in this vector
   */
  Iterator Begin (void) const;
  /**
   * \returns an iterator to the last object contained in this vector
   */
  Iterator End (void) const;
  /**
   * \returns the number of objects contained in this vector.
   */
  uint32_t GetN (void) const;
  /**
   * \param i the index of the requested object.
   * \returns the requested object
   */
  Ptr<Object> Get (uint32_t i) const;

  virtual Ptr<AttributeValue> Copy (void) const;
  virtual std::string SerializeToString (Ptr<const AttributeChecker> checker) const;
  virtual bool DeserializeFromString (std::string value, Ptr<const AttributeChecker> checker);

private:
  friend class ObjectPtrVectorAccessor;
  std::vector<Ptr<Object> > m_objects;
};


template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectPtrVectorAccessor (Ptr<U> (T::*get)(INDEX) const,
                             INDEX (T::*getN)(void) const);

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectPtrVectorAccessor (INDEX (T::*getN)(void) const,
                             Ptr<U> (T::*get)(INDEX) const);

class ObjectPtrVectorChecker : public AttributeChecker
{
public:
  virtual TypeId GetItemTypeId (void) const = 0;
};

template <typename T>
Ptr<const AttributeChecker> MakeObjectPtrVectorChecker (void);

} // namespace ns3

namespace ns3 {

namespace internal {

template <typename T>
class AnObjectPtrVectorChecker : public ObjectPtrVectorChecker
{
public:
  virtual TypeId GetItemTypeId (void) const {
    return T::GetTypeId ();
  }
  virtual bool Check (const AttributeValue &value) const {
    return dynamic_cast<const ObjectPtrVectorValue *> (&value) != 0;
  }
  virtual std::string GetValueTypeName (void) const {
    return "ns3::ObjectPtrVectorValue";
  }
  virtual bool HasUnderlyingTypeInformation (void) const {
    return true;
  }
  virtual std::string GetUnderlyingTypeInformation (void) const {
    return "ns3::Ptr< " + T::GetTypeId ().GetName () + " >";
  }
  virtual Ptr<AttributeValue> Create (void) const {
    return ns3::Create<ObjectPtrVectorValue> ();
  }
  virtual bool Copy (const AttributeValue &source, AttributeValue &destination) const {
    const ObjectPtrVectorValue *src = dynamic_cast<const ObjectPtrVectorValue *> (&source);
    ObjectPtrVectorValue *dst = dynamic_cast<ObjectPtrVectorValue *> (&destination);
    if (src == 0 || dst == 0)
      {
        return false;
      }
    *dst = *src;
    return true;
  }
};

} // namespace internal


class ObjectPtrVectorAccessor : public AttributeAccessor
{
public:
  virtual bool Set (ObjectBase * object, const AttributeValue &value) const;
  virtual bool Get (const ObjectBase * object, AttributeValue &value) const;
  virtual bool HasGetter (void) const;
  virtual bool HasSetter (void) const;
private:
  virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const = 0;
  virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i) const = 0;
};

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectPtrVectorAccessor (Ptr<U> (T::*get)(INDEX) const,
                             INDEX (T::*getN)(void) const)
{
  struct MemberGetters : public ObjectPtrVectorAccessor
  {
    virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {
      const T *obj = dynamic_cast<const T *> (object);
      if (obj == 0)
        {
          return false;
        }
      *n = (obj->*m_getN)();
      return true;
    }
    virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i) const {
      const T *obj = static_cast<const T *> (object);
      return (obj->*m_get)(i);
    }
    Ptr<U> (T::*m_get)(INDEX) const;
    INDEX (T::*m_getN)(void) const;
  } *spec = new MemberGetters ();
  spec->m_get = get;
  spec->m_getN = getN;
  return Ptr<const AttributeAccessor> (spec, false);
}

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectPtrVectorAccessor (INDEX (T::*getN)(void) const,
                             Ptr<U> (T::*get)(INDEX) const)
{
  return MakeObjectPtrVectorAccessor (get, getN);
}

template <typename T>
Ptr<const AttributeChecker> MakeObjectPtrVectorChecker (void)
{
  return Create<internal::AnObjectPtrVectorChecker<T> > ();
}


} // namespace ns3

#endif /* OBJECT_PTR_VECTOR_H */




#include "object.h"
#include "ptr.h"
#include "attribute.h"
#include "object-ptr-vector.h"

namespace ns3 {

typedef ObjectPtrVectorValue ObjectVectorValue;

template <typename T, typename U>
Ptr<const AttributeAccessor>

Ptr<const AttributeAccessor>
MakeObjectVectorAccessor (U T::*memberVector)
{
  struct MemberStdContainer : public ObjectPtrVectorAccessor
  {
    virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {
      const T *obj = dynamic_cast<const T *> (object);

template <typename T>
Ptr<const AttributeChecker> MakeObjectVectorChecker (void)
{
  return MakeObjectPtrVectorChecker<T> ();
}

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectVectorAccessor (Ptr<U> (T::*get)(INDEX) const,
                          INDEX (T::*getN)(void) const)
{
  return MakeObjectPtrVectorAccessor<T,U,INDEX>(get, getN);
}

template <typename T, typename U, typename INDEX>
Ptr<const AttributeAccessor>
MakeObjectVectorAccessor (INDEX (T::*getN)(void) const,
                          Ptr<U> (T::*get)(INDEX) const)
{
  return MakeObjectPtrVectorAccessor<T,U,INDEX>(get, getN);
}






        'model/int64x64.cc',
        'model/string.cc',
        'model/pointer.cc',
        'model/object-ptr-vector.cc',
        'model/object-ptr-map.cc',
        'model/object-factory.cc',
        'model/global-value.cc',
        'model/trace-source-accessor.cc',

        'model/traced-value.h',
        'model/trace-source-accessor.h',
        'model/config.h',
        'model/object-ptr-vector.h',
        'model/object-ptr-map.h',
        'model/object-vector.h',
        'model/object-map.h',
        'model/deprecated.h',

Return to bug 1352