Re: [Boost-users] make member functions (in)accessible

26 Feb 2009


      ...
...
These two cases are indistinguishable.
Are they? While we seem to have wandered off the Boost territories,
consider this: If B (== typeof(propB)) were defined effectively as
class B {
public: void get(...);
private: void set(...);
friend class A;
};
would that not have the effect desired? Conceptually you could use the CRTP
pattern to mix A in to the instantiation of propB so that only A was a
friend.
I don't think you can do this in real life with templates because gcc does
not allow declaring template parameters as friends
(e.g., this does not compile)
template < typename T > class X { friend T; };
I would suggest using something similar as a "password type". Tested with
MSVC 9


#include <boost/type_traits/is_same.hpp>
#include <boost/utility/enable_if.hpp>

#include <iostream>

template<class Type, class PasswordT=void>
class Property
{

public:
    Type const& get()const
    {
        return value_;
    }


    template<class PwdT>
    void set( Type const& value)
    {
        set_impl<PwdT, PasswordT>(value);
    }

    void set(Type const& value)
    {
        set_impl<void, PasswordT>(value);
    }


private:
    template<class Pwd, class ExpectedPwd>
    void set_impl( Type const& value
                 , typename boost::enable_if<boost::is_same<Pwd,
ExpectedPwd> >::type* enable =0
                 )
    {
        value_ = value;
    }


private:
    Type value_;
};


class A
{
private:
    struct secret {};

public:
    Property<int>                test1;
    Property<long, secret>        test2;

    void set_via_a(long l)
    {
        test2.set<secret>(l);
    }
};


int main()
{
    A a;
    a.test1.set(10);
    //a.test2.set(20); //ERROR

    a.set_via_a(20);

    using namespace std;

    cout << "test1: " << a.test1.get()
        << "\ntest2: " << a.test2.get();


    return 0;
}


Hope that helps,
Ovanes

Re: [Boost-users] make member functions (in)accessible

Ovanes Markarian