diff --git a/src/core/boolean-value.cc b/src/core/boolean-value.cc
index 2326a4887..e6681dcb6 100644
--- a/src/core/boolean-value.cc
+++ b/src/core/boolean-value.cc
@@ -71,7 +71,7 @@ BooleanValue::operator Attribute () const
   return Attribute::Create<BooleanValue> (*this);
 }
 
-Ptr<AttributeChecker> MakeBooleanChecker (void)
+Ptr<const AttributeChecker> MakeBooleanChecker (void)
 {
   return MakeSimpleAttributeChecker<BooleanValue> ();
 }
diff --git a/src/core/boolean-value.h b/src/core/boolean-value.h
index deffbb5fc..34baab2ec 100644
--- a/src/core/boolean-value.h
+++ b/src/core/boolean-value.h
@@ -24,16 +24,16 @@ private:
   bool m_value;
 };
 
-class BooleanAccessor : public Accessor {};
+class BooleanAccessor : public AttributeAccessor {};
 
 
 template <typename T1>
-Ptr<Accessor> MakeBooleanAccessor (T1 a1);
+Ptr<const AttributeAccessor> MakeBooleanAccessor (T1 a1);
 
 template <typename T1, typename T2>
-Ptr<Accessor> MakeBooleanAccessor (T1 a1, T2 a2);
+Ptr<const AttributeAccessor> MakeBooleanAccessor (T1 a1, T2 a2);
 
-Ptr<AttributeChecker> MakeBooleanChecker (void);
+Ptr<const AttributeChecker> MakeBooleanChecker (void);
 
 } // namespace ns3
 
@@ -42,13 +42,13 @@ Ptr<AttributeChecker> MakeBooleanChecker (void);
 namespace ns3 {
 
 template <typename T1>
-Ptr<Accessor> MakeBooleanAccessor (T1 a1)
+Ptr<const AttributeAccessor> MakeBooleanAccessor (T1 a1)
 {
   return MakeAccessorHelper<BooleanAccessor,BooleanValue> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<Accessor> MakeBooleanAccessor (T1 a1, T2 a2)
+Ptr<const AttributeAccessor> MakeBooleanAccessor (T1 a1, T2 a2)
 {
   return MakeAccessorHelper<BooleanAccessor,BooleanValue> (a1, a2);
 }
diff --git a/src/core/class-value-helper.h b/src/core/class-value-helper.h
index a4673d469..d3f547012 100644
--- a/src/core/class-value-helper.h
+++ b/src/core/class-value-helper.h
@@ -77,7 +77,7 @@ ClassValueHelperConvertTo (const T *self)
 
 
 template <typename T, typename U, typename BASE, typename T1>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeClassValueHelperAccessor (T1 a1)
 {
   return MakeAccessorHelper<BASE,ClassValue<T,U> > (a1);
@@ -85,7 +85,7 @@ MakeClassValueHelperAccessor (T1 a1)
 
 
 template <typename T, typename U, typename BASE, typename T1, typename T2>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeClassValueHelperAccessor (T1 a1, T2 a2)
 {
   return MakeAccessorHelper<BASE,ClassValue<T,U> > (a1, a2);
diff --git a/src/core/enum-value.cc b/src/core/enum-value.cc
index 37cd13c15..e4755f53f 100644
--- a/src/core/enum-value.cc
+++ b/src/core/enum-value.cc
@@ -104,7 +104,7 @@ EnumChecker::Check (Attribute value) const
   return false;
 }
 
-Ptr<AttributeChecker> 
+Ptr<const AttributeChecker> 
 MakeEnumChecker (int v1, std::string n1,
 		 int v2, std::string n2,
 		 int v3, std::string n3,
diff --git a/src/core/enum-value.h b/src/core/enum-value.h
index ff6bd3cb4..a4f7f16d4 100644
--- a/src/core/enum-value.h
+++ b/src/core/enum-value.h
@@ -24,7 +24,7 @@ private:
   int m_v;
 };
 
-class EnumAccessor : public Accessor {};
+class EnumAccessor : public AttributeAccessor {};
 class EnumChecker : public AttributeChecker
 {
 public:
@@ -42,23 +42,23 @@ private:
 };
 
 template <typename T1>
-Ptr<Accessor> MakeEnumAccessor (T1 a1);
+Ptr<const AttributeAccessor> MakeEnumAccessor (T1 a1);
 
 template <typename T1, typename T2>
-Ptr<Accessor> MakeEnumAccessor (T1 a1, T2 a2);
+Ptr<const AttributeAccessor> MakeEnumAccessor (T1 a1, T2 a2);
 
-Ptr<AttributeChecker> MakeEnumChecker (int v1, std::string n1,
-				       int v2 = 0, std::string n2 = "",
-				       int v3 = 0, std::string n3 = "",
-				       int v4 = 0, std::string n4 = "",
-				       int v5 = 0, std::string n5 = "",
-				       int v6 = 0, std::string n6 = "",
-				       int v7 = 0, std::string n7 = "",
-				       int v8 = 0, std::string n8 = "",
-				       int v9 = 0, std::string n9 = "",
-				       int v10 = 0, std::string n10 = "",
-				       int v11 = 0, std::string n11 = "",
-				       int v12 = 0, std::string n12 = "");
+Ptr<const AttributeChecker> MakeEnumChecker (int v1, std::string n1,
+					     int v2 = 0, std::string n2 = "",
+					     int v3 = 0, std::string n3 = "",
+					     int v4 = 0, std::string n4 = "",
+					     int v5 = 0, std::string n5 = "",
+					     int v6 = 0, std::string n6 = "",
+					     int v7 = 0, std::string n7 = "",
+					     int v8 = 0, std::string n8 = "",
+					     int v9 = 0, std::string n9 = "",
+					     int v10 = 0, std::string n10 = "",
+					     int v11 = 0, std::string n11 = "",
+					     int v12 = 0, std::string n12 = "");
 
 
 } // namespace ns3
@@ -66,13 +66,13 @@ Ptr<AttributeChecker> MakeEnumChecker (int v1, std::string n1,
 namespace ns3 {
 
 template <typename T1>
-Ptr<Accessor> MakeEnumAccessor (T1 a1)
+Ptr<const AttributeAccessor> MakeEnumAccessor (T1 a1)
 {
   return MakeAccessorHelper<EnumAccessor,EnumValue> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<Accessor> MakeEnumAccessor (T1 a1, T2 a2)
+Ptr<const AttributeAccessor> MakeEnumAccessor (T1 a1, T2 a2)
 {
   return MakeAccessorHelper<EnumAccessor,EnumValue> (a1, a2);
 }
diff --git a/src/core/fp-value.cc b/src/core/fp-value.cc
index e45d8100f..935facf89 100644
--- a/src/core/fp-value.cc
+++ b/src/core/fp-value.cc
@@ -59,7 +59,7 @@ FpValue::operator Attribute () const
   return Attribute::Create<FpValue> (*this);
 }
 
-Ptr<AttributeChecker> MakeFpChecker (double min, double max)
+Ptr<const AttributeChecker> MakeFpChecker (double min, double max)
 {
   struct Checker : public AttributeChecker
   {
@@ -77,7 +77,7 @@ Ptr<AttributeChecker> MakeFpChecker (double min, double max)
     double m_minValue;
     double m_maxValue;
   } *checker = new Checker (min, max);
-  return Ptr<AttributeChecker> (checker, false);
+  return Ptr<const AttributeChecker> (checker, false);
 }
 
 
diff --git a/src/core/fp-value.h b/src/core/fp-value.h
index 64065a492..d21889b3a 100644
--- a/src/core/fp-value.h
+++ b/src/core/fp-value.h
@@ -25,17 +25,17 @@ private:
   double m_value;
 };
 
-class FpAccessor : public Accessor {};
+class FpAccessor : public AttributeAccessor {};
 
 template <typename T1>
-Ptr<Accessor> MakeFpAccessor (T1 a1);
+Ptr<const AttributeAccessor> MakeFpAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<Accessor> MakeFpAccessor (T1 a1, T2 a2);
+Ptr<const AttributeAccessor> MakeFpAccessor (T1 a1, T2 a2);
 
 template <typename T>
-Ptr<AttributeChecker> MakeFpChecker (void);
+Ptr<const AttributeChecker> MakeFpChecker (void);
 
-Ptr<AttributeChecker> MakeFpChecker (double min, double max);
+Ptr<const AttributeChecker> MakeFpChecker (double min, double max);
 
 
 
@@ -44,18 +44,18 @@ Ptr<AttributeChecker> MakeFpChecker (double min, double max);
 namespace ns3 {
 
 template <typename T1>
-Ptr<Accessor> MakeFpAccessor (T1 a1)
+Ptr<const AttributeAccessor> MakeFpAccessor (T1 a1)
 {
   return MakeAccessorHelper<FpAccessor,FpValue> (a1);
 }
 template <typename T1, typename T2>
-Ptr<Accessor> MakeFpAccessor (T1 a1, T2 a2)
+Ptr<const AttributeAccessor> MakeFpAccessor (T1 a1, T2 a2)
 {
   return MakeAccessorHelper<FpAccessor,FpValue> (a1, a2);
 }
 
 template <typename T>
-Ptr<AttributeChecker> MakeFpChecker (void)
+Ptr<const AttributeChecker> MakeFpChecker (void)
 {
   return MakeFpChecker (-std::numeric_limits<T>::max (),
 			std::numeric_limits<T>::max ());
diff --git a/src/core/int-value.cc b/src/core/int-value.cc
index 5a560abe1..30f068c5e 100644
--- a/src/core/int-value.cc
+++ b/src/core/int-value.cc
@@ -59,7 +59,7 @@ IntValue::operator Attribute () const
   return Attribute::Create<IntValue> (*this);
 }
 
-Ptr<AttributeChecker>
+Ptr<const AttributeChecker>
 MakeIntChecker (int64_t min, int64_t max)
 {
   struct IntChecker : public AttributeChecker
diff --git a/src/core/int-value.h b/src/core/int-value.h
index 3307e06c8..f67377f99 100644
--- a/src/core/int-value.h
+++ b/src/core/int-value.h
@@ -24,36 +24,36 @@ private:
   int64_t m_value;
 };
 
-class IntAccessor : public Accessor {};
+class IntAccessor : public AttributeAccessor {};
 
 template <typename T1>
-Ptr<Accessor> MakeIntAccessor (T1 a1);
+Ptr<const AttributeAccessor> MakeIntAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<Accessor> MakeIntAccessor (T1 a1, T2 a2);
+Ptr<const AttributeAccessor> MakeIntAccessor (T1 a1, T2 a2);
 
 template <typename T>
-Ptr<AttributeChecker> MakeIntChecker (void);
+Ptr<const AttributeChecker> MakeIntChecker (void);
 
-Ptr<AttributeChecker> MakeIntChecker (int64_t min, int64_t max);
+Ptr<const AttributeChecker> MakeIntChecker (int64_t min, int64_t max);
 
 } // namespace ns3
 
 namespace ns3 {
 
 template <typename T1>
-Ptr<Accessor> 
+Ptr<const AttributeAccessor> 
 MakeIntAccessor (T1 a1)
 {
   return MakeAccessorHelper<IntAccessor,IntValue> (a1);
 }
 template <typename T1, typename T2>
-Ptr<Accessor> MakeIntAccessor (T1 a1, T2 a2)
+Ptr<const AttributeAccessor> MakeIntAccessor (T1 a1, T2 a2)
 {
   return MakeAccessorHelper<IntAccessor,IntValue> (a1, a2);
 }
 
 template <typename T>
-Ptr<AttributeChecker>
+Ptr<const AttributeChecker>
 MakeIntChecker (void)
 {
   return MakeIntChecker (std::numeric_limits<T>::min (),
diff --git a/src/core/object-vector.cc b/src/core/object-vector.cc
index 3ea8eb22d..10701de2c 100644
--- a/src/core/object-vector.cc
+++ b/src/core/object-vector.cc
@@ -101,7 +101,7 @@ ObjectVectorAccessor::Get (const ObjectBase * object, Attribute value) const
     }
   return true;
 }
-Ptr<AttributeChecker> 
+Ptr<const AttributeChecker> 
 MakeObjectVectorChecker (void)
 {
   return MakeSimpleAttributeChecker<ObjectVectorValue> ();
diff --git a/src/core/object-vector.h b/src/core/object-vector.h
index 66f99b09e..60994740f 100644
--- a/src/core/object-vector.h
+++ b/src/core/object-vector.h
@@ -28,21 +28,21 @@ private:
 };
 
 template <typename T, typename U>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeObjectVectorAccessor (U T::*memberVector);
 
 template <typename T, typename U, typename INDEX>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeObjectVectorAccessor (Ptr<U> (T::*get) (INDEX) const,
 			   INDEX (T::*getN) (void) const);
 
 template <typename T, typename U, typename INDEX>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeObjectVectorAccessor (INDEX (T::*getN) (void) const,
 			   Ptr<U> (T::*get) (INDEX) const);
 
 
-Ptr<AttributeChecker> MakeObjectVectorChecker (void);
+Ptr<const AttributeChecker> MakeObjectVectorChecker (void);
 
 } // namespace ns3
 
@@ -65,7 +65,7 @@ private:
   ObjectVector m_vector;
 };
 
-class ObjectVectorAccessor : public Accessor
+class ObjectVectorAccessor : public AttributeAccessor
 {
 public:
   virtual bool Set (ObjectBase * object, Attribute value) const;
@@ -76,7 +76,7 @@ private:
 };
 
 template <typename T, typename U>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeObjectVectorAccessor (U T::*memberVector)
 {
   struct MemberStdContainer : public ObjectVectorAccessor
@@ -97,11 +97,11 @@ MakeObjectVectorAccessor (U T::*memberVector)
     U T::*m_memberVector;
   } *spec = new MemberStdContainer ();
   spec->m_memberVector = memberVector;
-  return Ptr<Accessor> (spec, false);
+  return Ptr<const AttributeAccessor> (spec, false);
 }
 
 template <typename T, typename U, typename INDEX>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeObjectVectorAccessor (Ptr<U> (T::*get) (INDEX) const,
 			   INDEX (T::*getN) (void) const)
 {
@@ -125,11 +125,11 @@ MakeObjectVectorAccessor (Ptr<U> (T::*get) (INDEX) const,
   } *spec = new MemberGetters ();
   spec->m_get = get;
   spec->m_getN = getN;
-  return Ptr<Accessor> (spec, false);
+  return Ptr<const AttributeAccessor> (spec, false);
 }
 
 template <typename T, typename U, typename INDEX>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeObjectVectorAccessor (INDEX (T::*getN) (void) const,
 			   Ptr<U> (T::*get) (INDEX) const)
 {
diff --git a/src/core/object.cc b/src/core/object.cc
index ca93ac5b7..282cafbac 100644
--- a/src/core/object.cc
+++ b/src/core/object.cc
@@ -58,13 +58,13 @@ public:
                      std::string help, 
                      uint32_t flags,
                      ns3::Attribute initialValue,
-                     ns3::Ptr<const ns3::Accessor> spec,
+                     ns3::Ptr<const ns3::AttributeAccessor> spec,
                      ns3::Ptr<const ns3::AttributeChecker> checker);
   uint32_t GetParametersN (uint16_t uid) const;
   std::string GetParameterName (uint16_t uid, uint32_t i) const;
   uint32_t GetParameterFlags (uint16_t uid, uint32_t i) const;
   ns3::Attribute GetParameterInitialValue (uint16_t uid, uint32_t i) const;
-  ns3::Ptr<const ns3::Accessor> GetParameterAccessor (uint16_t uid, uint32_t i) const;
+  ns3::Ptr<const ns3::AttributeAccessor> GetParameterAccessor (uint16_t uid, uint32_t i) const;
   ns3::Ptr<const ns3::AttributeChecker> GetParameterChecker (uint16_t uid, uint32_t i) const;
 private:
   struct ConstructorInformation {
@@ -76,7 +76,7 @@ private:
     std::string help;
     uint32_t flags;
     ns3::Attribute initialValue;
-    ns3::Ptr<const ns3::Accessor> param;
+    ns3::Ptr<const ns3::AttributeAccessor> param;
     ns3::Ptr<const ns3::AttributeChecker> checker;
   };
   struct IidInformation {
@@ -247,7 +247,7 @@ IidManager::AddParameter (uint16_t uid,
                           std::string help, 
                           uint32_t flags,
                           ns3::Attribute initialValue,
-                          ns3::Ptr<const ns3::Accessor> spec,
+                          ns3::Ptr<const ns3::AttributeAccessor> spec,
                           ns3::Ptr<const ns3::AttributeChecker> checker)
 {
   struct IidInformation *information = LookupInformation (uid);
@@ -298,7 +298,7 @@ IidManager::GetParameterInitialValue (uint16_t uid, uint32_t i) const
   NS_ASSERT (i < information->parameters.size ());
   return information->parameters[i].initialValue;
 }
-ns3::Ptr<const ns3::Accessor>
+ns3::Ptr<const ns3::AttributeAccessor>
 IidManager::GetParameterAccessor (uint16_t uid, uint32_t i) const
 {
   struct IidInformation *information = LookupInformation (uid);
@@ -544,7 +544,7 @@ TypeId
 TypeId::AddParameter (std::string name,
                       std::string help, 
                       Attribute initialValue,
-                      Ptr<const Accessor> param,
+                      Ptr<const AttributeAccessor> param,
                       Ptr<const AttributeChecker> checker)
 {
   Singleton<IidManager>::Get ()->AddParameter (m_tid, name, help, ATTR_SGC, initialValue, param, checker);
@@ -556,7 +556,7 @@ TypeId::AddParameter (std::string name,
                       std::string help, 
                       uint32_t flags,
                       Attribute initialValue,
-                      Ptr<const Accessor> param,
+                      Ptr<const AttributeAccessor> param,
                       Ptr<const AttributeChecker> checker)
 {
   Singleton<IidManager>::Get ()->AddParameter (m_tid, name, help, flags, initialValue, param, checker);
@@ -609,11 +609,11 @@ TypeId::GetParameterInitialValue (uint32_t i) const
   Attribute value = Singleton<IidManager>::Get ()->GetParameterInitialValue (m_tid, i);
   return value;
 }
-Ptr<const Accessor>
+Ptr<const AttributeAccessor>
 TypeId::GetParameterAccessor (uint32_t i) const
 {
   // Used exclusively by the Object class.
-  Ptr<const Accessor> param = Singleton<IidManager>::Get ()->GetParameterAccessor (m_tid, i);
+  Ptr<const AttributeAccessor> param = Singleton<IidManager>::Get ()->GetParameterAccessor (m_tid, i);
   return param;
 }
 uint32_t 
@@ -896,7 +896,7 @@ Object::Construct (const Parameters &parameters)
     NS_LOG_DEBUG ("construct tid="<<tid.GetName ()<<", params="<<tid.GetParametersN ());
     for (uint32_t i = 0; i < tid.GetParametersN (); i++)
       {
-        Ptr<const Accessor> paramSpec = tid.GetParameterAccessor (i);
+        Ptr<const AttributeAccessor> paramSpec = tid.GetParameterAccessor (i);
         Attribute initial = tid.GetParameterInitialValue (i);
         Ptr<const AttributeChecker> checker = tid.GetParameterChecker (i);
         NS_LOG_DEBUG ("try to construct \""<< tid.GetName ()<<"::"<<
@@ -950,7 +950,7 @@ Object::Construct (const Parameters &parameters)
   NotifyConstructionCompleted ();
 }
 bool
-Object::DoSet (Ptr<const Accessor> spec, Attribute initialValue, 
+Object::DoSet (Ptr<const AttributeAccessor> spec, Attribute initialValue, 
                Ptr<const AttributeChecker> checker, Attribute value)
 {
   bool ok = checker->Check (value);
diff --git a/src/core/object.h b/src/core/object.h
index 4c58bff6d..da11c768c 100644
--- a/src/core/object.h
+++ b/src/core/object.h
@@ -44,7 +44,7 @@ namespace ns3 {
 class TraceContext;
 class CallbackBase;
 class Object;
-class Accessor;
+class AttributeAccessor;
 class Value;
 class Parameters;
 
@@ -210,7 +210,7 @@ public:
   TypeId AddParameter (std::string name,
                        std::string help, 
                        Attribute initialValue,
-                       Ptr<const Accessor> spec,
+                       Ptr<const AttributeAccessor> spec,
                        Ptr<const AttributeChecker> checker);
 
   /**
@@ -227,7 +227,7 @@ public:
                        std::string help, 
                        uint32_t flags,
                        Attribute initialValue,
-                       Ptr<const Accessor> spec,
+                       Ptr<const AttributeAccessor> spec,
                        Ptr<const AttributeChecker> checker);
 
   // construct an invalid TypeId.
@@ -240,7 +240,7 @@ private:
   friend bool operator != (TypeId a, TypeId b);
 
   struct ParameterInfo {
-    Ptr<const Accessor> spec;
+    Ptr<const AttributeAccessor> spec;
     Attribute initialValue;
     uint32_t flags;
     Ptr<const AttributeChecker> checker;
@@ -265,7 +265,7 @@ private:
   explicit TypeId (uint16_t tid);
   void DoAddConstructor (CallbackBase callback, uint32_t nArguments);
   CallbackBase LookupConstructor (uint32_t nArguments) const;
-  Ptr<const Accessor> GetParameterAccessor (uint32_t i) const;
+  Ptr<const AttributeAccessor> GetParameterAccessor (uint32_t i) const;
   uint32_t GetParameterFlags (uint32_t i) const;
   Ptr<const AttributeChecker> GetParameterChecker (uint32_t i) const;
   
@@ -470,7 +470,7 @@ private:
   friend Ptr<T> CreateObject (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7);
 
 
-  bool DoSet (Ptr<const Accessor> spec, Attribute intialValue, 
+  bool DoSet (Ptr<const AttributeAccessor> spec, Attribute intialValue, 
               Ptr<const AttributeChecker> checker, Attribute value);
   Ptr<Object> DoGetObject (TypeId tid) const;
   void DoCollectSources (std::string path, const TraceContext &context, 
diff --git a/src/core/param-spec-helper.h b/src/core/param-spec-helper.h
index 15f98f9f2..8bdee3fc4 100644
--- a/src/core/param-spec-helper.h
+++ b/src/core/param-spec-helper.h
@@ -4,11 +4,11 @@
 namespace ns3 {
 
 template <typename BASE, typename V, typename T1>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeAccessorHelper (T1 a1);
 
 template <typename BASE, typename V, typename T1, typename T2>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeAccessorHelper (T1 a1, T2 a2);
 
 } // namespace ns3
@@ -62,7 +62,7 @@ private:
 };
 
 template <typename BASE, typename V, typename T, typename U>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 DoMakeAccessorHelperOne (U T::*memberVariable)
 {
   class MemberVariable : public AccessorHelper<BASE,T,V>
@@ -84,11 +84,11 @@ DoMakeAccessorHelperOne (U T::*memberVariable)
       
       U T::*m_memberVariable;
     };
-  return Ptr<Accessor> (new MemberVariable (memberVariable), false);
+  return Ptr<const AttributeAccessor> (new MemberVariable (memberVariable), false);
 }
 
 template <typename BASE, typename V, typename T, typename U>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 DoMakeAccessorHelperOne (U (T::*getter) (void) const)
 {
   class MemberMethod : public AccessorHelper<BASE,T,V>
@@ -108,12 +108,12 @@ DoMakeAccessorHelperOne (U (T::*getter) (void) const)
       }
       U (T::*m_getter) (void) const;
     };
-  return Ptr<Accessor> (new MemberMethod (getter), false);
+  return Ptr<const AttributeAccessor> (new MemberMethod (getter), false);
 }
 
 
 template <typename BASE, typename V, typename T, typename U>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 DoMakeAccessorHelperOne (void (T::*setter) (U))
 {
   class MemberMethod : public AccessorHelper<BASE,T,V>
@@ -133,11 +133,11 @@ DoMakeAccessorHelperOne (void (T::*setter) (U))
       }
       void (T::*m_setter) (U);
     };
-  return Ptr<Accessor> (new MemberMethod (setter), false);
+  return Ptr<const AttributeAccessor> (new MemberMethod (setter), false);
 }
 
 template <typename BASE, typename W, typename T, typename U, typename V>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 DoMakeAccessorHelperTwo (void (T::*setter) (U), 
 			  V (T::*getter) (void) const)
 {
@@ -162,11 +162,11 @@ DoMakeAccessorHelperTwo (void (T::*setter) (U),
       void (T::*m_setter) (U);
       V (T::*m_getter) (void) const;
     };
-  return Ptr<Accessor> (new MemberMethod (setter, getter), false);
+  return Ptr<const AttributeAccessor> (new MemberMethod (setter, getter), false);
 }
 
 template <typename BASE, typename W, typename T, typename U, typename V>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 DoMakeAccessorHelperTwo (V (T::*getter) (void) const, 
 			  void (T::*setter) (U))
 {
@@ -174,14 +174,14 @@ DoMakeAccessorHelperTwo (V (T::*getter) (void) const,
 }
 
 template <typename BASE, typename V, typename T1>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeAccessorHelper (T1 a1)
 {
   return DoMakeAccessorHelperOne<BASE,V> (a1);
 }
 
 template <typename BASE, typename V, typename T1, typename T2>
-Ptr<Accessor>
+Ptr<const AttributeAccessor>
 MakeAccessorHelper (T1 a1, T2 a2)
 {
   return DoMakeAccessorHelperTwo<BASE,V> (a1, a2);
diff --git a/src/core/random-variable.cc b/src/core/random-variable.cc
index face9958d..1e3929cfe 100644
--- a/src/core/random-variable.cc
+++ b/src/core/random-variable.cc
@@ -309,7 +309,7 @@ RandomVariable::operator Attribute () const
   return ClassValueHelperConvertTo<RandomVariable,RandomVariableValue> (this);
 }
 
-Ptr<AttributeChecker> 
+Ptr<const AttributeChecker> 
 MakeRandomVariableChecker (void)
 {
   return MakeSimpleAttributeChecker<RandomVariableValue> ();
diff --git a/src/core/random-variable.h b/src/core/random-variable.h
index 4e708bbc6..023e88b21 100644
--- a/src/core/random-variable.h
+++ b/src/core/random-variable.h
@@ -666,14 +666,14 @@ std::istream &operator >> (std::istream &os, RandomVariable &var);
 
 
 class RandomVariableValue : public Value {};
-class RandomVariableAccessor : public Accessor {};
+class RandomVariableAccessor : public AttributeAccessor {};
 
 template <typename T1>
-Ptr<Accessor> MakeRandomVariableAccessor (T1 a1);
+Ptr<const AttributeAccessor> MakeRandomVariableAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<Accessor> MakeRandomVariableAccessor (T1 a1, T2 a2);
+Ptr<const AttributeAccessor> MakeRandomVariableAccessor (T1 a1, T2 a2);
 
-Ptr<AttributeChecker> MakeRandomVariableChecker (void);
+Ptr<const AttributeChecker> MakeRandomVariableChecker (void);
 
 }//namespace ns3
 
@@ -681,14 +681,14 @@ Ptr<AttributeChecker> MakeRandomVariableChecker (void);
 namespace ns3 {
 
 template <typename T1>
-Ptr<Accessor> MakeRandomVariableAccessor (T1 a1)
+Ptr<const AttributeAccessor> MakeRandomVariableAccessor (T1 a1)
 {
   return MakeClassValueHelperAccessor<RandomVariable, 
     RandomVariableValue, RandomVariableAccessor> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<Accessor> MakeRandomVariableAccessor (T1 a1, T2 a2)
+Ptr<const AttributeAccessor> MakeRandomVariableAccessor (T1 a1, T2 a2)
 {
   return MakeClassValueHelperAccessor<RandomVariable, 
     RandomVariableValue,RandomVariableAccessor> (a1, a2);
diff --git a/src/core/uint-value.cc b/src/core/uint-value.cc
index 6f96951d7..bc7727b9e 100644
--- a/src/core/uint-value.cc
+++ b/src/core/uint-value.cc
@@ -60,7 +60,7 @@ UintValue::operator Attribute () const
 }
 
 
-Ptr<AttributeChecker> MakeUintChecker (uint64_t min, uint64_t max)
+Ptr<const AttributeChecker> MakeUintChecker (uint64_t min, uint64_t max)
 {
   struct Checker : public AttributeChecker
   {
@@ -78,7 +78,7 @@ Ptr<AttributeChecker> MakeUintChecker (uint64_t min, uint64_t max)
     uint64_t m_minValue;
     uint64_t m_maxValue;
   } *checker = new Checker (min, max);
-  return Ptr<AttributeChecker> (checker, false);
+  return Ptr<const AttributeChecker> (checker, false);
 }
 
 
diff --git a/src/core/uint-value.h b/src/core/uint-value.h
index d2d59a73b..8bba6b7dc 100644
--- a/src/core/uint-value.h
+++ b/src/core/uint-value.h
@@ -24,37 +24,37 @@ private:
   uint64_t m_value;
 };
 
-class UintAccessor : public Accessor {};
+class UintAccessor : public AttributeAccessor {};
 
 template <typename T1>
-Ptr<Accessor> MakeUintAccessor (T1 a1);
+Ptr<const AttributeAccessor> MakeUintAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<Accessor> MakeUintAccessor (T1 a1, T2 a2);
+Ptr<const AttributeAccessor> MakeUintAccessor (T1 a1, T2 a2);
 
 template <typename T>
-Ptr<AttributeChecker> MakeUintChecker (void);
+Ptr<const AttributeChecker> MakeUintChecker (void);
 
-Ptr<AttributeChecker> MakeUintChecker (uint64_t min, uint64_t max);
+Ptr<const AttributeChecker> MakeUintChecker (uint64_t min, uint64_t max);
 
 } // namespace ns3
 
 namespace ns3 {
 
 template <typename T1>
-Ptr<Accessor> 
+Ptr<const AttributeAccessor> 
 MakeUintAccessor (T1 a1)
 {
   return MakeAccessorHelper<UintAccessor,UintValue> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<Accessor> MakeUintAccessor (T1 a1, T2 a2)
+Ptr<const AttributeAccessor> MakeUintAccessor (T1 a1, T2 a2)
 {
   return MakeAccessorHelper<UintAccessor,UintValue> (a1, a2);
 }
 
 template <typename T>
-Ptr<AttributeChecker> MakeUintChecker (void)
+Ptr<const AttributeChecker> MakeUintChecker (void)
 {
   return MakeUintChecker (std::numeric_limits<T>::min (),
 			  std::numeric_limits<T>::max ());
diff --git a/src/core/value-helper.h b/src/core/value-helper.h
index a5a1f8d40..d1377a258 100644
--- a/src/core/value-helper.h
+++ b/src/core/value-helper.h
@@ -7,25 +7,25 @@
   type (Attribute value); \
   operator Attribute () const;
 
-#define VALUE_HELPER_HEADER_2(type)				\
-  class type##Value : public Value {};				\
-  class type##Accessor : public Accessor {};			\
-  Ptr<AttributeChecker> Make##type##Checker (void);		\
-  template <typename T1>					\
-  Ptr<Accessor> Make##type##Accessor (T1 a1)			\
-  {								\
-    return MakeClassValueHelperAccessor< type ,		\
-      type##Value, type##Accessor> (a1);			\
-  }								\
-  template <typename T1, typename T2>				\
-    Ptr<Accessor> Make##type##Accessor (T1 a1, T2 a2)	\
-  {								\
-    return MakeClassValueHelperAccessor<type,			\
-      type##Value,type##Accessor> (a1, a2);			\
+#define VALUE_HELPER_HEADER_2(type)					\
+  class type##Value : public Value {};					\
+  class type##Accessor : public AttributeAccessor {};				\
+  Ptr<const AttributeChecker> Make##type##Checker (void);		\
+  template <typename T1>						\
+  Ptr<const AttributeAccessor> Make##type##Accessor (T1 a1)		\
+  {									\
+    return MakeClassValueHelperAccessor< type ,				\
+      type##Value, type##Accessor> (a1);				\
+  }									\
+  template <typename T1, typename T2>					\
+  Ptr<const AttributeAccessor> Make##type##Accessor (T1 a1, T2 a2)	\
+  {									\
+    return MakeClassValueHelperAccessor<type,				\
+      type##Value,type##Accessor> (a1, a2);				\
   }
 
 #define VALUE_HELPER_CPP(type)						\
-  Ptr<AttributeChecker> Make##type##Checker (void)			\
+  Ptr<const AttributeChecker> Make##type##Checker (void)		\
   {									\
     return MakeSimpleAttributeChecker<type> ();				\
   }									\
diff --git a/src/core/value.cc b/src/core/value.cc
index f45b265b5..c29629879 100644
--- a/src/core/value.cc
+++ b/src/core/value.cc
@@ -121,16 +121,16 @@ Attribute::Attribute (std::string value)
 {}
 
 
-Accessor::Accessor ()
+AttributeAccessor::AttributeAccessor ()
   : m_count (1)
 {}
 void 
-Accessor::Ref (void) const
+AttributeAccessor::Ref (void) const
 {
   m_count++;
 }
 void 
-Accessor::Unref (void) const
+AttributeAccessor::Unref (void) const
 {
   m_count--;
   if (m_count == 0)
@@ -138,7 +138,7 @@ Accessor::Unref (void) const
       delete this;
     }
 }
-Accessor::~Accessor ()
+AttributeAccessor::~AttributeAccessor ()
 {}
 
 AttributeChecker::AttributeChecker ()
diff --git a/src/core/value.h b/src/core/value.h
index 547e39edd..19c3c6abd 100644
--- a/src/core/value.h
+++ b/src/core/value.h
@@ -8,7 +8,7 @@
 
 namespace ns3 {
 
-class Accessor;
+class AttributeAccessor;
 class AttributeChecker;
 class Attribute;
 
@@ -60,13 +60,13 @@ private:
   Value *m_value;
 };
 
-class Accessor : public ObjectBase
+class AttributeAccessor : public ObjectBase
 {
 public:
-  Accessor ();
+  AttributeAccessor ();
   void Ref (void) const;
   void Unref (void) const;
-  virtual ~Accessor ();
+  virtual ~AttributeAccessor ();
 
   /**
    * \param object the object instance to set the value in
@@ -97,14 +97,14 @@ Ptr<AttributeChecker>
 MakeSimpleAttributeChecker (void);
 
 template <typename T, typename U>
-Ptr<const Accessor>
+Ptr<const AttributeAccessor>
 MakePtrAccessor (Ptr<U> T::*memberVariable);
 
 template <typename T, typename U>
-Ptr<const Accessor>
+Ptr<const AttributeAccessor>
 MakePtrAccessor (void (T::*setter) (Ptr<U>));
 template <typename T, typename U>
-Ptr<const Accessor>
+Ptr<const AttributeAccessor>
 MakePtrAccessor (Ptr<U> (T::*getter) (void) const);
 
 
@@ -232,7 +232,7 @@ Attribute::operator Ptr<T> ()
  ********************************************************/
 
 template <typename T, typename U>
-class PtrAccessor : public Accessor
+class PtrAccessor : public AttributeAccessor
 {
 public:
   virtual ~PtrAccessor () {}
@@ -275,7 +275,7 @@ private:
 
 
 template <typename T, typename U>
-Ptr<const Accessor>
+Ptr<const AttributeAccessor>
 MakePtrAccessor (Ptr<U> T::*memberVariable)
 {
   struct MemberVariable : public PtrAccessor<T,U>
@@ -292,11 +292,11 @@ MakePtrAccessor (Ptr<U> T::*memberVariable)
     }
   } *spec = new MemberVariable ();
   spec->m_memberVariable = memberVariable;
-  return Ptr<const Accessor> (spec, false);
+  return Ptr<const AttributeAccessor> (spec, false);
 }
 
 template <typename T, typename U>
-Ptr<const Accessor>
+Ptr<const AttributeAccessor>
 MakePtrAccessor (void (T::*setter) (Ptr<U>))
 {
   struct MemberMethod : public PtrAccessor<T,U>
@@ -314,11 +314,11 @@ MakePtrAccessor (void (T::*setter) (Ptr<U>))
     }
   } *spec = new MemberMethod ();
   spec->m_setter = setter;
-  return Ptr<const Accessor> (spec, false);
+  return Ptr<const AttributeAccessor> (spec, false);
 }
 
 template <typename T, typename U>
-Ptr<const Accessor>
+Ptr<const AttributeAccessor>
 MakePtrAccessor (Ptr<U> (T::*getter) (void) const)
 {
   struct MemberMethod : public PtrAccessor<T,U>
@@ -335,7 +335,7 @@ MakePtrAccessor (Ptr<U> (T::*getter) (void) const)
     }
   } *spec = new MemberMethod ();
   spec->m_getter = getter;
-  return Ptr<const Accessor> (spec, false);
+  return Ptr<const AttributeAccessor> (spec, false);
 }
 
 template <typename T>
diff --git a/src/simulator/nstime.h b/src/simulator/nstime.h
index c6b926a0f..a4d8a1d94 100644
--- a/src/simulator/nstime.h
+++ b/src/simulator/nstime.h
@@ -671,14 +671,14 @@ typedef TimeUnit<2> TimeSquare;
 
 
 class TimeValue : public Value {};
-class TimeAccessor : public Accessor {};
+class TimeAccessor : public AttributeAccessor {};
 
 template <typename T1>
-Ptr<Accessor> MakeTimeAccessor (T1 a1);
+Ptr<const AttributeAccessor> MakeTimeAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<Accessor> MakeTimeAccessor (T1 a1, T2 a2);
+Ptr<const AttributeAccessor> MakeTimeAccessor (T1 a1, T2 a2);
 
-Ptr<AttributeChecker> MakeTimeChecker (void);
+Ptr<const AttributeChecker> MakeTimeChecker (void);
 
 
 
@@ -687,13 +687,13 @@ Ptr<AttributeChecker> MakeTimeChecker (void);
 namespace ns3 {
 
 template <typename T1>
-Ptr<Accessor> MakeTimeAccessor (T1 a1)
+Ptr<const AttributeAccessor> MakeTimeAccessor (T1 a1)
 {
   return MakeClassValueHelperAccessor<Time,TimeValue,TimeAccessor> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<Accessor> MakeTimeAccessor (T1 a1, T2 a2)
+Ptr<const AttributeAccessor> MakeTimeAccessor (T1 a1, T2 a2)
 {
   return MakeClassValueHelperAccessor<Time,TimeValue,TimeAccessor> (a1, a2);
 }
diff --git a/src/simulator/time.cc b/src/simulator/time.cc
index 41c48a892..1448a1b05 100644
--- a/src/simulator/time.cc
+++ b/src/simulator/time.cc
@@ -305,7 +305,7 @@ TimeUnit<1>::operator Attribute () const
   return ClassValueHelperConvertTo<Time,TimeValue> (this);
 }
 
-Ptr<AttributeChecker> MakeTimeChecker (void)
+Ptr<const AttributeChecker> MakeTimeChecker (void)
 {
   return MakeSimpleAttributeChecker<Time> ();
 }