FXGenericTools.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                        Tools for generic programming                          *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003-2009 by Niall Douglas.   All Rights Reserved.       *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code is distributed in the hope that it will be useful,                  *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#ifndef FXGENERICTOOLS_H
#define FXGENERICTOOLS_H

#include "FXString.h"
#include "FXPolicies.h"
#include "FXException.h"
#include "FXPath.h"
#include <typeinfo>
#include <assert.h>

namespace FX {

namespace Generic {
// MSVC doesn't define type_info within namespace std :(
#ifdef _MSC_VER
typedef ::type_info type_info;
#else
typedef std::type_info type_info;
#endif

#ifndef HAVE_CPP0XSTATICASSERT
template<bool> struct StaticAssert;
template<> struct StaticAssert<true>
{
    StaticAssert() { }
};
#define FXSTATIC_ASSERT2(expr, msg) \
    FX::Generic::StaticAssert<(expr)!=0> ERROR_##msg

#define FXSTATIC_ASSERT(expr, msg) \
{ \
    FXSTATIC_ASSERT2(expr, msg); \
}

template<typename foo> struct StaticError;
#else
#define FXSTATIC_ASSERT(expr, msg) static_assert((expr)!=0, #msg )
#define FXSTATIC_ASSERT2(expr, msg) static_assert((expr)!=0, #msg )
#endif

struct NullType { };
template<int n> struct IntToType { static const int value=n; };
template<typename type> struct TypeToType { typedef type value; };
template<bool v, typename type=NullType> struct Boolean { static const bool value=v; };

template<bool v, typename A, typename B> struct select
{
    typedef A value;
};
template<typename A, typename B> struct select<false, A, B>
{
    typedef B value;
};
template<typename A, typename B> struct sameType
{
    static const bool value=false;
};
template<typename T> struct sameType<T, T>
{
    static const bool value=true;
};
template<typename type> struct addRef { typedef type &value; };
template<typename type> struct addRef<type &> { typedef type value; };
template<> struct addRef<void> { typedef void value; };
template<> struct addRef<const void> { typedef const void value; };
template<typename type> struct addConstRef { typedef const type &value; };
template<typename type> struct addConstRef<type &> { typedef typename addConstRef<type>::value value; };
template<typename type> struct addConstRef<const type> { typedef typename addConstRef<type>::value value; };
template<typename type> struct addConstRef<const type &> { typedef const type &value; };
template<> struct addConstRef<void> { typedef void value; };

namespace convertiblePrivate {
    struct TwoChar { char foo[2]; };
    template<typename to, typename from> struct impl
    {
        static from makeFrom();
        static TwoChar test(...);
        static    char test(to);
    };
}
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4244)  // possible loss of data
#pragma warning(disable: 4800)  // forcing value to bool true or false
#endif

template<typename to, typename from> struct convertible
{
private:
    typedef typename addConstRef<to>::value refTo;
    typedef typename addConstRef<from>::value refFrom;
    typedef convertiblePrivate::impl<refTo, refFrom> impl;
public:
    static const bool value=sizeof(impl::test(impl::makeFrom()))==sizeof(char);
};
template<typename T> struct convertible<void, T> { static const bool value=false; };
template<typename T> struct convertible<T, void> { static const bool value=false; };
template<> struct convertible<void, void> { static const bool value=true; };
#ifdef _MSC_VER
#pragma warning(pop)
#endif

template<typename ptr> struct lessIndir
{
    typedef ptr value;
    static const bool failed=true;
};
template<typename ptr> struct lessIndir<ptr *>
{
    typedef ptr value;
    static const bool failed=false;
};
template<typename ptr> struct lessIndir<const ptr *>
{
    typedef ptr value;
    static const bool failed=false;
};
template<typename ptr> struct lessIndir<volatile ptr *>
{
    typedef ptr value;
    static const bool failed=false;
};
template<typename ptr> struct lessIndir<const volatile ptr *>
{
    typedef ptr value;
    static const bool failed=false;
};
template<typename ptr> struct lessIndir<ptr &>
{
    typedef ptr value;
    static const bool failed=false;
};
template<typename ptr> struct lessIndir<const ptr &>
{
    typedef ptr value;
    static const bool failed=false;
};
template<typename ptr> struct lessIndir<volatile ptr &>
{
    typedef ptr value;
    static const bool failed=false;
};
template<typename ptr> struct lessIndir<const volatile ptr &>
{
    typedef ptr value;
    static const bool failed=false;
};
template<typename type> struct indirs { static const int value=0; };
template<typename type> struct indirs<type &> { static const int value=1+indirs<type>::value; };
template<typename type> struct indirs<const type &> { static const int value=1+indirs<type>::value; };
template<typename type> struct indirs<volatile type &> { static const int value=1+indirs<type>::value; };
template<typename type> struct indirs<const volatile type &> { static const int value=1+indirs<type>::value; };
template<typename type> struct indirs<type *> { static const int value=1+indirs<type>::value; };
template<typename type> struct indirs<const type *> { static const int value=1+indirs<type>::value; };
template<typename type> struct indirs<volatile type *> { static const int value=1+indirs<type>::value; };
template<typename type> struct indirs<const volatile type *> { static const int value=1+indirs<type>::value; };
template<typename ptr> struct leastIndir { typedef ptr value; };
template<typename ptr> struct leastIndir<ptr *> { typedef typename leastIndir<ptr>::value value; };
template<typename ptr> struct leastIndir<const ptr *> { typedef typename leastIndir<ptr>::value value; };
template<typename ptr> struct leastIndir<volatile ptr *> { typedef typename leastIndir<ptr>::value value; };
template<typename ptr> struct leastIndir<const volatile ptr *> { typedef typename leastIndir<ptr>::value value; };
template<typename ptr> struct leastIndir<ptr &> { typedef typename leastIndir<ptr>::value value; };
template<typename ptr> struct leastIndir<const ptr &> { typedef typename leastIndir<ptr>::value value; };
template<typename ptr> struct leastIndir<volatile ptr &> { typedef typename leastIndir<ptr>::value value; };
template<typename ptr> struct leastIndir<const volatile ptr &> { typedef typename leastIndir<ptr>::value value; };

#if defined(_MSC_VER) && _MSC_VER>=1400
namespace msvc_typeof_impl {
    /* This is a fusion of Igor Chesnokov's method (http://rsdn.ru/forum/src/1094305.aspx)
    and Steven Watanabe's method (http://lists.boost.org/Archives/boost/2006/12/115006.php)

    How it works:
    C++ allows template type inference for templated function parameters but nothing else.
    What we do is to pass the expression sent to typeof() into the templated function vartypeID()
    as its parameter, thus extracting its type. The big problem traditionally now is how to get
    that type out of the vartypeID() instance, and here's how we do it:
        1. unique_type_id() returns a monotonically increasing integer for every unique type
           passed to it during this compilation unit. It also specialises an instance of
           msvc_extract_type<unique_type_id, type>::id2type_impl<true>.
        2. vartypeID() returns a sized<unique_type_id> for the type where
           sizeof(sized<unique_type_id>)==unique_type_id. We vector through sized as a means
           of returning the unique_type_id at compile time rather than runtime.
        3. msvc_extract_type<unique_type_id> then extracts the type by using a bug in MSVC to
           reselect the specialised child type (id2type_impl<true>) from within the specialisation
           of itself originally performed by the above instance of unique_type_id. This bug works
           because when MSVC calculated the signature of the specialised
           msvc_extract_type<unique_type_id, type>::id2type_impl<true>, it does not include the
           value of type in the signature of id2type_impl<true>. Therefore when we reselect
           msvc_extract_type<unique_type_id>::id2type_impl<true> it erroneously returns the one
           already in its list of instantiated types rather than correctly generating a newly
           specialised msvc_extract_type<unique_type_id, msvc_extract_type_default_param>::id2type_impl<true>

    This bug allows the impossible and gives us a working typeof() in MSVC. Hopefully Microsoft
    won't fix this bug until they implement a native typeof.
    */

    struct msvc_extract_type_default_param {};
    template<int ID, typename T = msvc_extract_type_default_param> struct msvc_extract_type;

    template<int ID> struct msvc_extract_type<ID, msvc_extract_type_default_param>
    {
        template<bool> struct id2type_impl; 

        typedef id2type_impl<true> id2type; 
    };

    template<int ID, typename T> struct msvc_extract_type : msvc_extract_type<ID, msvc_extract_type_default_param> 
    { 
        template<> struct id2type_impl<true> //VC8.0 specific bugfeature 
        { 
            typedef T type; 
        }; 
        template<bool> struct id2type_impl; 

        typedef id2type_impl<true> id2type; 
    }; 


    template<int N> class CCounter;

    // TUnused is required to force compiler to recompile CCountOf class
    template<typename TUnused, int NTested = 0> struct CCountOf
    {
        enum
        {
            __if_exists(CCounter<NTested>) { count = CCountOf<TUnused, NTested + 1>::count }
            __if_not_exists(CCounter<NTested>) { count = NTested }
        };
    };

    template<class TTypeReg, class TUnused, int NValue> struct CProvideCounterValue { enum { value = NValue }; };

    // type_id
    #define unique_type_id(type) \
        (CProvideCounterValue< \
            /*register TYPE--ID*/ typename msvc_extract_type<CCountOf<type >::count, type>::id2type, \
            /*increment compile-time Counter*/ CCounter<CCountOf<type >::count>, \
            /*pass value of Counter*/CCountOf<type >::count \
         >::value)

    // Lets type_id() be > than 0
    class __Increment_type_id { enum { value = unique_type_id(__Increment_type_id) }; };

    // vartypeID() returns a type with sizeof(type_id)
    template<int NSize> class sized { char m_pad[NSize]; };
    template<typename T> typename sized<unique_type_id(T)> vartypeID(T&);
    template<typename T> typename sized<unique_type_id(const T)> vartypeID(const T&);
    template<typename T> typename sized<unique_type_id(volatile  T)> vartypeID(volatile T&);
    template<typename T> typename sized<unique_type_id(const volatile T)> vartypeID(const volatile T&);
}

#define typeof(expression) FX::Generic::msvc_typeof_impl::msvc_extract_type<sizeof(FX::Generic::msvc_typeof_impl::vartypeID(expression))>::id2type::type
#endif

class typeInfoBase
{
    FXString decorated, readable;
public:
    typeInfoBase() { }
    typeInfoBase(const type_info &ti) :
#ifdef _MSC_VER
        decorated(ti.raw_name()), readable(ti.name())
#elif defined(__GNUC__) || defined(__DMC__)
        decorated(ti.name()), readable(fxdemanglesymbol(ti.name()))
#else
#error Method of demangling RTTI unknown
#endif
        {
            assert(!decorated.empty());
        }
    bool operator!() const throw() { return !!decorated.empty(); }
    bool operator==(const typeInfoBase &o) const { return (decorated==o.decorated)!=0; }
    bool operator!=(const typeInfoBase &o) const { return (decorated!=o.decorated)!=0; }
    const FXString &name() const { return readable; }
    const FXString &mangled() const { return decorated; }
    FXString asIdentifier() const
    {
        FXString ret(readable);
        ret.substitute('<', '_'); ret.substitute('>', '_'); ret.substitute(',', '_'); ret.substitute(':', '_');
        return ret;
    }
    FXString asLeafIdentifier() const
    {
        FXint rpos=readable.rfind(':'); if(-1==rpos) rpos=readable.rfind(' ');
        FXString ret(readable.mid(rpos+1));
        return ret;
    }
    // These defined in fxutils.cpp
    friend FXAPI FXStream &operator<<(FXStream &s, const typeInfoBase &i);
    friend FXAPI FXStream &operator>>(FXStream &s, typeInfoBase &i);
};
template<typename type> class typeInfo : public typeInfoBase
{
public:
    typeInfo(const type_info &ti=typeid(type)) : typeInfoBase(ti) { }
};
template<typename type,
    template<class> class ownershipPolicy=FX::Pol::destructiveCopy>
class ptr : public ownershipPolicy<type>
{
    typedef ownershipPolicy<type> op;
public:
    ptr(type *data=0) : op(data) { }
    ptr(const ptr &o) : op(o) { }
    ptr &operator=(type *data) { PtrReset(*this, data); return *this; }
    type &operator *() { assert(PtrPtr(*this)); return *PtrPtr(*this); }
    const type &operator *() const { assert(PtrPtr(*this)); return *PtrPtr(*this); }
    type *operator->()
    {
        type *ret=PtrPtr(*this);
        if(!ret)
        {
            assert(ret);
        }
        return ret;
    }
    const type *operator->() const
    {
        const type *ret=PtrPtr(*this);
        if(!ret)
        {
            assert(ret);
        }
        return ret;
    }
    friend type *PtrRelease(ptr &p)
    {
        type *ret=PtrRef(p);
        PtrRef(p)=0;
        return ret;
    }
    friend void PtrReset(ptr &p, type *data)
    {
        p=ptr(data);
    }
    template<typename T> bool operator==(const ptr<T> &o) const { return PtrRef(*this)==PtrRef(o); }
    template<typename T> bool operator==(T *o) const { return PtrRef(*this)==o; }
    // Workaround to implement if(sp)
private:
    struct Tester
    {
    private:
        void operator delete(void *);
    };
public:
    operator Tester *() const
    {
        if(!*this) return 0;
        static Tester t;
        return &t;
    }

    // For if(!sp) 
    bool operator!() const { return PtrRef(*this)==0; }
    template<typename T> bool operator!=(const ptr<T> &o) const { return !(*this==o); }
    template<typename T> bool operator!=(T *o) const { return !(*this==o); }
};

namespace TL
{
    template<typename A, typename B> struct item
    {
        typedef A value;
        typedef B next;
    };
    template<typename T1 =NullType, typename T2 =NullType, typename T3 =NullType, typename T4 =NullType,
             typename T5 =NullType, typename T6 =NullType, typename T7 =NullType, typename T8 =NullType,
             typename T9 =NullType, typename T10=NullType, typename T11=NullType, typename T12=NullType,
             typename T13=NullType, typename T14=NullType, typename T15=NullType, typename T16=NullType>
    struct create
    {
    private:
        typedef typename create<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value temp;
    public:
        typedef item<T1, temp> value;
    };
    template<> struct create<> { typedef NullType value; };
    template<class typelist> struct length
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Not_A_TypeList);
    };
    template<> struct length<NullType> { static const int value=0; };
    template<class A, class B> struct length< item<A, B> >
    {
        static const int value=1+length<B>::value;
    };
    template<class typelist, FXuint idx> struct at { typedef NullType value; };
    template<class A, class B> struct at<item<A, B>, 0> { typedef A value; };
    template<class A, class B, FXuint idx> struct at<item<A, B>, idx>
    {
        typedef typename at<B, idx-1>::value value;
    };
    template<class typelist, FXuint idx> struct atC
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Out_Of_Bounds_Or_Not_A_TypeList);
    };
    template<class A, class B> struct atC<item<A, B>, 0> { typedef A value; };
    template<class A, class B, FXuint idx> struct atC<item<A, B>, idx>
    {
        typedef typename atC<B, idx-1>::value value;
    };
    template<class typelist, typename type> struct find
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Not_A_TypeList);
    };
    template<typename type> struct find<NullType, type> { static const int value=-1; };
    template<typename type, class next> struct find<item<type, next>, type> { static const int value=0; };
    template<typename A, class next, typename type> struct find<item<A, next>, type>
    {
    private:
        static const int temp=find<next, type>::value;
    public:
        static const int value=(temp==-1 ? -1 : 1+temp);
    };
    template<class typelist, typename type> struct findC
    {
        static const int value=find<typelist, type>::value;
    private:
        FXSTATIC_ASSERT2(value!=-1, ERROR_Type_Not_Found);
    };
    template<class typelist, typename type> struct findParent
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Not_A_TypeList);
    };
    template<typename type> struct findParent<NullType, type> { static const int value=-1; };
    template<typename type, class next> struct findParent<item<type, next>, type> { static const int value=0; };
    template<typename A, class next, typename type> struct findParent<item<A, next>, type>
    {
    private:
        static const bool isSubclass=convertible<A, type>::value;
        static const int temp=isSubclass ? 0 : findParent<next, type>::value;
    public:
        static const int value=(temp==-1 ? -1 : 1+temp-isSubclass);
    };
    template<class typelist, typename type> struct findParentC
    {
        static const int value=findParent<typelist, type>::value;
    private:
        FXSTATIC_ASSERT2(value!=-1, ERROR_Type_Not_Found);
    };
    template<class typelist, typename type> struct append
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Not_A_TypeList);
    };
    template<> struct append<NullType, NullType> { typedef NullType value; };
    template<typename type> struct append<NullType, type> { typedef typename create<type>::value value; };
    template<typename A, class next> struct append<NullType, item<A, next> >
    {
        typedef item<A, next> value;
    };
    template<typename A, class next, typename type> struct append<item<A,next>, type>
    {
        typedef item<A, typename append<next, type>::value> value;
    };
    template<class typelist, typename type> struct remove
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Not_A_TypeList);
    };
    template<typename type> struct remove<NullType, type> { typedef NullType value; };
    template<typename type, class next> struct remove<item<type, next>, type> { typedef next value; };
    template<typename A, class next, typename type> struct remove<item<A, next>, type>
    {
        typedef item<A, typename remove<next, type>::value> value;
    };
    namespace numberRangePrivate {
        template<int no, template<int> class instance, int top> struct Impl
        {
            typedef item<instance<top-no>, typename Impl<no-1, instance, top>::value> value;
        };
        template<template<int> class instance, int top> struct Impl<0, instance, top>
        {
            typedef NullType value;
        };
    }
    template<int no, template<int> class instance=IntToType> struct numberRange
    {
        typedef typename numberRangePrivate::Impl<no, instance, no>::value value;
    };
    template<typename typelist, template<class> class instance> struct apply
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Not_A_TypeList);
    };
    template<typename type, class next, template<class> class instance> struct apply<item<type, next>, instance>
    {
        typedef item<instance<type>, typename apply<next, instance>::value> value;
    };
    template<template<class> class instance> struct apply<NullType, instance>
    {
        typedef NullType value;
    };
    template<typename typelist, template<class> class filt> struct filter
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Not_A_TypeList);
    };
    template<typename type, class next, template<class> class filt> struct filter<item<type, next>, filt>
    {
    private:
        typedef typename filter<next, filt>::value nextfilter;
    public:
        typedef typename select<filt<type>::value, item<type, nextfilter>, nextfilter>::value value;
    };
    template<template<class> class filt> struct filter<NullType, filt>
    {
        typedef NullType value;
    };
    template<int no, typename type> struct replicate
    {
        typedef item<type, typename replicate<no-1, type>::value> value;
    };
    template<typename type> struct replicate<0, type>
    {
        typedef NullType value;
    };

#if defined(_MSC_VER)
#pragma warning(push)
// Disable silly warning about class inheriting off itself
#pragma warning(disable : 4584)
#endif // _MSC_VER

    template<typename type> struct instanceHolderH
    {
        type value;
        instanceHolderH() { }
        template<typename P1> instanceHolderH(P1 p1) : value(p1) { }
        template<typename P1, typename P2> instanceHolderH(P1 p1, P2 p2) : value(p1, p2) { }
        template<typename P1, typename P2, typename P3> instanceHolderH(P1 p1, P2 p2, P3 p3) : value(p1, p2, p3) { }
    };

    namespace Private
    {
        template<int idx, class instance> struct instanceHHolder : public instance
        {   // Hold an indexed instantiation of a typelist member
            instanceHHolder() : instance() { }
            template<typename P1> explicit instanceHHolder(P1 p1) : instance(p1) { }
            template<typename P1, typename P2> explicit instanceHHolder(P1 p1, P2 p2) : instance(p1, p2) { }
            template<typename P1, typename P2, typename P3> explicit instanceHHolder(P1 p1, P2 p2, P3 p3) : instance(p1, p2, p3) { }
        };
    }
    template<typename typelist, template<class> class instance=instanceHolderH, int idx=0> struct instantiateH
    {
        FXSTATIC_ASSERT2((Boolean<false, typelist>::value), ERROR_Not_A_TypeList);
    };
    template<typename type, class next, template<class> class instance, int idx> struct instantiateH<item<type, next>, instance, idx>
        : public Private::instanceHHolder<idx, instance<type> >, public instantiateH<next, instance, idx+1>
    {
        instantiateH() : Private::instanceHHolder<idx, instance<type> >(), instantiateH<next, instance, idx+1>() { }
        template<typename P1> explicit instantiateH(P1 p1)
            : Private::instanceHHolder<idx, instance<type> >(p1), instantiateH<next, instance, idx+1>(p1) { }
        template<typename P1, typename P2> explicit instantiateH(P1 p1, P2 p2)
            : Private::instanceHHolder<idx, instance<type> >(p1, p2), instantiateH<next, instance, idx+1>(p1, p2) { }
        template<typename P1, typename P2, typename P3> explicit instantiateH(P1 p1, P2 p2, P3 p3)
            : Private::instanceHHolder<idx, instance<type> >(p1, p2, p3), instantiateH<next, instance, idx+1>(p1, p2, p3) { }
    };
    template<template<class> class instance, int idx> struct instantiateH<NullType, instance, idx>
    {
        instantiateH() { }
        template<typename P1> explicit instantiateH(P1 p1) { }
        template<typename P1, typename P2> explicit instantiateH(P1 p1, P2 p2) { }
        template<typename P1, typename P2, typename P3> explicit instantiateH(P1 p1, P2 p2, P3 p3) { }
    };

    namespace Private
    {
        // TODO: volatile specialisations & instantiateV
        template<int i, class container> struct accessInstantiateH
        {
            FXSTATIC_ASSERT2((Boolean<false, container>::value), ERROR_Not_An_InstantiateH_Container);
        };
        template<int i, typename typelist, template<class> class instance> struct accessInstantiateH<i, instantiateH<typelist, instance, 0> >
        {
            typedef instance<typename atC<typelist, i>::value> IdxType;
            typedef instantiateH<typelist, instance, 0> containerType;
            static IdxType &Get(containerType &c)
            {
                return static_cast<instanceHHolder<i, IdxType> &>(c);
            }
        };
        template<int i, typename typelist, template<class> class instance> struct accessInstantiateH<i, const instantiateH<typelist, instance, 0> >
        {
            typedef instance<typename atC<typelist, i>::value> IdxTypeO;
            typedef const IdxTypeO IdxType;
            typedef const instantiateH<typelist, instance, 0> containerType;
            static IdxType &Get(const containerType &c)
            {
                return static_cast<const instanceHHolder<i, IdxTypeO> &>(c);
            }
        };
    }
    template<int i, class container> typename Private::accessInstantiateH<i, container>::IdxType &instance(container &c)
    {
        return Private::accessInstantiateH<i, container>::Get(c);
    }
#if defined(_MSC_VER)
#pragma warning(pop) 
#endif
}
#define FXTYPELIST1(P1) FX::Generic::TL::list<P1, FX::Generic::NullType>
#define FXTYPELIST2(P1,P2) FX::Generic::TL::list<P1, FXTYPELIST1(P2) >
#define FXTYPELIST3(P1,P2,P3) FX::Generic::TL::list<P1, FXTYPELIST2(P2,P3) >
#define FXTYPELIST4(P1,P2,P3,P4) FX::Generic::TL::list<P1, FXTYPELIST3(P2,P3,P4) >
#define FXTYPELIST5(P1,P2,P3,P4,P5) FX::Generic::TL::list<P1, FXTYPELIST4(P2,P3,P4,P5) >
#define FXTYPELIST6(P1,P2,P3,P4,P5,P6) FX::Generic::TL::list<P1, FXTYPELIST5(P2,P3,P4,P5,P6) >
#define FXTYPELIST7(P1,P2,P3,P4,P5,P6,P7) FX::Generic::TL::list<P1, FXTYPELIST6(P2,P3,P4,P5,P6,P7) >
#define FXTYPELIST8(P1,P2,P3,P4,P5,P6,P7,P8) FX::Generic::TL::list<P1, FXTYPELIST7(P2,P3,P4,P5,P6,P7,P8) >
#define FXTYPELIST9(P1,P2,P3,P4,P5,P6,P7,P8,P9) FX::Generic::TL::list<P1, FXTYPELIST8(P2,P3,P4,P5,P6,P7,P8,P9) >
#define FXTYPELIST10(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10) \
    FX::Generic::TL::list<P1, FXTYPELIST9(P2,P3,P4,P5,P6,P7,P8,P9,P10) >
#define FXTYPELIST11(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11) \
    FX::Generic::TL::list<P1, FXTYPELIST10(P2,P3,P4,P5,P6,P7,P8,P9,P10,P11) >
#define FXTYPELIST12(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12) \
    FX::Generic::TL::list<P1, FXTYPELIST11(P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12) >
#define FXTYPELIST13(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13) \
    FX::Generic::TL::list<P1, FXTYPELIST12(P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13) >
#define FXTYPELIST14(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14) \
    FX::Generic::TL::list<P1, FXTYPELIST13(P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14) >
#define FXTYPELIST15(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15) \
    FX::Generic::TL::list<P1, FXTYPELIST14(P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15) >
#define FXTYPELIST16(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16) \
    FX::Generic::TL::list<P1, FXTYPELIST15(P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16) >

template<typename fn> struct FnInfo
{
    typedef fn resultType;
    typedef NullType objectType;
    static const bool isConst=false;
    static const int arity=-1;
    typedef typename TL::create<resultType>::value asList;
};
template<typename R, typename O> struct FnInfo<R (O::*)()>
{
    typedef R resultType;
    typedef O objectType;
    static const bool isConst=false;
    static const int arity=0;
    typedef typename TL::create<resultType>::value asList;
};
template<typename R, typename O> struct FnInfo<R (O::*)() const>
{
    typedef R resultType;
    typedef O objectType;
    static const bool isConst=true;
    static const int arity=0;
    typedef typename TL::create<resultType>::value asList;
};
template<typename R> struct FnInfo<R (*)(void)>
{
    typedef R resultType;
    typedef NullType objectType;
    static const bool isConst=false;
    static const int arity=0;
    typedef typename TL::create<resultType>::value asList;
};
template<typename R, typename O, typename P1> struct FnInfo<R (O::*)(P1)>
{
    typedef R resultType;
    typedef O objectType;
    typedef P1 par1Type;
    static const bool isConst=false;
    static const int arity=1;
    typedef typename TL::create<resultType, par1Type>::value asList;
};
template<typename R, typename O, typename P1> struct FnInfo<R (O::*)(P1) const>
{
    typedef R resultType;
    typedef O objectType;
    typedef P1 par1Type;
    static const bool isConst=true;
    static const int arity=1;
    typedef typename TL::create<resultType, par1Type>::value asList;
};
template<typename R, typename P1> struct FnInfo<R (*)(P1)>
{
    typedef R resultType;
    typedef NullType objectType;
    typedef P1 par1Type;
    static const bool isConst=false;
    static const int arity=1;
    typedef typename TL::create<resultType, par1Type>::value asList;
};
template<typename R, typename O, typename P1, typename P2> struct FnInfo<R (O::*)(P1, P2)>
{
    typedef R resultType;
    typedef O objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    static const bool isConst=false;
    static const int arity=2;
    typedef typename TL::create<resultType, par1Type, par2Type>::value asList;
};
template<typename R, typename O, typename P1, typename P2> struct FnInfo<R (O::*)(P1, P2) const>
{
    typedef R resultType;
    typedef O objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    static const bool isConst=true;
    static const int arity=2;
    typedef typename TL::create<resultType, par1Type, par2Type>::value asList;
};
template<typename R, typename P1, typename P2> struct FnInfo<R (*)(P1, P2)>
{
    typedef R resultType;
    typedef NullType objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    static const bool isConst=false;
    static const int arity=2;
    typedef typename TL::create<resultType, par1Type, par2Type>::value asList;
};
template<typename R, typename O, typename P1, typename P2, typename P3> struct FnInfo<R (O::*)(P1, P2, P3)>
{
    typedef R resultType;
    typedef O objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    typedef P3 par3Type;
    static const bool isConst=false;
    static const int arity=3;
    typedef typename TL::create<resultType, par1Type, par2Type, par3Type>::value asList;
};
template<typename R, typename O, typename P1, typename P2, typename P3> struct FnInfo<R (O::*)(P1, P2, P3) const>
{
    typedef R resultType;
    typedef O objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    typedef P3 par3Type;
    static const bool isConst=true;
    static const int arity=3;
    typedef typename TL::create<resultType, par1Type, par2Type, par3Type>::value asList;
};
template<typename R, typename P1, typename P2, typename P3> struct FnInfo<R (*)(P1, P2, P3)>
{
    typedef R resultType;
    typedef NullType objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    typedef P3 par3Type;
    static const bool isConst=false;
    static const int arity=3;
    typedef typename TL::create<resultType, par1Type, par2Type, par3Type>::value asList;
};
template<typename R, typename O, typename P1, typename P2, typename P3, typename P4> struct FnInfo<R (O::*)(P1, P2, P3, P4)>
{
    typedef R resultType;
    typedef O objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    typedef P3 par3Type;
    typedef P4 par4Type;
    static const bool isConst=false;
    static const int arity=4;
    typedef typename TL::create<resultType, par1Type, par2Type, par3Type, par4Type>::value asList;
};
template<typename R, typename O, typename P1, typename P2, typename P3, typename P4> struct FnInfo<R (O::*)(P1, P2, P3, P4) const>
{
    typedef R resultType;
    typedef O objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    typedef P3 par3Type;
    typedef P4 par4Type;
    static const bool isConst=true;
    static const int arity=4;
    typedef typename TL::create<resultType, par1Type, par2Type, par3Type, par4Type>::value asList;
};
template<typename R, typename P1, typename P2, typename P3, typename P4> struct FnInfo<R (*)(P1, P2, P3, P4)>
{
    typedef R resultType;
    typedef NullType objectType;
    typedef P1 par1Type;
    typedef P2 par2Type;
    typedef P3 par3Type;
    typedef P4 par4Type;
    static const bool isConst=false;
    static const int arity=4;
    typedef typename TL::create<resultType, par1Type, par2Type, par3Type, par4Type>::value asList;
};
namespace FnFromListPrivate {
    template<typename list, int pars> struct impl;
    template<typename list> struct impl<list, 0> { typedef typename TL::at<list, 0>::value (*value)(); };
    template<typename list> struct impl<list, 1>
    { typedef typename TL::at<list, 0>::value (*value)(typename TL::at<list, 1>::value); };
    template<typename list> struct impl<list, 2>
    { typedef typename TL::at<list, 0>::value (*value)(typename TL::at<list, 1>::value, typename TL::at<list, 2>::value); };
    template<typename list> struct impl<list, 3>
    { typedef typename TL::at<list, 0>::value (*value)(typename TL::at<list, 1>::value, typename TL::at<list, 2>::value, typename TL::at<list, 3>::value); };
    template<typename list> struct impl<list, 4>
    { typedef typename TL::at<list, 0>::value (*value)(typename TL::at<list, 1>::value, typename TL::at<list, 2>::value, typename TL::at<list, 3>::value, typename TL::at<list, 4>::value); };
}
template<typename list> struct FnFromList
{
public:
    typedef typename FnFromListPrivate::impl<list, TL::length<list>::value-1>::value value;
};

struct IntegralLists
{
    typedef TL::create<unsigned char, FXushort, FXuint, unsigned long, FXulong>::value unsignedInts;
    typedef TL::create<signed char, FXshort, FXint, signed long, FXlong>::value signedInts;
    typedef TL::create<bool, char>::value otherInts;
    typedef TL::create<FXfloat, FXdouble>::value floats;

    typedef TL::append<TL::append<unsignedInts, signedInts>::value, otherInts>::value Ints;
    typedef TL::append<TL::append<unsignedInts, signedInts>::value, floats>::value Arithmetical;
    typedef TL::append<signedInts, floats>::value Signeds;
    typedef TL::append<Ints, floats>::value All;

    typedef TL::at<unsignedInts, 0>::value smallestUnsignedInt;
    typedef TL::at<signedInts,   0>::value smallestSignedInt;
    typedef TL::at<floats,       0>::value smallestFloat;
    typedef TL::at<unsignedInts, TL::length<unsignedInts>::value-1>::value biggestUnsignedInt;
    typedef TL::at<signedInts,   TL::length<signedInts>::value-1>::value biggestSignedInt;
    typedef TL::at<floats,       TL::length<floats>::value-1>::value biggestFloat;
};

template<typename type, bool minus=false> struct BiggestValue
{
protected:
    static const int UnsignedIntIdx=TL::find<IntegralLists::unsignedInts, type>::value;
    static const int SignedIntIdx  =TL::find<IntegralLists::signedInts, type>::value;
    static const int intIdx=(-1==UnsignedIntIdx) ? SignedIntIdx : UnsignedIntIdx;
    typedef typename TL::atC<IntegralLists::unsignedInts, intIdx>::value typeAsUnsigned;
    static const typeAsUnsigned maxUnsignedValue=(typeAsUnsigned)-1;
    static const typeAsUnsigned maxUnsignedValueL1=(typeAsUnsigned)((-1==UnsignedIntIdx) ? maxUnsignedValue<<1 : maxUnsignedValue);
    static const typeAsUnsigned maxSignedValue=(typeAsUnsigned)((-1==UnsignedIntIdx) ? maxUnsignedValueL1>>1 : maxUnsignedValue);
public:
    static const type value=(type)(minus ? ~maxSignedValue : maxSignedValue);
};
template<typename type, bool minus=false> struct SmallestValue : public BiggestValue<type, minus>
{
    static const type value=1;
};
template<typename type> struct SmallestValue<type, true> : public BiggestValue<type, true>
{
    static const type value=(BiggestValue<type, true>::UnsignedIntIdx==-1) ? -1 : 1;
};
#if defined(_MSC_VER) && _MSC_VER<=1400
// Sadly <=MSVC80 doesn't support static const <double|float>
namespace Impl { namespace
{
    template<typename type, bool minus> struct MSVCBiggestValue;
    template<typename type, bool minus> struct MSVCSmallestValue;
    template<> struct  MSVCBiggestValue<float, false> { static  float value; };
    template<> struct  MSVCBiggestValue<float, true>  { static  float value; };
    template<> struct  MSVCBiggestValue<double, false>{ static double value; };
    template<> struct  MSVCBiggestValue<double, true> { static double value; };
    template<> struct MSVCSmallestValue<float, false> { static  float value; };
    template<> struct MSVCSmallestValue<float, true>  { static  float value; };
    template<> struct MSVCSmallestValue<double, false>{ static double value; };
    template<> struct MSVCSmallestValue<double, true> { static double value; };
     float MSVCBiggestValue <float,  false>::value=3.402823466e+38F;
     float MSVCBiggestValue <float,  true>::value=-3.402823466e+38F;
    double MSVCBiggestValue <double, false>::value=1.7976931348623158e+308;
    double MSVCBiggestValue <double, true>::value=-1.7976931348623158e+308;
     float MSVCSmallestValue<float,  false>::value=1.175494351e-38F;
     float MSVCSmallestValue<float,  true>::value=-1.175494351e-38F;
    double MSVCSmallestValue<double, false>::value=2.2250738585072014e-308;
    double MSVCSmallestValue<double, true>::value=-2.2250738585072014e-308;
} }
template<bool minus> struct  BiggestValue<float,  minus> : public Impl::MSVCBiggestValue <float , minus> { };
template<bool minus> struct  BiggestValue<double, minus> : public Impl::MSVCBiggestValue <double, minus> { };
template<bool minus> struct SmallestValue<float,  minus> : public Impl::MSVCSmallestValue<float , minus> { };
template<bool minus> struct SmallestValue<double, minus> : public Impl::MSVCSmallestValue<double, minus> { };
#else
template<> struct FXAPI BiggestValue<float, false>
{
    static const float value;
};
template<> struct FXAPI BiggestValue<float, true>
{
    static const float value;
};
template<> struct FXAPI BiggestValue<double, false>
{
    static const double value;
};
template<> struct FXAPI BiggestValue<double, true>
{
    static const double value;
};

template<> struct FXAPI SmallestValue<float, false>
{
    static const float value;
};
template<> struct FXAPI SmallestValue<float, true>
{
    static const float value;
};
template<> struct FXAPI SmallestValue<double, false>
{
    static const double value;
};
template<> struct FXAPI SmallestValue<double, true>
{
    static const double value;
};
#endif

namespace ClassTraits
{
    struct POD;
    template<class T1=NullType> struct combine
    {
        typedef typename TL::create<T1>::value pars;
        static const bool PODness=TL::find<pars, POD>::value>=0;
    };
    template<class type> struct has : public combine<> { };
}
namespace TraitsHelper
{
    template<typename par> struct isVoidI { static const bool value=false; };
    template<> struct isVoidI<void> { static const bool value=true; };
    template<typename par> struct polyA : public par
    {
        char foo[64];
    };
    template<typename par> struct polyB : public par
    {
        char foo[64];
        virtual ~polyB() { }
    };
    template<bool isComplex, typename par> struct isPolymorphicI { static const bool value=false; };
    template<typename par> struct isPolymorphicI<true, par>
    {
        static const bool value=sizeof(polyA<par>)==sizeof(polyB<par>);
    };
}
template<typename type> class TraitsBasic
{
protected:
    template<typename par> struct isVoidI { static const bool value=TraitsHelper::isVoidI<par>::value; };
    template<typename par> struct isPtrI { static const bool value=false; };
    template<typename par> struct isPtrI<par *> { static const bool value=true; };
    template<typename par> struct isRefI { static const bool value=false; };
    template<typename par> struct isRefI<par &> { static const bool value=true; };
    template<typename par> struct isArrayI { static const bool value=false; };
    template<typename T, unsigned int len> struct isArrayI<T[len]> { static const bool value=true; };
    template<typename T, unsigned int len> struct isArrayI<T const[len]> { static const bool value=true; };
    template<typename T, unsigned int len> struct isArrayI<T volatile[len]> { static const bool value=true; };
    template<typename T, unsigned int len> struct isArrayI<T const volatile[len]> { static const bool value=true; };
    template<typename par> struct isConstI { static const bool value=false; };
    template<typename par> struct isConstI<const par> { static const bool value=true; };
    template<typename par> struct isVolatileI { static const bool value=false; };
    template<typename par> struct isVolatileI<volatile par> { static const bool value=true; };
    typedef FnInfo<type> fnInfo;
    template<bool wantConst, typename par> struct addConstI { typedef par value; };
    template<typename par> struct addConstI<true, par> { typedef const par value; };
public:
    static const bool isVoid=isVoidI<type>::value;
    static const bool isPtr=isPtrI<type>::value;
    static const bool isRef=isRefI<type>::value;
    static const bool isPtrToCode=fnInfo::arity>=0;
    static const bool isMemberPtr=isPtrToCode && !sameType<typename fnInfo::objectType, NullType>::value;
    static const bool isFunctionPtr=isPtrToCode && sameType<typename fnInfo::objectType, NullType>::value;
    static const bool isValue=!isPtr && !isRef && !isPtrToCode;
    static const bool isIndirect=!isValue;
    static const bool isConst=isConstI<type>::value;
    static const bool isVolatile=isVolatileI<type>::value;

    typedef typename leastIndir<type>::value baseType;
    static const bool isArray=isArrayI<baseType>::value;
    static const bool isFloat=TL::find<IntegralLists::floats, baseType>::value>=0;
    static const bool isInt=TL::find<IntegralLists::Ints, baseType>::value>=0;
    static const bool isSigned=TL::find<IntegralLists::Signeds, baseType>::value>=0;
    static const bool isUnsigned=TL::find<IntegralLists::unsignedInts, baseType>::value>=0;
    static const bool isArithmetical=TL::find<IntegralLists::Arithmetical, baseType>::value>=0;
    static const bool isIntegral=TL::find<IntegralLists::All, baseType>::value>=0;
    static const bool isBasic=isIntegral;
    static const bool holdsData=!isIntegral && !isPtrToCode;

    static const bool isPOD=isBasic || ClassTraits::has<type>::PODness;

    typedef typename select<isIntegral || isIndirect, type, typename addRef<type>::value >::value asRWParam;
    typedef typename addConstI<!isIntegral && !isRef, type>::value asConstParam;
private:
    typedef typename TL::create<asRWParam, asConstParam, typename addRef<asConstParam>::value>::value ROParams;
public:
    typedef typename TL::at<ROParams, ((isValue && isBasic) || isRef) ? 0 : (isIndirect) ? 1 : 2>::value asROParam;
};
template<typename type> class Traits : public TraitsBasic<type>
{
    enum TestEnum {};
    template<bool isCodePtr, typename par> struct isEnumSizeI { static const bool value=false; };
    template<typename par> struct isEnumSizeI<false, par> { static const bool value=sizeof(TestEnum)==sizeof(par); };
private:
    static const bool int_baseTypeIsVoid=TraitsHelper::isVoidI<typename TraitsBasic<type>::baseType>::value;
    static const bool int_isEnumSize=isEnumSizeI<TraitsBasic<type>::isPtrToCode || int_baseTypeIsVoid, typename TraitsBasic<type>::baseType>::value;
    static const bool int_isConvertibleToInt=!TraitsBasic<type>::isPtrToCode && convertible<int, typename TraitsBasic<type>::baseType>::value;
public:
    static const bool isEnum=TraitsBasic<type>::holdsData && !TraitsBasic<type>::isArray && int_isEnumSize && int_isConvertibleToInt;
    static const bool isPolymorphic=TraitsHelper::isPolymorphicI<TraitsBasic<type>::holdsData && !TraitsBasic<type>::isArray && !isEnum && !int_baseTypeIsVoid, typename TraitsBasic<type>::baseType>::value;
};




namespace FunctorHelper {
    template<typename parslist> struct ImplBaseBase
    {
        typedef typename TL::at<parslist, 0>::value R;
        typedef typename TL::at<parslist, 1>::value P1base;
        typedef typename TraitsBasic<P1base>::asROParam P1;
        typedef typename TL::at<parslist, 2>::value P2base;
        typedef typename TraitsBasic<P2base>::asROParam P2;
        typedef typename TL::at<parslist, 3>::value P3base;
        typedef typename TraitsBasic<P3base>::asROParam P3;
        typedef typename TL::at<parslist, 4>::value P4base;
        typedef typename TraitsBasic<P4base>::asROParam P4;
        virtual ~ImplBaseBase() { }
        virtual ImplBaseBase *copy() const=0;
    };
    template<typename parslist, int pars> struct ImplBaseOp;
    template<typename parslist> struct ImplBaseOp<parslist, 0> : public ImplBaseBase<parslist>
    {   virtual bool operator==(const ImplBaseOp &) const=0; virtual typename ImplBaseBase<parslist>::R operator()()=0; };
    template<typename parslist> struct ImplBaseOp<parslist, 1> : public ImplBaseBase<parslist>
    {   virtual bool operator==(const ImplBaseOp &) const=0; virtual typename ImplBaseBase<parslist>::R operator()(typename ImplBaseBase<parslist>::P1 p1)=0; };
    template<typename parslist> struct ImplBaseOp<parslist, 2> : public ImplBaseBase<parslist>
    {   virtual bool operator==(const ImplBaseOp &) const=0; virtual typename ImplBaseBase<parslist>::R operator()(typename ImplBaseBase<parslist>::P1 p1, typename ImplBaseBase<parslist>::P2 p2)=0; };
    template<typename parslist> struct ImplBaseOp<parslist, 3> : public ImplBaseBase<parslist>
    {   virtual bool operator==(const ImplBaseOp &) const=0; virtual typename ImplBaseBase<parslist>::R operator()(typename ImplBaseBase<parslist>::P1 p1, typename ImplBaseBase<parslist>::P2 p2, typename ImplBaseBase<parslist>::P3 p3)=0; };
    template<typename parslist> struct ImplBaseOp<parslist, 4> : public ImplBaseBase<parslist>
    {   virtual bool operator==(const ImplBaseOp &) const=0; virtual typename ImplBaseBase<parslist>::R operator()(typename ImplBaseBase<parslist>::P1 p1, typename ImplBaseBase<parslist>::P2 p2, typename ImplBaseBase<parslist>::P3 p3, typename ImplBaseBase<parslist>::P4 p4)=0; };

    template<typename parentfunctor, typename fn> class ImplFn : public parentfunctor::ImplBase
    {
        typedef typename parentfunctor::ImplBase::R  R;
        typedef typename parentfunctor::ImplBase::P1 P1;
        typedef typename parentfunctor::ImplBase::P2 P2;
        typedef typename parentfunctor::ImplBase::P3 P3;
        typedef typename parentfunctor::ImplBase::P4 P4;
        fn fnptr;
    public:
        ImplFn(fn _fnptr) : fnptr(_fnptr) { }
        ImplFn(const ImplFn &o) : fnptr(o.fnptr) { }
        ImplFn *copy() const { return new ImplFn(*this); }
        bool operator==(typename parentfunctor::ImplBase const &o) const { return fnptr==static_cast<const ImplFn &>(o).fnptr; }
        R operator()() { return fnptr(); }
        R operator()(P1 p1) { return fnptr(p1); }
        R operator()(P1 p1, P2 p2) { return fnptr(p1, p2); }
        R operator()(P1 p1, P2 p2, P3 p3) { return fnptr(p1, p2, p3); }
        R operator()(P1 p1, P2 p2, P3 p3, P4 p4) { return fnptr(p1, p2, p3, p4); }
    };
    template<typename parentfunctor, class obj, typename fn> class ImplMemFn : public parentfunctor::ImplBase
    {
        typedef typename parentfunctor::ImplBase::R  R;
        typedef typename parentfunctor::ImplBase::P1 P1;
        typedef typename parentfunctor::ImplBase::P2 P2;
        typedef typename parentfunctor::ImplBase::P3 P3;
        typedef typename parentfunctor::ImplBase::P4 P4;
        obj &objinst;
        fn fnptr;
    public:
        ImplMemFn(obj &_objinst, fn _fnptr) : objinst(_objinst), fnptr(_fnptr) { }
        ImplMemFn(const ImplMemFn &o) : objinst(o.objinst), fnptr(o.fnptr) { }
        ImplMemFn *copy() const { return new ImplMemFn(*this); }
        bool operator==(typename parentfunctor::ImplBase const &o) const { return &objinst==&static_cast<const ImplMemFn &>(o).objinst && fnptr==static_cast<const ImplMemFn &>(o).fnptr; }
        R operator()() { return (objinst.*fnptr)(); }
        R operator()(P1 p1) { return (objinst.*fnptr)(p1); }
        R operator()(P1 p1, P2 p2) { return (objinst.*fnptr)(p1, p2); }
        R operator()(P1 p1, P2 p2, P3 p3) { return (objinst.*fnptr)(p1, p2, p3); }
        R operator()(P1 p1, P2 p2, P3 p3, P4 p4) { return (objinst.*fnptr)(p1, p2, p3, p4); }
    };
}

template<typename parslist> class Functor
{
public: // Has to be public unfortunately so it can be inherited off
    typedef typename FunctorHelper::ImplBaseOp<parslist, TL::length<parslist>::value-1> ImplBase;
private:
    ImplBase *fnimpl;
    typedef typename FnFromList<parslist>::value ParsListAsFnType;
public:
    typedef parslist ParsList;
    typedef typename ImplBase::R  R;
    typedef typename ImplBase::P1 P1;
    typedef typename ImplBase::P2 P2;
    typedef typename ImplBase::P3 P3;
    typedef typename ImplBase::P4 P4;
    Functor() : fnimpl(0) { }
    template<typename fn> explicit Functor(fn fnptr) : fnimpl(0)
    { FXERRHM((fnimpl=new FunctorHelper::ImplFn<Functor, fn>(fnptr))); }
    template<typename obj, typename fn> Functor(obj &objinst, fn fnptr) : fnimpl(0)
    { FXERRHM((fnimpl=new FunctorHelper::ImplMemFn<Functor, obj, fn>(objinst, fnptr))); }
    template<typename obj, typename fn> Functor(obj *objinst, fn fnptr) : fnimpl(0)
    { FXERRHM((fnimpl=new FunctorHelper::ImplMemFn<Functor, obj, fn>(*objinst, fnptr))); }
    struct void_ {};
    Functor(void_ *fnptr) : fnimpl(0)
    { if(fnptr) FXERRHM((fnimpl=new FunctorHelper::ImplFn<Functor, ParsListAsFnType>((ParsListAsFnType) fnptr))); }
    explicit Functor(ImplBase *_fnimpl) : fnimpl(_fnimpl) { }
#ifndef HAVE_CPP0XRVALUEREFS
#ifdef HAVE_CONSTTEMPORARIES
    Functor(const Functor &other) : fnimpl(other.fnimpl)
    {
        Functor &o=const_cast<Functor &>(other);
#else
    Functor(Functor &o) : fnimpl(o.fnimpl)
    {
#endif
#else
private:
    Functor(const Functor &);       // disable copy constructor
public:
    Functor(Functor &&o) : fnimpl(std::move(o.fnimpl))
    {
#endif
        o.fnimpl=0;
    }
#ifndef HAVE_CPP0XRVALUEREFS
    Functor &operator=(Functor &o)
#else
    Functor &&operator=(Functor &&o)
#endif
    {
        FXDELETE(fnimpl);
        fnimpl=o.fnimpl;
        o.fnimpl=0;
        return *this;
    }
    ~Functor() { FXDELETE(fnimpl); }
    Functor copy() const
    {
        ImplBase *newimpl(static_cast<ImplBase *>(fnimpl->copy()));
        FXERRHM(newimpl);
        return Functor(newimpl);
    }
    bool operator==(const Functor &o) const { return *fnimpl==*o.fnimpl; }
    bool operator!=(const Functor &o) const { return !(*fnimpl==*o.fnimpl); }
    // Workaround to implement if(sp)
private:
    struct Tester
    {
    private:
        void operator delete(void *);
    };
public:
    operator Tester *() const
    {
        if(!*this) return 0;
        static Tester t;
        return &t;
    }
    // For if(!sp) 
    bool operator!() const { return !fnimpl; }
    R operator()() { return (*fnimpl)(); }
    R operator()(P1 p1) { return (*fnimpl)(p1); }
    R operator()(P1 p1, P2 p2) { return (*fnimpl)(p1, p2); }
    R operator()(P1 p1, P2 p2, P3 p3) { return (*fnimpl)(p1, p2, p3); }
    R operator()(P1 p1, P2 p2, P3 p3, P4 p4) { return (*fnimpl)(p1, p2, p3, p4); }
};
class BoundFunctorV
{
    virtual void callV()=0;
protected:
    BoundFunctorV() {}
    BoundFunctorV(const BoundFunctorV &) {}
    BoundFunctorV &operator=(const BoundFunctorV &) { return *this; }
public:
    virtual ~BoundFunctorV() { }
    void operator()() { callV(); }
};

template<typename parslist> class BoundFunctor : public BoundFunctorV
{
    typedef typename TL::at<parslist, 0>::value R;
    typedef typename TraitsBasic<typename TL::at<parslist, 1>::value>::asROParam P1;
    typedef typename TraitsBasic<typename TL::at<parslist, 2>::value>::asROParam P2;
    typedef typename TraitsBasic<typename TL::at<parslist, 3>::value>::asROParam P3;
    typedef typename TraitsBasic<typename TL::at<parslist, 4>::value>::asROParam P4;
    Functor<parslist> myfunctor;
    typedef typename parslist::next realparslist;
    TL::instantiateH<realparslist> parvals;
    // Stupid GCC won't permit explicit specialisation inside a class
    // and we can't partially specialise functions :(
    R call(IntToType<0>) { return myfunctor(); }
    R call(IntToType<1>) { return myfunctor(TL::instance<0>(parvals).value); }
    R call(IntToType<2>) { return myfunctor(TL::instance<0>(parvals).value, TL::instance<1>(parvals).value); }
    R call(IntToType<3>) { return myfunctor(TL::instance<0>(parvals).value, TL::instance<1>(parvals).value, TL::instance<2>(parvals).value); }
    R call(IntToType<4>) { return myfunctor(TL::instance<0>(parvals).value, TL::instance<1>(parvals).value, TL::instance<2>(parvals).value, TL::instance<3>(parvals).value); }
public:
    template<typename fn> BoundFunctor(fn fnptr, TL::instantiateH<realparslist> &_parvals)
        : myfunctor(fnptr), parvals(_parvals), BoundFunctorV() { }
    template<typename obj, typename fn> BoundFunctor(obj &objinst, fn fnptr, TL::instantiateH<realparslist> &_parvals)
        : myfunctor(objinst, fnptr), parvals(_parvals), BoundFunctorV() { }
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER<=800
    // Avoid usage of templated copy constructor (bug in ICC)
    BoundFunctor(const Functor<parslist> &_functor)
    {
        Functor<parslist> functor=_functor.copy();
        myfunctor=functor;
#else
    BoundFunctor(const Functor<parslist> &_functor) : myfunctor(_functor.copy())
    {
#endif
    }
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER<=800
    // Avoid usage of templated copy constructor (bug in ICC)
    BoundFunctor(const Functor<parslist> &_functor, P1 p1)
    {
        Functor<parslist> functor=_functor.copy();
        myfunctor=functor;
#else
    BoundFunctor(const Functor<parslist> &_functor, P1 p1) : myfunctor(_functor.copy())
    {
#endif
        TL::instance<0>(parvals).value=p1;
    }
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER<=800
    // Avoid usage of templated copy constructor (bug in ICC)
    BoundFunctor(const Functor<parslist> &_functor, P1 p1, P2 p2)
    {
        Functor<parslist> functor=_functor.copy();
        myfunctor=functor;
#else
    BoundFunctor(const Functor<parslist> &_functor, P1 p1, P2 p2) : myfunctor(_functor.copy())
    {
#endif
        TL::instance<0>(parvals).value=p1;
        TL::instance<1>(parvals).value=p2;
    }
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER<=800
    // Avoid usage of templated copy constructor (bug in ICC)
    BoundFunctor(const Functor<parslist> &_functor, P1 p1, P2 p2, P3 p3)
    {
        Functor<parslist> functor=_functor.copy();
        myfunctor=functor;
#else
    BoundFunctor(const Functor<parslist> &_functor, P1 p1, P2 p2, P3 p3) : myfunctor(_functor.copy())
    {
#endif
        TL::instance<0>(parvals).value=p1;
        TL::instance<1>(parvals).value=p2;
        TL::instance<2>(parvals).value=p3;
    }
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER<=800
    // Avoid usage of templated copy constructor (bug in ICC)
    BoundFunctor(const Functor<parslist> &_functor, P1 p1, P2 p2, P3 p3, P4 p4)
    {
        Functor<parslist> functor=_functor.copy();
        myfunctor=functor;
#else
    BoundFunctor(const Functor<parslist> &_functor, P1 p1, P2 p2, P3 p3, P4 p4) : myfunctor(_functor.copy())
    {
#endif
        TL::instance<0>(parvals).value=p1;
        TL::instance<1>(parvals).value=p2;
        TL::instance<2>(parvals).value=p3;
        TL::instance<3>(parvals).value=p4;
    }
    BoundFunctor(const BoundFunctor &o) : myfunctor(o.myfunctor.copy()), parvals(o.parvals), BoundFunctorV(o) { }
    BoundFunctor &operator=(const BoundFunctor &o)
    {
        myfunctor=o.myfunctor.copy();
        parvals=o.parvals;
        return *this;
    }
    Functor<parslist> &functor() { return myfunctor; }
    TL::instantiateH<realparslist> &parameters() { return parvals; }
    R operator()() { return call(IntToType<TL::length<parslist>::value-1>()); }
private:
    void callV() { (*this)(); }

    // MSVC compiles wrong code if these are defined :(
    //template<typename F> friend BoundFunctor<typename F::ParsList> BindFunctor(F &functor);
    //template<typename F> friend BoundFunctor<typename F::ParsList> *BindFunctorN(F &functor);
    //template<typename fn> friend BoundFunctor<typename FnInfo<fn>::asList> BindFunc(fn fnptr);
    //template<typename fn> friend BoundFunctor<typename FnInfo<fn>::asList> *BindFuncN(fn fnptr);
    //template<typename obj, typename fn> friend BoundFunctor<typename FnInfo<fn>::asList> BindObj(obj &objinst, fn fnptr);
    //template<typename obj, typename fn> friend BoundFunctor<typename FnInfo<fn>::asList> *BindObjN(obj &objinst, fn fnptr);
};
#ifdef DOXYGEN_SHOULD_SKIP_THIS

BoundFunctor BindFunctor(FX::Generic::Functor &functor [, par1 [, par2 ...]]);
BoundFunctor *BindFunctorN(FX::Generic::Functor &functor [, par1 [, par2 ...]]);
#else
template<typename F> BoundFunctor<typename F::ParsList>
    BindFunctor(F &functor)
{
    return BoundFunctor<typename F::ParsList>(functor);
}
template<typename F> BoundFunctor<typename F::ParsList> *
    BindFunctorN(F &functor)
{
    return new BoundFunctor<typename F::ParsList>(functor);
}
template<typename F> BoundFunctor<typename F::ParsList>
    BindFunctor(F &functor, typename TraitsBasic<typename F::P1>::asROParam p1)
{
    return BoundFunctor<typename F::ParsList>(functor, p1);
}
template<typename F> BoundFunctor<typename F::ParsList> *
    BindFunctorN(F &functor, typename TraitsBasic<typename F::P1>::asROParam p1)
{
    return new BoundFunctor<typename F::ParsList>(functor, p1);
}
template<typename F> BoundFunctor<typename F::ParsList>
    BindFunctor(F &functor, typename TraitsBasic<typename F::P1>::asROParam p1,
    typename TraitsBasic<typename F::P2>::asROParam p2)
{
    return BoundFunctor<typename F::ParsList>(functor, p1, p2);
}
template<typename F> BoundFunctor<typename F::ParsList> *
    BindFunctorN(F &functor, typename TraitsBasic<typename F::P1>::asROParam p1,
    typename TraitsBasic<typename F::P2>::asROParam p2)
{
    return new BoundFunctor<typename F::ParsList>(functor, p1, p2);
}
template<typename F> BoundFunctor<typename F::ParsList>
    BindFunctor(F &functor, typename TraitsBasic<typename F::P1>::asROParam p1,
    typename TraitsBasic<typename F::P2>::asROParam p2, typename TraitsBasic<typename F::P3>::asROParam p3)
{
    return BoundFunctor<typename F::ParsList>(functor, p1, p2, p3);
}
template<typename F> BoundFunctor<typename F::ParsList> *
    BindFunctorN(F &functor, typename TraitsBasic<typename F::P1>::asROParam p1,
    typename TraitsBasic<typename F::P2>::asROParam p2, typename TraitsBasic<typename F::P3>::asROParam p3)
{
    return new BoundFunctor<typename F::ParsList>(functor, p1, p2, p3);
}
template<typename F> BoundFunctor<typename F::ParsList>
    BindFunctor(F &functor, typename TraitsBasic<typename F::P1>::asROParam p1,
    typename TraitsBasic<typename F::P2>::asROParam p2, typename TraitsBasic<typename F::P3>::asROParam p3,
    typename TraitsBasic<typename F::P4>::asROParam p4)
{
    return BoundFunctor<typename F::ParsList>(functor, p1, p2, p3, p4);
}
template<typename F> BoundFunctor<typename F::ParsList> *
    BindFunctorN(F &functor, typename TraitsBasic<typename F::P1>::asROParam p1,
    typename TraitsBasic<typename F::P2>::asROParam p2, typename TraitsBasic<typename F::P3>::asROParam p3,
    typename TraitsBasic<typename F::P4>::asROParam p4)
{
    return new BoundFunctor<typename F::ParsList>(functor, p1, p2, p3, p4);
}
#endif
#ifdef DOXYGEN_SHOULD_SKIP_THIS

BoundFunctor<> BindFunc(functptr [, par1 [, par2 ...]]);
BoundFunctor<> BindFuncN(functptr [, par1 [, par2 ...]]);
BoundFunctor<> BindObj(obj &, memfunctptr [, par1 [, par2 ...]]);
BoundFunctor<> BindObjN(obj &, memfunctptr [, par1 [, par2 ...]]);
#else
namespace Bind {
    template<int pars, typename fn> struct Impl
    {
        typedef typename FnInfo<fn>::asList fnspec;
        TL::instantiateH<typename fnspec::next> parvals;
        void checkParms()
        {
            FXSTATIC_ASSERT(TL::length<fnspec>::value-1==pars, Function_Spec_Not_Equal_To_Parameters_Specified);
        }
        Impl() {}
        template<typename P1> Impl(P1 p1)
        {
            TL::instance<0>(parvals).value=p1;
        }
        template<typename P1, typename P2> Impl(P1 p1, P2 p2)
        {
            TL::instance<0>(parvals).value=p1;
            TL::instance<1>(parvals).value=p2;
        }
        template<typename P1, typename P2, typename P3> Impl(P1 p1, P2 p2, P3 p3)
        {
            TL::instance<0>(parvals).value=p1;
            TL::instance<1>(parvals).value=p2;
            TL::instance<2>(parvals).value=p3;
        }
        template<typename P1, typename P2, typename P3, typename P4> Impl(P1 p1, P2 p2, P3 p3, P4 p4)
        {
            TL::instance<0>(parvals).value=p1;
            TL::instance<1>(parvals).value=p2;
            TL::instance<2>(parvals).value=p3;
            TL::instance<3>(parvals).value=p4;
        }
    };
}
template<typename fn> BoundFunctor<typename FnInfo<fn>::asList>
    BindFunc(fn fnptr)
{
    typedef typename Bind::Impl<0, fn> Impl;
    Impl impl;
    return BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn> BoundFunctor<typename FnInfo<fn>::asList> *
    BindFuncN(fn fnptr)
{
    typedef typename Bind::Impl<0, fn> Impl;
    Impl impl;
    return new BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn, typename P1> BoundFunctor<typename FnInfo<fn>::asList>
    BindFunc(fn fnptr, P1 p1)
{
    typedef typename Bind::Impl<1, fn> Impl;
    Impl impl(p1);
    return BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn, typename P1> BoundFunctor<typename FnInfo<fn>::asList> *
    BindFuncN(fn fnptr, P1 p1)
{
    typedef typename Bind::Impl<1, fn> Impl;
    Impl impl(p1);
    return new BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn, typename P1, typename P2> BoundFunctor<typename FnInfo<fn>::asList>
    BindFunc(fn fnptr, P1 p1, P2 p2)
{
    typedef typename Bind::Impl<2, fn> Impl;
    Impl impl(p1, p2);
    return BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn, typename P1, typename P2> BoundFunctor<typename FnInfo<fn>::asList> *
    BindFuncN(fn fnptr, P1 p1, P2 p2)
{
    typedef typename Bind::Impl<2, fn> Impl;
    Impl impl(p1, p2);
    return new BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn, typename P1, typename P2, typename P3> BoundFunctor<typename FnInfo<fn>::asList>
    BindFunc(fn fnptr, P1 p1, P2 p2, P3 p3)
{
    typedef typename Bind::Impl<3, fn> Impl;
    Impl impl(p1, p2, p3);
    return BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn, typename P1, typename P2, typename P3> BoundFunctor<typename FnInfo<fn>::asList> *
    BindFuncN(fn fnptr, P1 p1, P2 p2, P3 p3)
{
    typedef typename Bind::Impl<3, fn> Impl;
    Impl impl(p1, p2, p3);
    return new BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn, typename P1, typename P2, typename P3, typename P4> BoundFunctor<typename FnInfo<fn>::asList>
    BindFunc(fn fnptr, P1 p1, P2 p2, P3 p3, P4 p4)
{
    typedef typename Bind::Impl<4, fn> Impl;
    Impl impl(p1, p2, p3, p4);
    return BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename fn, typename P1, typename P2, typename P3, typename P4> BoundFunctor<typename FnInfo<fn>::asList> *
    BindFuncN(fn fnptr, P1 p1, P2 p2, P3 p3, P4 p4)
{
    typedef typename Bind::Impl<3, fn> Impl;
    Impl impl(p1, p2, p3, p4);
    return new BoundFunctor<typename Impl::fnspec>(fnptr, impl.parvals);
}
template<typename obj, typename fn> BoundFunctor<typename FnInfo<fn>::asList>
    BindObj(obj &objinst, fn fnptr)
{
    typedef typename Bind::Impl<0, fn> Impl;
    Impl impl;
    return BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn> BoundFunctor<typename FnInfo<fn>::asList> *
    BindObjN(obj &objinst, fn fnptr)
{
    typedef typename Bind::Impl<0, fn> Impl;
    Impl impl;
    return new BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn, typename P1> BoundFunctor<typename FnInfo<fn>::asList>
    BindObj(obj &objinst, fn fnptr, P1 p1)
{
    typedef typename Bind::Impl<1, fn> Impl;
    Impl impl(p1);
    return BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn, typename P1> BoundFunctor<typename FnInfo<fn>::asList> *
    BindObjN(obj &objinst, fn fnptr, P1 p1)
{
    typedef typename Bind::Impl<1, fn> Impl;
    Impl impl(p1);
    return new BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn, typename P1, typename P2> BoundFunctor<typename FnInfo<fn>::asList>
    BindObj(obj &objinst, fn fnptr, P1 p1, P2 p2)
{
    typedef typename Bind::Impl<2, fn> Impl;
    Impl impl(p1, p2);
    return BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn, typename P1, typename P2> BoundFunctor<typename FnInfo<fn>::asList> *
    BindObjN(obj &objinst, fn fnptr, P1 p1, P2 p2)
{
    typedef typename Bind::Impl<2, fn> Impl;
    Impl impl(p1, p2);
    return new BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn, typename P1, typename P2, typename P3> BoundFunctor<typename FnInfo<fn>::asList>
    BindObj(obj &objinst, fn fnptr, P1 p1, P2 p2, P3 p3)
{
    typedef typename Bind::Impl<3, fn> Impl;
    Impl impl(p1, p2, p3);
    return BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn, typename P1, typename P2, typename P3> BoundFunctor<typename FnInfo<fn>::asList> *
    BindObjN(obj &objinst, fn fnptr, P1 p1, P2 p2, P3 p3)
{
    typedef typename Bind::Impl<3, fn> Impl;
    Impl impl(p1, p2, p3);
    return new BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn, typename P1, typename P2, typename P3, typename P4> BoundFunctor<typename FnInfo<fn>::asList>
    BindObj(obj &objinst, fn fnptr, P1 p1, P2 p2, P3 p3, P4 p4)
{
    typedef typename Bind::Impl<4, fn> Impl;
    Impl impl(p1, p2, p3, p4);
    return BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
template<typename obj, typename fn, typename P1, typename P2, typename P3, typename P4> BoundFunctor<typename FnInfo<fn>::asList> *
    BindObjN(obj &objinst, fn fnptr, P1 p1, P2 p2, P3 p3, P4 p4)
{
    typedef typename Bind::Impl<4, fn> Impl;
    Impl impl(p1, p2, p3, p4);
    return new BoundFunctor<typename Impl::fnspec>(objinst, fnptr, impl.parvals);
}
#endif

namespace TL
{
    namespace dynamicAtHelper
    {
        template<typename fnspeclist, typename typelist, template<class> class instance> struct Impl
        {
            typedef typename FnFromList<fnspeclist>::value fnspec;
            static fnspec getArray(FXuint idx)
            {
                FXSTATIC_ASSERT(length<typelist>::value<=16, DynamicAt_Maximum_Exceeded);
                typedef instance<NullType> nullinst;
                if(idx>=length<typelist>::value)
                    return &nullinst::Do;
                typedef typename apply<typelist, instance>::value instancedtypelist;
                typedef typename replicate<16-length<typelist>::value, instance<NullType> >::value instancedtypelistend;
                typedef typename append<instancedtypelist, instancedtypelistend>::value atypelist;

                static const fnspec mytable[16]={
                    &at<atypelist, 0>::value::Do,           &at<atypelist, 1>::value::Do,
                    &at<atypelist, 2>::value::Do,           &at<atypelist, 3>::value::Do,
                    &at<atypelist, 4>::value::Do,           &at<atypelist, 5>::value::Do,
                    &at<atypelist, 6>::value::Do,           &at<atypelist, 7>::value::Do,
                    &at<atypelist, 8>::value::Do,           &at<atypelist, 9>::value::Do,
                    &at<atypelist, 10>::value::Do,          &at<atypelist, 11>::value::Do,
                    &at<atypelist, 12>::value::Do,          &at<atypelist, 13>::value::Do,
                    &at<atypelist, 14>::value::Do,          &at<atypelist, 15>::value::Do
                    };
                return mytable[idx];
            }
        };
    }
    template<typename typelist, template<class> class instance> struct dynamicAt
    {
        static const FXuint MaxEntries=16;          
        static const FXuint DisableMagicIdx=1<<28;  

        dynamicAt(FXuint idx)
        {
            typedef typename create<void>::value parslist;
            if(DisableMagicIdx!=idx)
                dynamicAtHelper::Impl<parslist, typelist, instance>::getArray(idx)();
        }
        template<typename P1> dynamicAt(FXuint idx, P1 p1)
        {
            typedef typename create<void, P1>::value parslist;
            if(DisableMagicIdx!=idx)
                dynamicAtHelper::Impl<parslist, typelist, instance>::getArray(idx)(p1);
        }
        template<typename P1, typename P2> dynamicAt(FXuint idx, P1 p1, P2 p2)
        {
            typedef typename create<void, P1, P2>::value parslist;
            if(DisableMagicIdx!=idx)
                dynamicAtHelper::Impl<parslist, typelist, instance>::getArray(idx)(p1,p2);
        }
        template<typename P1, typename P2, typename P3> dynamicAt(FXuint idx, P1 p1, P2 p2, P3 p3)
        {
            typedef typename create<void, P1, P2, P3>::value parslist;
            if(DisableMagicIdx!=idx)
                dynamicAtHelper::Impl<parslist, typelist, instance>::getArray(idx)(p1,p2,p3);
        }
        template<typename P1, typename P2, typename P3, typename P4> dynamicAt(FXuint idx, P1 p1, P2 p2, P3 p3, P4 p4)
        {
            typedef typename create<void, P1, P2, P3, P4>::value parslist;
            if(DisableMagicIdx!=idx)
                dynamicAtHelper::Impl<parslist, typelist, instance>::getArray(idx)(p1,p2,p3,p4);
        }

    };
}

template<int len> struct MapBools
{
    FXSTATIC_ASSERT2(len<=sizeof(FXulong)*8, ERROR_Too_Many_Bools_To_Fit_Into_Integral_Type);
    typedef typename Generic::select<(len>sizeof(FXuchar)*8),
                typename Generic::select<(len>sizeof(FXushort)*8),
                    typename Generic::select<(len>sizeof(FXuint)*8),
                        FXulong,
                        FXuint>::value,
                    FXushort>::value,
                FXuchar>::value
            holdtype;
    bool *base;
    MapBools(const bool *_base) throw() : base(const_cast<bool *>(_base)) { }

    // Avoid variable bit shifts as they're slow on x86
    friend inline FXStream &operator<<(FXStream &s, const MapBools<len> i) throw()
    {
        holdtype val=0;
        for(int n=len-1; n>=0; n--)
        {
            val=(val<<1)|((FXuchar)i.base[n]);
        }
        s << val;
        return s;
    }
    friend inline FXStream &operator>>(FXStream &s, MapBools<len> i) throw()
    {
        holdtype val; s >> val;
        for(int n=0; n<len; n++)
        {
            i.base[n]=(bool)(val & 1); val>>=1;
        }
        return s;
    }
};

template<class obj=NullType, typename doaddr=NullType, typename undoaddr=NullType> class DoUndo
{
    bool done;
    obj *instance;
    doaddr doa;
    undoaddr undoa;
public:
    DoUndo(obj *_instance, doaddr _doa, undoaddr _undoa) : done(false), instance(_instance), doa(_doa), undoa(_undoa) { redo(); }
    ~DoUndo() { undo(); }
    void undo()
    {
        if(done)
        {
            (*instance.*undoa)();
            done=false;
        }
    }
    void redo()
    {
        if(!done)
        {
            (*instance.*doa)();
            done=true;
        }
    }
};
template<typename doaddr, typename undoaddr> class DoUndo<void, doaddr, undoaddr>
{
    bool done;
    doaddr doa;
    undoaddr undoa;
public:
    DoUndo(doaddr _doa, undoaddr _undoa) : done(false), doa(_doa), undoa(_undoa) { redo(); }
    ~DoUndo() { undo(); }
    void undo()
    {
        if(done)
        {
            (undoa)();
            done=false;
        }
    }
    void redo()
    {
        if(!done)
        {
            (doa)();
            done=true;
        }
    }
};
template<> class DoUndo<NullType, NullType, NullType>
{
    bool done;
    BoundFunctorV *do_, *undo_;
public:
    DoUndo(BoundFunctorV *_do_, BoundFunctorV *_undo_)
        : done(false), do_(_do_), undo_(_undo_) { redo(); }
    ~DoUndo() { undo(); FXDELETE(do_); FXDELETE(undo_); }
    void undo()
    {
        if(done)
        {
            (*undo_)();
            done=false;
        }
    }
    void redo()
    {
        if(!done)
        {
            (*do_)();
            done=true;
        }
    }
};

} // namespace

#define FXAutoPtr FX::Generic::ptr  // TODO: FIXME when templated typedefs get implemented

#if defined(WIN32) && defined(UNICODE)
template<size_t fastlen=2048> class FXUnicodify
{
    bool myIsPath;
    FXnchar stkbuff[fastlen], *mybuffer;
    FXAutoPtr<FXnchar> membuff;
    FXint bufflen;
    void doConv(const FXString &_str)
    {
        FXString str(_str);
        if(myIsPath)
        {
            str=FXPath::absolute(str);
            str.prepend("\\\\?\\");
            // Also all \ must be /
            str.substitute('/', '\\');
        }
        FXint strlen=str.length()+1;    // Outputted buffer will always be shorter than this
        if(strlen>sizeof(stkbuff))
            FXERRHM(membuff=mybuffer=new FXnchar[strlen]);
        else mybuffer=stkbuff;
        bufflen=utf2ncs(mybuffer, str.text(), strlen)*sizeof(FXnchar);
    }
public:
    FXUnicodify(bool isPath=false) : myIsPath(isPath), mybuffer(0), bufflen(0) { }
    FXUnicodify(const FXString &str, bool isPath=false) : myIsPath(isPath), mybuffer(0), bufflen(0) { doConv(str); }
    const FXnchar *buffer() const throw() { return mybuffer; }
    const FXnchar *buffer(const FXString &str) { if(!mybuffer) doConv(str); return mybuffer; }
    FXint length() const throw() { return bufflen; }
    FXint length(const FXString &str) { if(!mybuffer) doConv(str); return bufflen; }
};
#else
template<size_t fastlen=2048> class FXUnicodify
{
    const FXchar *mybuffer;
    FXint bufflen;
public:
    FXUnicodify(bool isPath=false) : mybuffer(0) { }
    FXUnicodify(const FXString &str, bool isPath=false) : mybuffer(str.text()), bufflen(str.length()) { }
    const FXchar *buffer() const throw() { return mybuffer; }
    const FXchar *buffer(const FXString &str) const throw() { return str.text(); }
    FXint length() const throw() { return bufflen; }
    FXint length(const FXString &str) const throw() { return str.length(); }
};
#endif

} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.