---

MultiMethod.h

Go to the documentation of this file.

#ifndef CLASSLIB_MULTIMETHOD_H
# define CLASSLIB_MULTIMETHOD_H

//<<<<<< INCLUDES                                                       >>>>>>

# include "classlib/utils/XTypeInfo.h"
# include "classlib/utils/PODVector.h"
# include "classlib/utils/Macros.h"

namespace lat {
//<<<<<< PUBLIC DEFINES                                                 >>>>>>

// Usage:
//   x.h:
//     MULTIMETHOD_DECLARE (extern API,Point,intersect,2,0,
//                          (Trajectory,Surface));
//   x.cc:
//     MULTIMETHOD_DEFINE (::, intersect);
//      NB: `::' because the multi-method is at global scope!
//
//   y.cc:
//     MMM_DEFUN_FUNC (Point,::,intersect,(Line *line, Plane *plane))
//     { Point p = /* use `line' and `plane' */; return p; }
//
//      NB: `::' is the scope of the multi-method, in this case global.
//
// or:
//   X.h:
//     class X {
//     public:
//        MULTIMETHOD_DECLARE(static,Point,intersect,2,0,(Trajectory,Surface));
//     };
//   X.cc:
//     MULTIMETHOD_DEFINE (X::,intersect);
//      NB: `X::' is the scope of the multi-method.
//
//   Y.h:
//     class Y : public X {
//     public: // <-- multimethod members *must* be public
//        static MMM_DECLARE (Point,intersect,(Line *,Plane *));
//     };
//   Y.cc:
//     MMM_DEFUN_METHOD(Point,X::,Y::,intersect, (Line *line, Plane *plane))
//     { Point p = /* use `line' and `plane' */; return p; }
//
//      NB: `X::' is the scope of the multi-method.  `Y::' is the
//          scope of the family member.

// All this would be so simple if we had GNU or ISO C 9x vararg macros...
#  define MULTIMETHOD_ARGS_1_0(V1)              V1
#  define MULTIMETHOD_ARGS_1_1(V1,A1)           V1,             A1
#  define MULTIMETHOD_ARGS_1_2(V1,A1,A2)        V1,             A1, A2
#  define MULTIMETHOD_ARGS_2_0(V1,V2)           V1, V2
#  define MULTIMETHOD_ARGS_2_1(V1,V2,A1)        V1, V2,         A1
#  define MULTIMETHOD_ARGS_2_2(V1,V2,A1,A2)     V1, V2,         A1, A2
#  define MULTIMETHOD_ARGS_3_0(V1,V2,V3)        V1, V2, V3
#  define MULTIMETHOD_ARGS_3_1(V1,V2,V3,A1)     V1, V2, V3,     A1
#  define MULTIMETHOD_ARGS_3_2(V1,V2,V3,A1,A2)  V1, V2, V3,     A1, A2

#  define MULTIMETHOD_DECLARE(ext,rettype,name,nvirt,nnonvirt,args)     \
    ext lat::MultiMethod::Definition name ## Def;                       \
    typedef lat::MultiMethod_##nvirt##_##nnonvirt<                      \
      rettype, MULTIMETHOD_ARGS_##nvirt##_##nnonvirt args               \
    > name##Type;                                                       \
    ext name##Type name

#  define MULTIMETHOD_DEFINE(scope,name)                                \
    lat::MultiMethod::Definition scope name ## Def =            \
      { #name, 0, false, false, 0, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0, 0 };  \
    scope name ## Type scope name (&name ##Def)

#  define MMM_SYM(pre,line,post)                CLASSLIB_name3(pre,line,post)
#  define MMM_DECLARE(ret,name,proto)           ret mmm_##name proto
#  define MMM_DECLARE_STUB(mscope,scope,name,proto,regsym)              \
    static lat::MultiMethodMember< mscope name##Type,proto,     \
        &scope mmm_##name, &mscope name##Def> regsym
#  define MMM_DEFUN_METHOD(ret,mscope,scope,name,proto)                 \
    MMM_DECLARE_STUB(mscope,scope,name,ret (*) proto,                   \
                     MMM_SYM(name,Init,__LINE__));                      \
    ret scope mmm_##name proto
#  define MMM_DEFUN_FUNC(ret,mscope,name,proto)                         \
    ret mmm_##name proto;                                               \
    MMM_DECLARE_STUB(mscope,::,name,ret (*) proto,                      \
                     MMM_SYM(name,Init,__LINE__));                      \
    ret mmm_##name proto

//<<<<<< PUBLIC CONSTANTS                                               >>>>>>
//<<<<<< PUBLIC TYPES                                                   >>>>>>
//<<<<<< PUBLIC VARIABLES                                               >>>>>>
//<<<<<< PUBLIC FUNCTIONS                                               >>>>>>
//<<<<<< CLASS DECLARATIONS                                             >>>>>>

class MultiMethod : protected XTypeInfo::Monitor
{
public:
    struct Definition;
#if ! HAVE_BROKEN_CLASS_ACCESS
protected:
#endif
    struct Score;
#if ! HAVE_BROKEN_CLASS_ACCESS
private:
#endif
    struct Member;
    struct ScoreHunk;
    struct EntryHunk;
    struct Entry;

    friend struct Definition;
    friend struct Member;
    friend struct ScoreHunk;
    friend struct EntryHunk;
    friend struct Entry;
public:
    typedef void (*MemberFunction) (void);

    struct Definition
    {
        const char              *m_name;

        STDC::size_t            m_key;

        bool                    m_hooked;

        bool                    m_dirty;

        STDC::size_t            m_generation;

        STDC::size_t            m_formals;

        XTypeInfo::ClassDef     **m_formalTypes;


        PODVector<Member>::Data m_family;

        STDC::size_t            m_familyMaxSize;

        STDC::size_t            m_familyMaxCapacity;

        ScoreHunk               *m_scoreHunks;

        EntryHunk               *m_entryHunks;

        Entry                   *m_freeEntries;

        void                    extend (MemberFunction function,
                                        XTypeInfo::ClassDef **formalTypes);
        void                    remove (MemberFunction function);
    };

#if ! HAVE_BROKEN_CLASS_ACCESS
protected:
#endif

    struct Score
    {
        unsigned short          m_distance;

        unsigned short          m_index;
    };

    MultiMethod (void);
    ~MultiMethod (void);
    
    void                        initialise (Definition *data,
                                            STDC::size_t formals,
                                            XTypeInfo::ClassDef **formalTypes);

    MemberFunction              dispatch (XTypeInfo **actualTypes,
                                          Score **candidates,
                                          Score *best) const;

#if ! HAVE_BROKEN_CLASS_ACCESS
private:
#endif

    enum { INITIAL_FAMILY_SIZE = 32 };          // FIXME: STDC::size_t

    enum { SCORE_HUNK_SIZE = 64 };              // FIXME: STDC::size_t

    enum { ENTRY_HUNK_SIZE = 32 };              // FIXME: STDC::size_t

    enum { LAST_SCORE = USHRT_MAX };            // FIXME: unsigned short

    enum { INFINITE_DISTANCE = USHRT_MAX };     // FIXME: unsigned short

    struct Member
    {
        MemberFunction          m_function;
        XTypeInfo::ClassDef     **m_formalTypes;
    };

    struct ScoreHunk
    {
        ScoreHunk               *m_next;        //< Next hunk
        Score                   *m_scores;      //< The score vector
        Score                   *m_free;        //< List of free scores
        STDC::size_t            m_capacity;     //< Number of scores allocated
    };

    struct EntryHunk
    {
        EntryHunk               *m_next;        //< Next hunk
        Entry                   *m_entries;     //< The entry vector
        Entry                   *m_free;        //< List of free entries
        STDC::size_t            m_capacity;     //< Number of entries allocated
    };

    struct Entry
    {
        Entry                   *m_next;

        STDC::size_t            m_key;

        STDC::size_t            m_formal;

        STDC::size_t            m_generation;

        Score                   *m_scores;
    };

    // global data
    static XTypeInfo::ExtensionKey
                                extensionKey (void);
    static STDC::size_t         methodKey (void);

    // memory management
    ScoreHunk *                 createScoreHunk (STDC::size_t min) const;
    void                        freeScoreHunks (void) const;
    Score *                     allocateScores (STDC::size_t n) const;

    EntryHunk *                 createEntryHunk (void) const;
    void                        freeEntryHunks (void) const;
    Entry *                     allocateEntry (void) const;
    void                        freeEntry (Entry *item) const;

    // dynamic type management
    STDC::size_t                relatedFormal (const XTypeInfo *type) const;
    static Entry *              findTypeEntries (const XTypeInfo *type,
                                                 Entry *&previous,
                                                 STDC::size_t key,
                                                 STDC::size_t formal
                                                 = STDC::size_t(-1));

    void                        typePrepare (STDC::size_t formal,
                                             XTypeInfo *type) const;
    bool                        typeClean (STDC::size_t formal,
                                           XTypeInfo *type) const;
    virtual void                typeHook (XTypeInfo *type);
    virtual void                typeUnhook (XTypeInfo *type);

    static bool                 orderScores (const Score &x, const Score &y);
    void                        cleanScores (const XTypeInfo *type) const;
    void                        buildScores (const XTypeInfo *type) const;
    void                        newGeneration (void) const;
    void                        regenerate (const XTypeInfo *type) const;

    // dispatching
    void                        noViableAlt (XTypeInfo **actuals) const;
    void                        ambiguity (XTypeInfo **actuals,
                                           Score **candidates,
                                           Score *best) const;

    // actual data members -- forwarded
    Definition                  *m_data;

    // undefined, no semantics
    MultiMethod (const MultiMethod &);
    MultiMethod &operator= (const MultiMethod &);
};

// Classes for the real multi-methods the user will end up declaring;
// see MULTIMETHOD_DECLARE on how these end up getting used.  These
// classes know the actual arguments used for that specific method,
// and take care of initialising the method.  They also record just
// enough information for the black magic below to recover enough
// details when members for this family are registered.
template <class R, class V1>
class MultiMethod_1_0 : public MultiMethod
{
public:
    static const int    NVIRT = 1;
    static const int    NNONVIRT = 0;
    typedef R           RTYPE;
    typedef V1          VTYPE1;

    MultiMethod_1_0 (Definition *def);
    R operator() (V1 *v1);

private:
    XTypeInfo::ClassDef *m_formals [1];
};

template <class R, class V1, class T1>
class MultiMethod_1_1 : public MultiMethod
{
public:
    static const int    NVIRT = 1;
    static const int    NNONVIRT = 1;
    typedef R           RTYPE;
    typedef V1          VTYPE1;
    typedef T1          NONVTYPE1;

    MultiMethod_1_1 (Definition *def);
    R operator() (V1 *v1, T1 t1);

private:
    XTypeInfo::ClassDef *m_formals [1];
};

template <class R, class V1, class T1, class T2>
class MultiMethod_1_2 : public MultiMethod
{
public:
    static const int    NVIRT = 1;
    static const int    NNONVIRT = 2;
    typedef R           RTYPE;
    typedef V1          VTYPE1;
    typedef T1          NONVTYPE1;
    typedef T2          NONVTYPE2;

    MultiMethod_1_2 (Definition *def);
    R operator() (V1 *v1, T1 t1, T2 t2);

private:
    XTypeInfo::ClassDef *m_formals [1];
};

template <class R, class V1, class V2>
class MultiMethod_2_0 : public MultiMethod
{
public:
    static const int    NVIRT = 2;
    static const int    NNONVIRT = 0;
    typedef R           RTYPE;
    typedef V1          VTYPE1;
    typedef V2          VTYPE2;

    MultiMethod_2_0 (Definition *def);
    R operator() (V1 *v1, V2 *v2);

private:
    XTypeInfo::ClassDef *m_formals [2];
};

template <class R, class V1, class V2, class T1>
class MultiMethod_2_1 : public MultiMethod
{
public:
    static const int    NVIRT = 2;
    static const int    NNONVIRT = 1;
    typedef R           RTYPE;
    typedef V1          VTYPE1;
    typedef V2          VTYPE2;
    typedef T1          NONVTYPE1;

    MultiMethod_2_1 (Definition *def);
    R operator() (V1 *v1, V2 *v2, T1 t1);

private:
    XTypeInfo::ClassDef *m_formals [2];
};

template <class R, class V1, class V2, class T1, class T2>
class MultiMethod_2_2 : public MultiMethod
{
public:
    static const int    NVIRT = 2;
    static const int    NNONVIRT = 2;
    typedef R           RTYPE;
    typedef V1          VTYPE1;
    typedef V2          VTYPE2;
    typedef T1          NONVTYPE1;
    typedef T2          NONVTYPE2;

    MultiMethod_2_2 (Definition *def);
    R operator() (V1 *v1, V2 *v2, T1 t1, T2 t2);

private:
    XTypeInfo::ClassDef *m_formals [2];
};

template <class R, class V1, class V2, class V3>
class MultiMethod_3_0 : public MultiMethod
{
public:
    static const int    NVIRT = 3;
    static const int    NNONVIRT = 0;
    typedef R           RTYPE;
    typedef V1          VTYPE1;
    typedef V2          VTYPE2;
    typedef V3          VTYPE3;

    MultiMethod_3_0 (Definition *def);
    R operator() (V1 *v1, V2 *v2, V3 *v3);

private:
    XTypeInfo::ClassDef *m_formals [3];
};

template <class R, class V1, class V2, class V3, class T1>
class MultiMethod_3_1 : public MultiMethod
{
public:
    static const int    NVIRT = 3;
    static const int    NNONVIRT = 1;
    typedef R           RTYPE;
    typedef V1          VTYPE1;
    typedef V2          VTYPE2;
    typedef V3          VTYPE3;
    typedef T1          NONVTYPE1;

    MultiMethod_3_1 (Definition *def);
    R operator() (V1 *v1, V2 *v2, V3 *v3, T1 t1);

private:
    XTypeInfo::ClassDef *m_formals [3];
};

template <class R, class V1, class V2, class V3, class T1, class T2>
class MultiMethod_3_2 : public MultiMethod
{
public:
    static const int    NVIRT = 3;
    static const int    NNONVIRT = 2;
    typedef R           RTYPE;
    typedef V1          VTYPE1;
    typedef V2          VTYPE2;
    typedef V3          VTYPE3;
    typedef T1          NONVTYPE1;
    typedef T2          NONVTYPE2;

    MultiMethod_3_2 (Definition *def);
    R operator() (V1 *v1, V2 *v2, V3 *v3, T1 t1, T2 t2);

private:
    XTypeInfo::ClassDef *m_formals [3];
};


template <int NV, int NNV, class M, class R, class P> class MultiMethodCarrier {};

template <class M, class P, P F, MultiMethod::Definition *D>
struct MultiMethodMember {
    typedef MultiMethodCarrier<M::NVIRT, M::NNONVIRT, M, typename M::RTYPE, P> Carrier;
    MultiMethodMember (void)  { MultiMethodStub ((Carrier *)0)->init(D,F); }
    ~MultiMethodMember (void) { MultiMethodStub ((Carrier *)0)->reset(D); }
};

// classes for internal template magic ugliness; see MultiMethodStub
// and MultiMethodMember for the details on how these are used.
template <class M, class V1>
struct MultiMethodMemberStub_1_0 {
    typedef typename M::RTYPE (*F) (V1 *);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT] = { xtypedata(V1) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1)
        { return s_f (dynamic_cast<V1 *> (v1)); }
};

template <class M, class V1>
struct MultiMethodMemberStub_1_1 {
    typedef typename M::RTYPE (*F) (V1 *, typename M::NONVTYPE1);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT] = { xtypedata(V1) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1,
                                   typename M::NONVTYPE1 a1)
        { return s_f (dynamic_cast<V1 *> (v1), a1); }
};

template <class M, class V1>
struct MultiMethodMemberStub_1_2 {
    typedef typename M::RTYPE (*F) (V1 *, typename M::NONVTYPE1,
                                    typename M::NONVTYPE2);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT] = { xtypedata(V1) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1,
                                   typename M::NONVTYPE1 a1,
                                   typename M::NONVTYPE2 a2)
        { return s_f (dynamic_cast<V1 *> (v1), a1, a2); }
};

template <class M, class V1, class V2>
struct MultiMethodMemberStub_2_0 {
    typedef typename M::RTYPE (*F) (V1 *, V2 *);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT]
              = { xtypedata(V1), xtypedata(V2) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1,
                                   typename M::VTYPE2 *v2)
        { return s_f (dynamic_cast<V1 *> (v1), dynamic_cast<V2 *> (v2)); }
};

template <class M, class V1, class V2>
struct MultiMethodMemberStub_2_1 {
    typedef typename M::RTYPE (*F) (V1 *, V2 *, typename M::NONVTYPE1);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT]
              = { xtypedata(V1), xtypedata(V2) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1,
                                   typename M::VTYPE2 *v2,
                                   typename M::NONVTYPE1 a1)
        { return s_f (dynamic_cast<V1 *> (v1), dynamic_cast<V2 *> (v2), a1); }
};

template <class M, class V1, class V2>
struct MultiMethodMemberStub_2_2 {
    typedef typename M::RTYPE (*F) (V1 *, V2 *, typename M::NONVTYPE1,
                                    typename M::NONVTYPE2);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT]
              = { xtypedata(V1), xtypedata(V2) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1,
                                   typename M::VTYPE2 *v2,
                                   typename M::NONVTYPE1 a1,
                                   typename M::NONVTYPE2 a2)
        { return s_f (dynamic_cast<V1 *> (v1), dynamic_cast<V2 *> (v2),
                      a1, a2); }
};

template <class M, class V1, class V2, class V3>
struct MultiMethodMemberStub_3_0 {
    typedef typename M::RTYPE (*F) (V1 *, V2 *, V3 *);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT]
              = { xtypedata(V1), xtypedata(V2), xtypedata(V3) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1,
                                   typename M::VTYPE2 *v2,
                                   typename M::VTYPE3 *v3)
        { return s_f (dynamic_cast<V1 *> (v1), dynamic_cast<V2 *> (v2),
                      dynamic_cast<V3 *> (v3)); }
};

template <class M, class V1, class V2, class V3>
struct MultiMethodMemberStub_3_1 {
    typedef typename M::RTYPE (*F) (V1 *, V2 *, V3 *, typename M::NONVTYPE1);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT]
              = { xtypedata(V1), xtypedata(V2), xtypedata(V3) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1,
                                   typename M::VTYPE2 *v2,
                                   typename M::VTYPE3 *v3,
                                   typename M::NONVTYPE1 a1)
        { return s_f (dynamic_cast<V1 *> (v1), dynamic_cast<V2 *> (v2),
                      dynamic_cast<V3 *> (v3), a1); }
};

template <class M, class V1, class V2, class V3>
struct MultiMethodMemberStub_3_2 {
    typedef typename M::RTYPE (*F) (V1 *, V2 *, V3 *, typename M::NONVTYPE1,
                                    typename M::NONVTYPE2);
    static F s_f;
    static void init (MultiMethod::Definition *d, F f)
        { static XTypeInfo::ClassDef *actuals [M::NVIRT]
              = { xtypedata(V1), xtypedata(V2), xtypedata(V3) };
          s_f = f; d->extend ((MultiMethod::MemberFunction) &stub, actuals); }
    static void reset (MultiMethod::Definition *d)
        { d->remove ((MultiMethod::MemberFunction) &stub); }
    static typename M::RTYPE stub (typename M::VTYPE1 *v1,
                                   typename M::VTYPE2 *v2,
                                   typename M::VTYPE3 *v3,
                                   typename M::NONVTYPE1 a1,
                                   typename M::NONVTYPE2 a2)
        { return s_f (dynamic_cast<V1 *> (v1), dynamic_cast<V2 *> (v2),
                      dynamic_cast<V3 *> (v3), a1, a2); }
};

template <class M, class V1>
typename MultiMethodMemberStub_1_0<M,V1>::F
MultiMethodMemberStub_1_0<M,V1>::s_f = 0;
template <class M, class V1>
typename MultiMethodMemberStub_1_1<M,V1>::F
MultiMethodMemberStub_1_1<M,V1>::s_f = 0;
template <class M, class V1>
typename MultiMethodMemberStub_1_2<M,V1>::F
MultiMethodMemberStub_1_2<M,V1>::s_f = 0;

template <class M, class V1, class V2>
typename MultiMethodMemberStub_2_0<M,V1,V2>::F
MultiMethodMemberStub_2_0<M,V1,V2>::s_f = 0;
template <class M, class V1, class V2>
typename MultiMethodMemberStub_2_1<M,V1,V2>::F
MultiMethodMemberStub_2_1<M,V1,V2>::s_f = 0;
template <class M, class V1, class V2>
typename MultiMethodMemberStub_2_2<M,V1,V2>::F
MultiMethodMemberStub_2_2<M,V1,V2>::s_f = 0;

template <class M, class V1, class V2, class V3>
typename MultiMethodMemberStub_3_0<M,V1,V2,V3>::F
MultiMethodMemberStub_3_0<M,V1,V2,V3>::s_f = 0;
template <class M, class V1, class V2, class V3>
typename MultiMethodMemberStub_3_1<M,V1,V2,V3>::F
MultiMethodMemberStub_3_1<M,V1,V2,V3>::s_f = 0;
template <class M, class V1, class V2, class V3>
typename MultiMethodMemberStub_3_2<M,V1,V2,V3>::F
MultiMethodMemberStub_3_2<M,V1,V2,V3>::s_f = 0;

//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
//<<<<<< INLINE MEMBER FUNCTIONS                                        >>>>>>

template <class R, class V1>
inline
MultiMethod_1_0<R,V1>::MultiMethod_1_0 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    initialise (def, 1, m_formals);
}

template <class R, class V1>
inline R
MultiMethod_1_0<R,V1>::operator() (V1 *v1)
{
    XTypeInfo           *actuals [1] = { xtypeid (*v1) };
    Score               *candidates [1];
    Score               best [1];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *)> (match))
        (v1);
}


template <class R, class V1, class T1>
inline
MultiMethod_1_1<R,V1,T1>::MultiMethod_1_1 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    initialise (def, 1, m_formals);
}

template <class R, class V1, class T1>
inline R
MultiMethod_1_1<R,V1,T1>::operator() (V1 *v1, T1 t1)
{
    XTypeInfo           *actuals [1] = { xtypeid (*v1) };
    Score               *candidates [1];
    Score               best [1];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *, T1)> (match))
        (v1, t1);
}

template <class R, class V1, class T1, class T2>
inline
MultiMethod_1_2<R,V1,T1,T2>::MultiMethod_1_2 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    initialise (def, 1, m_formals);
}

template <class R, class V1, class T1, class T2>
inline R
MultiMethod_1_2<R,V1,T1,T2>::operator() (V1 *v1, T1 t1, T2 t2)
{
    XTypeInfo           *actuals [1] = { xtypeid (*v1) };
    Score               *candidates [1];
    Score               best [1];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *, T1, T2)> (match))
        (v1, t1, t2);
}

template <class R, class V1, class V2>
inline
MultiMethod_2_0<R,V1,V2>::MultiMethod_2_0 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    m_formals [1] = xtypedata (V2);
    initialise (def, 2, m_formals);
}

template <class R, class V1, class V2>
inline R
MultiMethod_2_0<R,V1,V2>::operator() (V1 *v1, V2 *v2)
{
    XTypeInfo           *actuals [2] = { xtypeid (*v1), xtypeid (*v2) };
    Score               *candidates [2];
    Score               best [2];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *, V2 *)> (match))
        (v1, v2);
}

template <class R, class V1, class V2, class T1>
inline
MultiMethod_2_1<R,V1,V2,T1>::MultiMethod_2_1 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    m_formals [1] = xtypedata (V2);
    initialise (def, 2, m_formals);
}

template <class R, class V1, class V2, class T1>
inline R
MultiMethod_2_1<R,V1,V2,T1>::operator() (V1 *v1, V2 *v2, T1 t1)
{
    XTypeInfo           *actuals [2] = { xtypeid (*v1), xtypeid (*v2) };
    Score               *candidates [2];
    Score               best [2];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *, V2 *, T1)> (match))
        (v1, v2, t1);
}

template <class R, class V1, class V2, class T1, class T2>
inline
MultiMethod_2_2<R,V1,V2,T1,T2>::MultiMethod_2_2 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    m_formals [1] = xtypedata (V2);
    initialise (def, 2, m_formals);
}

template <class R, class V1, class V2, class T1, class T2>
inline R
MultiMethod_2_2<R,V1,V2,T1,T2>::operator() (V1 *v1, V2 *v2, T1 t1, T2 t2)
{
    XTypeInfo           *actuals [2] = { xtypeid (*v1), xtypeid (*v2) };
    Score               *candidates [2];
    Score               best [2];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *, V2 *, T1, T2)> (match))
        (v1, v2, t1, t2);
}

template <class R, class V1, class V2, class V3>
inline
MultiMethod_3_0<R,V1,V2,V3>::MultiMethod_3_0 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    m_formals [1] = xtypedata (V2);
    m_formals [3] = xtypedata (V3);
    initialise (def, 3, m_formals);
}

template <class R, class V1, class V2, class V3>
inline R
MultiMethod_3_0<R,V1,V2,V3>::operator() (V1 *v1, V2 *v2, V3 *v3)
{
    XTypeInfo           *actuals [3] = { xtypeid (*v1), xtypeid (*v2), xtypeid (*v3) };
    Score               *candidates [3];
    Score               best [3];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *, V2 *, V3 *)> (match))
        (v1, v2, v3);
}

template <class R, class V1, class V2, class V3, class T1>
inline
MultiMethod_3_1<R,V1,V2,V3,T1>::MultiMethod_3_1 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    m_formals [1] = xtypedata (V2);
    m_formals [3] = xtypedata (V3);
    initialise (def, 3, m_formals);
}

template <class R, class V1, class V2, class V3, class T1>
inline R
MultiMethod_3_1<R,V1,V2,V3,T1>::operator() (V1 *v1, V2 *v2, V3 *v3, T1 t1)
{
    XTypeInfo           *actuals [3] = { xtypeid (*v1), xtypeid (*v2), xtypeid (*v3) };
    Score               *candidates [3];
    Score               best [3];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *, V2 *, V3 *, T1)> (match))
        (v1, v2, v3, t1);
}

template <class R, class V1, class V2, class V3, class T1, class T2>
inline
MultiMethod_3_2<R,V1,V2,V3,T1,T2>::MultiMethod_3_2 (Definition *def)
{
    m_formals [0] = xtypedata (V1);
    m_formals [1] = xtypedata (V2);
    m_formals [3] = xtypedata (V3);
    initialise (def, 3, m_formals);
}

template <class R, class V1, class V2, class V3, class T1, class T2>
inline R
MultiMethod_3_2<R,V1,V2,V3,T1,T2>::operator() (V1 *v1, V2 *v2, V3 *v3, T1 t1, T2 t2)
{
    XTypeInfo           *actuals [3] = { xtypeid (*v1), xtypeid (*v2), xtypeid (*v3) };
    Score               *candidates [3];
    Score               best [3];
    MemberFunction      match;

    match = dispatch (actuals, candidates, best);
    return (*reinterpret_cast<R (*) (V1 *, V2 *, V3 *, T1, T2)> (match))
        (v1, v2, v3, t1, t2);
}

// Ugly magic template function to select the right stub type based on
// the type of the member function.  The type of the member function
// is the last argument of MultiMethodCarrier; we select the right
// stub class here based on that function prototype (and pass it all
// the relevant information).
//
// Note that the returned null pointer is never used -- we are only
// interested in the return type.  We cannot actually name the return
// type in MultiMethodMember (we can only use an expression, not a
// declaration), so we use a trick: everything interesting in the
// returned stub class type is actually class-static.  So even though
// we nominally dereference the returned pointer, the compiler really
// never does it and the code is safe!  (I told you this was ugly...
// Now you wish you never would have heard.)
//
// Note also that MSVC++ 7 chokes on `typename M::something' when used
// in the prototype argument list, so we have to use ugly magic to get
// M::RTYPE and M::NONVTYPEn.  For return type we dig the actual type
// out in the caller and it gets passed in with MultiMethodCarrier.
// For NONVTYPEn we just accept anything and make sure in the
// function body that we got the right match.
template <class M, class R, class V1>
inline MultiMethodMemberStub_1_0<M,V1> *
MultiMethodStub (MultiMethodCarrier<1,0,M,R, R (*) (V1*)> *)
{ return 0; }

template <class M, class R, class V1, class A1>
inline MultiMethodMemberStub_1_1<M,V1> *
MultiMethodStub (MultiMethodCarrier<1,1,M,R, R (*) (V1 *, A1)> *)
{ (void) static_cast<A1 **> ((typename M::NONVTYPE1 **) 0); return 0; }

template <class M, class R, class V1, class A1, class A2>
inline MultiMethodMemberStub_1_2<M,V1> *
MultiMethodStub (MultiMethodCarrier<1,2,M,R, R (*) (V1 *, A1, A2)> *)
{ (void) static_cast<A1 **> ((typename M::NONVTYPE1 **) 0);
  (void) static_cast<A2 **> ((typename M::NONVTYPE2 **) 0); return 0; }

template <class M, class R, class V1, class V2>
inline MultiMethodMemberStub_2_0<M,V1,V2> *
MultiMethodStub (MultiMethodCarrier<2,0,M,R, R (*) (V1 *, V2 *)> *)
{ return 0; }

template <class M, class R, class V1, class V2, class A1>
inline MultiMethodMemberStub_2_1<M,V1,V2> *
MultiMethodStub (MultiMethodCarrier<2,1,M,R, R (*) (V1 *, V2 *, A1)> *)
{ (void) static_cast<A1 **> ((typename M::NONVTYPE1 **) 0); return 0; }

template <class M, class R, class V1, class V2, class A1, class A2>
inline MultiMethodMemberStub_2_2<M,V1,V2> *
MultiMethodStub (MultiMethodCarrier<2,2,M,R, R (*) (V1 *, V2 *, A1, A2)> *)
{ (void) static_cast<A1 **> ((typename M::NONVTYPE1 **) 0);
  (void) static_cast<A2 **> ((typename M::NONVTYPE2 **) 0); return 0; }

template <class M, class R, class V1, class V2, class V3>
inline MultiMethodMemberStub_3_0<M,V1,V2,V3> *
MultiMethodStub (MultiMethodCarrier<3,0,M,R, R (*) (V1 *, V2 *, V3 *)> *)
{ return 0; }

template <class M, class R, class V1, class V2, class V3, class A1>
inline MultiMethodMemberStub_3_1<M,V1,V2,V3> *
MultiMethodStub (MultiMethodCarrier<3,1,M,R, R (*) (V1 *, V2 *, V3 *, A1)> *)
{ (void) static_cast<A1 **> ((typename M::NONVTYPE1 **) 0); return 0; }

template <class M, class R, class V1, class V2, class V3, class A1, class A2>
inline MultiMethodMemberStub_3_2<M,V1,V2,V3> *
MultiMethodStub (MultiMethodCarrier<3,2,M,R, R (*) (V1 *, V2 *, V3 *, A1, A2)> *)
{ (void) static_cast<A1 **> ((typename M::NONVTYPE1 **) 0);
  (void) static_cast<A2 **> ((typename M::NONVTYPE2 **) 0); return 0; }

} // namespace lat
#endif // CLASSLIB_MULTIMETHOD_H

---