F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ParamSpec -> Accessor

Browse Source
This commit is contained in:
Mathieu Lacage
2008-02-20 20:24:52 +01:00
parent c182f4d479
commit ad7d70ae34
24 changed files with 247 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/core/boolean-value.h
View File

@@ -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

12
src/core/class-value-helper.h
View File

@@ -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

14
src/core/enum-value.h
View File

@@ -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

14
src/core/fp-value.h
View File

@@ -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>

16
src/core/int-value.h
View File

@@ -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>

4
src/core/object-vector.cc
View File

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

40
src/core/object-vector.h
View File

@@ -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

32
src/core/object.cc
View File

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

22
src/core/object.h
View File

@@ -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,

70
src/core/param-spec-helper.h
View File

@@ -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

18
src/core/random-variable.h
View File

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

16
src/core/uint-value.h
View File

@@ -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>

14
src/core/value-helper.h
View File

@@ -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) \

78
src/core/value-test.cc
View File

@@ -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

8
src/core/value.cc
View File

@@ -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 ()

50
src/core/value.h
View File

@@ -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>

4
src/mobility/hierarchical-mobility-model.cc
View File

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

4
src/mobility/mobility-model.cc
View File

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

24
src/mobility/position-allocator.cc
View File

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

6
src/mobility/random-direction-2d-mobility-model.cc
View File

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

12
src/mobility/random-walk-2d-mobility-model.cc
View File

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

6
src/mobility/random-waypoint-mobility-model.cc
View File

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

2
src/node/drop-tail-queue.cc
View File

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

14
src/simulator/nstime.h
View File

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