Attachment #1356 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 ());




{
}
void 
AttributeIterator::DoStartVisitArrayAttribute (Ptr<Object> object,
                                               std::string name, const ObjectPtrVectorValue &vector)
{
}
void 

{
}
void 
AttributeIterator::DoStartVisitArrayItem (const ObjectPtrVectorValue &vector,
                                          uint32_t index, Ptr<Object> item)
{
}
void 

}

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

}
void 
AttributeIterator::DoEndVisitMapAttribute (void)
{

}

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

}

void 
AttributeIterator::DoEndVisitMapItem (void)
{

}

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

  DoEndVisitPointerAttribute ();
}
void 
AttributeIterator::StartVisitArrayAttribute (Ptr<Object> object,
                                             std::string name, const ObjectPtrVectorValue &vector)
{
  m_currentPath.push_back (name);
  DoStartVisitArrayAttribute (object, name, vector);

}

void 
AttributeIterator::StartVisitArrayItem (const ObjectPtrVectorValue &vector,
                                        uint32_t index, Ptr<Object> item)
{
  std::ostringstream oss;
  oss << index;

  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);

              Ptr<Object> tmp = ptr.Get<Object> ();
              if (tmp != 0)
                {
                  StartVisitPointerAttribute (object, info.name, tmp);
                                              tmp);
                  m_examined.push_back (object);
                  DoIterate (tmp);
                  m_examined.pop_back ();

              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)

              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);
            }

              NS_LOG_DEBUG ("could not store " << info.name);
            }
        }
      Object::AggregateIterator iter = object->GetAggregateIterator ();
      bool recursiveAggregate = false;
  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<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




public:
  ModelCreator ();

  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);
                                           const ObjectPtrContainerValue &vector);
  virtual void DoEndVisitArrayAttribute (void);
  virtual void DoStartVisitArrayItem (const ObjectPtrVectorValue &vector, uint32_t index, Ptr<Object> item);
                                      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);





#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);
}






#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);
}



(-)a/src/core/wscript (+4 lines)

Lines 138-143	Link Here

138

        'model/string.cc',

138

        'model/string.cc',

139

        'model/pointer.cc',

139

        'model/pointer.cc',

140

        'model/object-ptr-container.cc',

140

        'model/object-ptr-container.cc',

141

        'model/object-ptr-vector.cc',

142

        'model/object-ptr-map.cc',

141

        'model/object-factory.cc',

143

        'model/object-factory.cc',

142

        'model/global-value.cc',

144

        'model/global-value.cc',

143

        'model/trace-source-accessor.cc',

145

        'model/trace-source-accessor.cc',

Lines 232-237	Link Here

232

        'model/trace-source-accessor.h',

234

        'model/trace-source-accessor.h',

233

        'model/config.h',

235

        'model/config.h',

234

        'model/object-ptr-container.h',

236

        'model/object-ptr-container.h',

237

        'model/object-ptr-vector.h',

238

        'model/object-ptr-map.h',

235

        'model/object-vector.h',

239

        'model/object-vector.h',

236

        'model/object-map.h',

240

        'model/object-map.h',

237

        'model/deprecated.h',

241

        'model/deprecated.h',

Return to bug 1352