forward_val.h

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

#ifndef LEAN_PIMPL_FORWARD_VAL
#define LEAN_PIMPL_FORWARD_VAL

#include "../cpp0x.h"

namespace lean
{
namespace pimpl
{

template <class Value, size_t Size>
class forward_val
{
private:
    char m_value[Size];

    LEAN_INLINE static void assert_size()
    {
        LEAN_STATIC_ASSERT_MSG_ALT(sizeof(Value) == Size,
            "specified size does not match value size",
            specified_size_does_not_match_value_size);
    }

public:
    typedef Value value_type;

    forward_val()
    {
        assert_size();
        new(static_cast<void*>(m_value)) Value();
    }
    forward_val(const value_type &value)
    {
        assert_size();
        new(static_cast<void*>(m_value)) Value(value);
    }
    forward_val(const forward_val &right)
    {
        assert_size();
        new(static_cast<void*>(m_value)) Value(right.get());
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    forward_val(value_type &&value)
    {
        assert_size();
        new(static_cast<void*>(m_value)) Value(std::move(value));
    }
    forward_val(forward_val &&right)
    {
        assert_size();
        new(static_cast<void*>(m_value)) Value(std::move(right.get()));
    }
#endif

    ~forward_val()
    {
        get().~Value();
    }

    forward_val& operator =(const value_type &value)
    {
        get() = value;
        return *this;
    }
    forward_val& operator =(const forward_val &right)
    {
        get() = right.get();
        return *this;
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    forward_val& operator =(value_type &&value)
    {
        get() = std::move(value);
        return *this;
    }
    forward_val& operator =(forward_val &&right)
    {
        get() = std::move(right.get());
        return *this;
    }
#endif

    LEAN_INLINE value_type* getptr(void) { assert_size(); return reinterpret_cast<Value*>(m_value); }
    LEAN_INLINE const value_type* getptr(void) const { assert_size(); return reinterpret_cast<const Value*>(m_value); }
    LEAN_INLINE value_type& get(void) { return *getptr(); }
    LEAN_INLINE const value_type& get(void) const { return *getptr(); }
    
    LEAN_INLINE value_type& operator *() { return get(); }
    LEAN_INLINE const value_type& operator *() const { return get(); }
    LEAN_INLINE value_type* operator ->() { return getptr(); }
    LEAN_INLINE const value_type* operator ->() const { return getptr(); }

    LEAN_INLINE operator value_type&() { return get(); }
    LEAN_INLINE operator const value_type&() const { return get(); }
};

} // namespace

using pimpl::forward_val;

} // namespace

#endif