0,0 → 1,1036 |
// -*- c++ -*- |
/* This is a generated file, do not edit. Generated from ../sigc++/macros/slot.h.m4 */ |
|
|
#ifndef SIGCXX_SLOT_H |
#define SIGCXX_SLOT_H |
|
/* |
|
This file just gives the basic definition of Slots. |
|
Callback# is the 4 byte data necessary for representing all |
callback types. |
|
CallData is a specific interpretation of the Callback data. |
|
Slot_ is a pimple on SlotData containing an Object for |
holding its referencees, a Dependency that removes the slot |
when its caller or receiver die, and a Callback. |
|
Slot is a handle to a Slot_. |
|
*/ |
|
#include <sigc++config.h> |
#include <sigc++/type.h> |
#include <sigc++/object.h> |
#include <sigc++/handle.h> |
|
#ifdef SIGC_CXX_NAMESPACES |
namespace SigC |
{ |
#endif |
|
// Base node for a polymorphic list of "extra" data needed |
// by various slots. |
struct LIBSIGC_API SlotNode |
{ |
void *next_; |
SlotNode(); |
virtual ~SlotNode()=0; |
}; |
|
struct LIBSIGC_API SlotIterator_ |
{ |
typedef SlotNode NodeType; |
typedef SlotIterator_ Iterator; |
NodeType *node_; |
|
NodeType* node() {return node_;} |
const NodeType* node() const {return node_;} |
|
NodeType& operator*() |
{return *node_; |
} |
const NodeType& operator*() const |
{return *node_; |
} |
|
bool operator==(const Iterator& i) const |
{return node_==i.node_; |
} |
bool operator!=(const Iterator& i) const |
{return node_!=i.node_; |
} |
|
Iterator& operator++() |
{ |
if (node_) |
node_=(NodeType*)node_->next_; |
return *this; |
} |
|
Iterator operator++(int) |
{Iterator tmp=*this; |
++*this; |
return tmp; |
} |
|
Iterator& operator= (const Iterator& i) |
{ |
node_=i.node_; |
return *this; |
} |
|
SlotIterator_():node_(0) {} |
SlotIterator_(NodeType *node):node_(node) {} |
}; |
|
// This is a list for storing internal data for slots |
struct LIBSIGC_API SlotList_ |
{ |
typedef SlotNode NodeType; |
typedef SlotIterator_ Iterator; |
NodeType* head_; |
|
Iterator begin() {return ((NodeType*)head_);} |
Iterator end() {return Iterator();} |
const Iterator begin() const {return ((NodeType*)head_);} |
const Iterator end() const {return Iterator();} |
|
// this is best used at the begining of list. |
Iterator insert_direct(Iterator pos,NodeType *n); |
|
void clear(); |
bool empty() const {return head_==0;} |
|
SlotList_():head_(0) |
{} |
~SlotList_() |
{clear();} |
|
private: |
SlotList_(const SlotList_&); |
}; |
|
|
struct SlotData; |
|
// SlotDependent is an internal of SlotData used to unreference the |
// Slot when either the sender or receiver have gone away |
struct LIBSIGC_API SlotDependent:public ScopeNode |
{ |
struct LIBSIGC_API Dep: public ScopeNode |
{ |
SlotData *parent; |
virtual void erase(); |
Dep() {} |
virtual ~Dep(); |
} dep; |
|
ScopeNode* receiver() {return &dep;} |
ScopeNode* sender() {return this;} |
SlotData* parent() {return dep.parent;} |
|
bool connected() |
{return (next_!=this);} |
|
virtual void erase(); |
|
void set_parent(SlotData *s) |
{dep.parent=s;} |
|
SlotDependent(SlotData &s) |
{dep.parent=&s;} |
|
SlotDependent() |
{} |
|
virtual ~SlotDependent(); |
}; |
|
// common data to all callbacks. |
struct Callback_ |
{ |
// callback function |
void* (*func_)(void*); |
|
struct O; |
struct C1 |
{ |
void* (*f1)(void*); |
}; |
struct C2 |
{ |
O* o; |
void (O::*v)(void); |
}; |
|
// Object pointer or function pointer |
union {C1 a1; C2 a2;}; |
}; |
|
// All slots have the same base |
struct LIBSIGC_API SlotData:public ObjectScoped |
{ |
typedef SlotList_ List; |
|
SlotDependent dep_; |
|
ScopeNode* receiver() {return dep_.receiver();} |
ScopeNode* sender() {return dep_.sender();} |
|
// Called from signals to tell slot object it is connected |
// invalidates list and sets weak reference |
void connect(); |
|
List list_; |
Callback_ data_; |
|
Callback_& callback() {return data_;} |
|
SlotData() |
{dep_.set_parent(this);} |
virtual ~SlotData(); |
}; |
|
|
typedef Scopes::Extend SlotExtend; |
#ifdef LIBSIGC_MSC |
#pragma warning(disable: 4231) |
LIBSIGC_TMPL template class LIBSIGC_API Handle<SlotData,SlotExtend>; |
#endif |
class LIBSIGC_API Connection:protected Handle<SlotData,SlotExtend> |
{ |
typedef Handle<SlotData,SlotExtend> Base; |
public: |
// hides virtual method |
void disconnect() {if (obj()) obj()->invalid();} |
bool connected() {return Base::connected ();} |
|
Connection():Base() {} |
Connection(SlotData *s):Base(s) {} |
Connection(const Connection& s):Base(s) { } |
~Connection() {} |
}; |
|
// possible casts of Callback |
template <class C,class F> |
struct CallDataFunc |
{ |
C callback; |
F func; |
}; |
|
template <class C,class O> |
struct CallDataObj2 |
{ |
C callback; |
O *obj; |
}; |
|
template <class C,class O,class F> |
struct CallDataObj3 |
{ |
C callback; |
O* obj; |
F func; |
}; |
|
// from Abstract_Slots we build abstract slots |
// with various lengths of arguments |
// A slot is not concrete til it has a call |
|
|
|
/**************************************************************** |
***** Abstract Slot 0 |
****************************************************************/ |
|
template <class R> |
struct Callback0:public Callback_ |
{ |
#ifdef SIGC_CXX_PARTIAL_SPEC |
typedef R RType; |
#else |
typedef Trait<R>::type RType; |
#endif |
typedef RType (*Func)(void*); |
inline RType call() |
{return ((Func)(func_))((void*)this);} |
inline RType operator()() |
{return ((Func)(func_))((void*)this);} |
}; |
|
template <class R> |
class Slot0 |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback0<R> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot0() {} |
Slot0(SlotData *s):Base(s) {} |
Slot0(const Slot0& s):Base(s.obj()) {} |
|
inline RType call() |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(); |
return RType(); |
} |
inline RType operator()() |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(); |
return RType(); |
} |
}; |
|
|
#ifndef SIGC_CXX_VOID_RETURN |
#ifdef SIGC_CXX_PARTIAL_SPEC |
|
template <> |
struct Callback0<void>:public Callback_ |
{ |
typedef void RType; |
typedef RType (*Func)(void*); |
inline RType call() |
{((Func)(func_))((void*)this);} |
inline RType operator()() |
{((Func)(func_))((void*)this);} |
}; |
|
template <> |
class Slot0<void> |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback0<void> Callback; |
typedef Callback::RType RType; |
typedef RType (*Func)(void*); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot0() {} |
Slot0(SlotData *s):Base(s) {} |
Slot0(const Slot0& s):Base(s.obj()) {} |
|
inline RType call() |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(); |
} |
inline RType operator()() |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(); |
} |
}; |
|
#endif |
#endif |
|
|
/**************************************************************** |
***** Abstract Slot 1 |
****************************************************************/ |
|
template <class R,class P1> |
struct Callback1:public Callback_ |
{ |
#ifdef SIGC_CXX_PARTIAL_SPEC |
typedef R RType; |
#else |
typedef Trait<R>::type RType; |
#endif |
typedef RType (*Func)(void*,P1); |
inline RType call(typename Trait<P1>::ref p1) |
{return ((Func)(func_))((void*)this,p1);} |
inline RType operator()(typename Trait<P1>::ref p1) |
{return ((Func)(func_))((void*)this,p1);} |
}; |
|
template <class R,class P1> |
class Slot1 |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback1<R,P1> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot1() {} |
Slot1(SlotData *s):Base(s) {} |
Slot1(const Slot1& s):Base(s.obj()) {} |
|
inline RType call(typename Trait<P1>::ref p1) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1); |
return RType(); |
} |
inline RType operator()(typename Trait<P1>::ref p1) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1); |
return RType(); |
} |
}; |
|
|
#ifndef SIGC_CXX_VOID_RETURN |
#ifdef SIGC_CXX_PARTIAL_SPEC |
|
template <class P1> |
struct Callback1<void,P1>:public Callback_ |
{ |
typedef void RType; |
typedef RType (*Func)(void*,P1); |
inline RType call(typename Trait<P1>::ref p1) |
{((Func)(func_))((void*)this,p1);} |
inline RType operator()(typename Trait<P1>::ref p1) |
{((Func)(func_))((void*)this,p1);} |
}; |
|
template <class P1> |
class Slot1<void,P1> |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback1<void,P1> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot1() {} |
Slot1(SlotData *s):Base(s) {} |
Slot1(const Slot1& s):Base(s.obj()) {} |
|
inline RType call(typename Trait<P1>::ref p1) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1); |
} |
inline RType operator()(typename Trait<P1>::ref p1) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1); |
} |
}; |
|
#endif |
#endif |
|
|
/**************************************************************** |
***** Abstract Slot 2 |
****************************************************************/ |
|
template <class R,class P1,class P2> |
struct Callback2:public Callback_ |
{ |
#ifdef SIGC_CXX_PARTIAL_SPEC |
typedef R RType; |
#else |
typedef Trait<R>::type RType; |
#endif |
typedef RType (*Func)(void*,P1,P2); |
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2) |
{return ((Func)(func_))((void*)this,p1,p2);} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2) |
{return ((Func)(func_))((void*)this,p1,p2);} |
}; |
|
template <class R,class P1,class P2> |
class Slot2 |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback2<R,P1,P2> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot2() {} |
Slot2(SlotData *s):Base(s) {} |
Slot2(const Slot2& s):Base(s.obj()) {} |
|
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2); |
return RType(); |
} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2); |
return RType(); |
} |
}; |
|
|
#ifndef SIGC_CXX_VOID_RETURN |
#ifdef SIGC_CXX_PARTIAL_SPEC |
|
template <class P1,class P2> |
struct Callback2<void,P1,P2>:public Callback_ |
{ |
typedef void RType; |
typedef RType (*Func)(void*,P1,P2); |
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2) |
{((Func)(func_))((void*)this,p1,p2);} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2) |
{((Func)(func_))((void*)this,p1,p2);} |
}; |
|
template <class P1,class P2> |
class Slot2<void,P1,P2> |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback2<void,P1,P2> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot2() {} |
Slot2(SlotData *s):Base(s) {} |
Slot2(const Slot2& s):Base(s.obj()) {} |
|
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2); |
} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2); |
} |
}; |
|
#endif |
#endif |
|
|
/**************************************************************** |
***** Abstract Slot 3 |
****************************************************************/ |
|
template <class R,class P1,class P2,class P3> |
struct Callback3:public Callback_ |
{ |
#ifdef SIGC_CXX_PARTIAL_SPEC |
typedef R RType; |
#else |
typedef Trait<R>::type RType; |
#endif |
typedef RType (*Func)(void*,P1,P2,P3); |
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3) |
{return ((Func)(func_))((void*)this,p1,p2,p3);} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3) |
{return ((Func)(func_))((void*)this,p1,p2,p3);} |
}; |
|
template <class R,class P1,class P2,class P3> |
class Slot3 |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback3<R,P1,P2,P3> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot3() {} |
Slot3(SlotData *s):Base(s) {} |
Slot3(const Slot3& s):Base(s.obj()) {} |
|
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3); |
return RType(); |
} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3); |
return RType(); |
} |
}; |
|
|
#ifndef SIGC_CXX_VOID_RETURN |
#ifdef SIGC_CXX_PARTIAL_SPEC |
|
template <class P1,class P2,class P3> |
struct Callback3<void,P1,P2,P3>:public Callback_ |
{ |
typedef void RType; |
typedef RType (*Func)(void*,P1,P2,P3); |
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3) |
{((Func)(func_))((void*)this,p1,p2,p3);} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3) |
{((Func)(func_))((void*)this,p1,p2,p3);} |
}; |
|
template <class P1,class P2,class P3> |
class Slot3<void,P1,P2,P3> |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback3<void,P1,P2,P3> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot3() {} |
Slot3(SlotData *s):Base(s) {} |
Slot3(const Slot3& s):Base(s.obj()) {} |
|
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3); |
} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3); |
} |
}; |
|
#endif |
#endif |
|
|
/**************************************************************** |
***** Abstract Slot 4 |
****************************************************************/ |
|
template <class R,class P1,class P2,class P3,class P4> |
struct Callback4:public Callback_ |
{ |
#ifdef SIGC_CXX_PARTIAL_SPEC |
typedef R RType; |
#else |
typedef Trait<R>::type RType; |
#endif |
typedef RType (*Func)(void*,P1,P2,P3,P4); |
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4) |
{return ((Func)(func_))((void*)this,p1,p2,p3,p4);} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4) |
{return ((Func)(func_))((void*)this,p1,p2,p3,p4);} |
}; |
|
template <class R,class P1,class P2,class P3,class P4> |
class Slot4 |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback4<R,P1,P2,P3,P4> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot4() {} |
Slot4(SlotData *s):Base(s) {} |
Slot4(const Slot4& s):Base(s.obj()) {} |
|
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3,p4); |
return RType(); |
} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3,p4); |
return RType(); |
} |
}; |
|
|
#ifndef SIGC_CXX_VOID_RETURN |
#ifdef SIGC_CXX_PARTIAL_SPEC |
|
template <class P1,class P2,class P3,class P4> |
struct Callback4<void,P1,P2,P3,P4>:public Callback_ |
{ |
typedef void RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4); |
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4) |
{((Func)(func_))((void*)this,p1,p2,p3,p4);} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4) |
{((Func)(func_))((void*)this,p1,p2,p3,p4);} |
}; |
|
template <class P1,class P2,class P3,class P4> |
class Slot4<void,P1,P2,P3,P4> |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback4<void,P1,P2,P3,P4> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot4() {} |
Slot4(SlotData *s):Base(s) {} |
Slot4(const Slot4& s):Base(s.obj()) {} |
|
inline RType call(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3,p4); |
} |
inline RType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3,p4); |
} |
}; |
|
#endif |
#endif |
|
|
/**************************************************************** |
***** Abstract Slot 5 |
****************************************************************/ |
|
template <class R,class P1,class P2,class P3,class P4,class P5> |
struct Callback5:public Callback_ |
{ |
#ifdef SIGC_CXX_PARTIAL_SPEC |
typedef R RType; |
#else |
typedef Trait<R>::type RType; |
#endif |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5); |
inline RType call(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) |
{return ((Func)(func_))((void*)this,p1,p2,p3,p4,p5);} |
inline RType operator()(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) |
{return ((Func)(func_))((void*)this,p1,p2,p3,p4,p5);} |
}; |
|
template <class R,class P1,class P2,class P3,class P4,class P5> |
class Slot5 |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback5<R,P1,P2,P3,P4,P5> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot5() {} |
Slot5(SlotData *s):Base(s) {} |
Slot5(const Slot5& s):Base(s.obj()) {} |
|
inline RType call(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) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5); |
return RType(); |
} |
inline RType operator()(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) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5); |
return RType(); |
} |
}; |
|
|
#ifndef SIGC_CXX_VOID_RETURN |
#ifdef SIGC_CXX_PARTIAL_SPEC |
|
template <class P1,class P2,class P3,class P4,class P5> |
struct Callback5<void,P1,P2,P3,P4,P5>:public Callback_ |
{ |
typedef void RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5); |
inline RType call(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) |
{((Func)(func_))((void*)this,p1,p2,p3,p4,p5);} |
inline RType operator()(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) |
{((Func)(func_))((void*)this,p1,p2,p3,p4,p5);} |
}; |
|
template <class P1,class P2,class P3,class P4,class P5> |
class Slot5<void,P1,P2,P3,P4,P5> |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback5<void,P1,P2,P3,P4,P5> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot5() {} |
Slot5(SlotData *s):Base(s) {} |
Slot5(const Slot5& s):Base(s.obj()) {} |
|
inline RType call(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) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5); |
} |
inline RType operator()(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) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5); |
} |
}; |
|
#endif |
#endif |
|
|
/**************************************************************** |
***** Abstract Slot 6 |
****************************************************************/ |
|
template <class R,class P1,class P2,class P3,class P4,class P5,class P6> |
struct Callback6:public Callback_ |
{ |
#ifdef SIGC_CXX_PARTIAL_SPEC |
typedef R RType; |
#else |
typedef Trait<R>::type RType; |
#endif |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5,P6); |
inline RType call(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) |
{return ((Func)(func_))((void*)this,p1,p2,p3,p4,p5,p6);} |
inline RType operator()(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) |
{return ((Func)(func_))((void*)this,p1,p2,p3,p4,p5,p6);} |
}; |
|
template <class R,class P1,class P2,class P3,class P4,class P5,class P6> |
class Slot6 |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback6<R,P1,P2,P3,P4,P5,P6> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5,P6); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot6() {} |
Slot6(SlotData *s):Base(s) {} |
Slot6(const Slot6& s):Base(s.obj()) {} |
|
inline RType call(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) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5,p6); |
return RType(); |
} |
inline RType operator()(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) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5,p6); |
return RType(); |
} |
}; |
|
|
#ifndef SIGC_CXX_VOID_RETURN |
#ifdef SIGC_CXX_PARTIAL_SPEC |
|
template <class P1,class P2,class P3,class P4,class P5,class P6> |
struct Callback6<void,P1,P2,P3,P4,P5,P6>:public Callback_ |
{ |
typedef void RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5,P6); |
inline RType call(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) |
{((Func)(func_))((void*)this,p1,p2,p3,p4,p5,p6);} |
inline RType operator()(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) |
{((Func)(func_))((void*)this,p1,p2,p3,p4,p5,p6);} |
}; |
|
template <class P1,class P2,class P3,class P4,class P5,class P6> |
class Slot6<void,P1,P2,P3,P4,P5,P6> |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback6<void,P1,P2,P3,P4,P5,P6> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5,P6); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot6() {} |
Slot6(SlotData *s):Base(s) {} |
Slot6(const Slot6& s):Base(s.obj()) {} |
|
inline RType call(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) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5,p6); |
} |
inline RType operator()(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) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5,p6); |
} |
}; |
|
#endif |
#endif |
|
|
/**************************************************************** |
***** Abstract Slot 7 |
****************************************************************/ |
|
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7> |
struct Callback7:public Callback_ |
{ |
#ifdef SIGC_CXX_PARTIAL_SPEC |
typedef R RType; |
#else |
typedef Trait<R>::type RType; |
#endif |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5,P6,P7); |
inline RType call(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,typename Trait<P7>::ref p7) |
{return ((Func)(func_))((void*)this,p1,p2,p3,p4,p5,p6,p7);} |
inline RType operator()(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,typename Trait<P7>::ref p7) |
{return ((Func)(func_))((void*)this,p1,p2,p3,p4,p5,p6,p7);} |
}; |
|
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7> |
class Slot7 |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback7<R,P1,P2,P3,P4,P5,P6,P7> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5,P6,P7); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot7() {} |
Slot7(SlotData *s):Base(s) {} |
Slot7(const Slot7& s):Base(s.obj()) {} |
|
inline RType call(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,typename Trait<P7>::ref p7) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5,p6,p7); |
return RType(); |
} |
inline RType operator()(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,typename Trait<P7>::ref p7) |
{ |
if (connected()) |
return ((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5,p6,p7); |
return RType(); |
} |
}; |
|
|
#ifndef SIGC_CXX_VOID_RETURN |
#ifdef SIGC_CXX_PARTIAL_SPEC |
|
template <class P1,class P2,class P3,class P4,class P5,class P6,class P7> |
struct Callback7<void,P1,P2,P3,P4,P5,P6,P7>:public Callback_ |
{ |
typedef void RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5,P6,P7); |
inline RType call(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,typename Trait<P7>::ref p7) |
{((Func)(func_))((void*)this,p1,p2,p3,p4,p5,p6,p7);} |
inline RType operator()(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,typename Trait<P7>::ref p7) |
{((Func)(func_))((void*)this,p1,p2,p3,p4,p5,p6,p7);} |
}; |
|
template <class P1,class P2,class P3,class P4,class P5,class P6,class P7> |
class Slot7<void,P1,P2,P3,P4,P5,P6,P7> |
:public Handle<SlotData,SlotExtend> |
{ |
public: |
typedef Handle<SlotData,SlotExtend> Base; |
typedef Callback7<void,P1,P2,P3,P4,P5,P6,P7> Callback; |
typedef typename Callback::RType RType; |
typedef RType (*Func)(void*,P1,P2,P3,P4,P5,P6,P7); |
|
SlotData* data() const {return (SlotData*)(scope_.object());} |
|
Slot7() {} |
Slot7(SlotData *s):Base(s) {} |
Slot7(const Slot7& s):Base(s.obj()) {} |
|
inline RType call(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,typename Trait<P7>::ref p7) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5,p6,p7); |
} |
inline RType operator()(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,typename Trait<P7>::ref p7) |
{ |
if (connected()) |
|
((Callback&)(data()->callback())).call(p1,p2,p3,p4,p5,p6,p7); |
} |
}; |
|
#endif |
#endif |
|
|
|
#ifdef SIGC_CXX_NAMESPACES |
} // namespace |
#endif |
|
#endif // SIGCXX_SLOT_H |