Концепт группировки типов в C++

#include "stdafx.h"
 
// .... Core ...
 
#include <iostream>
#include <tchar.h>
 
#include <boost/mpl/front.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/remove_if.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/utility/enable_if.hpp>
 
struct NA {};
 
//! Hierarchy generation core
template< class T1, class T2 >
struct Derive : T1, T2 {};
template< class T1 >
struct Derive< T1, NA > : T1 {};
 
template< class V, class EnableIf = void >
struct GenerateLinearHierarchy
    : boost::mpl::identity< Derive< 
        typename boost::mpl::front< V >::type,
        typename GenerateLinearHierarchy< typename boost::mpl::pop_front< V >::type >::type > >
{
};
 
template< class V >
struct GenerateLinearHierarchy< V, typename boost::enable_if< boost::mpl::empty< V > >::type >
    : boost::mpl::identity< NA >
{
};
 
//! Transforms interface type to proxy-to-interface type
template< class T >
struct InterfaceToProxyTransformOp : boost::mpl::identity< typename T::CProxy > {};
 
template<>
struct InterfaceToProxyTransformOp< boost::mpl::_ > {};
 
//! IGroup implementation, V is MPL array of interfaces.
template< class V >
struct IGroup_Impl
{
private:
 
    typedef typename boost::mpl::transform< V, InterfaceToProxyTransformOp< boost::mpl::_ > >::type
        TProxies;
 
    class CPointerImpl : public GenerateLinearHierarchy< TProxies >::type
    {
        template< class V, class T >
        typename boost::disable_if< boost::mpl::empty< V > >::type
        Initialize( T *p )
        {
            static_cast< typename boost::mpl::front< V >::type * >( this )->SetTarget( p );
            Initialize< typename boost::mpl::pop_front< V >::type >( p );
        }
 
        template< class V, class T >
        typename boost::enable_if< boost::mpl::empty< V > >::type
        Initialize( T * ){}
 
    public:
 
        template< class T >
        CPointerImpl( T *p ){ Initialize< TProxies >( p ); };
    };
 
    class CPointer
    {
    public:
 
        template< class T >
        CPointer( T *pGroup ) : m_oImpl( pGroup ) {}
 
    public:
 
        CPointerImpl *operator->() { return &m_oImpl; }
        const CPointerImpl *operator->() const { return &m_oImpl; }
        const CPointerImpl &operator*() const { return m_oImpl; }
        CPointerImpl &operator*() { return m_oImpl; }
 
    protected:
 
        CPointerImpl m_oImpl;
    };
 
public:
 
    typedef CPointer
        TPointer;
};
 
template
<
    class T1 = NA, class T2 = NA, class T3 = NA,
    class T4 = NA, class T5 = NA, class T6 = NA,
    class T7 = NA, class T8 = NA, class T9 = NA
>
struct IGroup
    : IGroup_Impl<
            typename boost::mpl::remove_if<
                boost::mpl::vector< T1, T2, T3, T4, T5, T6, T7, T8, T9 >,
                std::is_same< boost::mpl::_, NA > >::type >
{
};
 
template< class T >
class TProxy
{
public:
    TProxy() : m_pTarget( nullptr ) {}
    void SetTarget( T *pTarget ){ m_pTarget = pTarget; }
protected:
    T *m_pTarget;
};
 
// .... Usage ...
 
class IQuackable
{
public:
    struct CProxy : TProxy< IQuackable >
    {
        void Quack(){ m_pTarget->Quack(); }
    };
public:
    virtual void Quack() = 0;
};
 
class IFlyable
{
public:
    struct CProxy : TProxy< IFlyable >
    {
        void Fly(){ m_pTarget->Fly(); }
    };
public:
    virtual void Fly() = 0;
};
 
class IWalkable
{
public:
    struct CProxy : TProxy< IWalkable >
    {
        void Walk(){ m_pTarget->Walk(); }
    };
public:
    virtual void Walk() = 0;
};
 
class CDuck : public IQuackable, public IFlyable, public IWalkable
{
public:
    virtual void Quack(){ std::cout << "Quack!" << std::endl; }
    virtual void Fly(){ std::cout << "Fly!" << std::endl; }
    virtual void Walk(){ std::cout << "Walk!" << std::endl; }
};
 
void DoFlyQuacking( IGroup< IFlyable, IQuackable >::TPointer p ){ p->Fly(); p->Quack(); }
void DoFlyWalkQuacking( IGroup< IFlyable, IWalkable, IQuackable >::TPointer p ){ p->Fly(); p->Walk(); p->Quack(); }
void DoFly( IGroup< IFlyable >::TPointer p ){ p->Fly(); }
 
int _tmain( int, _TCHAR*[] )
{
    CDuck oDuck;
 
    DoFlyQuacking( &oDuck );
    DoFlyWalkQuacking( &oDuck );
    DoFly( &oDuck );
 
    return 0;
}