--- a/src/core/boolean-value.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/boolean-value.h Wed Feb 20 20:24:52 2008 +0100
@@ -24,14 +24,14 @@
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 @@
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
--- a/src/core/class-value-helper.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/class-value-helper.h Wed Feb 20 20:24:52 2008 +0100
@@ -77,18 +77,18 @@
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
--- a/src/core/enum-value.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/enum-value.h Wed Feb 20 20:24:52 2008 +0100
@@ -24,7 +24,7 @@
int m_v;
};
-class EnumParamSpec : public ParamSpec {};
+class EnumAccessor : public Accessor {};
class EnumChecker : public AttributeChecker
{
public:
@@ -42,10 +42,10 @@
};
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 @@
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
--- a/src/core/fp-value.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/fp-value.h Wed Feb 20 20:24:52 2008 +0100
@@ -25,12 +25,12 @@
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 @@
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>
--- a/src/core/int-value.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/int-value.h Wed Feb 20 20:24:52 2008 +0100
@@ -24,12 +24,12 @@
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 @@
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>
--- a/src/core/object-vector.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/object-vector.cc Wed Feb 20 20:24:52 2008 +0100
@@ -74,13 +74,13 @@
}
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)
--- a/src/core/object-vector.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/object-vector.h Wed Feb 20 20:24:52 2008 +0100
@@ -23,22 +23,22 @@
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 @@
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 @@
};
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 @@
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 @@
} *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
--- a/src/core/object.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/object.cc Wed Feb 20 20:24:52 2008 +0100
@@ -58,13 +58,13 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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::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 @@
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 @@
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 @@
}
}
}
- NS_FATAL_ERROR ("Could not find requested ParamSpec.");
+ NS_FATAL_ERROR ("Could not find requested Accessor.");
// quiet compiler.
return "";
}
@@ -896,7 +896,7 @@
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 @@
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);
--- a/src/core/object.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/object.h Wed Feb 20 20:24:52 2008 +0100
@@ -44,7 +44,7 @@
class TraceContext;
class CallbackBase;
class Object;
-class ParamSpec;
+class Accessor;
class Value;
class Parameters;
@@ -202,7 +202,7 @@
* \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 @@
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 @@
* \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 @@
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 @@
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 @@
/**
* \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 @@
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,
--- a/src/core/param-spec-helper.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/param-spec-helper.h Wed Feb 20 20:24:52 2008 +0100
@@ -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 @@
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 @@
};
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 @@
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 @@
}
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 @@
}
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 @@
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
--- a/src/core/random-variable.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/random-variable.h Wed Feb 20 20:24:52 2008 +0100
@@ -666,12 +666,12 @@
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 @@
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);
}
--- a/src/core/uint-value.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/uint-value.h Wed Feb 20 20:24:52 2008 +0100
@@ -24,12 +24,12 @@
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 @@
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>
--- a/src/core/value-helper.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/value-helper.h Wed Feb 20 20:24:52 2008 +0100
@@ -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) \
--- a/src/core/value-test.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/value-test.cc Wed Feb 20 20:24:52 2008 +0100
@@ -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 @@
}
};
-class ParamSpecObjectTest : public Object
+class AccessorObjectTest : public Object
{
public:
enum TestEnum {
@@ -39,60 +39,60 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
-static ParamSpecTest g_parameterTest;
+static AccessorTest g_parameterTest;
} // namespace ns3
--- a/src/core/value.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/value.cc Wed Feb 20 20:24:52 2008 +0100
@@ -121,16 +121,16 @@
{}
-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 @@
delete this;
}
}
-ParamSpec::~ParamSpec ()
+Accessor::~Accessor ()
{}
AttributeChecker::AttributeChecker ()
--- a/src/core/value.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/core/value.h Wed Feb 20 20:24:52 2008 +0100
@@ -8,7 +8,7 @@
namespace ns3 {
-class ParamSpec;
+class Accessor;
class AttributeChecker;
class Attribute;
@@ -60,13 +60,13 @@
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 @@
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 @@
}
/********************************************************
- * 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 @@
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 @@
}
} *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 @@
}
} *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 @@
}
} *spec = new MemberMethod ();
spec->m_getter = getter;
- return Ptr<const ParamSpec> (spec, false);
+ return Ptr<const Accessor> (spec, false);
}
template <typename T>
--- a/src/mobility/hierarchical-mobility-model.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/mobility/hierarchical-mobility-model.cc Wed Feb 20 20:24:52 2008 +0100
@@ -32,11 +32,11 @@
.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;
--- a/src/mobility/mobility-model.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/mobility/mobility-model.cc Wed Feb 20 20:24:52 2008 +0100
@@ -31,13 +31,13 @@
.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;
--- a/src/mobility/position-allocator.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/mobility/position-allocator.cc Wed Feb 20 20:24:52 2008 +0100
@@ -55,27 +55,27 @@
.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 @@
.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 @@
.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;
--- a/src/mobility/random-direction-2d-mobility-model.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/mobility/random-direction-2d-mobility-model.cc Wed Feb 20 20:24:52 2008 +0100
@@ -43,15 +43,15 @@
.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;
--- a/src/mobility/random-walk-2d-mobility-model.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/mobility/random-walk-2d-mobility-model.cc Wed Feb 20 20:24:52 2008 +0100
@@ -40,34 +40,34 @@
.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;
}
--- a/src/mobility/random-waypoint-mobility-model.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/mobility/random-waypoint-mobility-model.cc Wed Feb 20 20:24:52 2008 +0100
@@ -39,17 +39,17 @@
.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;
--- a/src/node/drop-tail-queue.cc Wed Feb 20 19:58:46 2008 +0100
+++ b/src/node/drop-tail-queue.cc Wed Feb 20 20:24:52 2008 +0100
@@ -34,7 +34,7 @@
.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> ())
;
--- a/src/simulator/nstime.h Wed Feb 20 19:58:46 2008 +0100
+++ b/src/simulator/nstime.h Wed Feb 20 20:24:52 2008 +0100
@@ -671,12 +671,12 @@
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 @@
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);
}