From 250eed3667df2329b65af467e22bd27dd5bdacad Mon Sep 17 00:00:00 2001 From: Mathieu Lacage Date: Wed, 12 Mar 2008 11:17:16 -0700 Subject: [PATCH] Add sufficient information to AttributeChecker to generate nice-looking documentation. --- src/core/attribute-helper.h | 35 ++++++++++++++++++++++++++- src/core/attribute-test.cc | 2 +- src/core/attribute.h | 34 ++++++++++---------------- src/core/double.cc | 26 ++++++++++++++++---- src/core/double.h | 27 ++++++++++++++++++--- src/core/enum.cc | 25 +++++++++++++++++++ src/core/enum.h | 3 +++ src/core/integer.cc | 23 +++++++++++++++--- src/core/integer.h | 27 ++++++++++++++++++--- src/core/object-vector.cc | 7 ++---- src/core/object-vector.h | 8 +++--- src/core/uinteger.cc | 23 +++++++++++++++--- src/core/uinteger.h | 28 ++++++++++++++++++--- src/devices/wifi/amrr-wifi-manager.cc | 4 +-- src/devices/wifi/wifi-mac.cc | 2 +- 15 files changed, 214 insertions(+), 60 deletions(-) diff --git a/src/core/attribute-helper.h b/src/core/attribute-helper.h index c9834f7e4..b2b444be1 100644 --- a/src/core/attribute-helper.h +++ b/src/core/attribute-helper.h @@ -26,6 +26,39 @@ #include #include "fatal-error.h" +namespace ns3 { + +template +Ptr +MakeSimpleAttributeChecker (std::string name) +{ + struct SimpleAttributeChecker : public BASE + { + virtual bool Check (Attribute value) const { + return value.DynCast () != 0; + } + virtual std::string GetType (void) const { + return m_type; + } + virtual bool HasTypeConstraints (void) const { + return false; + } + virtual std::string GetTypeConstraints (void) const { + return ""; + } + virtual Attribute Create (void) const { + return Attribute::Create (); + } + std::string m_type; + } *checker = new SimpleAttributeChecker (); + checker->m_type = name; + return Ptr (checker, false); +} + +} + + + /** * \defgroup AttributeHelper * @@ -188,7 +221,7 @@ #define ATTRIBUTE_CHECKER_IMPLEMENT(type) \ Ptr Make##type##Checker (void) \ { \ - return MakeSimpleAttributeChecker (); \ + return MakeSimpleAttributeChecker (#type); \ } \ /** diff --git a/src/core/attribute-test.cc b/src/core/attribute-test.cc index 05c9dc578..df2e04b8f 100644 --- a/src/core/attribute-test.cc +++ b/src/core/attribute-test.cc @@ -118,7 +118,7 @@ public: .AddAttribute ("TestInt16WithBounds", "help text", Integer (-2), MakeIntegerAccessor (&AttributeObjectTest::m_int16WithBounds), - MakeIntegerChecker (-5, 10)) + MakeIntegerChecker (-5, 10)) .AddAttribute ("TestInt16SetGet", "help text", Integer (6), MakeIntegerAccessor (&AttributeObjectTest::DoSetInt16, diff --git a/src/core/attribute.h b/src/core/attribute.h index dee008bef..505e492ff 100644 --- a/src/core/attribute.h +++ b/src/core/attribute.h @@ -216,6 +216,9 @@ public: * false otherwise. */ virtual bool Check (Attribute value) const = 0; + virtual std::string GetType (void) const = 0; + virtual bool HasTypeConstraints (void) const = 0; + virtual std::string GetTypeConstraints (void) const = 0; /** * \returns a new instance of an AttributeValue (wrapper in an Attribute * instance) which matches the type of the underlying attribute. @@ -228,10 +231,6 @@ private: mutable uint32_t m_count; }; -template -Ptr -MakeSimpleAttributeChecker (void); - template Ptr MakePtrAccessor (Ptr T::*memberVariable); @@ -323,6 +322,16 @@ class APtrChecker : public PtrChecker } return true; } + virtual std::string GetType (void) const { + // XXX: we should be able to return better information + return "Ptr<>"; + } + virtual bool HasTypeConstraints (void) const { + return false; + } + virtual std::string GetTypeConstraints (void) const { + return ""; + } virtual Attribute Create (void) const { return Attribute::Create > (); } @@ -488,23 +497,6 @@ MakePtrChecker (void) return Create > (); } -template -Ptr -MakeSimpleAttributeChecker (void) -{ - struct SimpleAttributeChecker : public BASE - { - virtual bool Check (Attribute value) const { - return value.DynCast () != 0; - } - virtual Attribute Create (void) const { - return Attribute::Create (); - } - } *checker = new SimpleAttributeChecker (); - return Ptr (checker, false); -} - - } // namespace ns3 #endif /* ATTRIBUTE_H */ diff --git a/src/core/double.cc b/src/core/double.cc index 1ba29c57a..937220560 100644 --- a/src/core/double.cc +++ b/src/core/double.cc @@ -56,15 +56,18 @@ std::istream & operator >> (std::istream &is, Double &value) } ATTRIBUTE_VALUE_IMPLEMENT (Double); - ATTRIBUTE_CONVERTER_IMPLEMENT (Double); +ATTRIBUTE_CONVERTER_IMPLEMENT (Double); -Ptr MakeDoubleChecker (double min, double max) +namespace internal { + +Ptr MakeDoubleChecker (double min, double max, std::string name) { struct Checker : public AttributeChecker { - Checker (double minValue, double maxValue) + Checker (double minValue, double maxValue, std::string name) : m_minValue (minValue), - m_maxValue (maxValue) {} + m_maxValue (maxValue), + m_name (name) {} virtual bool Check (Attribute value) const { const DoubleValue *v = value.DynCast (); if (v == 0) @@ -73,14 +76,27 @@ Ptr MakeDoubleChecker (double min, double max) } return v->Get () >= m_minValue && v->Get () <= m_maxValue; } + virtual std::string GetType (void) const { + return m_name; + } + virtual bool HasTypeConstraints (void) const { + return true; + } + virtual std::string GetTypeConstraints (void) const { + std::ostringstream oss; + oss << m_minValue << ":" << m_maxValue; + return oss.str (); + } virtual Attribute Create (void) const { return Attribute::Create (); } double m_minValue; double m_maxValue; - } *checker = new Checker (min, max); + std::string m_name; + } *checker = new Checker (min, max, name); return Ptr (checker, false); } +} // namespace internal } // namespace ns3 diff --git a/src/core/double.h b/src/core/double.h index 2d87aa46b..e5ab55bd3 100644 --- a/src/core/double.h +++ b/src/core/double.h @@ -60,25 +60,44 @@ Ptr MakeDoubleChecker (void); template Ptr MakeDoubleChecker (double min); +template Ptr MakeDoubleChecker (double min, double max); } // namespace ns3 +#include "type-name.h" + namespace ns3 { +namespace internal { + +Ptr MakeDoubleChecker (double min, double max, std::string name); + +} // namespace internal + template Ptr MakeDoubleChecker (void) { - return MakeDoubleChecker (-std::numeric_limits::max (), - std::numeric_limits::max ()); + return internal::MakeDoubleChecker (-std::numeric_limits::max (), + std::numeric_limits::max (), + TypeNameGet ()); } template Ptr MakeDoubleChecker (double min) { - return MakeDoubleChecker (min, - std::numeric_limits::max ()); + return internal::MakeDoubleChecker (min, + std::numeric_limits::max (), + TypeNameGet ()); +} + +template +Ptr MakeDoubleChecker (double min, double max) +{ + return internal::MakeDoubleChecker (min, + max, + TypeNameGet ()); } } // namespace ns3 diff --git a/src/core/enum.cc b/src/core/enum.cc index 1eee42959..b8b484b59 100644 --- a/src/core/enum.cc +++ b/src/core/enum.cc @@ -124,6 +124,31 @@ EnumChecker::Check (Attribute value) const } return false; } +std::string +EnumChecker::GetType (void) const +{ + return "Enum"; +} +bool +EnumChecker::HasTypeConstraints (void) const +{ + return true; +} +std::string +EnumChecker::GetTypeConstraints (void) const +{ + std::ostringstream oss; + for (ValueSet::const_iterator i = m_valueSet.begin (); i != m_valueSet.end ();) + { + oss << i->second; + i++; + if (i != m_valueSet.end ()) + { + oss << "|"; + } + } + return oss.str (); +} Attribute EnumChecker::Create (void) const { diff --git a/src/core/enum.h b/src/core/enum.h index 1e0aa78b2..80e86b2a2 100644 --- a/src/core/enum.h +++ b/src/core/enum.h @@ -59,6 +59,9 @@ public: void Add (int v, std::string name); virtual bool Check (Attribute value) const; + virtual std::string GetType (void) const; + virtual bool HasTypeConstraints (void) const; + virtual std::string GetTypeConstraints (void) const; virtual Attribute Create (void) const; private: diff --git a/src/core/integer.cc b/src/core/integer.cc index 3f8961ad5..98fc6eaf8 100644 --- a/src/core/integer.cc +++ b/src/core/integer.cc @@ -62,15 +62,17 @@ std::istream &operator >> (std::istream &is, Integer &integer) ATTRIBUTE_CONVERTER_IMPLEMENT (Integer); +namespace internal { Ptr -MakeIntegerChecker (int64_t min, int64_t max) +MakeIntegerChecker (int64_t min, int64_t max, std::string name) { struct IntegerChecker : public AttributeChecker { - IntegerChecker (int64_t minValue, int64_t maxValue) + IntegerChecker (int64_t minValue, int64_t maxValue, std::string name) : m_minValue (minValue), - m_maxValue (maxValue) {} + m_maxValue (maxValue), + m_name (name) {} virtual bool Check (Attribute value) const { const IntegerValue *v = value.DynCast (); if (v == 0) @@ -79,14 +81,27 @@ MakeIntegerChecker (int64_t min, int64_t max) } return v->Get ().Get () >= m_minValue && v->Get ().Get() <= m_maxValue; } + virtual std::string GetType (void) const { + return m_name; + } + virtual bool HasTypeConstraints (void) const { + return true; + } + virtual std::string GetTypeConstraints (void) const { + std::ostringstream oss; + oss << m_minValue << ":" << m_maxValue; + return oss.str (); + } virtual Attribute Create (void) const { return Attribute::Create (); } int64_t m_minValue; int64_t m_maxValue; - } *checker = new IntegerChecker (min, max); + std::string m_name; + } *checker = new IntegerChecker (min, max, name); return Ptr (checker, false); } +} // namespace internal } // namespace ns3 diff --git a/src/core/integer.h b/src/core/integer.h index dfd63ff94..eab6d7032 100644 --- a/src/core/integer.h +++ b/src/core/integer.h @@ -59,26 +59,45 @@ Ptr MakeIntegerChecker (void); template Ptr MakeIntegerChecker (int64_t min); +template Ptr MakeIntegerChecker (int64_t min, int64_t max); } // namespace ns3 +#include "type-name.h" + namespace ns3 { +namespace internal { + +Ptr MakeIntegerChecker (int64_t min, int64_t max, std::string name); + +} // internal + +template +Ptr +MakeIntegerChecker (int64_t min, int64_t max) +{ + return internal::MakeIntegerChecker (min, + max, TypeNameGet ()); +} + template Ptr MakeIntegerChecker (int64_t min) { - return MakeIntegerChecker (min, - std::numeric_limits::max ()); + return internal::MakeIntegerChecker (min, + std::numeric_limits::max (), + TypeNameGet ()); } template Ptr MakeIntegerChecker (void) { - return MakeIntegerChecker (std::numeric_limits::min (), - std::numeric_limits::max ()); + return internal::MakeIntegerChecker (std::numeric_limits::min (), + std::numeric_limits::max (), + TypeNameGet ()); } } // namespace ns3 diff --git a/src/core/object-vector.cc b/src/core/object-vector.cc index 5fdc0ce8a..618946fac 100644 --- a/src/core/object-vector.cc +++ b/src/core/object-vector.cc @@ -101,10 +101,7 @@ ObjectVectorAccessor::Get (const ObjectBase * object, Attribute value) const } return true; } -Ptr -MakeObjectVectorChecker (void) -{ - return MakeSimpleAttributeChecker (); -} + +ATTRIBUTE_CHECKER_IMPLEMENT (ObjectVector); } // name diff --git a/src/core/object-vector.h b/src/core/object-vector.h index 4d797c65b..6f43b8c9f 100644 --- a/src/core/object-vector.h +++ b/src/core/object-vector.h @@ -5,6 +5,7 @@ #include "object.h" #include "ptr.h" #include "attribute.h" +#include "attribute-helper.h" namespace ns3 { @@ -34,16 +35,15 @@ MakeObjectVectorAccessor (U T::*memberVector); template Ptr MakeObjectVectorAccessor (Ptr (T::*get) (INDEX) const, - INDEX (T::*getN) (void) const); + INDEX (T::*getN) (void) const); template Ptr MakeObjectVectorAccessor (INDEX (T::*getN) (void) const, - Ptr (T::*get) (INDEX) const); + Ptr (T::*get) (INDEX) const); -class ObjectVectorChecker : public AttributeChecker {}; -Ptr MakeObjectVectorChecker (void); +ATTRIBUTE_CHECKER_DEFINE (ObjectVector); } // namespace ns3 diff --git a/src/core/uinteger.cc b/src/core/uinteger.cc index c54192137..1e8625169 100644 --- a/src/core/uinteger.cc +++ b/src/core/uinteger.cc @@ -58,14 +58,16 @@ std::istream & operator >> (std::istream &is, Uinteger &uinteger) ATTRIBUTE_CONVERTER_IMPLEMENT(Uinteger); ATTRIBUTE_VALUE_IMPLEMENT(Uinteger); +namespace internal { -Ptr MakeUintegerChecker (uint64_t min, uint64_t max) +Ptr MakeUintegerChecker (uint64_t min, uint64_t max, std::string name) { struct Checker : public AttributeChecker { - Checker (uint64_t minValue, uint64_t maxValue) + Checker (uint64_t minValue, uint64_t maxValue, std::string name) : m_minValue (minValue), - m_maxValue (maxValue) {} + m_maxValue (maxValue), + m_name (name) {} virtual bool Check (Attribute value) const { const UintegerValue *v = value.DynCast (); if (v == 0) @@ -74,14 +76,27 @@ Ptr MakeUintegerChecker (uint64_t min, uint64_t max) } return v->Get ().Get () >= m_minValue && v->Get ().Get () <= m_maxValue; } + virtual std::string GetType (void) const { + return m_name; + } + virtual bool HasTypeConstraints (void) const { + return true; + } + virtual std::string GetTypeConstraints (void) const { + std::ostringstream oss; + oss << m_minValue << ":" << m_maxValue; + return oss.str (); + } virtual Attribute Create (void) const { return Attribute::Create (); } uint64_t m_minValue; uint64_t m_maxValue; - } *checker = new Checker (min, max); + std::string m_name; + } *checker = new Checker (min, max, name); return Ptr (checker, false); } +} // namespace internal } // namespace ns3 diff --git a/src/core/uinteger.h b/src/core/uinteger.h index 84cd2f4e5..3c1503951 100644 --- a/src/core/uinteger.h +++ b/src/core/uinteger.h @@ -61,24 +61,44 @@ Ptr MakeUintegerChecker (void); template Ptr MakeUintegerChecker (uint64_t min); +template Ptr MakeUintegerChecker (uint64_t min, uint64_t max); } // namespace ns3 +#include "type-name.h" + namespace ns3 { +namespace internal { + +Ptr MakeUintegerChecker (uint64_t min, uint64_t max, std::string name); + +} // namespace internal + + template Ptr MakeUintegerChecker (void) { - return MakeUintegerChecker (std::numeric_limits::min (), - std::numeric_limits::max ()); + return internal::MakeUintegerChecker (std::numeric_limits::min (), + std::numeric_limits::max (), + TypeNameGet ()); } template Ptr MakeUintegerChecker (uint64_t min) { - return MakeUintegerChecker (min, - std::numeric_limits::max ()); + return internal::MakeUintegerChecker (min, + std::numeric_limits::max (), + TypeNameGet ()); +} + +template +Ptr MakeUintegerChecker (uint64_t min, uint64_t max) +{ + return internal::MakeUintegerChecker (min, + max, + TypeNameGet ()); } } // namespace ns3 diff --git a/src/devices/wifi/amrr-wifi-manager.cc b/src/devices/wifi/amrr-wifi-manager.cc index df259c82e..77fc41505 100644 --- a/src/devices/wifi/amrr-wifi-manager.cc +++ b/src/devices/wifi/amrr-wifi-manager.cc @@ -45,12 +45,12 @@ AmrrWifiManager::GetTypeId (void) "Ratio of minimum erronous transmissions needed to switch to a lower rate", Double (1.0/3.0), MakeDoubleAccessor (&AmrrWifiManager::m_failureRatio), - MakeDoubleChecker (0.0, 1.0)) + MakeDoubleChecker (0.0, 1.0)) .AddAttribute ("SuccessRatio", "Ratio of maximum erronous transmissions needed to switch to a higher rate", Double (1.0/10.0), MakeDoubleAccessor (&AmrrWifiManager::m_successRatio), - MakeDoubleChecker (0.0, 1.0)) + MakeDoubleChecker (0.0, 1.0)) .AddAttribute ("MaxSuccessThreshold", "Maximum number of consecutive success periods needed to switch to a higher rate", Uinteger (10), diff --git a/src/devices/wifi/wifi-mac.cc b/src/devices/wifi/wifi-mac.cc index 444a7d91c..79e95c710 100644 --- a/src/devices/wifi/wifi-mac.cc +++ b/src/devices/wifi/wifi-mac.cc @@ -88,7 +88,7 @@ WifiMac::GetTypeId (void) .AddAttribute ("MaxMsduSize", "XXX", Uinteger (2304), MakeUintegerAccessor (&WifiMac::m_maxMsduSize), - MakeUintegerChecker (1,2304)) + MakeUintegerChecker (1,2304)) .AddAttribute ("Ssid", "XXX", Ssid ("default"), MakeSsidAccessor (&WifiMac::GetSsid,