Re: [boost] [property] interest in C# like properties for C++?

Subject: Re: [boost] [property] interest in C# like properties for C++?
From: Edward Diener (eldiener_at_[hidden])
Date: 2009-10-20 23:42:52

Peder Holt wrote:
> <snip>
> 
> 
>> Thanks ! Very clever. The self() idea is very worthy, and I may steal it
>>  for my own idea/implementation about "property" in C++, which I have been
>> working on indefinitely ( may never get completed to my satisfaction ). The
>> metaprogramming is breathtaking, if I can slowly figure it out <g> . In my
>> own implementation a "property" does not need to be nested class but can
>> exist as a global/static object, so I don't know how I can use your self()
>> idea but I really appreciate your doing it and publishing it.
>>
> Thank you :)
> 
> It would be very interesting to look at your implementation to see how you
> tackle the problem. Have you posted your code anywhere that I can look?

No, I have no posted it anywhere yet. I also have still to test all of 
it, and the parts I have tested have been only on VC9 although I feel 
confident it should work on gcc and Comeau also.

I am unfortunately, in a way, one of those people who feel that an 
implementation of mine must be complete as far as code, documentation, 
and testing are concerned before I can post/release it anywhere.

I am also much less of a template metaprogrammer, largely by practice, 
than you and other Boost programmers so my implementation of "property" 
is much simpler in template metaprogramming techniques than what you 
present. Also my goals are different.

If you are still interested I would be glad to zip up what I have done 
so far, albeit with no documentation as yet although I would be willing 
to discuss it privately, and send it directly to you, but I fear this 
private exchange is not in the spirit of Boost. You of course would have 
no obligation to pay any attention to it if you like, especially since 
my goals for a C++ "property" implementation are somewhat different.

I can not see posting it anywhere until I am happy that my 
implementation is complete given my goals, but I can assure you that my 
reply was not an effort to "tease" you or anyone with my own 
implementation but rather simply to show my interest in a C++ "property" 
implementation and in appreciation of you own techniques in implementing 
your C#-like property.

> 
> Actually, the property implementation does not have to be a nested class.

What I should have said is that my "property" does not have to be a 
variable which is a member of a class. It can be a global/static 
variable. So there is not necessarily a "self", which is an enclosing 
class pointer. Also my property comes in many flavors, with slightly 
different names, corresponding to the various ways in which one can 
refer to the backing "data". In some of those flavors no actual data in 
memory needs to even exist. This latter may of course be seen as overkill.

However I intend to study your code to see if it is possible to use the 
self() technique when a flavor of my property is used as a member of a 
class, and still be able go discard the self() implementation when it is 
not used as a member of a class, without having to bifurcate my property 
flavors under more different names.

> The following:
> template<typename Base>
> class Property_Length : public Base {
> public:
>    const double& get() const {
>         return sqrt(
>              Base::self()->X*Base::self()->X+
>              Base::self()->Y*Base::self()->Y+
>              Base::self()->Z*Base::self()->Z
>         );
>     }
> };
> template<typename Base>
> class Property_Double : public Base {
> public:
>    const double& get() const {return m_arg;}
>    void set(const double& arg) {m_arg=arg;}
> private:
>    double m_arg;
> };
> class Vector {
> public:
>     BOOST_PROPERTY(Vector,Property_Double,X);
>     BOOST_PROPERTY(Vector,Property_Double,Y);
>     BOOST_PROPERTY(Vector,Property_Double,Z);
>     BOOST_PROPERTY(Vector,Property_Length,Length);
> };
> 
> is legal. (but untested.)

Yes, this is understandable, thanks ! Your BOOST_PROPERTY properties 
must still be members of a class, but that follows perfectly your design 
goals of emulating C#-style properties.