#include <iostream>
#include <string>

struct C
{
    std::string b;    
};

template <typename Type, Type> struct Helper;
template <typename T, typename Type> char Finder(Helper<Type, &T::b>*);

int main()
{
    std::cout << sizeof(Finder<C, std::string C::*>(0)) << std::endl;
}

struct A;
struct B
{
    A* a;
};

Helper<B>::type is the same as struct A

//typedef int X;
struct X {};

struct C
{
    X b;    
};

template <typename PtrType, PtrType PtrValue> struct Helper {};
template <typename HostType, typename DataType> char Finder(Helper<DataType HostType::*, &HostType::b>*);

int main()
{
    Helper<X C::*, &C::b> h;
    Finder(&h);
}

 
namespace fl
{
struct yes_type{ char _[1]; };
struct no_type { char _[8]; };
struct _Empty;

template<typename _Cur, typename _Next>
   struct item_type0 {  typedef _Cur cur_type; typedef _Next type_next;  };

template <typename _Ty>
   yes_type _Is_regged_func(typename _Ty::_Is_registered_tag* ptr= 0);

template <typename _Ty>
   no_type _Is_regged_func(...);

template <typename _Ty>
   struct _Is_registered { static const int value = (sizeof(_Is_regged_func<_Ty>()) == sizeof(yes_type));  };

template <typename _Ty, typename _Branch = struct _New_branch >
   struct _Get_fields
{
   template <int _I=1, int _Is_regged = _Is_registered<_Ty::fields_storage<_I> > >
      struct _Iterator   
    {
            typedef item_type0<typename _Ty::fields_storage<_I>::field_type, typename _Iterator<_I+1>::result > result;       
            static const int count = _Iterator<_I+1>::count;
        };

   template <int _I >
      struct _Iterator<_I, 0>   
    {
            typedef _Empty result;       
            static const int count = _I;
        };

   typedef _Iterator<>::result result;
   static const int count = _Iterator<>::count;

};

#define serrialization(_Class) typedef _Class this_class;   template <int _I>     struct fields_storage;

#define decl_field(type, ident) type ident; \
   struct field_tag_##ident \
{  \
   typedef type result_type; typedef type this_class::*TypeField; \
   static TypeField field(){ return &this_class::ident; } \
};\
template <>\
    struct fields_storage<_Get_fields<this_class, field_tag_##ident >::count > { typedef field_tag_##ident field_type; };


}
 
struct some_class 
{
   serrialization(some_class);

   decl_field(int,m_A);
   decl_field(std::string, m_B);
};

int main()
{
    typedef fl::_Get_fields<some_class>::result fields;
    //there are we look typelist with metadata fields .. ^) thanks 
    print_type(fields);   
}

C>struct A;
C>struct B
C>{
C>    A* a;
C>};

C>Helper<B>::type is the same as struct A
C>

struct A8 {};
struct A9 : A8 {};
struct B8
{
    A8* a;
};
template<typename T>
struct Helper
{
    typedef T type ;
};

template<typename T>
struct IsSame
{
    template<typename T2> static bool As(T2*, T *) {return true;}
    static bool As(void *, void *) {return false;}
    template<typename T2> static bool As()
    {return  As((T2*)0,(T2*)0);}
};
template<typename T1, typename T2> 
bool AreSame()
{
    return IsSame<T1>::As<T2>() && IsSame<T2>::As<T1>();
}

int main()
{
    bool testik = AreSame<A9,Helper<A8>::type>();
    bool testik0 = AreSame<A8,Helper<A8>::type>();
    bool testik1 = IsSame<A9>::As<Helper<A8>::type>();
    bool testik2 = IsSame<Helper<A8>::type>::As<A9>();
        cout << testik << endl << testik0 << endl << testik1 << endl << testik2 << endl;
        return 0;
}

template<bool ok> struct IsDerrived{};
template<bool ok> struct InterDerrived{};
template<typename T> struct Derrived
{
    template<typename T2> 
    static IsDerrived<true> From(T2*, T *) {return IsDerrived<true>();}
    static IsDerrived<false> From(void *, void *) {return IsDerrived<false>();}
};
template<bool derrived, bool base>
InterDerrived<derrived && base> TestInterDerrived(IsDerrived<derrived>, IsDerrived<base>) {return InterDerrived<derrived && base>();}
#define AreInterDerrived(T1, T2) TestInterDerrived(Derrived<T1>::From((T2*)0,(T2*)0), Derrived<T2>::From((T1*)0,(T1*)0))

// example functions 
template<typename T1, typename T2> 
void func(T1 p1, T2 p2, void * extra, InterDerrived<true>)
{
}
template<typename T1, typename T2> 
void func(T1 p1, T2 p2, void * extra, InterDerrived<false>)
{
}
template<typename T1, typename T2> 
void func(T1 p1, T2 p2, void * extra)
{
func(p1, p2, extra, AreInterDerrived(T1,T2));
}

// use 
struct C { typedef int T; T v;};
struct A { struct A1 { typedef int T; }; A1::T v; };
template<typename T> 
struct B { typedef T TT; TT v;};

void Some(void * extData)
{
A a = A();
B<char> b = B<char>();
C c = C();
func(a.v, c.v, extData);
func(b.v, c.v, extData);
func(a.v, b.v, extData);
}

template <typename _Ty>
  struct _Accessor;

class A {  public:  int m_A;  };

//псевдокод
template<>
  struct _Accessor<A>
{
   ...
   decl_field(int, &A::m_A);
};

#include <iostream>
#include <string>

struct Yes{int i;};
struct No{Yes i[10];};


template< typename T,typename R > No Helper(...); 
template< typename T,typename R > Yes Helper(R (T::* t)); 

template< typename T,typename R >
struct Finder
{
enum {value=(sizeof(Helper<T,R>(&T::b)) == sizeof(Yes))};
};


struct A { int b; }; 
struct B { char b; }; 
struct C { std::string b; }; 

int main()
{

    std::cout << Finder<A,int>::value << std::endl;
    std::cout << Finder<B,int>::value << std::endl;
    std::cout << Finder<C,std::string>::value << std::endl;
}

#include <iostream>
#include <string>

struct Yes{int i;};
struct No{Yes i[10];};


template< typename T,typename R > No Helper(...); 
template< typename T,typename R > Yes Helper(R (T::*)); 
template< typename T,typename R > Yes Helper(R); 

template< typename T,typename R >
struct Finder
{
    enum {value=(sizeof(Helper<T,R>(&T::b)) == sizeof(Yes))};
};


struct A { int b; }; 
struct B { char b; }; 
struct C { std::string b; }; 
struct D { int b(int) const; };
struct E { int (*b)(int); };

int main()
{
    std::cout << Finder<A, int>::value << std::endl;
    std::cout << Finder<B, char>::value << std::endl;
    std::cout << Finder<C, std::string>::value << std::endl;
    std::cout << Finder<D, int (D::*)(int) const>::value << std::endl;
    std::cout << Finder<E, int (*)(int)>::value << std::endl;

    std::cout << Finder<A, int (*)()>::value << std::endl;
    std::cout << Finder<B, int>::value << std::endl;
    std::cout << Finder<C, B>::value << std::endl;
    std::cout << Finder<D, int (D::*)(int)>::value << std::endl;
    std::cout << Finder<E, int (E::*)(int)>::value << std::endl;
}