#include <boost/variant.hpp>
using namespace boost;



class ptr_to_test_variant;

typedef
	variant
	<
		int,
		ptr_to_test_variant
	>
	test_variant
;

class ptr_to_test_variant
{
	public:
		explicit
		ptr_to_test_variant(const test_variant& pointed_test_variant);

		ptr_to_test_variant(const ptr_to_test_variant& rhs);

		~ptr_to_test_variant();

		ptr_to_test_variant&
		operator=(const ptr_to_test_variant& rhs);

		const test_variant&
		pointed_test_variant() const;

	private:
		test_variant* pointed_test_variant_;
};

bool
operator==(const ptr_to_test_variant& lhs, const ptr_to_test_variant& rhs);

bool
operator!=(const ptr_to_test_variant& lhs, const ptr_to_test_variant& rhs);



ptr_to_test_variant::ptr_to_test_variant(const test_variant& pointed_test_variant):
	pointed_test_variant_(new test_variant(pointed_test_variant))
{
}

ptr_to_test_variant::ptr_to_test_variant(const ptr_to_test_variant& rhs):
	pointed_test_variant_(new test_variant(*rhs.pointed_test_variant_))
{
}

ptr_to_test_variant::~ptr_to_test_variant()
{
	delete pointed_test_variant_;
}

ptr_to_test_variant&
ptr_to_test_variant::operator=(const ptr_to_test_variant& rhs)
{
	delete pointed_test_variant_; //no more assertion failure if one comments this line
	pointed_test_variant_ = new test_variant(*rhs.pointed_test_variant_);
	return *this;
}

const test_variant&
ptr_to_test_variant::pointed_test_variant() const
{
	return *pointed_test_variant_;
}

bool
operator==(const ptr_to_test_variant& lhs, const ptr_to_test_variant& rhs)
{
	return
		lhs.pointed_test_variant() == rhs.pointed_test_variant()
	;
}

bool
operator!=(const ptr_to_test_variant& lhs, const ptr_to_test_variant& rhs)
{
	return !operator==(lhs, rhs);
}



int main()
{
	test_variant tv1 = 88;
	test_variant ptr_to_tv1 = ptr_to_test_variant(tv1);
	test_variant ptr_to_ptr_to_tv1 = ptr_to_test_variant(ptr_to_tv1);

	const ptr_to_test_variant& direct_ptr_to_ptr_to_tv1 = get<ptr_to_test_variant>(ptr_to_ptr_to_tv1);
	ptr_to_ptr_to_tv1 = direct_ptr_to_ptr_to_tv1.pointed_test_variant();
}