// encode: shift_jis
//   140行目から使い方サンプルがあります

#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
namespace mpl = boost::mpl;

namespace bd {

//--------------------------------------------------------------
// <he,she> の he の方を指すポインタを模擬する場合の実装。
//--------------------------------------------------------------

template<class traits>
class bidi_ptr_left
{
	friend traits;
protected:
	typedef typename traits::left_type* pointer;
	typedef typename traits::left_type  value_type;
	typedef typename traits::right_type owner_type;
	void assign( value_type* p ) { traits::assign_2(p, owner); }
	bidi_ptr_left( owner_type* o ) : owner(o) {}
public:
	value_type& operator*()  const { return *ptr; }
	value_type* operator->() const { return ptr; }
private:
	owner_type* const owner;
	value_type*       ptr;
};

//--------------------------------------------------------------
// <he,she> の she の方を指すポインタを模擬する場合の実装。
//--------------------------------------------------------------

template<class traits>
class bidi_ptr_right
{
	friend traits;
protected:
	typedef typename traits::right_type* pointer;
	typedef typename traits::right_type  value_type;
	typedef typename traits::left_type   owner_type;
	void assign( value_type* p ) { traits::assign_2(owner, p); }
	bidi_ptr_right( owner_type* o ) : owner(o) {}
public:
	value_type& operator*()  const { return *ptr; }
	value_type* operator->() const { return ptr; }
private:
	owner_type* const owner;
	value_type*       ptr;
};

//---------------------------------------------
// 双方向ポインタ bidi_ptr<>
//    bidi_ptr<HeAndShe, Male>
//    bidi_ptr<HeAndShe, Female>
//    bidi_ptr<HeAndShe, bd::left>
//    bidi_ptr<HeAndShe, bd::right>
// のいずれかの形式で使えます。
//---------------------------------------------

template<class traits, class Pointee> class bidi_ptr
	: public mpl::if_c<
		boost::is_same<Pointee, typename traits::left_type>::value,
			bidi_ptr_left<traits>, bidi_ptr_right<traits> >::type
{
friend class traits;
	typedef bidi_ptr<traits, Pointee> this_type;
	typedef typename mpl::if_c<
		boost::is_same<Pointee, typename traits::left_type>::value,
			bidi_ptr_left<traits>, bidi_ptr_right<traits> >::type
		parent_type;
public:
	typedef typename parent_type::value_type value_type;
	typedef typename parent_type::pointer    pointer;
	typedef typename parent_type::owner_type owner_type;
	bidi_ptr( owner_type* o ) : parent_type(o) {}
	this_type& operator=( pointer p ) { assign(p); return *this; }
};

class left;
template<class traits> class bidi_ptr<traits, bd::left>
	: public bidi_ptr_left<traits>
{
friend class traits;
	typedef bidi_ptr<traits, bd::left> this_type;
	typedef bidi_ptr_left<traits>      parent_type;
public:
	typedef typename parent_type::value_type value_type;
	typedef typename parent_type::pointer    pointer;
	typedef typename parent_type::owner_type owner_type;
	bidi_ptr( owner_type* o ) : parent_type(o) {}
	this_type& operator=( pointer p ) { assign(p); return *this; }
};

class right;
template<class traits> class bidi_ptr<traits, bd::right>
	: public bidi_ptr_right<traits>
{
friend class traits;
	typedef bidi_ptr<traits, bd::right> this_type;
	typedef bidi_ptr_right<traits>      parent_type;
public:
	typedef typename parent_type::value_type value_type;
	typedef typename parent_type::pointer    pointer;
	typedef typename parent_type::owner_type owner_type;
	bidi_ptr( owner_type* o ) : parent_type(o) {}
	this_type& operator=( pointer p ) { assign(p); return *this; }
};


#define DEFINE_BIDI_PTR_TRAITS(TraitsName, LeftType, LeftField, RightType, RightField) \
	class TraitsName\
	{\
		friend bd::bidi_ptr_left<TraitsName>;\
		friend bd::bidi_ptr_right<TraitsName>;\
		friend bd::bidi_ptr<TraitsName,class LeftType>;\
		friend bd::bidi_ptr<TraitsName,class RightType>;\
	\
		typedef class LeftType  left_type;\
		typedef class RightType right_type;\
	\
		template<typename left_type_, typename right_type_>\
		static void assign_2( left_type_* lhs, right_type_* rhs )\
		{\
			lhs->LeftField.ptr  = rhs;\
			rhs->RightField.ptr = lhs;\
		}\
	}
		//※ 無駄にassign_2がtemplateなのは、コンパイル時の依存関係を
		//※ 避けるためのdirty hackです。

} // namespace end





//----------------------------------------------------------------------------
// 使い方
//----------------------------------------------------------------------------

using bd::bidi_ptr;

// HeShe : Maleのshe と Femaleのhe は双方向関係です
DEFINE_BIDI_PTR_TRAITS(HeShe, Male, she, Female, he);

// WifeHusband : Maleのshe と Femaleのhe は双方向関係です
DEFINE_BIDI_PTR_TRAITS(WifeHusband, Male, wife, Female, husband);

// DaughterFather : FemaleのFather と Maleのdaughter は双方向関係です
DEFINE_BIDI_PTR_TRAITS(DaughterFather, Female, father, Male, daughter);

// Male / Female の定義

class Male;
class Female;

class Male {
public:
	Male(const char* name) : name(name), she(this), wife(this), daughter(this) {}
	const char* name;

	bidi_ptr<HeShe,          Female> she;
	bidi_ptr<WifeHusband,    Female> wife;
	bidi_ptr<DaughterFather, Female> daughter;
};

class Female {
public:
	Female(const char* name) : name(name), he(this), husband(this), father(this) {}
	const char* name;

	bidi_ptr<HeShe,          Male> he;
	bidi_ptr<WifeHusband,    Male> husband;
	bidi_ptr<DaughterFather, Male> father;
};

#include <iostream>
using namespace std;

int main()
{
	Male namihei("namihei"), masuo("masuo");
	Female fune("fune"), sazae("sazae");

	namihei.wife     = &fune;
	namihei.daughter = &sazae;
	sazae.he         = &masuo;

	cout << sazae.father->name << endl; // namihei
	cout << fune.husband->name << endl; // namihei
	cout << masuo.she->name    << endl; // sazae
}