// -*- c++ -*-
// Copyright 2000, Karl Einar Nelson
/* This is a generated file, do not edit. Generated from ../sigc++/macros/template.macros.m4 */
#ifndef SIGC_METHOD_SLOT
#define SIGC_METHOD_SLOT
#include <sigc++/slot.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/**************************************************************/
// These are internal classes used to represent function varients of slots
class Object;
// (internal)
struct LIBSIGC_API MethodSlotNode : public SlotNode
{
#ifdef _MSC_VER
private:
/** the sole purpose of this declaration is to introduce a new type that is
guaranteed not to be related to any other type. (Ab)using class SigC::Object
for this lead to some faulty conversions taking place with MSVC6. */
class GenericObject;
typedef void* (GenericObject::*Method)(void*);
public:
#else
typedef void* (Object::*Method)(void*);
#endif
Method method_;
template <class T2>
MethodSlotNode(FuncPtr proxy,T2 method)
: SlotNode(proxy)
{ init(reinterpret_cast<Method&>(method)); }
void init(Method method);
virtual ~MethodSlotNode();
};
struct LIBSIGC_API ConstMethodSlotNode : public SlotNode
{
#ifdef _MSC_VER
private:
/** the sole purpose of this declaration is to introduce a new type that is
guaranteed not to be related to any other type. (Ab)using class SigC::Object
for this lead to some faulty conversions taking place with MSVC6. */
class GenericObject;
typedef void* (GenericObject::*Method)(void*) const;
public:
#else
typedef void* (Object::*Method)(void*) const;
#endif
Method method_;
template <class T2>
ConstMethodSlotNode(FuncPtr proxy,T2 method)
: SlotNode(proxy)
{ init(reinterpret_cast<Method&>(method)); }
void init(Method method);
virtual ~ConstMethodSlotNode();
};
// These do not derive from MethodSlot, they merely are extended
// ctor wrappers. They introduce how to deal with the proxy.
template <class R,class Obj>
struct MethodSlot0_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,void * s)
{
typedef RType (Obj::*Method)();
MethodSlotNode* os = (MethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))();
}
};
template <class R,class Obj>
struct ConstMethodSlot0_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,void * s)
{
typedef RType (Obj::*Method)() const;
ConstMethodSlotNode* os = (ConstMethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))();
}
};
template <class R,class Obj>
Slot1<R,Obj&>
slot(R (Obj::*method)())
{
typedef MethodSlot0_<R,Obj> SType;
return new MethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj>
Slot1<R,const Obj&>
slot(R (Obj::*method)() const)
{
typedef ConstMethodSlot0_<R,Obj> SType;
return new ConstMethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1>
struct MethodSlot1_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,void * s)
{
typedef RType (Obj::*Method)(P1);
MethodSlotNode* os = (MethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1);
}
};
template <class R,class Obj,class P1>
struct ConstMethodSlot1_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,void * s)
{
typedef RType (Obj::*Method)(P1) const;
ConstMethodSlotNode* os = (ConstMethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1);
}
};
template <class R,class Obj,class P1>
Slot2<R,Obj&,P1>
slot(R (Obj::*method)(P1))
{
typedef MethodSlot1_<R,Obj,P1> SType;
return new MethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1>
Slot2<R,const Obj&,P1>
slot(R (Obj::*method)(P1) const)
{
typedef ConstMethodSlot1_<R,Obj,P1> SType;
return new ConstMethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1,class P2>
struct MethodSlot2_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,void * s)
{
typedef RType (Obj::*Method)(P1,P2);
MethodSlotNode* os = (MethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2);
}
};
template <class R,class Obj,class P1,class P2>
struct ConstMethodSlot2_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,void * s)
{
typedef RType (Obj::*Method)(P1,P2) const;
ConstMethodSlotNode* os = (ConstMethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2);
}
};
template <class R,class Obj,class P1,class P2>
Slot3<R,Obj&,P1,P2>
slot(R (Obj::*method)(P1,P2))
{
typedef MethodSlot2_<R,Obj,P1,P2> SType;
return new MethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1,class P2>
Slot3<R,const Obj&,P1,P2>
slot(R (Obj::*method)(P1,P2) const)
{
typedef ConstMethodSlot2_<R,Obj,P1,P2> SType;
return new ConstMethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1,class P2,class P3>
struct MethodSlot3_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,void * s)
{
typedef RType (Obj::*Method)(P1,P2,P3);
MethodSlotNode* os = (MethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3);
}
};
template <class R,class Obj,class P1,class P2,class P3>
struct ConstMethodSlot3_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,void * s)
{
typedef RType (Obj::*Method)(P1,P2,P3) const;
ConstMethodSlotNode* os = (ConstMethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3);
}
};
template <class R,class Obj,class P1,class P2,class P3>
Slot4<R,Obj&,P1,P2,P3>
slot(R (Obj::*method)(P1,P2,P3))
{
typedef MethodSlot3_<R,Obj,P1,P2,P3> SType;
return new MethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1,class P2,class P3>
Slot4<R,const Obj&,P1,P2,P3>
slot(R (Obj::*method)(P1,P2,P3) const)
{
typedef ConstMethodSlot3_<R,Obj,P1,P2,P3> SType;
return new ConstMethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1,class P2,class P3,class P4>
struct MethodSlot4_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,void * s)
{
typedef RType (Obj::*Method)(P1,P2,P3,P4);
MethodSlotNode* os = (MethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3,p4);
}
};
template <class R,class Obj,class P1,class P2,class P3,class P4>
struct ConstMethodSlot4_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,void * s)
{
typedef RType (Obj::*Method)(P1,P2,P3,P4) const;
ConstMethodSlotNode* os = (ConstMethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3,p4);
}
};
template <class R,class Obj,class P1,class P2,class P3,class P4>
Slot5<R,Obj&,P1,P2,P3,P4>
slot(R (Obj::*method)(P1,P2,P3,P4))
{
typedef MethodSlot4_<R,Obj,P1,P2,P3,P4> SType;
return new MethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1,class P2,class P3,class P4>
Slot5<R,const Obj&,P1,P2,P3,P4>
slot(R (Obj::*method)(P1,P2,P3,P4) const)
{
typedef ConstMethodSlot4_<R,Obj,P1,P2,P3,P4> SType;
return new ConstMethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1,class P2,class P3,class P4,class P5>
struct MethodSlot5_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,void * s)
{
typedef RType (Obj::*Method)(P1,P2,P3,P4,P5);
MethodSlotNode* os = (MethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3,p4,p5);
}
};
template <class R,class Obj,class P1,class P2,class P3,class P4,class P5>
struct ConstMethodSlot5_
{
typedef typename Trait<R>::type RType;
static RType proxy(Obj& obj,typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,void * s)
{
typedef RType (Obj::*Method)(P1,P2,P3,P4,P5) const;
ConstMethodSlotNode* os = (ConstMethodSlotNode*)s;
return ((Obj*)(&obj)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3,p4,p5);
}
};
template <class R,class Obj,class P1,class P2,class P3,class P4,class P5>
Slot6<R,Obj&,P1,P2,P3,P4,P5>
slot(R (Obj::*method)(P1,P2,P3,P4,P5))
{
typedef MethodSlot5_<R,Obj,P1,P2,P3,P4,P5> SType;
return new MethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
template <class R,class Obj,class P1,class P2,class P3,class P4,class P5>
Slot6<R,const Obj&,P1,P2,P3,P4,P5>
slot(R (Obj::*method)(P1,P2,P3,P4,P5) const)
{
typedef ConstMethodSlot5_<R,Obj,P1,P2,P3,P4,P5> SType;
return new ConstMethodSlotNode((FuncPtr)(&SType::proxy),
method);
}
#ifdef SIGC_CXX_NAMESPACES
}
#endif
#endif // SIGC_SLOT
syntax highlighted by Code2HTML, v. 0.9.1