00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef ATTRIBUTE_ACCESSOR_HELPER_H
00021 #define ATTRIBUTE_ACCESSOR_HELPER_H
00022
00023 #include "attribute.h"
00024
00025 namespace ns3 {
00026
00027
00028
00029
00030 template <typename V, typename T1>
00031 Ptr<const AttributeAccessor>
00032 MakeAccessorHelper (T1 a1);
00033
00034
00035
00036
00037 template <typename V, typename T1, typename T2>
00038 Ptr<const AttributeAccessor>
00039 MakeAccessorHelper (T1 a1, T2 a2);
00040
00041 }
00042
00043
00044
00045
00046
00047 #include "type-traits.h"
00048
00049 namespace ns3 {
00050
00051 template <typename T>
00052 struct AccessorTrait
00053 {
00054 typedef typename TypeTraits<typename TypeTraits<T>::ReferencedType>::NonConstType Result;
00055 };
00056
00057 template <typename T, typename U>
00058 class AccessorHelper : public AttributeAccessor
00059 {
00060 public:
00061 AccessorHelper () {}
00062
00063 virtual bool Set (ObjectBase * object, const AttributeValue & val) const {
00064 const U *value = dynamic_cast<const U *> (&val);
00065 if (value == 0)
00066 {
00067 return false;
00068 }
00069 T *obj = dynamic_cast<T *> (object);
00070 if (obj == 0)
00071 {
00072 return false;
00073 }
00074 return DoSet (obj, value);
00075 }
00076
00077 virtual bool Get (const ObjectBase * object, AttributeValue &val) const {
00078 U *value = dynamic_cast<U *> (&val);
00079 if (value == 0)
00080 {
00081 return false;
00082 }
00083 const T *obj = dynamic_cast<const T *> (object);
00084 if (obj == 0)
00085 {
00086 return false;
00087 }
00088 return DoGet (obj, value);
00089 }
00090
00091 private:
00092 virtual bool DoSet (T *object, const U *v) const = 0;
00093 virtual bool DoGet (const T *object, U *v) const = 0;
00094 };
00095
00096 template <typename V, typename T, typename U>
00097 Ptr<const AttributeAccessor>
00098 DoMakeAccessorHelperOne (U T::*memberVariable)
00099 {
00100 class MemberVariable : public AccessorHelper<T,V>
00101 {
00102 public:
00103 MemberVariable (U T::*memberVariable)
00104 : AccessorHelper<T,V> (),
00105 m_memberVariable (memberVariable)
00106 {}
00107 private:
00108 virtual bool DoSet (T *object, const V *v) const {
00109 typename AccessorTrait<U>::Result tmp;
00110 bool ok = v->GetAccessor (tmp);
00111 if (!ok)
00112 {
00113 return false;
00114 }
00115 (object->*m_memberVariable) = tmp;
00116 return true;
00117 }
00118 virtual bool DoGet (const T *object, V *v) const {
00119 v->Set (object->*m_memberVariable);
00120 return true;
00121 }
00122 virtual bool HasGetter (void) const {
00123 return true;
00124 }
00125 virtual bool HasSetter (void) const {
00126 return true;
00127 }
00128
00129 U T::*m_memberVariable;
00130 };
00131 return Ptr<const AttributeAccessor> (new MemberVariable (memberVariable), false);
00132 }
00133
00134 template <typename V, typename T, typename U>
00135 Ptr<const AttributeAccessor>
00136 DoMakeAccessorHelperOne (U (T::*getter) (void) const)
00137 {
00138 class MemberMethod : public AccessorHelper<T,V>
00139 {
00140 public:
00141 MemberMethod (U (T::*getter) (void) const)
00142 : AccessorHelper<T,V> (),
00143 m_getter (getter)
00144 {}
00145 private:
00146 virtual bool DoSet (T *object, const V *v) const {
00147 return false;
00148 }
00149 virtual bool DoGet (const T *object, V *v) const {
00150 v->Set ((object->*m_getter) ());
00151 return true;
00152 }
00153 virtual bool HasGetter (void) const {
00154 return true;
00155 }
00156 virtual bool HasSetter (void) const {
00157 return false;
00158 }
00159 U (T::*m_getter) (void) const;
00160 };
00161 return Ptr<const AttributeAccessor> (new MemberMethod (getter), false);
00162 }
00163
00164
00165 template <typename V, typename T, typename U>
00166 Ptr<const AttributeAccessor>
00167 DoMakeAccessorHelperOne (void (T::*setter) (U))
00168 {
00169 class MemberMethod : public AccessorHelper<T,V>
00170 {
00171 public:
00172 MemberMethod (void (T::*setter) (U))
00173 : AccessorHelper<T,V> (),
00174 m_setter (setter)
00175 {}
00176 private:
00177 virtual bool DoSet (T *object, const V *v) const {
00178 typename AccessorTrait<U>::Result tmp;
00179 bool ok = v->GetAccessor (tmp);
00180 if (!ok)
00181 {
00182 return false;
00183 }
00184 (object->*m_setter) (tmp);
00185 return true;
00186 }
00187 virtual bool DoGet (const T *object, V *v) const {
00188 return false;
00189 }
00190 virtual bool HasGetter (void) const {
00191 return false;
00192 }
00193 virtual bool HasSetter (void) const {
00194 return true;
00195 }
00196 void (T::*m_setter) (U);
00197 };
00198 return Ptr<const AttributeAccessor> (new MemberMethod (setter), false);
00199 }
00200
00201 template <typename W, typename T, typename U, typename V>
00202 Ptr<const AttributeAccessor>
00203 DoMakeAccessorHelperTwo (void (T::*setter) (U),
00204 V (T::*getter) (void) const)
00205 {
00206 class MemberMethod : public AccessorHelper<T,W>
00207 {
00208 public:
00209 MemberMethod (void (T::*setter) (U),
00210 V (T::*getter) (void) const)
00211 : AccessorHelper<T,W> (),
00212 m_setter (setter),
00213 m_getter (getter)
00214 {}
00215 private:
00216 virtual bool DoSet (T *object, const W *v) const {
00217 typename AccessorTrait<U>::Result tmp;
00218 bool ok = v->GetAccessor (tmp);
00219 if (!ok)
00220 {
00221 return false;
00222 }
00223 (object->*m_setter) (tmp);
00224 return true;
00225 }
00226 virtual bool DoGet (const T *object, W *v) const {
00227 v->Set ((object->*m_getter) ());
00228 return true;
00229 }
00230 virtual bool HasGetter (void) const {
00231 return true;
00232 }
00233 virtual bool HasSetter (void) const {
00234 return true;
00235 }
00236 void (T::*m_setter) (U);
00237 V (T::*m_getter) (void) const;
00238 };
00239 return Ptr<const AttributeAccessor> (new MemberMethod (setter, getter), false);
00240 }
00241
00242 template <typename W, typename T, typename U, typename V>
00243 Ptr<const AttributeAccessor>
00244 DoMakeAccessorHelperTwo (V (T::*getter) (void) const,
00245 void (T::*setter) (U))
00246 {
00247 return DoMakeAccessorHelperTwo<W> (setter, getter);
00248 }
00249
00250 template <typename W, typename T, typename U, typename V>
00251 Ptr<const AttributeAccessor>
00252 DoMakeAccessorHelperTwo (bool (T::*setter) (U),
00253 V (T::*getter) (void) const)
00254 {
00255 class MemberMethod : public AccessorHelper<T,W>
00256 {
00257 public:
00258 MemberMethod (bool (T::*setter) (U),
00259 V (T::*getter) (void) const)
00260 : AccessorHelper<T,W> (),
00261 m_setter (setter),
00262 m_getter (getter)
00263 {}
00264 private:
00265 virtual bool DoSet (T *object, const W *v) const {
00266 typename AccessorTrait<U>::Result tmp;
00267 bool ok = v->GetAccessor (tmp);
00268 if (!ok)
00269 {
00270 return false;
00271 }
00272 ok = (object->*m_setter) (tmp);
00273 return ok;
00274 }
00275 virtual bool DoGet (const T *object, W *v) const {
00276 v->Set ((object->*m_getter) ());
00277 return true;
00278 }
00279 virtual bool HasGetter (void) const {
00280 return true;
00281 }
00282 virtual bool HasSetter (void) const {
00283 return true;
00284 }
00285 bool (T::*m_setter) (U);
00286 V (T::*m_getter) (void) const;
00287 };
00288 return Ptr<const AttributeAccessor> (new MemberMethod (setter, getter), false);
00289 }
00290
00291 template <typename W, typename T, typename U, typename V>
00292 Ptr<const AttributeAccessor>
00293 DoMakeAccessorHelperTwo (bool (T::*getter) (void) const,
00294 void (T::*setter) (U))
00295 {
00296 return DoMakeAccessorHelperTwo<W> (setter, getter);
00297 }
00298
00299 template <typename V, typename T1>
00300 Ptr<const AttributeAccessor>
00301 MakeAccessorHelper (T1 a1)
00302 {
00303 return DoMakeAccessorHelperOne<V> (a1);
00304 }
00305
00306 template <typename V, typename T1, typename T2>
00307 Ptr<const AttributeAccessor>
00308 MakeAccessorHelper (T1 a1, T2 a2)
00309 {
00310 return DoMakeAccessorHelperTwo<V> (a1, a2);
00311 }
00312
00313 }
00314
00315 #endif