diff --git a/src/core/boolean-value.h b/src/core/boolean-value.h
index 95efd9f9b..deffbb5fc 100644
--- a/src/core/boolean-value.h
+++ b/src/core/boolean-value.h
@@ -24,14 +24,14 @@ private:
   bool m_value;
 };
 
-class BooleanParamSpec : public ParamSpec {};
+class BooleanAccessor : public Accessor {};
 
 
 template <typename T1>
-Ptr<ParamSpec> MakeBooleanParamSpec (T1 a1);
+Ptr<Accessor> MakeBooleanAccessor (T1 a1);
 
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeBooleanParamSpec (T1 a1, T2 a2);
+Ptr<Accessor> MakeBooleanAccessor (T1 a1, T2 a2);
 
 Ptr<AttributeChecker> MakeBooleanChecker (void);
 
@@ -42,15 +42,15 @@ Ptr<AttributeChecker> MakeBooleanChecker (void);
 namespace ns3 {
 
 template <typename T1>
-Ptr<ParamSpec> MakeBooleanParamSpec (T1 a1)
+Ptr<Accessor> MakeBooleanAccessor (T1 a1)
 {
-  return MakeParamSpecHelper<BooleanParamSpec,BooleanValue> (a1);
+  return MakeAccessorHelper<BooleanAccessor,BooleanValue> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeBooleanParamSpec (T1 a1, T2 a2)
+Ptr<Accessor> MakeBooleanAccessor (T1 a1, T2 a2)
 {
-  return MakeParamSpecHelper<BooleanParamSpec,BooleanValue> (a1, a2);
+  return MakeAccessorHelper<BooleanAccessor,BooleanValue> (a1, a2);
 }
 
 } // namespace ns3
diff --git a/src/core/class-value-helper.h b/src/core/class-value-helper.h
index 7b0aa07fd..a4673d469 100644
--- a/src/core/class-value-helper.h
+++ b/src/core/class-value-helper.h
@@ -77,18 +77,18 @@ ClassValueHelperConvertTo (const T *self)
 
 
 template <typename T, typename U, typename BASE, typename T1>
-Ptr<ParamSpec>
-MakeClassValueHelperParamSpec (T1 a1)
+Ptr<Accessor>
+MakeClassValueHelperAccessor (T1 a1)
 {
-  return MakeParamSpecHelper<BASE,ClassValue<T,U> > (a1);
+  return MakeAccessorHelper<BASE,ClassValue<T,U> > (a1);
 }
 
 
 template <typename T, typename U, typename BASE, typename T1, typename T2>
-Ptr<ParamSpec>
-MakeClassValueHelperParamSpec (T1 a1, T2 a2)
+Ptr<Accessor>
+MakeClassValueHelperAccessor (T1 a1, T2 a2)
 {
-  return MakeParamSpecHelper<BASE,ClassValue<T,U> > (a1, a2);
+  return MakeAccessorHelper<BASE,ClassValue<T,U> > (a1, a2);
 }
 
 } // namespace ns3
diff --git a/src/core/enum-value.h b/src/core/enum-value.h
index 64afa6864..ff6bd3cb4 100644
--- a/src/core/enum-value.h
+++ b/src/core/enum-value.h
@@ -24,7 +24,7 @@ private:
   int m_v;
 };
 
-class EnumParamSpec : public ParamSpec {};
+class EnumAccessor : public Accessor {};
 class EnumChecker : public AttributeChecker
 {
 public:
@@ -42,10 +42,10 @@ private:
 };
 
 template <typename T1>
-Ptr<ParamSpec> MakeEnumParamSpec (T1 a1);
+Ptr<Accessor> MakeEnumAccessor (T1 a1);
 
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeEnumParamSpec (T1 a1, T2 a2);
+Ptr<Accessor> MakeEnumAccessor (T1 a1, T2 a2);
 
 Ptr<AttributeChecker> MakeEnumChecker (int v1, std::string n1,
 				       int v2 = 0, std::string n2 = "",
@@ -66,15 +66,15 @@ Ptr<AttributeChecker> MakeEnumChecker (int v1, std::string n1,
 namespace ns3 {
 
 template <typename T1>
-Ptr<ParamSpec> MakeEnumParamSpec (T1 a1)
+Ptr<Accessor> MakeEnumAccessor (T1 a1)
 {
-  return MakeParamSpecHelper<EnumParamSpec,EnumValue> (a1);
+  return MakeAccessorHelper<EnumAccessor,EnumValue> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeEnumParamSpec (T1 a1, T2 a2)
+Ptr<Accessor> MakeEnumAccessor (T1 a1, T2 a2)
 {
-  return MakeParamSpecHelper<EnumParamSpec,EnumValue> (a1, a2);
+  return MakeAccessorHelper<EnumAccessor,EnumValue> (a1, a2);
 }
 
 } // namespace ns3
diff --git a/src/core/fp-value.h b/src/core/fp-value.h
index 232cc810e..64065a492 100644
--- a/src/core/fp-value.h
+++ b/src/core/fp-value.h
@@ -25,12 +25,12 @@ private:
   double m_value;
 };
 
-class FpParamSpec : public ParamSpec {};
+class FpAccessor : public Accessor {};
 
 template <typename T1>
-Ptr<ParamSpec> MakeFpParamSpec (T1 a1);
+Ptr<Accessor> MakeFpAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeFpParamSpec (T1 a1, T2 a2);
+Ptr<Accessor> MakeFpAccessor (T1 a1, T2 a2);
 
 template <typename T>
 Ptr<AttributeChecker> MakeFpChecker (void);
@@ -44,14 +44,14 @@ Ptr<AttributeChecker> MakeFpChecker (double min, double max);
 namespace ns3 {
 
 template <typename T1>
-Ptr<ParamSpec> MakeFpParamSpec (T1 a1)
+Ptr<Accessor> MakeFpAccessor (T1 a1)
 {
-  return MakeParamSpecHelper<FpParamSpec,FpValue> (a1);
+  return MakeAccessorHelper<FpAccessor,FpValue> (a1);
 }
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeFpParamSpec (T1 a1, T2 a2)
+Ptr<Accessor> MakeFpAccessor (T1 a1, T2 a2)
 {
-  return MakeParamSpecHelper<FpParamSpec,FpValue> (a1, a2);
+  return MakeAccessorHelper<FpAccessor,FpValue> (a1, a2);
 }
 
 template <typename T>
diff --git a/src/core/int-value.h b/src/core/int-value.h
index 5e41c3cdf..3307e06c8 100644
--- a/src/core/int-value.h
+++ b/src/core/int-value.h
@@ -24,12 +24,12 @@ private:
   int64_t m_value;
 };
 
-class IntParamSpec : public ParamSpec {};
+class IntAccessor : public Accessor {};
 
 template <typename T1>
-Ptr<ParamSpec> MakeIntParamSpec (T1 a1);
+Ptr<Accessor> MakeIntAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeIntParamSpec (T1 a1, T2 a2);
+Ptr<Accessor> MakeIntAccessor (T1 a1, T2 a2);
 
 template <typename T>
 Ptr<AttributeChecker> MakeIntChecker (void);
@@ -41,15 +41,15 @@ Ptr<AttributeChecker> MakeIntChecker (int64_t min, int64_t max);
 namespace ns3 {
 
 template <typename T1>
-Ptr<ParamSpec> 
-MakeIntParamSpec (T1 a1)
+Ptr<Accessor> 
+MakeIntAccessor (T1 a1)
 {
-  return MakeParamSpecHelper<IntParamSpec,IntValue> (a1);
+  return MakeAccessorHelper<IntAccessor,IntValue> (a1);
 }
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeIntParamSpec (T1 a1, T2 a2)
+Ptr<Accessor> MakeIntAccessor (T1 a1, T2 a2)
 {
-  return MakeParamSpecHelper<IntParamSpec,IntValue> (a1, a2);
+  return MakeAccessorHelper<IntAccessor,IntValue> (a1, a2);
 }
 
 template <typename T>
diff --git a/src/core/object-vector.cc b/src/core/object-vector.cc
index 46248226f..3ea8eb22d 100644
--- a/src/core/object-vector.cc
+++ b/src/core/object-vector.cc
@@ -74,13 +74,13 @@ ObjectVectorValue::DeserializeFromString (std::string value, Ptr<const Attribute
 }
 
 bool 
-ObjectVectorParamSpec::Set (ObjectBase * object, Attribute value) const
+ObjectVectorAccessor::Set (ObjectBase * object, Attribute value) const
 {
   // not allowed.
   return false;
 }
 bool 
-ObjectVectorParamSpec::Get (const ObjectBase * object, Attribute value) const
+ObjectVectorAccessor::Get (const ObjectBase * object, Attribute value) const
 {
   ObjectVectorValue *v = value.DynCast<ObjectVectorValue *> ();
   if (v == 0)
diff --git a/src/core/object-vector.h b/src/core/object-vector.h
index 8704d0bac..66f99b09e 100644
--- a/src/core/object-vector.h
+++ b/src/core/object-vector.h
@@ -23,22 +23,22 @@ public:
   ObjectVector (Attribute value);
   operator Attribute () const;
 private:
-  friend class ObjectVectorParamSpec;
+  friend class ObjectVectorAccessor;
   std::vector<Ptr<Object> > m_objects;
 };
 
 template <typename T, typename U>
-Ptr<ParamSpec>
-MakeObjectVectorParamSpec (U T::*memberVector);
+Ptr<Accessor>
+MakeObjectVectorAccessor (U T::*memberVector);
 
 template <typename T, typename U, typename INDEX>
-Ptr<ParamSpec>
-MakeObjectVectorParamSpec (Ptr<U> (T::*get) (INDEX) const,
+Ptr<Accessor>
+MakeObjectVectorAccessor (Ptr<U> (T::*get) (INDEX) const,
 			   INDEX (T::*getN) (void) const);
 
 template <typename T, typename U, typename INDEX>
-Ptr<ParamSpec>
-MakeObjectVectorParamSpec (INDEX (T::*getN) (void) const,
+Ptr<Accessor>
+MakeObjectVectorAccessor (INDEX (T::*getN) (void) const,
 			   Ptr<U> (T::*get) (INDEX) const);
 
 
@@ -61,11 +61,11 @@ public:
   virtual bool DeserializeFromString (std::string value, Ptr<const AttributeChecker> checker);
 
 private:
-  friend class ObjectVectorParamSpec;
+  friend class ObjectVectorAccessor;
   ObjectVector m_vector;
 };
 
-class ObjectVectorParamSpec : public ParamSpec
+class ObjectVectorAccessor : public Accessor
 {
 public:
   virtual bool Set (ObjectBase * object, Attribute value) const;
@@ -76,10 +76,10 @@ private:
 };
 
 template <typename T, typename U>
-Ptr<ParamSpec>
-MakeObjectVectorParamSpec (U T::*memberVector)
+Ptr<Accessor>
+MakeObjectVectorAccessor (U T::*memberVector)
 {
-  struct MemberStdContainer : public ObjectVectorParamSpec
+  struct MemberStdContainer : public ObjectVectorAccessor
   {
     virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {
       const T *obj = dynamic_cast<const T *> (object);
@@ -97,15 +97,15 @@ MakeObjectVectorParamSpec (U T::*memberVector)
     U T::*m_memberVector;
   } *spec = new MemberStdContainer ();
   spec->m_memberVector = memberVector;
-  return Ptr<ParamSpec> (spec, false);
+  return Ptr<Accessor> (spec, false);
 }
 
 template <typename T, typename U, typename INDEX>
-Ptr<ParamSpec>
-MakeObjectVectorParamSpec (Ptr<U> (T::*get) (INDEX) const,
+Ptr<Accessor>
+MakeObjectVectorAccessor (Ptr<U> (T::*get) (INDEX) const,
 			   INDEX (T::*getN) (void) const)
 {
-  struct MemberGetters : public ObjectVectorParamSpec
+  struct MemberGetters : public ObjectVectorAccessor
   {
     virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {
       const T *obj = dynamic_cast<const T *> (object);
@@ -125,15 +125,15 @@ MakeObjectVectorParamSpec (Ptr<U> (T::*get) (INDEX) const,
   } *spec = new MemberGetters ();
   spec->m_get = get;
   spec->m_getN = getN;
-  return Ptr<ParamSpec> (spec, false);
+  return Ptr<Accessor> (spec, false);
 }
 
 template <typename T, typename U, typename INDEX>
-Ptr<ParamSpec>
-MakeObjectVectorParamSpec (INDEX (T::*getN) (void) const,
+Ptr<Accessor>
+MakeObjectVectorAccessor (INDEX (T::*getN) (void) const,
 			   Ptr<U> (T::*get) (INDEX) const)
 {
-  return MakeObjectVectorParamSpec (get, getN);
+  return MakeObjectVectorAccessor (get, getN);
 }
 
 } // namespace ns3
diff --git a/src/core/object.cc b/src/core/object.cc
index 320c549d1..ca93ac5b7 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::ParamSpec> spec,
+                     ns3::Ptr<const ns3::Accessor> 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::ParamSpec> GetParameterParamSpec (uint16_t uid, uint32_t i) const;
+  ns3::Ptr<const ns3::Accessor> 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::ParamSpec> param;
+    ns3::Ptr<const ns3::Accessor> 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::ParamSpec> spec,
+                          ns3::Ptr<const ns3::Accessor> spec,
                           ns3::Ptr<const ns3::AttributeChecker> checker)
 {
   struct IidInformation *information = LookupInformation (uid);
@@ -298,8 +298,8 @@ IidManager::GetParameterInitialValue (uint16_t uid, uint32_t i) const
   NS_ASSERT (i < information->parameters.size ());
   return information->parameters[i].initialValue;
 }
-ns3::Ptr<const ns3::ParamSpec>
-IidManager::GetParameterParamSpec (uint16_t uid, uint32_t i) const
+ns3::Ptr<const ns3::Accessor>
+IidManager::GetParameterAccessor (uint16_t uid, uint32_t i) const
 {
   struct IidInformation *information = LookupInformation (uid);
   NS_ASSERT (i < information->parameters.size ());
@@ -446,7 +446,7 @@ TypeId::LookupParameterByName (std::string name, struct TypeId::ParameterInfo *i
         std::string paramName = GetParameterName (i);
         if (paramName == name)
           {
-            info->spec = GetParameterParamSpec (i);
+            info->spec = GetParameterAccessor (i);
             info->flags = GetParameterFlags (i);
             info->initialValue = tid.GetParameterInitialValue (i);
             info->checker = tid.GetParameterChecker (i);
@@ -469,7 +469,7 @@ TypeId::LookupParameterByPosition (uint32_t i, struct TypeId::ParameterInfo *inf
       {
         if (cur == i)
           {
-            info->spec = tid.GetParameterParamSpec (j);
+            info->spec = tid.GetParameterAccessor (j);
             info->flags = tid.GetParameterFlags (j);
             info->initialValue = tid.GetParameterInitialValue (j);
             info->checker = tid.GetParameterChecker (j);
@@ -544,7 +544,7 @@ TypeId
 TypeId::AddParameter (std::string name,
                       std::string help, 
                       Attribute initialValue,
-                      Ptr<const ParamSpec> param,
+                      Ptr<const Accessor> 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 ParamSpec> param,
+                      Ptr<const Accessor> 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 ParamSpec>
-TypeId::GetParameterParamSpec (uint32_t i) const
+Ptr<const Accessor>
+TypeId::GetParameterAccessor (uint32_t i) const
 {
   // Used exclusively by the Object class.
-  Ptr<const ParamSpec> param = Singleton<IidManager>::Get ()->GetParameterParamSpec (m_tid, i);
+  Ptr<const Accessor> param = Singleton<IidManager>::Get ()->GetParameterAccessor (m_tid, i);
   return param;
 }
 uint32_t 
@@ -777,7 +777,7 @@ Parameters::LookupParameterFullNameByChecker (Ptr<const AttributeChecker> checke
             }
         }
     }
-  NS_FATAL_ERROR ("Could not find requested ParamSpec.");
+  NS_FATAL_ERROR ("Could not find requested Accessor.");
   // quiet compiler.
   return "";
 }
@@ -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 ParamSpec> paramSpec = tid.GetParameterParamSpec (i);
+        Ptr<const Accessor> 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 ParamSpec> spec, Attribute initialValue, 
+Object::DoSet (Ptr<const Accessor> 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 6eee2f440..4c58bff6d 100644
--- a/src/core/object.h
+++ b/src/core/object.h
@@ -44,7 +44,7 @@ namespace ns3 {
 class TraceContext;
 class CallbackBase;
 class Object;
-class ParamSpec;
+class Accessor;
 class Value;
 class Parameters;
 
@@ -202,7 +202,7 @@ public:
    * \param name the name of the new parameter
    * \param help some help text which describes the purpose of this
    *        parameter
-   * \param param an instance of the associated ParamSpec subclass
+   * \param param an instance of the associated Accessor subclass
    * \returns this TypeId instance
    *
    * Record in this TypeId the fact that a new parameter exists.
@@ -210,7 +210,7 @@ public:
   TypeId AddParameter (std::string name,
                        std::string help, 
                        Attribute initialValue,
-                       Ptr<const ParamSpec> spec,
+                       Ptr<const Accessor> spec,
                        Ptr<const AttributeChecker> checker);
 
   /**
@@ -218,7 +218,7 @@ public:
    * \param help some help text which describes the purpose of this
    *        parameter
    * \param flags flags which describe how this parameter can be read and/or written.
-   * \param param an instance of the associated ParamSpec subclass
+   * \param param an instance of the associated Accessor subclass
    * \returns this TypeId instance
    *
    * Record in this TypeId the fact that a new parameter exists.
@@ -227,7 +227,7 @@ public:
                        std::string help, 
                        uint32_t flags,
                        Attribute initialValue,
-                       Ptr<const ParamSpec> spec,
+                       Ptr<const Accessor> 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 ParamSpec> spec;
+    Ptr<const Accessor> spec;
     Attribute initialValue;
     uint32_t flags;
     Ptr<const AttributeChecker> checker;
@@ -248,24 +248,24 @@ private:
 
   /**
    * \param name the name of the requested parameter
-   * \returns the ParamSpec associated to the requested parameter
+   * \returns the Accessor associated to the requested parameter
    */
   bool LookupParameterByName (std::string name, struct ParameterInfo *info) const;
   /**
    * \param i the position of the requested parameter
-   * \returns the ParamSpec associated to the requested parameter
+   * \returns the Accessor associated to the requested parameter
    */
   bool LookupParameterByPosition (uint32_t i, struct ParameterInfo *info) const;
   /**
    * \param fullName the full name of the requested parameter
-   * \returns the ParamSpec associated to the requested parameter
+   * \returns the Accessor associated to the requested parameter
    */
   static bool LookupParameterByFullName (std::string fullName, struct ParameterInfo *info);
 
   explicit TypeId (uint16_t tid);
   void DoAddConstructor (CallbackBase callback, uint32_t nArguments);
   CallbackBase LookupConstructor (uint32_t nArguments) const;
-  Ptr<const ParamSpec> GetParameterParamSpec (uint32_t i) const;
+  Ptr<const Accessor> 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 ParamSpec> spec, Attribute intialValue, 
+  bool DoSet (Ptr<const Accessor> 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 79d34aa1b..15f98f9f2 100644
--- a/src/core/param-spec-helper.h
+++ b/src/core/param-spec-helper.h
@@ -4,12 +4,12 @@
 namespace ns3 {
 
 template <typename BASE, typename V, typename T1>
-Ptr<ParamSpec>
-MakeParamSpecHelper (T1 a1);
+Ptr<Accessor>
+MakeAccessorHelper (T1 a1);
 
 template <typename BASE, typename V, typename T1, typename T2>
-Ptr<ParamSpec>
-MakeParamSpecHelper (T1 a1, T2 a2);
+Ptr<Accessor>
+MakeAccessorHelper (T1 a1, T2 a2);
 
 } // namespace ns3
 
@@ -22,10 +22,10 @@ MakeParamSpecHelper (T1 a1, T2 a2);
 namespace ns3 {
 
 template <typename BASE, typename T, typename U>
-class ParamSpecHelper : public BASE
+class AccessorHelper : public BASE
 {
 public:
-  ParamSpecHelper () {}
+  AccessorHelper () {}
 
   virtual bool Set (ObjectBase * object, Attribute val) const {
     const U *value = val.DynCast<const U*> ();
@@ -62,14 +62,14 @@ private:
 };
 
 template <typename BASE, typename V, typename T, typename U>
-Ptr<ParamSpec>
-DoMakeParamSpecHelperOne (U T::*memberVariable)
+Ptr<Accessor>
+DoMakeAccessorHelperOne (U T::*memberVariable)
 {
-  class MemberVariable : public ParamSpecHelper<BASE,T,V>
+  class MemberVariable : public AccessorHelper<BASE,T,V>
     {
     public:
       MemberVariable (U T::*memberVariable)
-	: ParamSpecHelper<BASE,T,V> (),
+	: AccessorHelper<BASE,T,V> (),
 	m_memberVariable (memberVariable)
 	{}
     private:
@@ -84,18 +84,18 @@ DoMakeParamSpecHelperOne (U T::*memberVariable)
       
       U T::*m_memberVariable;
     };
-  return Ptr<ParamSpec> (new MemberVariable (memberVariable), false);
+  return Ptr<Accessor> (new MemberVariable (memberVariable), false);
 }
 
 template <typename BASE, typename V, typename T, typename U>
-Ptr<ParamSpec>
-DoMakeParamSpecHelperOne (U (T::*getter) (void) const)
+Ptr<Accessor>
+DoMakeAccessorHelperOne (U (T::*getter) (void) const)
 {
-  class MemberMethod : public ParamSpecHelper<BASE,T,V>
+  class MemberMethod : public AccessorHelper<BASE,T,V>
     {
     public:
       MemberMethod (U (T::*getter) (void) const)
-	: ParamSpecHelper<BASE,T,V> (),
+	: AccessorHelper<BASE,T,V> (),
 	m_getter (getter)
 	{}
     private:
@@ -108,19 +108,19 @@ DoMakeParamSpecHelperOne (U (T::*getter) (void) const)
       }
       U (T::*m_getter) (void) const;
     };
-  return Ptr<ParamSpec> (new MemberMethod (getter), false);
+  return Ptr<Accessor> (new MemberMethod (getter), false);
 }
 
 
 template <typename BASE, typename V, typename T, typename U>
-Ptr<ParamSpec>
-DoMakeParamSpecHelperOne (void (T::*setter) (U))
+Ptr<Accessor>
+DoMakeAccessorHelperOne (void (T::*setter) (U))
 {
-  class MemberMethod : public ParamSpecHelper<BASE,T,V>
+  class MemberMethod : public AccessorHelper<BASE,T,V>
     {
     public:
       MemberMethod (void (T::*setter) (U))
-	: ParamSpecHelper<BASE,T,V> (),
+	: AccessorHelper<BASE,T,V> (),
 	m_setter (setter)
 	{}
     private:
@@ -133,20 +133,20 @@ DoMakeParamSpecHelperOne (void (T::*setter) (U))
       }
       void (T::*m_setter) (U);
     };
-  return Ptr<ParamSpec> (new MemberMethod (setter), false);
+  return Ptr<Accessor> (new MemberMethod (setter), false);
 }
 
 template <typename BASE, typename W, typename T, typename U, typename V>
-Ptr<ParamSpec>
-DoMakeParamSpecHelperTwo (void (T::*setter) (U), 
+Ptr<Accessor>
+DoMakeAccessorHelperTwo (void (T::*setter) (U), 
 			  V (T::*getter) (void) const)
 {
-  class MemberMethod : public ParamSpecHelper<BASE,T,W>
+  class MemberMethod : public AccessorHelper<BASE,T,W>
     {
     public:
       MemberMethod (void (T::*setter) (U), 
 		    V (T::*getter) (void) const)
-	: ParamSpecHelper<BASE,T,W> (),
+	: AccessorHelper<BASE,T,W> (),
 	m_setter (setter),
 	m_getter (getter)
 	{}
@@ -162,29 +162,29 @@ DoMakeParamSpecHelperTwo (void (T::*setter) (U),
       void (T::*m_setter) (U);
       V (T::*m_getter) (void) const;
     };
-  return Ptr<ParamSpec> (new MemberMethod (setter, getter), false);
+  return Ptr<Accessor> (new MemberMethod (setter, getter), false);
 }
 
 template <typename BASE, typename W, typename T, typename U, typename V>
-Ptr<ParamSpec>
-DoMakeParamSpecHelperTwo (V (T::*getter) (void) const, 
+Ptr<Accessor>
+DoMakeAccessorHelperTwo (V (T::*getter) (void) const, 
 			  void (T::*setter) (U))
 {
-  return DoMakeParamSpecHelperTwo<BASE,W> (setter, getter);
+  return DoMakeAccessorHelperTwo<BASE,W> (setter, getter);
 }
 
 template <typename BASE, typename V, typename T1>
-Ptr<ParamSpec>
-MakeParamSpecHelper (T1 a1)
+Ptr<Accessor>
+MakeAccessorHelper (T1 a1)
 {
-  return DoMakeParamSpecHelperOne<BASE,V> (a1);
+  return DoMakeAccessorHelperOne<BASE,V> (a1);
 }
 
 template <typename BASE, typename V, typename T1, typename T2>
-Ptr<ParamSpec>
-MakeParamSpecHelper (T1 a1, T2 a2)
+Ptr<Accessor>
+MakeAccessorHelper (T1 a1, T2 a2)
 {
-  return DoMakeParamSpecHelperTwo<BASE,V> (a1, a2);
+  return DoMakeAccessorHelperTwo<BASE,V> (a1, a2);
 }
 
 } // namespace ns3
diff --git a/src/core/random-variable.h b/src/core/random-variable.h
index d559e363d..4e708bbc6 100644
--- a/src/core/random-variable.h
+++ b/src/core/random-variable.h
@@ -666,12 +666,12 @@ std::istream &operator >> (std::istream &os, RandomVariable &var);
 
 
 class RandomVariableValue : public Value {};
-class RandomVariableParamSpec : public ParamSpec {};
+class RandomVariableAccessor : public Accessor {};
 
 template <typename T1>
-Ptr<ParamSpec> MakeRandomVariableParamSpec (T1 a1);
+Ptr<Accessor> MakeRandomVariableAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeRandomVariableParamSpec (T1 a1, T2 a2);
+Ptr<Accessor> MakeRandomVariableAccessor (T1 a1, T2 a2);
 
 Ptr<AttributeChecker> MakeRandomVariableChecker (void);
 
@@ -681,17 +681,17 @@ Ptr<AttributeChecker> MakeRandomVariableChecker (void);
 namespace ns3 {
 
 template <typename T1>
-Ptr<ParamSpec> MakeRandomVariableParamSpec (T1 a1)
+Ptr<Accessor> MakeRandomVariableAccessor (T1 a1)
 {
-  return MakeClassValueHelperParamSpec<RandomVariable, 
-    RandomVariableValue, RandomVariableParamSpec> (a1);
+  return MakeClassValueHelperAccessor<RandomVariable, 
+    RandomVariableValue, RandomVariableAccessor> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeRandomVariableParamSpec (T1 a1, T2 a2)
+Ptr<Accessor> MakeRandomVariableAccessor (T1 a1, T2 a2)
 {
-  return MakeClassValueHelperParamSpec<RandomVariable, 
-    RandomVariableValue,RandomVariableParamSpec> (a1, a2);
+  return MakeClassValueHelperAccessor<RandomVariable, 
+    RandomVariableValue,RandomVariableAccessor> (a1, a2);
 }
 
 
diff --git a/src/core/uint-value.h b/src/core/uint-value.h
index a7d4dfc40..d2d59a73b 100644
--- a/src/core/uint-value.h
+++ b/src/core/uint-value.h
@@ -24,12 +24,12 @@ private:
   uint64_t m_value;
 };
 
-class UintParamSpec : public ParamSpec {};
+class UintAccessor : public Accessor {};
 
 template <typename T1>
-Ptr<ParamSpec> MakeUintParamSpec (T1 a1);
+Ptr<Accessor> MakeUintAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeUintParamSpec (T1 a1, T2 a2);
+Ptr<Accessor> MakeUintAccessor (T1 a1, T2 a2);
 
 template <typename T>
 Ptr<AttributeChecker> MakeUintChecker (void);
@@ -41,16 +41,16 @@ Ptr<AttributeChecker> MakeUintChecker (uint64_t min, uint64_t max);
 namespace ns3 {
 
 template <typename T1>
-Ptr<ParamSpec> 
-MakeUintParamSpec (T1 a1)
+Ptr<Accessor> 
+MakeUintAccessor (T1 a1)
 {
-  return MakeParamSpecHelper<UintParamSpec,UintValue> (a1);
+  return MakeAccessorHelper<UintAccessor,UintValue> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeUintParamSpec (T1 a1, T2 a2)
+Ptr<Accessor> MakeUintAccessor (T1 a1, T2 a2)
 {
-  return MakeParamSpecHelper<UintParamSpec,UintValue> (a1, a2);
+  return MakeAccessorHelper<UintAccessor,UintValue> (a1, a2);
 }
 
 template <typename T>
diff --git a/src/core/value-helper.h b/src/core/value-helper.h
index 57dbe7916..a5a1f8d40 100644
--- a/src/core/value-helper.h
+++ b/src/core/value-helper.h
@@ -9,19 +9,19 @@
 
 #define VALUE_HELPER_HEADER_2(type)				\
   class type##Value : public Value {};				\
-  class type##ParamSpec : public ParamSpec {};			\
+  class type##Accessor : public Accessor {};			\
   Ptr<AttributeChecker> Make##type##Checker (void);		\
   template <typename T1>					\
-  Ptr<ParamSpec> Make##type##ParamSpec (T1 a1)			\
+  Ptr<Accessor> Make##type##Accessor (T1 a1)			\
   {								\
-    return MakeClassValueHelperParamSpec< type ,		\
-      type##Value, type##ParamSpec> (a1);			\
+    return MakeClassValueHelperAccessor< type ,		\
+      type##Value, type##Accessor> (a1);			\
   }								\
   template <typename T1, typename T2>				\
-    Ptr<ParamSpec> Make##type##ParamSpec (T1 a1, T2 a2)	\
+    Ptr<Accessor> Make##type##Accessor (T1 a1, T2 a2)	\
   {								\
-    return MakeClassValueHelperParamSpec<type,			\
-      type##Value,type##ParamSpec> (a1, a2);			\
+    return MakeClassValueHelperAccessor<type,			\
+      type##Value,type##Accessor> (a1, a2);			\
   }
 
 #define VALUE_HELPER_CPP(type)						\
diff --git a/src/core/value-test.cc b/src/core/value-test.cc
index a5b70768a..681e87419 100644
--- a/src/core/value-test.cc
+++ b/src/core/value-test.cc
@@ -11,10 +11,10 @@
 
 namespace ns3 {
 
-class ParamSpecTest : public Test
+class AccessorTest : public Test
 {
 public:
-  ParamSpecTest ();
+  AccessorTest ();
   virtual bool RunTests (void);
 private:
 };
@@ -30,7 +30,7 @@ public:
   }
 };
 
-class ParamSpecObjectTest : public Object
+class AccessorObjectTest : public Object
 {
 public:
   enum TestEnum {
@@ -39,60 +39,60 @@ public:
     TEST_C
   };
   static TypeId GetTypeId (void) {
-    static TypeId tid = TypeId ("ParamSpecObjectTest")
+    static TypeId tid = TypeId ("AccessorObjectTest")
       .SetParent<Object> ()
       .AddParameter ("TestBoolName", "help text",
 		     BooleanValue (false),
-		     MakeBooleanParamSpec (&ParamSpecObjectTest::m_boolTest),
+		     MakeBooleanAccessor (&AccessorObjectTest::m_boolTest),
 		     MakeBooleanChecker ())
       .AddParameter ("TestBoolA", "help text",
 		     BooleanValue (false),
-		     MakeBooleanParamSpec (&ParamSpecObjectTest::DoSetTestB,
-					   &ParamSpecObjectTest::DoGetTestB),
+		     MakeBooleanAccessor (&AccessorObjectTest::DoSetTestB,
+					   &AccessorObjectTest::DoGetTestB),
 		     MakeBooleanChecker ())
       .AddParameter ("TestPtr", "help text", 
 		     Ptr<Derived> (0),
-		     MakePtrParamSpec (&ParamSpecObjectTest::m_derived),
+		     MakePtrAccessor (&AccessorObjectTest::m_derived),
 		     MakePtrChecker<Derived> ())
       .AddParameter ("TestInt16", "help text",
 		     IntValue (-2),
-		     MakeIntParamSpec (&ParamSpecObjectTest::m_int16),
+		     MakeIntAccessor (&AccessorObjectTest::m_int16),
 		     MakeIntChecker<int16_t> ())
       .AddParameter ("TestInt16WithBounds", "help text",
 		     IntValue (-2),
-		     MakeIntParamSpec (&ParamSpecObjectTest::m_int16WithBounds),
+		     MakeIntAccessor (&AccessorObjectTest::m_int16WithBounds),
 		     MakeIntChecker (-5, 10))
       .AddParameter ("TestInt16SetGet", "help text",
 		     IntValue (6),
-		     MakeIntParamSpec (&ParamSpecObjectTest::DoSetInt16,
-				       &ParamSpecObjectTest::DoGetInt16),
+		     MakeIntAccessor (&AccessorObjectTest::DoSetInt16,
+				       &AccessorObjectTest::DoGetInt16),
 		     MakeIntChecker<int16_t> ())
       .AddParameter ("TestUint8", "help text",
 		     UintValue (1),
-		     MakeUintParamSpec (&ParamSpecObjectTest::m_uint8),
+		     MakeUintAccessor (&AccessorObjectTest::m_uint8),
 		     MakeUintChecker<uint8_t> ())
       .AddParameter ("TestEnum", "help text",
 		     EnumValue (TEST_A),
-		     MakeEnumParamSpec (&ParamSpecObjectTest::m_enum),
+		     MakeEnumAccessor (&AccessorObjectTest::m_enum),
 		     MakeEnumChecker (TEST_A, "TestA",
 				      TEST_B, "TestB",
 				      TEST_C, "TestC"))
       .AddParameter ("TestRandom", "help text",
 		     ConstantVariable (1.0),
-		     MakeRandomVariableParamSpec (&ParamSpecObjectTest::m_random),
+		     MakeRandomVariableAccessor (&AccessorObjectTest::m_random),
 		     MakeRandomVariableChecker ())
       .AddParameter ("TestFloat", "help text",
 		     FpValue (-1.1),
-		     MakeFpParamSpec (&ParamSpecObjectTest::m_float),
+		     MakeFpAccessor (&AccessorObjectTest::m_float),
 		     MakeFpChecker<float> ())
       .AddParameter ("TestVector1", "help text",
 		     ObjectVector (),
-		     MakeObjectVectorParamSpec (&ParamSpecObjectTest::m_vector1),
+		     MakeObjectVectorAccessor (&AccessorObjectTest::m_vector1),
 		     MakeObjectVectorChecker ())
       .AddParameter ("TestVector2", "help text",
 		     ObjectVector (),
-		     MakeObjectVectorParamSpec (&ParamSpecObjectTest::DoGetVectorN,
-						&ParamSpecObjectTest::DoGetVector),
+		     MakeObjectVectorAccessor (&AccessorObjectTest::DoGetVectorN,
+						&AccessorObjectTest::DoGetVector),
 		     MakeObjectVectorChecker ())
       ;
         
@@ -158,20 +158,20 @@ private:
     NS_TEST_ASSERT_EQUAL (got.Get (), expected.Get ());	\
   }
 
-NS_OBJECT_ENSURE_REGISTERED (ParamSpecObjectTest);
+NS_OBJECT_ENSURE_REGISTERED (AccessorObjectTest);
 
-ParamSpecTest::ParamSpecTest ()
-  : Test ("ParamSpec")
+AccessorTest::AccessorTest ()
+  : Test ("Accessor")
 {}
 bool 
-ParamSpecTest::RunTests (void)
+AccessorTest::RunTests (void)
 {
   bool result = true;
 
   Parameters params;
-  Ptr<ParamSpecObjectTest> p;
-  NS_TEST_ASSERT (params.Set ("ParamSpecObjectTest::TestBoolName", "false"));
-  p = CreateObject<ParamSpecObjectTest> (params);
+  Ptr<AccessorObjectTest> p;
+  NS_TEST_ASSERT (params.Set ("AccessorObjectTest::TestBoolName", "false"));
+  p = CreateObject<AccessorObjectTest> (params);
   CHECK_GET_STR (p, "TestBoolName", "false");
   CHECK_GET_PARAM (p, "TestBoolName", BooleanValue, false);
 
@@ -183,11 +183,11 @@ ParamSpecTest::RunTests (void)
   CHECK_GET_STR (p, "TestBoolName", "false");
   CHECK_GET_PARAM (p, "TestBoolName", BooleanValue, false);
 
-  p = CreateObjectWith<ParamSpecObjectTest> ("TestBoolName", "true");
+  p = CreateObjectWith<AccessorObjectTest> ("TestBoolName", "true");
   CHECK_GET_STR (p, "TestBoolName", "true");
   CHECK_GET_PARAM (p, "TestBoolName", BooleanValue, true);
 
-  p = CreateObjectWith<ParamSpecObjectTest> ("TestBoolName", BooleanValue (true));
+  p = CreateObjectWith<AccessorObjectTest> ("TestBoolName", BooleanValue (true));
   CHECK_GET_STR (p, "TestBoolName", "true");
   CHECK_GET_PARAM (p, "TestBoolName", BooleanValue, true);
 
@@ -208,10 +208,10 @@ ParamSpecTest::RunTests (void)
   NS_TEST_ASSERT (stored == derived);
   Ptr<Object> storedBase = p->Get ("TestPtr");
   NS_TEST_ASSERT (stored == storedBase);
-  Ptr<ParamSpecObjectTest> x = p->Get ("TestPtr");
+  Ptr<AccessorObjectTest> x = p->Get ("TestPtr");
   NS_TEST_ASSERT (x == 0);
 
-  p = CreateObjectWith<ParamSpecObjectTest> ("TestPtr", Create<Derived> ());
+  p = CreateObjectWith<AccessorObjectTest> ("TestPtr", Create<Derived> ());
   NS_TEST_ASSERT (p != 0);
   derived = 0;
   derived = p->Get ("TestPtr");
@@ -290,19 +290,19 @@ ParamSpecTest::RunTests (void)
   CHECK_GET_PARAM (p, "TestFloat", FpValue, (float)+2.3);
 
   CHECK_GET_STR (p, "TestEnum", "TestA");
-  CHECK_GET_PARAM (p, "TestEnum", EnumValue, ParamSpecObjectTest::TEST_A);
-  NS_TEST_ASSERT (p->Set ("TestEnum", EnumValue (ParamSpecObjectTest::TEST_C)));
+  CHECK_GET_PARAM (p, "TestEnum", EnumValue, AccessorObjectTest::TEST_A);
+  NS_TEST_ASSERT (p->Set ("TestEnum", EnumValue (AccessorObjectTest::TEST_C)));
   CHECK_GET_STR (p, "TestEnum", "TestC");
-  CHECK_GET_PARAM (p, "TestEnum", EnumValue, ParamSpecObjectTest::TEST_C);
+  CHECK_GET_PARAM (p, "TestEnum", EnumValue, AccessorObjectTest::TEST_C);
   NS_TEST_ASSERT (p->Set ("TestEnum", "TestB"));
   CHECK_GET_STR (p, "TestEnum", "TestB");
-  CHECK_GET_PARAM (p, "TestEnum", EnumValue, ParamSpecObjectTest::TEST_B);
+  CHECK_GET_PARAM (p, "TestEnum", EnumValue, AccessorObjectTest::TEST_B);
   NS_TEST_ASSERT (!p->Set ("TestEnum", "TestD"));
   CHECK_GET_STR (p, "TestEnum", "TestB");
-  CHECK_GET_PARAM (p, "TestEnum", EnumValue, ParamSpecObjectTest::TEST_B);
+  CHECK_GET_PARAM (p, "TestEnum", EnumValue, AccessorObjectTest::TEST_B);
   NS_TEST_ASSERT (!p->Set ("TestEnum", EnumValue (5)));
   CHECK_GET_STR (p, "TestEnum", "TestB");
-  CHECK_GET_PARAM (p, "TestEnum", EnumValue, ParamSpecObjectTest::TEST_B);
+  CHECK_GET_PARAM (p, "TestEnum", EnumValue, AccessorObjectTest::TEST_B);
 
   RandomVariable ran = p->Get ("TestRandom");
   NS_TEST_ASSERT (p->Set ("TestRandom", UniformVariable (0.0, 1.0)));
@@ -346,11 +346,11 @@ ParamSpecTest::RunTests (void)
   NS_TEST_ASSERT_EQUAL (p->Get ("TestBool"), "false");
 
   Parameters::GetGlobal ()->Set ("TestBool", "true");
-  p = CreateObjectWith<ParamSpecObjectTest> ();
+  p = CreateObjectWith<AccessorObjectTest> ();
   NS_TEST_ASSERT_EQUAL (p->Get ("TestBool"), "true");
 
   Parameters::GetGlobal ()->Set ("TestBool", "false");
-  p = CreateObjectWith<ParamSpecObjectTest> ();
+  p = CreateObjectWith<AccessorObjectTest> ();
   NS_TEST_ASSERT_EQUAL (p->Get ("TestBool"), "false");
 #endif
   return result;
@@ -358,7 +358,7 @@ ParamSpecTest::RunTests (void)
 
 
 
-static ParamSpecTest g_parameterTest;
+static AccessorTest g_parameterTest;
 
 } // namespace ns3
 
diff --git a/src/core/value.cc b/src/core/value.cc
index 2c4bb19be..f45b265b5 100644
--- a/src/core/value.cc
+++ b/src/core/value.cc
@@ -121,16 +121,16 @@ Attribute::Attribute (std::string value)
 {}
 
 
-ParamSpec::ParamSpec ()
+Accessor::Accessor ()
   : m_count (1)
 {}
 void 
-ParamSpec::Ref (void) const
+Accessor::Ref (void) const
 {
   m_count++;
 }
 void 
-ParamSpec::Unref (void) const
+Accessor::Unref (void) const
 {
   m_count--;
   if (m_count == 0)
@@ -138,7 +138,7 @@ ParamSpec::Unref (void) const
       delete this;
     }
 }
-ParamSpec::~ParamSpec ()
+Accessor::~Accessor ()
 {}
 
 AttributeChecker::AttributeChecker ()
diff --git a/src/core/value.h b/src/core/value.h
index 1ab6c6378..547e39edd 100644
--- a/src/core/value.h
+++ b/src/core/value.h
@@ -8,7 +8,7 @@
 
 namespace ns3 {
 
-class ParamSpec;
+class Accessor;
 class AttributeChecker;
 class Attribute;
 
@@ -60,13 +60,13 @@ private:
   Value *m_value;
 };
 
-class ParamSpec : public ObjectBase
+class Accessor : public ObjectBase
 {
 public:
-  ParamSpec ();
+  Accessor ();
   void Ref (void) const;
   void Unref (void) const;
-  virtual ~ParamSpec ();
+  virtual ~Accessor ();
 
   /**
    * \param object the object instance to set the value in
@@ -97,15 +97,15 @@ Ptr<AttributeChecker>
 MakeSimpleAttributeChecker (void);
 
 template <typename T, typename U>
-Ptr<const ParamSpec>
-MakePtrParamSpec (Ptr<U> T::*memberVariable);
+Ptr<const Accessor>
+MakePtrAccessor (Ptr<U> T::*memberVariable);
 
 template <typename T, typename U>
-Ptr<const ParamSpec>
-MakePtrParamSpec (void (T::*setter) (Ptr<U>));
+Ptr<const Accessor>
+MakePtrAccessor (void (T::*setter) (Ptr<U>));
 template <typename T, typename U>
-Ptr<const ParamSpec>
-MakePtrParamSpec (Ptr<U> (T::*getter) (void) const);
+Ptr<const Accessor>
+MakePtrAccessor (Ptr<U> (T::*getter) (void) const);
 
 
 } // namespace ns3
@@ -227,15 +227,15 @@ Attribute::operator Ptr<T> ()
 }
 
 /********************************************************
- *              The ParamSpec associated to 
+ *              The Accessor associated to 
  *               PtrValue<T>
  ********************************************************/
 
 template <typename T, typename U>
-class PtrParamSpec : public ParamSpec
+class PtrAccessor : public Accessor
 {
 public:
-  virtual ~PtrParamSpec () {}
+  virtual ~PtrAccessor () {}
   virtual bool Set (ObjectBase * object, Attribute val) const {
       T *obj = dynamic_cast<T *> (object);
       if (obj == 0)
@@ -275,10 +275,10 @@ private:
 
 
 template <typename T, typename U>
-Ptr<const ParamSpec>
-MakePtrParamSpec (Ptr<U> T::*memberVariable)
+Ptr<const Accessor>
+MakePtrAccessor (Ptr<U> T::*memberVariable)
 {
-  struct MemberVariable : public PtrParamSpec<T,U>
+  struct MemberVariable : public PtrAccessor<T,U>
   {
     Ptr<U> T::*m_memberVariable;
     virtual MemberVariable *Copy (void) const {
@@ -292,14 +292,14 @@ MakePtrParamSpec (Ptr<U> T::*memberVariable)
     }
   } *spec = new MemberVariable ();
   spec->m_memberVariable = memberVariable;
-  return Ptr<const ParamSpec> (spec, false);
+  return Ptr<const Accessor> (spec, false);
 }
 
 template <typename T, typename U>
-Ptr<const ParamSpec>
-MakePtrParamSpec (void (T::*setter) (Ptr<U>))
+Ptr<const Accessor>
+MakePtrAccessor (void (T::*setter) (Ptr<U>))
 {
-  struct MemberMethod : public PtrParamSpec<T,U>
+  struct MemberMethod : public PtrAccessor<T,U>
   {
     void (T::*m_setter) (Ptr<U>);
     virtual MemberMethod *Copy (void) const {
@@ -314,14 +314,14 @@ MakePtrParamSpec (void (T::*setter) (Ptr<U>))
     }
   } *spec = new MemberMethod ();
   spec->m_setter = setter;
-  return Ptr<const ParamSpec> (spec, false);
+  return Ptr<const Accessor> (spec, false);
 }
 
 template <typename T, typename U>
-Ptr<const ParamSpec>
-MakePtrParamSpec (Ptr<U> (T::*getter) (void) const)
+Ptr<const Accessor>
+MakePtrAccessor (Ptr<U> (T::*getter) (void) const)
 {
-  struct MemberMethod : public PtrParamSpec<T,U>
+  struct MemberMethod : public PtrAccessor<T,U>
   {
     void (T::*m_getter) (Ptr<U>);
     virtual MemberMethod *Copy (void) const {
@@ -335,7 +335,7 @@ MakePtrParamSpec (Ptr<U> (T::*getter) (void) const)
     }
   } *spec = new MemberMethod ();
   spec->m_getter = getter;
-  return Ptr<const ParamSpec> (spec, false);
+  return Ptr<const Accessor> (spec, false);
 }
 
 template <typename T>
diff --git a/src/mobility/hierarchical-mobility-model.cc b/src/mobility/hierarchical-mobility-model.cc
index 959c15957..666b3b12b 100644
--- a/src/mobility/hierarchical-mobility-model.cc
+++ b/src/mobility/hierarchical-mobility-model.cc
@@ -32,11 +32,11 @@ HierarchicalMobilityModel::GetTypeId (void)
     .AddConstructor<HierarchicalMobilityModel> ()
     .AddParameter ("child", "The child mobility model.",
                    Ptr<MobilityModel> (0),
-                   MakePtrParamSpec (&HierarchicalMobilityModel::SetChild),
+                   MakePtrAccessor (&HierarchicalMobilityModel::SetChild),
                    MakePtrChecker<MobilityModel> ())
     .AddParameter ("parent", "The parent mobility model.",
                    Ptr<MobilityModel> (0),
-                   MakePtrParamSpec (&HierarchicalMobilityModel::SetParent),
+                   MakePtrAccessor (&HierarchicalMobilityModel::SetParent),
                    MakePtrChecker<MobilityModel> ())
     ;
   return tid;
diff --git a/src/mobility/mobility-model.cc b/src/mobility/mobility-model.cc
index 9af634e69..0d8dffee9 100644
--- a/src/mobility/mobility-model.cc
+++ b/src/mobility/mobility-model.cc
@@ -31,13 +31,13 @@ MobilityModel::GetTypeId (void)
     .AddParameter ("position", "The current position of the mobility model.",
                    TypeId::ATTR_SGC,
                    Vector (0.0, 0.0, 0.0),
-                   MakeVectorParamSpec (&MobilityModel::SetPosition,
+                   MakeVectorAccessor (&MobilityModel::SetPosition,
                                         &MobilityModel::GetPosition),
                    MakeVectorChecker ())
     .AddParameter ("velocity", "The current velocity of the mobility model.",
                    TypeId::ATTR_GET,
                    Vector (0.0, 0.0, 0.0), // ignored initial value.
-                   MakeVectorParamSpec (&MobilityModel::GetVelocity),
+                   MakeVectorAccessor (&MobilityModel::GetVelocity),
                    MakeVectorChecker ())
     ;
   return tid;
diff --git a/src/mobility/position-allocator.cc b/src/mobility/position-allocator.cc
index ac23e85d2..30553dcb5 100644
--- a/src/mobility/position-allocator.cc
+++ b/src/mobility/position-allocator.cc
@@ -55,27 +55,27 @@ GridPositionAllocator::GetTypeId (void)
     .AddConstructor<GridPositionAllocator> ()
     .AddParameter ("GridWidth", "The number of objects layed out on a line.",
                    IntValue (10),
-                   MakeIntParamSpec (&GridPositionAllocator::m_n),
+                   MakeIntAccessor (&GridPositionAllocator::m_n),
                    MakeIntChecker<uint32_t> ())
     .AddParameter ("MinX", "The x coordinate where the grid starts.",
                    FpValue (1.0),
-                   MakeFpParamSpec (&GridPositionAllocator::m_xMin),
+                   MakeFpAccessor (&GridPositionAllocator::m_xMin),
                    MakeFpChecker<double> ())
     .AddParameter ("MinY", "The y coordinate where the grid starts.",
                    FpValue (0.0),
-                   MakeFpParamSpec (&GridPositionAllocator::m_yMin),
+                   MakeFpAccessor (&GridPositionAllocator::m_yMin),
                    MakeFpChecker<double> ())
     .AddParameter ("DeltaX", "The x space between objects.",
                    FpValue (1.0),
-                   MakeFpParamSpec (&GridPositionAllocator::m_deltaX),
+                   MakeFpAccessor (&GridPositionAllocator::m_deltaX),
                    MakeFpChecker<double> ())
     .AddParameter ("DeltaY", "The y space between objects.",
                    FpValue (1.0),
-                   MakeFpParamSpec (&GridPositionAllocator::m_deltaY),
+                   MakeFpAccessor (&GridPositionAllocator::m_deltaY),
                    MakeFpChecker<double> ())
     .AddParameter ("LayoutType", "The type of layout.",
                    EnumValue (ROW_FIRST),
-                   MakeEnumParamSpec (&GridPositionAllocator::m_layoutType),
+                   MakeEnumAccessor (&GridPositionAllocator::m_layoutType),
                    MakeEnumChecker (ROW_FIRST, "RowFirst",
                                     COLUMN_FIRST, "ColumnFirst"))
     ;
@@ -116,12 +116,12 @@ RandomRectanglePositionAllocator::GetTypeId (void)
     .AddParameter ("X",
                    "A random variable which represents the x coordinate of a position in a random rectangle.",
                    UniformVariable (0.0, 1.0),
-                   MakeRandomVariableParamSpec (&RandomRectanglePositionAllocator::m_x),
+                   MakeRandomVariableAccessor (&RandomRectanglePositionAllocator::m_x),
                    MakeRandomVariableChecker ())
     .AddParameter ("Y",
                    "A random variable which represents the y coordinate of a position in a random rectangle.",
                    UniformVariable (0.0, 1.0),
-                   MakeRandomVariableParamSpec (&RandomRectanglePositionAllocator::m_y),
+                   MakeRandomVariableAccessor (&RandomRectanglePositionAllocator::m_y),
                    MakeRandomVariableChecker ());
   return tid;
 }
@@ -150,22 +150,22 @@ RandomDiscPositionAllocator::GetTypeId (void)
     .AddParameter ("Theta",
                    "A random variable which represents the angle (gradients) of a position in a random disc.",
                    UniformVariable (0.0, 6.2830),
-                   MakeRandomVariableParamSpec (&RandomDiscPositionAllocator::m_theta),
+                   MakeRandomVariableAccessor (&RandomDiscPositionAllocator::m_theta),
                    MakeRandomVariableChecker ())
     .AddParameter ("Rho",
                    "A random variable which represents the radius of a position in a random disc.",
                    UniformVariable (0.0, 200.0),
-                   MakeRandomVariableParamSpec (&RandomDiscPositionAllocator::m_rho),
+                   MakeRandomVariableAccessor (&RandomDiscPositionAllocator::m_rho),
                    MakeRandomVariableChecker ())
     .AddParameter ("X",
                    "The x coordinate of the center of the random position disc.",
                    FpValue (0.0),
-                   MakeFpParamSpec (&RandomDiscPositionAllocator::m_x),
+                   MakeFpAccessor (&RandomDiscPositionAllocator::m_x),
                    MakeFpChecker<double> ())
     .AddParameter ("Y",
                    "The y coordinate of the center of the random position disc.",
                    FpValue (0.0),
-                   MakeFpParamSpec (&RandomDiscPositionAllocator::m_y),
+                   MakeFpAccessor (&RandomDiscPositionAllocator::m_y),
                    MakeFpChecker<double> ())
     ;
   return tid;
diff --git a/src/mobility/random-direction-2d-mobility-model.cc b/src/mobility/random-direction-2d-mobility-model.cc
index 94c197afe..024892d81 100644
--- a/src/mobility/random-direction-2d-mobility-model.cc
+++ b/src/mobility/random-direction-2d-mobility-model.cc
@@ -43,15 +43,15 @@ RandomDirection2dMobilityModel::GetTypeId (void)
     .AddConstructor<RandomDirection2dMobilityModel> ()
     .AddParameter ("bounds", "The 2d bounding area",
                    Rectangle (-100, 100, -100, 100),
-                   MakeRectangleParamSpec (&RandomDirection2dMobilityModel::m_bounds),
+                   MakeRectangleAccessor (&RandomDirection2dMobilityModel::m_bounds),
                    MakeRectangleChecker ())
     .AddParameter ("speed", "A random variable to control the speed (m/s).",
                    UniformVariable (1.0, 2.0),
-                   MakeRandomVariableParamSpec (&RandomDirection2dMobilityModel::m_speed),
+                   MakeRandomVariableAccessor (&RandomDirection2dMobilityModel::m_speed),
                    MakeRandomVariableChecker ())
     .AddParameter ("pause", "A random variable to control the pause (s).",
                    ConstantVariable (2.0),
-                   MakeRandomVariableParamSpec (&RandomDirection2dMobilityModel::m_pause),
+                   MakeRandomVariableAccessor (&RandomDirection2dMobilityModel::m_pause),
                    MakeRandomVariableChecker ())
     ;
   return tid;
diff --git a/src/mobility/random-walk-2d-mobility-model.cc b/src/mobility/random-walk-2d-mobility-model.cc
index 6022f1674..ab35964e0 100644
--- a/src/mobility/random-walk-2d-mobility-model.cc
+++ b/src/mobility/random-walk-2d-mobility-model.cc
@@ -40,34 +40,34 @@ RandomWalk2dMobilityModel::GetTypeId (void)
     .AddParameter ("bounds",
                    "Bounds of the area to cruise.",
                    Rectangle (0.0, 0.0, 100.0, 100.0),
-                   MakeRectangleParamSpec (&RandomWalk2dMobilityModel::m_bounds),
+                   MakeRectangleAccessor (&RandomWalk2dMobilityModel::m_bounds),
                    MakeRectangleChecker ())
     .AddParameter ("time",
                    "Change current direction and speed after moving for this delay.",
                    Seconds (1.0),
-                   MakeTimeParamSpec (&RandomWalk2dMobilityModel::m_modeTime),
+                   MakeTimeAccessor (&RandomWalk2dMobilityModel::m_modeTime),
                    MakeTimeChecker ())
     .AddParameter ("distance",
                    "Change current direction and speed after moving for this distance.",
                    Seconds (1.0),
-                   MakeTimeParamSpec (&RandomWalk2dMobilityModel::m_modeTime),
+                   MakeTimeAccessor (&RandomWalk2dMobilityModel::m_modeTime),
                    MakeTimeChecker ())
     .AddParameter ("mode",
                    "The mode indicates the condition used to "
                    "change the current speed and direction",
                    EnumValue (RandomWalk2dMobilityModel::MODE_DISTANCE),
-                   MakeEnumParamSpec (&RandomWalk2dMobilityModel::m_mode),
+                   MakeEnumAccessor (&RandomWalk2dMobilityModel::m_mode),
                    MakeEnumChecker (RandomWalk2dMobilityModel::MODE_DISTANCE, "Distance",
                                     RandomWalk2dMobilityModel::MODE_TIME, "Time"))
     .AddParameter ("direction",
                    "A random variable used to pick the direction (gradients).",
                    UniformVariable (0.0, 6.283184),
-                   MakeRandomVariableParamSpec (&RandomWalk2dMobilityModel::m_direction),
+                   MakeRandomVariableAccessor (&RandomWalk2dMobilityModel::m_direction),
                    MakeRandomVariableChecker ())
     .AddParameter ("speed",
                    "A random variable used to pick the speed (m/s).",
                    UniformVariable (2.0, 4.0),
-                   MakeRandomVariableParamSpec (&RandomWalk2dMobilityModel::m_speed),
+                   MakeRandomVariableAccessor (&RandomWalk2dMobilityModel::m_speed),
                    MakeRandomVariableChecker ());
   return tid;
 }
diff --git a/src/mobility/random-waypoint-mobility-model.cc b/src/mobility/random-waypoint-mobility-model.cc
index 26b3520f8..84043ed2a 100644
--- a/src/mobility/random-waypoint-mobility-model.cc
+++ b/src/mobility/random-waypoint-mobility-model.cc
@@ -39,17 +39,17 @@ RandomWaypointMobilityModel::GetTypeId (void)
     .AddParameter ("speed",
                    "A random variable used to pick the speed of a random waypoint model.",
                    UniformVariable (0.3, 0.7),
-                   MakeRandomVariableParamSpec (&RandomWaypointMobilityModel::m_speed),
+                   MakeRandomVariableAccessor (&RandomWaypointMobilityModel::m_speed),
                    MakeRandomVariableChecker ())
     .AddParameter ("pause",
                    "A random variable used to pick the pause of a random waypoint model.",
                    ConstantVariable (2.0),
-                   MakeRandomVariableParamSpec (&RandomWaypointMobilityModel::m_pause),
+                   MakeRandomVariableAccessor (&RandomWaypointMobilityModel::m_pause),
                    MakeRandomVariableChecker ())
     .AddParameter ("position",
                    "The position model used to pick a destination point.",
                    Ptr<PositionAllocator> (0),
-                   MakePtrParamSpec (&RandomWaypointMobilityModel::m_position),
+                   MakePtrAccessor (&RandomWaypointMobilityModel::m_position),
                    MakePtrChecker<PositionAllocator> ());
   
   return tid;
diff --git a/src/node/drop-tail-queue.cc b/src/node/drop-tail-queue.cc
index 703fed3a9..913f9dacc 100644
--- a/src/node/drop-tail-queue.cc
+++ b/src/node/drop-tail-queue.cc
@@ -34,7 +34,7 @@ TypeId DropTailQueue::GetTypeId (void)
     .AddConstructor<DropTailQueue> ()
     .AddParameter ("MaxPackets", "The maximum number of packets accepted by this DropTailQueue.",
                    UintValue (100),
-                   MakeUintParamSpec (&DropTailQueue::m_maxPackets),
+                   MakeUintAccessor (&DropTailQueue::m_maxPackets),
                    MakeUintChecker<uint32_t> ())
     ;
   
diff --git a/src/simulator/nstime.h b/src/simulator/nstime.h
index 18511bb9f..c6b926a0f 100644
--- a/src/simulator/nstime.h
+++ b/src/simulator/nstime.h
@@ -671,12 +671,12 @@ typedef TimeUnit<2> TimeSquare;
 
 
 class TimeValue : public Value {};
-class TimeParamSpec : public ParamSpec {};
+class TimeAccessor : public Accessor {};
 
 template <typename T1>
-Ptr<ParamSpec> MakeTimeParamSpec (T1 a1);
+Ptr<Accessor> MakeTimeAccessor (T1 a1);
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeTimeParamSpec (T1 a1, T2 a2);
+Ptr<Accessor> MakeTimeAccessor (T1 a1, T2 a2);
 
 Ptr<AttributeChecker> MakeTimeChecker (void);
 
@@ -687,15 +687,15 @@ Ptr<AttributeChecker> MakeTimeChecker (void);
 namespace ns3 {
 
 template <typename T1>
-Ptr<ParamSpec> MakeTimeParamSpec (T1 a1)
+Ptr<Accessor> MakeTimeAccessor (T1 a1)
 {
-  return MakeClassValueHelperParamSpec<Time,TimeValue,TimeParamSpec> (a1);
+  return MakeClassValueHelperAccessor<Time,TimeValue,TimeAccessor> (a1);
 }
 
 template <typename T1, typename T2>
-Ptr<ParamSpec> MakeTimeParamSpec (T1 a1, T2 a2)
+Ptr<Accessor> MakeTimeAccessor (T1 a1, T2 a2)
 {
-  return MakeClassValueHelperParamSpec<Time,TimeValue,TimeParamSpec> (a1, a2);
+  return MakeClassValueHelperAccessor<Time,TimeValue,TimeAccessor> (a1, a2);
 }