// -*- c++ -*-
// Copyright 2000, Karl Einar Nelson
/* This is a generated file, do not edit. Generated from ../sigc++/macros/template.macros.m4 */
#ifndef SIGC_OBJECT_SLOT
#define SIGC_OBJECT_SLOT
#include <sigc++/slot.h>
#include <sigc++/object.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/**************************************************************/
// These are internal classes used to represent function varients of slots
// (internal)
struct LIBSIGC_API ObjectSlotNode : 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
Control_ *control_;
void *object_;
Method method_;
Link link_;
// Can be a dependency
virtual Link* link();
virtual void notify(bool from_child);
template <class T,class T2>
ObjectSlotNode(FuncPtr proxy,T* control,void *object,T2 method)
: SlotNode(proxy)
{ init(control,object,reinterpret_cast<Method&>(method)); }
void init(Object* control, void* object, Method method);
virtual ~ObjectSlotNode();
};
// These do not derive from ObjectSlot, they merely are extended
// ctor wrappers. They introduce how to deal with the proxy.
template <class R,class Obj>
struct ObjectSlot0_
{
typedef typename Trait<R>::type RType;
static RType proxy(void * s)
{
typedef RType (Obj::*Method)();
ObjectSlotNode* os = (ObjectSlotNode*)s;
return ((Obj*)(os->object_)
->*(reinterpret_cast<Method&>(os->method_)))();
}
};
template <class R,class O1,class O2>
Slot0<R>
slot(O1& obj,R (O2::*method)())
{
typedef ObjectSlot0_<R,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class O1,class O2>
Slot0<R>
slot(O1& obj,R (O2::*method)() const)
{
typedef ObjectSlot0_<R,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class Obj>
struct ObjectSlot1_
{
typedef typename Trait<R>::type RType;
static RType proxy(typename Trait<P1>::ref p1,void * s)
{
typedef RType (Obj::*Method)(P1);
ObjectSlotNode* os = (ObjectSlotNode*)s;
return ((Obj*)(os->object_)
->*(reinterpret_cast<Method&>(os->method_)))(p1);
}
};
template <class R,class P1,class O1,class O2>
Slot1<R,P1>
slot(O1& obj,R (O2::*method)(P1))
{
typedef ObjectSlot1_<R,P1,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class O1,class O2>
Slot1<R,P1>
slot(O1& obj,R (O2::*method)(P1) const)
{
typedef ObjectSlot1_<R,P1,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class Obj>
struct ObjectSlot2_
{
typedef typename Trait<R>::type RType;
static RType proxy(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,void * s)
{
typedef RType (Obj::*Method)(P1,P2);
ObjectSlotNode* os = (ObjectSlotNode*)s;
return ((Obj*)(os->object_)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2);
}
};
template <class R,class P1,class P2,class O1,class O2>
Slot2<R,P1,P2>
slot(O1& obj,R (O2::*method)(P1,P2))
{
typedef ObjectSlot2_<R,P1,P2,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class O1,class O2>
Slot2<R,P1,P2>
slot(O1& obj,R (O2::*method)(P1,P2) const)
{
typedef ObjectSlot2_<R,P1,P2,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class P3,class Obj>
struct ObjectSlot3_
{
typedef typename Trait<R>::type RType;
static RType proxy(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,void * s)
{
typedef RType (Obj::*Method)(P1,P2,P3);
ObjectSlotNode* os = (ObjectSlotNode*)s;
return ((Obj*)(os->object_)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3);
}
};
template <class R,class P1,class P2,class P3,class O1,class O2>
Slot3<R,P1,P2,P3>
slot(O1& obj,R (O2::*method)(P1,P2,P3))
{
typedef ObjectSlot3_<R,P1,P2,P3,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class P3,class O1,class O2>
Slot3<R,P1,P2,P3>
slot(O1& obj,R (O2::*method)(P1,P2,P3) const)
{
typedef ObjectSlot3_<R,P1,P2,P3,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class P3,class P4,class Obj>
struct ObjectSlot4_
{
typedef typename Trait<R>::type RType;
static RType proxy(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);
ObjectSlotNode* os = (ObjectSlotNode*)s;
return ((Obj*)(os->object_)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3,p4);
}
};
template <class R,class P1,class P2,class P3,class P4,class O1,class O2>
Slot4<R,P1,P2,P3,P4>
slot(O1& obj,R (O2::*method)(P1,P2,P3,P4))
{
typedef ObjectSlot4_<R,P1,P2,P3,P4,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class P3,class P4,class O1,class O2>
Slot4<R,P1,P2,P3,P4>
slot(O1& obj,R (O2::*method)(P1,P2,P3,P4) const)
{
typedef ObjectSlot4_<R,P1,P2,P3,P4,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
struct ObjectSlot5_
{
typedef typename Trait<R>::type RType;
static RType proxy(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);
ObjectSlotNode* os = (ObjectSlotNode*)s;
return ((Obj*)(os->object_)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3,p4,p5);
}
};
template <class R,class P1,class P2,class P3,class P4,class P5,class O1,class O2>
Slot5<R,P1,P2,P3,P4,P5>
slot(O1& obj,R (O2::*method)(P1,P2,P3,P4,P5))
{
typedef ObjectSlot5_<R,P1,P2,P3,P4,P5,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class O1,class O2>
Slot5<R,P1,P2,P3,P4,P5>
slot(O1& obj,R (O2::*method)(P1,P2,P3,P4,P5) const)
{
typedef ObjectSlot5_<R,P1,P2,P3,P4,P5,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
struct ObjectSlot6_
{
typedef typename Trait<R>::type RType;
static RType proxy(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,typename Trait<P6>::ref p6,void * s)
{
typedef RType (Obj::*Method)(P1,P2,P3,P4,P5,P6);
ObjectSlotNode* os = (ObjectSlotNode*)s;
return ((Obj*)(os->object_)
->*(reinterpret_cast<Method&>(os->method_)))(p1,p2,p3,p4,p5,p6);
}
};
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class O1,class O2>
Slot6<R,P1,P2,P3,P4,P5,P6>
slot(O1& obj,R (O2::*method)(P1,P2,P3,P4,P5,P6))
{
typedef ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class O1,class O2>
Slot6<R,P1,P2,P3,P4,P5,P6>
slot(O1& obj,R (O2::*method)(P1,P2,P3,P4,P5,P6) const)
{
typedef ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,O2> SType;
O2& obj_of_method = obj;
return new ObjectSlotNode((FuncPtr)(&SType::proxy),
&obj,
&obj_of_method,
method);
}
#ifdef SIGC_CXX_NAMESPACES
}
#endif
#endif /* SIGC_OBJECT_SLOT */
syntax highlighted by Code2HTML, v. 0.9.1