138   /**

   139    * \param pointer a pointer to convert into an Attribute.

   140    */

   141   template <typename T>

   142   Attribute (Ptr<T> pointer);

   143   /**

   144    * \returns a pointer converted from this Attribute instance.

   145    */

   146   template <typename T>

   147   operator Ptr<T> ();

   148 

   234 template <typename T, typename U>

   235 Ptr<const AttributeAccessor>

   236 MakePtrAccessor (Ptr<U> T::*memberVariable);

   237 

   238 template <typename T, typename U>

   239 Ptr<const AttributeAccessor>

   240 MakePtrAccessor (void (T::*setter) (Ptr<U>));

   241 template <typename T, typename U>

   242 Ptr<const AttributeAccessor>

   243 MakePtrAccessor (Ptr<U> (T::*getter) (void) const);

   244 template <typename T, typename U>

   245 Ptr<const AttributeAccessor>

   246 MakePtrAccessor (void (T::*setter) (Ptr<U>),

   247                  Ptr<U> (T::*getter) (void) const);

   248 template <typename T, typename U>

   249 Ptr<const AttributeAccessor>

   250 MakePtrAccessor (Ptr<U> (T::*getter) (void) const,

   251                  void (T::*setter) (Ptr<U>));

   252 

   253 

   254 

   255 class PtrChecker : public AttributeChecker {};

   256 

   257 template <typename T>

   258 Ptr<AttributeChecker> MakePtrChecker (void);

   259 

   260 

   261 

   265 

   266 /********************************************************

   267  *   The class used to access the pointer stored in a

   268  *   PtrValue<T> AttributeValue instance.

   269  ********************************************************/

   270 

   271 class PtrValueBase : public AttributeValue

   272 {

   273 public:

   274   virtual ObjectBase *PeekObjectBase (void) const = 0;

   275   virtual bool SetObjectBase (ObjectBase *object) = 0;

   276   virtual std::string SerializeToString (Ptr<const AttributeChecker> checker) const;

   277   virtual bool DeserializeFromString (std::string value, Ptr<const AttributeChecker> checker);

   278 };

   279 

   280 /********************************************************

   281  *        Store the content of a Ptr<T> in a AttributeValue

   282  ********************************************************/

   283 

   284 namespace internal {

   285 

   286 template <typename T>

   287 class PtrValue : public PtrValueBase

   288 {

   289 public:

   290   PtrValue () 

   291     : m_pointer () {}

   292   PtrValue (Ptr<T> pointer) 

   293     : m_pointer (pointer) {}

   294 

   295   virtual ObjectBase *PeekObjectBase (void) const {

   296     return PeekPointer (m_pointer);

   297   }

   298   virtual bool SetObjectBase (ObjectBase *object) {

   299     T *ptr = dynamic_cast<T *> (object);

   300     if (ptr == 0)

   301       {

   302 	return false;

   303       }

   304     m_pointer = ptr;

   305     return true;

   306   }

   307   virtual Attribute Copy (void) const {

   308     return Attribute::Create<PtrValue<T> > (*this);

   309   }

   310 private:

   311   Ptr<T> m_pointer;

   312 };

   313 

   314 template <typename T>

   315 class APtrChecker : public PtrChecker

   316 {

   317   virtual bool Check (Attribute val) const {

   318     const PtrValueBase *value = val.DynCast<const PtrValueBase *> ();

   319     if (value == 0)

   320       {

   321 	return false;

   322       }

   323     if (value->PeekObjectBase () == 0)

   324       {

   325 	return true;

   326       }

   327     T *ptr = dynamic_cast<T*> (value->PeekObjectBase ());

   328     if (ptr == 0)

   329       {

   330 	return false;

   331       }

   332     return true;

   333   }

   334   virtual std::string GetType (void) const {

   335     // XXX: we should be able to return better information

   336     return "Ptr<>";

   337   }

   338   virtual bool HasTypeConstraints (void) const {

   339     return false;

   340   }

   341   virtual std::string GetTypeConstraints (void) const {

   342     return "";

   343   }

   344   virtual Attribute Create (void) const {

   345     return Attribute::Create<PtrValue<T> > ();

   346   }

   347 };

   348 

   349 /********************************************************

   350  *              The Accessor associated to 

   351  *               PtrValue<T>

   352  ********************************************************/

   353 

   354 template <typename T, typename U>

   355 class PtrAccessor : public AttributeAccessor

   356 {

   357 public:

   358   virtual ~PtrAccessor () {}

   359   virtual bool Set (ObjectBase * object, Attribute val) const {

   360       T *obj = dynamic_cast<T *> (object);

   361       if (obj == 0)

   362         {

   363           return false;

   364         }

   365       const PtrValueBase *value = val.DynCast<const PtrValueBase *> ();

   366       if (value == 0)

   367         {

   368           return false;

   369         }

   370       Ptr<U> ptr = dynamic_cast<U*> (value->PeekObjectBase ());

   371       if (ptr == 0)

   372         {

   373           return false;

   374         }

   375       DoSet (obj, ptr);

   376       return true;

   377     }

   378   virtual bool Get (const ObjectBase * object, Attribute val) const {

   379       const T *obj = dynamic_cast<const T *> (object);

   380       if (obj == 0)

   381         {

   382           return false;

   383         }

   384       PtrValueBase *value = val.DynCast<PtrValueBase *> ();

   385       if (value == 0)

   386         {

   387           return false;

   388         }

   389       return value->SetObjectBase (PeekPointer (DoGet (obj)));

   390     }

   391 private:

   392   virtual void DoSet (T *object, Ptr<U> value) const = 0;

   393   virtual Ptr<U> DoGet (const T *object) const = 0;

   394 };

   395 

   396 } // namespace internal

   423 template <typename T>

   424 Attribute::Attribute (Ptr<T> pointer)

   425   : m_value (new internal::PtrValue<T> (pointer))

   426 {}

   427 template <typename T>

   428 Attribute::operator Ptr<T> ()

   429 {

   430   PtrValueBase *value = DynCast<PtrValueBase *> ();

   431   if (value == 0)

   432     {

   433       return 0;

   434     }

   435   ObjectBase *objectBase = value->PeekObjectBase ();

   436   T *obj = dynamic_cast<T *> (objectBase);

   437   if (obj == 0)

   438     {

   439       return 0;

   440     }

   441   return obj;

   442 }

   443 

   444 

   445 

   446 template <typename T, typename U>

   447 Ptr<const AttributeAccessor>

   448 MakePtrAccessor (Ptr<U> T::*memberVariable)

   449 {

   450   struct MemberVariable : public internal::PtrAccessor<T,U>

   451   {

   452     Ptr<U> T::*m_memberVariable;

   453     virtual void DoSet (T *object, Ptr<U> value) const {

   454       (object->*m_memberVariable) = value;

   455     }

   456     virtual Ptr<U> DoGet (const T *object) const {

   457       return object->*m_memberVariable;

   458     }

   459   } *spec = new MemberVariable ();

   460   spec->m_memberVariable = memberVariable;

   461   return Ptr<const AttributeAccessor> (spec, false);

   462 }

   463 

   464 template <typename T, typename U>

   465 Ptr<const AttributeAccessor>

   466 MakePtrAccessor (void (T::*setter) (Ptr<U>))

   467 {

   468   struct MemberMethod : public internal::PtrAccessor<T,U>

   469   {

   470     void (T::*m_setter) (Ptr<U>);

   471     virtual void DoSet (T *object, Ptr<U> value) const {

   472       (object->*m_setter) (value);

   473     }

   474     virtual Ptr<U> DoGet (const T *object) const {

   475       return 0;

   476       //return (object->*m_getter) ();

   477     }

   478   } *spec = new MemberMethod ();

   479   spec->m_setter = setter;

   480   return Ptr<const AttributeAccessor> (spec, false);

   481 }

   482 

   483 template <typename T, typename U>

   484 Ptr<const AttributeAccessor>

   485 MakePtrAccessor (Ptr<U> (T::*getter) (void) const)

   486 {

   487   struct MemberMethod : public internal::PtrAccessor<T,U>

   488   {

   489     Ptr<U> (T::*m_getter) (void) const;

   490     virtual void DoSet (T *object, Ptr<U> value) const {

   491       //(object->*m_setter) (value);

   492     }

   493     virtual Ptr<U> DoGet (const T *object) const {

   494       return (object->*m_getter) ();

   495     }

   496   } *spec = new MemberMethod ();

   497   spec->m_getter = getter;

   498   return Ptr<const AttributeAccessor> (spec, false);

   499 }

   500 template <typename T, typename U>

   501 Ptr<const AttributeAccessor>

   502 MakePtrAccessor (void (T::*setter) (Ptr<U>),

   503                  Ptr<U> (T::*getter) (void) const)

   504 {

   505   return MakePtrAccessor (getter, setter);

   506 }

   507 template <typename T, typename U>

   508 Ptr<const AttributeAccessor>

   509 MakePtrAccessor (Ptr<U> (T::*getter) (void) const,

   510                  void (T::*setter) (Ptr<U>))

   511 {

   512   struct MemberMethod : public internal::PtrAccessor<T,U>

   513   {

   514     void (T::*m_setter) (Ptr<U>);

   515     Ptr<U> (T::*m_getter) (void) const;

   516     virtual void DoSet (T *object, Ptr<U> value) const {

   517       (object->*m_setter) (value);

   518     }

   519     virtual Ptr<U> DoGet (const T *object) const {

   520       return (object->*m_getter) ();

   521     }

   522   } *spec = new MemberMethod ();

   523   spec->m_setter = setter;

   524   spec->m_getter = getter;

   525   return Ptr<const AttributeAccessor> (spec, false);

   526 }

   527 

   528 

   529 

   530 template <typename T>

   531 Ptr<AttributeChecker>

   532 MakePtrChecker (void)

   533 {

   534   return Create<internal::APtrChecker<T> > ();

   535 }

   536