opaque_val.h

/*****************************************************/
/* lean PImpl                   (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_PIMPL_OPAQUE_VAL
#define LEAN_PIMPL_OPAQUE_VAL

#include "../cpp0x.h"
#include "../meta/conditional.h"
#include "../meta/dereference.h"

namespace lean
{
namespace pimpl
{

template <class OpaqueTypeWrapper, class OpaqueTypeWrapperBase>
class opaque_val
{
private:
    typename OpaqueTypeWrapperBase::type m_value;

public:
    typedef typename OpaqueTypeWrapperBase::type opaque_type;
    typedef typename complete_type_or_base<OpaqueTypeWrapper, OpaqueTypeWrapperBase>::type::type actual_type;
    typedef typename maybe_dereference_once<actual_type>::value_type dereferenced_type;
    typedef typename conditional_type<
        maybe_dereference_once<actual_type>::dereferenced,
        dereferenced_type&, dereferenced_type>::type dereferenced_return_type;
    static const bool is_opaque = !complete_type_or_base<OpaqueTypeWrapper, OpaqueTypeWrapperBase>::is_complete;

    opaque_val(const actual_type &value = actual_type())
        : m_value(value)
    {
        LEAN_STATIC_ASSERT_MSG_ALT(!is_opaque, "cannot construct value in opaque state", cannot_construct_value_in_opaque_state);
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    opaque_val(opaque_val &&right) : m_value(std::move(right.m_value)) { }
#endif

    opaque_val& operator =(const actual_type &value)
    {
        LEAN_STATIC_ASSERT_MSG_ALT(!is_opaque, "cannot assign value in opaque state", cannot_assign_value_in_opaque_state);

        m_value = value;
        return *this;
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    opaque_val& operator =(opaque_val &&right)
    {
        m_value = std::move(right.m_value);
        return *this;
    }
#endif

    actual_type get(void) const { return static_cast<actual_type>(m_value); }
    
    dereferenced_return_type operator *() const { return maybe_dereference_once<actual_type>::dereference(get()); }
    actual_type operator ->() const { return get(); }

    operator actual_type() const { return get(); }
};

} // namespace

using pimpl::opaque_val;

} // namespace


#define DECLARE_OPAQUE_TYPE(NAME, OPAQUE_TYPE)  \
    struct NAME##_opaque_type_wrapper           \
    {                                           \
        typedef OPAQUE_TYPE type;               \
    };                                          \
                                                \
    struct NAME##_actual_type_wrapper;          \
                                                \
    typedef ::lean::opaque_val<                 \
        NAME##_actual_type_wrapper,             \
        NAME##_opaque_type_wrapper> NAME;

#define DEFINE_OPAQUE_TYPE(NAME, ACTUAL_TYPE)                               \
    struct NAME##_actual_type_wrapper : public NAME##_opaque_type_wrapper   \
    {                                                                       \
        typedef ACTUAL_TYPE type;                                           \
    };


#endif