// Semantics Consulting's Tyr Library
// http://www.semantics.org
//
// Copyright (c) 2003 by Stephen C. Dewhurst
//
// Permission to use, copy, modify, distribute, and sell this software
// for any purpose is hereby granted without fee, provided that the above
// copyright notice appears in all copies and that both that copyright
// notice and this permission notice appear in supporting documentation.
// The author makes no representations about the suitability of this
// software for any purpose.  It is provided "as is" without express
// or implied warranty.

//	Described in:
//	Unfinished Business. C/C++ Users Journal Experts Forum, 21, 11 (November 2003).

#ifndef DISMANTLE_H
#define DISMANTLE_H

#include "typelist.h"

namespace Tyr {

//
//	This is a quick and experimental version of a template metaprogramming
//	facility for compile time type manipulation.  It is described in
//	Semantics Consulting's "Once, Weakly" feature of 23 February 2003, at
//	http://www.semantics.org/once_weakly.html.
//
//	Basically, we dismantle a type into its constituent parts.  We then have
//	the opportunity to examine its parts, change them, remove some, add some
//	new pieces, perform regular-expression-like matching and substitution, etc.
//	Finally, we can regenerate a "regular" type from the (potentially) modified
//	dismantled type.
//
//	From the web posting: "In effect, we now have two equivalent, but structurally
//	distinct, versions of the same type.  The normal version is optimized for use
//	in a traditional fashion: accessing its operations, causing code to be generated
//	that will execute at runtime, etc.  The dismantled version is optimized for
//	compile time analysis and manipulation.  Therefore, we now have the ability to
//	move an arbitrary type among different representations according to how we want
//	to use it.  The invertibility of the representations assures us that either
//	representation will contain all the information present in the other."

//------------------------------
//	WHAT'S HERE?
//
// Dismantle a type into its constituent parts.
template <typename T>
struct Dis;

// Regenerate a dismantled type.
template <class T>
struct Regen;

//-------------------------------
//
//	Types that represent type qualifiers and type modifiers in
//	the dismantled version of a type.
//
struct ConstDis {};
struct VolatileDis {};
struct RefDis {};
struct PtrDis {};

template <int b>
struct AryDis
	{ enum { bound = b }; };

template <class C>
struct PcmDis
	{ typedef typename Dis<C>::R Class; };

// Function modifiers (member and non-member) modify the return type.
// Therefore, only the arguments are available within these modifier types.
struct Fun0 {};

template <typename A>
struct Fun1
	{ typedef typename Dis<A>::R Arg; };
	
template <typename A1, typename A2>
struct Fun2 {
	typedef typename Dis<A1>::R Arg1;
	typedef typename Dis<A2>::R Arg2;
};

template <class C>
struct MFun0
	{ typedef typename Dis<C>::R Class; };

template <class C, typename A>
struct MFun1 {
	typedef typename Dis<C>::R Class;
	typedef typename Dis<A>::R Arg;
};

template <class C, typename A1, typename A2>
struct MFun2 {
	typedef typename Dis<C>::R Class;
	typedef typename Dis<A1>::R Arg1;
	typedef typename Dis<A2>::R Arg2;
};

template <class C>
struct CMFun0
	{ typedef typename Dis<C>::R Class; };
	
template <class C, typename A>
struct CMFun1 {
	typedef typename Dis<C>::R Class;
	typedef typename Dis<A>::R Arg;
};

template <class C, typename A1, typename A2>
struct CMFun2 {
	typedef typename Dis<C>::R Class;
	typedef typename Dis<A1>::R Arg1;
	typedef typename Dis<A2>::R Arg2;
};

//-------------------------------
//	TYPE DISMANTLING
//
//	The primary template is the catch-all for any type
//	that is not more specifically specialized.
//	See specialized types below.
//
template <typename T>
struct Dis {
	typedef typelist<T,null_typelist> R;
};

template <typename T>
struct Dis<const T> {
	typedef typelist<ConstDis, typename Dis<T>::R> R;
};

template <typename T>
struct Dis<volatile T> {
	typedef typelist<VolatileDis, typename Dis<T>::R> R;
};

template <typename T>
struct Dis<const volatile T> {
	typedef typelist<ConstDis, typename Dis<volatile T>::R> R;
};

template <typename T>
struct Dis<T &> {
	typedef typelist<RefDis, typename Dis<T>::R> R;
};

template <typename T>
struct Dis<T *> {
	typedef typelist<PtrDis, typename Dis<T>::R> R;
};

template <typename T>
struct Dis< T *const> {
	typedef typelist<ConstDis, typename Dis<T *>::R> R;
};

template <typename T>
struct Dis< T *volatile> {
	typedef typelist<VolatileDis, typename Dis<T *>::R> R;
};

template <typename T>
struct Dis< T *const volatile> {
	typedef typelist<ConstDis, typename Dis<T * volatile>::R> R;
};

template <typename T, int b>
struct Dis<T[b]> {
	typedef typelist<AryDis<b>,typename Dis<T>::R> R;
};

template <typename T, int b>
struct Dis<const T[b]> {
	typedef typelist<AryDis<b>,typelist<ConstDis,typename Dis<T>::R> > R;
};

template <typename T, int b>
struct Dis<volatile T[b]> {
	typedef typelist<AryDis<b>,typelist<VolatileDis,typename Dis<T>::R> > R;
};

template <typename T, int b>
struct Dis<const volatile T[b]> {
	typedef typelist<AryDis<b>,typelist<ConstDis,typelist<VolatileDis,typename Dis<T>::R> > > R;
};

template <class C, typename T>
struct Dis<T C::*> {
	typedef typelist<PcmDis<C>,typename Dis<T>::R> R;
};

template <class C, typename T>
struct Dis<T C::*const> {
	typedef typelist<ConstDis,typename Dis<T C::*>::R> R;
};

template <class C, typename T>
struct Dis<T C::*volatile> {
	typedef typelist<VolatileDis,typename Dis<T C::*>::R> R;
};

template <class C, typename T>
struct Dis<T C::*const volatile> {
	typedef typelist<ConstDis,typename Dis<T C::*volatile>::R> R;
};

template <typename Ret>
struct Dis<Ret(void)> {
	typedef typelist<Fun0,typename Dis<Ret>::R> R;
};

template <typename Ret, typename Arg>
struct Dis<Ret(Arg)> {
	typedef typelist<Fun1<Arg>,typename Dis<Ret>::R> R;
};

template <typename Ret, typename Arg1, typename Arg2>
struct Dis<Ret(Arg1,Arg2)> {
	typedef typelist<Fun2<Arg1,Arg2>,typename Dis<Ret>::R> R;
};

template <class C, typename Ret>
struct Dis<Ret (C::*)()> {
	typedef typelist<MFun0<C>,typename Dis<Ret>::R> R;
};

template <class C, typename Ret, typename Arg>
struct Dis<Ret (C::*)(Arg)> {
	typedef typelist<MFun1<C,Arg>,typename Dis<Ret>::R> R;
};

template <class C, typename Ret, typename Arg1, typename Arg2>
struct Dis<Ret(C::*)(Arg1,Arg2)> {
	typedef typelist<MFun2<C,Arg1,Arg2>,typename Dis<Ret>::R> R;
};

template <class C, typename Ret>
struct Dis<Ret (C::*)() const> {
	typedef typelist< ConstDis,typelist<CMFun0<C>,typename Dis<Ret>::R> > R;
};

template <class C, typename Ret, typename Arg>
struct Dis<Ret (C::*)(Arg )const> {
	typedef typelist< ConstDis, typelist<CMFun1<C,Arg>,typename Dis<Ret>::R> > R;
};

template <class C, typename Ret, typename Arg1, typename Arg2>
struct Dis<Ret(C::*)(Arg1,Arg2) const> {
	typedef typelist< ConstDis, typelist<CMFun2<C,Arg1,Arg2>,typename Dis<Ret>::R> > R;
};
//------------------------------
//	REGENERATING A DISMANTLED TYPE
//
template <class T>
struct Regen;

template <typename T>
struct Regen< typelist<T,null_typelist> > {
	typedef T R;
};

template <class T>
struct Regen< typelist<ConstDis,T> > {
	typedef const typename Regen<T>::R R;
};

template <class T>
struct Regen< typelist<VolatileDis,T> > {
	typedef volatile typename Regen<T>::R R;
};

template <class T>
struct Regen< typelist<RefDis,T> > {
	typedef typename Regen<T>::R &R;
};

template <class T>
struct Regen< typelist<PtrDis,T> > {
	typedef typename Regen<T>::R *R;
};

template <class T, int b>
struct Regen< typelist<AryDis<b>,T> > {
	typedef typename Regen<T>::R R[b];
};

template <class T, class C>
struct Regen< typelist<PcmDis<C>,T> > {
	typedef typename Regen<T>::R C::*R;
};

template <typename T>
struct Regen< typelist<Fun0,T> > {
	typedef typename Regen<T>::R R();
};

template <typename T, typename A>
struct Regen< typelist<Fun1<A>,T> > {
	typedef typename Regen<T>::R R( A );
};

template <typename T, typename A1, typename A2>
struct Regen< typelist<Fun2<A1,A2>,T> > {
	typedef typename Regen<T>::R R( A1, A2 );
};

template <class C, typename T>
struct Regen< typelist<MFun0<C>,T> > {
	typedef typename Regen<T>::R (C::*R)();
};

template <class C, typename T, typename A>
struct Regen< typelist<MFun1<C,A>,T> > {
	typedef typename Regen<T>::R (C::*R)( A );
};

template <class C, typename T, typename A1, typename A2>
struct Regen< typelist<MFun2<C,A1,A2>,T> > {
	typedef typename Regen<T>::R (C::*R)( A1, A2 );
};

template <class C, typename T>
struct Regen< typelist<CMFun0<C>,T> > {
	typedef typename Regen<T>::R (C::*R)() const;
};

template <class C, typename T, typename A>
struct Regen< typelist<CMFun1<C,A>,T> > {
	typedef typename Regen<T>::R (C::*R)( A ) const;
};

template <class C, typename T, typename A1, typename A2>
struct Regen< typelist<CMFun2<C,A1,A2>,T> > {
	typedef typename Regen<T>::R (C::*R)( A1, A2 ) const;
};

} // namespace Tyr

#endif