С++: шаблон «поводок»

#include <iostream>

#include <vector>
#include <algorithm>

template <typename H, typename T>
struct TypeList
{
	typedef H Head;
	typedef T Tail;
};

struct NullType
{
};

#define TYPE_LIST_1(t1) \
	TypeList<t1, NullType>

#define TYPE_LIST_2(t1, t2) \
	TypeList<t1, TYPE_LIST_1(t2) >

#define TYPE_LIST_3(t1, t2, t3) \
	TypeList<t1, TYPE_LIST_2(t2, t3) >

#define TYPE_LIST_4(t1, t2, t3, t4) \
	TypeList<t1, TYPE_LIST_3(t2, t3, t4) >

#define TYPE_LIST_5(t1, t2, t3, t4, t5) \
	TypeList<t1, TYPE_LIST_4(t2, t3, t4, t5) >

template <typename T>
struct TypeWrap
{
};

template <typename TClass, typename TLinkedClasses>
class LinkHolder
	: public LinkHolder<TClass, typename TLinkedClasses::Tail>
{
public:
	typedef typename TLinkedClasses::Head LinkType;
	virtual ~LinkHolder()
	{
		LinkPool Tmp = Links;
		for (LinkPool::const_iterator i = Tmp.begin() ; i != Tmp.end() ; ++i)
			(*i)->DelLink(static_cast<TClass *>(this));
	}
	using LinkHolder<TClass, typename TLinkedClasses::Tail>::AddLink;
	using LinkHolder<TClass, typename TLinkedClasses::Tail>::DelLink;
	void AddLink(LinkType *link)
	{
		if (std::find(Links.begin(), Links.end(), link) != Links.end())
			return;
		Links.push_back(link);
		link->AddLink(static_cast<TClass *>(this));
	}
	void DelLink(LinkType *link)
	{
		LinkPool::iterator Iter = std::find(Links.begin(), Links.end(), link);
		if (Iter == Links.end())
			return;
		LinkType *Link = *Iter;
		Links.erase(Iter);
		Link->DelLink(static_cast<TClass *>(this));
	}
	template <typename T>
	unsigned GetLinkCount() const
	{
		return GetLinkCountImpl(TypeWrap<T>());
	}
	template <typename T>
	T* GetLink(unsigned index) const
	{
		return GetLinkImpl(TypeWrap<T>(), index);
	}
protected:
	using LinkHolder<TClass, typename TLinkedClasses::Tail>::GetLinkCountImpl;
	unsigned GetLinkCountImpl(const TypeWrap<LinkType> &) const
	{
		return static_cast<unsigned>(Links.size());
	}
	using LinkHolder<TClass, typename TLinkedClasses::Tail>::GetLinkImpl;
	LinkType* GetLinkImpl(const TypeWrap<LinkType> &, unsigned index) const
	{
		return Links.size() > index ? Links[index] : 0;
	}
private:
	typedef std::vector<LinkType *> LinkPool;
	LinkPool Links;
};

template <typename TClass>
class LinkHolder<TClass, NullType>
{
public:
	virtual ~LinkHolder()
	{
	}
	void AddLink()
	{
	}
	void DelLink()
	{
	}
	unsigned GetLinkCountImpl(const TypeWrap<NullType> &) const
	{
		return -1;
	}
	NullType* GetLinkImpl(const TypeWrap<NullType> &, unsigned) const
	{
		return 0;
	}
};

class A;
class B;
class C;

class A
	: public LinkHolder<A, TYPE_LIST_3(A, B, C)>
{
public:
	void A2B();
	void Stop();
};

class B
	: public LinkHolder<B, TYPE_LIST_3(A, B, C)>
{
public:
	void B2C();
};

class C
	: public LinkHolder<C, TYPE_LIST_3(A, B, C)>
{
public:
	void C2A();
};

void A::A2B()
{
	std::cout << __FUNCTION__ << std::endl;
	unsigned Count = GetLinkCount<B>();
	for (unsigned i = 0 ; i < Count ; ++i)
		GetLink<B>(i)->B2C();
}

void A::Stop()
{
	std::cout << __FUNCTION__ << std::endl;
}

void B::B2C()
{
	std::cout << __FUNCTION__ << std::endl;
	unsigned Count = GetLinkCount<C>();
	for (unsigned i = 0 ; i < Count ; ++i)
		GetLink<C>(i)->C2A();
}

void C::C2A()
{
	std::cout << __FUNCTION__ << std::endl;
	unsigned Count = GetLinkCount<A>();
	for (unsigned i = 0 ; i < Count ; ++i)
		GetLink<A>(i)->Stop();
}

int main()
{
	A a;
	std::auto_ptr<B> b(new B);
	C c;

	a.AddLink(&a);
	a.AddLink(b.get());
	a.AddLink(&c);

	b->AddLink(&a);
	b->AddLink(b.get());
	b->AddLink(&c);

	c.AddLink(&a);
	c.AddLink(b.get());
	c.AddLink(&c);
	
	a.A2B();

	b.reset(0);

	std::cout << std::endl;
	a.A2B();
}