BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /programs/develop/libraries/menuetlibc/include/sigc++/ @ 4972

  → /programs/develop/libraries/menuetlibc/include/sigc++/ @ 4973

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Regard whitespace Rev 4972 → Rev 4973

/programs/develop/libraries/menuetlibc/include/sigc++/adaptor.h
0,0 → 1,43
// -*- c++ -*-
/*
* Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef _SIGC_ADAPTOR_H_
#define _SIGC_ADAPTOR_H_
#include <sigc++/slot.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
struct LIBSIGC_API AdaptorNode : public SlotNode
{
Callback_ data_;
};
struct LIBSIGC_API AdaptorSlot_
{
static void copy_callback(SlotData* sdata,AdaptorNode* node);
};
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/basic_signal.h
0,0 → 1,1185
// -*- c++ -*-
/* This is a generated file, do not edit. Generated from ../sigc++/macros/basic_signal.h.m4 */
#ifndef SIGCXX_BASIC_SIGNAL_H
#define SIGCXX_BASIC_SIGNAL_H
#include <sigc++/marshal.h>
#include <sigc++/slot.h>
// Qt steals a method name.
#ifdef SIGC_QT
#undef emit
#endif
#ifdef emit
#define SIGC_QT
#undef emit
#endif
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/****************************************************************
***** Signals (build by macros)
****************************************************************/
// common part to all signals
class LIBSIGC_API Signal_
{
private:
Signal_(const Signal_&);
protected:
typedef ScopeList List;
struct LIBSIGC_API Impl
{
typedef ScopeList List;
List incoming_;
List outgoing_;
Impl();
~Impl();
};
Impl *impl;
SlotData* in_connect();
SlotData* out_connect(SlotData *s);
Signal_();
~Signal_();
public:
bool empty() const;
void clear();
};
/****************************************************************
***** Signal 0
****************************************************************/
template <class R,typename Marsh=class Marshal<R> >
class Signal0:public Signal_
{
public:
typedef Slot0<R> InSlotType;
typedef Slot0<typename Marsh::OutType> OutSlotType;
private:
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef typename Marsh::OutType SType;
typedef R RType;
#else
typedef Trait<typename Marsh::OutType>::type SType;
typedef Trait<R>::type RType;
#endif
typedef typename InSlotType::Callback Callback;
typedef Signal0<R,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static SType callback(void* d)
{
CallData* data=(CallData*)d;
return data->obj->emit();
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=(typename OutSlotType::Func)callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
SType emit();
SType operator()()
{return emit();}
Signal0() {}
Signal0(const InSlotType &s) {connect(s);}
~Signal0() {}
};
// emit
template <class R,class Marsh>
typename Signal0<R,Marsh>::SType Signal0<R,Marsh>::
emit()
{
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
List &out=impl->outgoing_;
Marsh rc;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
if (rc.marshal(s.call())) return rc.value();
}
return rc.value();
}
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Marsh>
class Signal0<void,Marsh>
:public Signal_
{
public:
typedef Slot0<void> InSlotType;
typedef Slot0<void> OutSlotType;
private:
typedef InSlotType::Callback Callback;
typedef Signal0<void,Marsh> Self;
typedef CallDataObj2<OutSlotType::Func,Self> CallData;
static void callback(void* d)
{
CallData* data=(CallData*)d;
data->obj->emit();
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
void emit();
void operator()()
{emit();}
Signal0() {}
Signal0(const InSlotType &s) {connect(s);}
~Signal0() {}
};
// emit
template <class Marsh>
void Signal0<void,Marsh>::
emit()
{
if (!impl||impl->outgoing_.empty()) return;
List &out=impl->outgoing_;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
s.call();
}
}
#endif
/****************************************************************
***** Signal 1
****************************************************************/
template <class R,class P1,typename Marsh=class Marshal<R> >
class Signal1:public Signal_
{
public:
typedef Slot1<R,P1> InSlotType;
typedef Slot1<typename Marsh::OutType,P1> OutSlotType;
private:
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef typename Marsh::OutType SType;
typedef R RType;
#else
typedef Trait<typename Marsh::OutType>::type SType;
typedef Trait<R>::type RType;
#endif
typedef typename InSlotType::Callback Callback;
typedef Signal1<R,P1,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static SType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
return data->obj->emit(p1);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=(typename OutSlotType::Func)callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
SType emit(typename Trait<P1>::ref p1);
SType operator()(typename Trait<P1>::ref p1)
{return emit(p1);}
Signal1() {}
Signal1(const InSlotType &s) {connect(s);}
~Signal1() {}
};
// emit
template <class R,class P1,class Marsh>
typename Signal1<R,P1,Marsh>::SType Signal1<R,P1,Marsh>::
emit(typename Trait<P1>::ref p1)
{
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
List &out=impl->outgoing_;
Marsh rc;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
if (rc.marshal(s.call(p1))) return rc.value();
}
return rc.value();
}
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class Marsh>
class Signal1<void,P1,Marsh>
:public Signal_
{
public:
typedef Slot1<void,P1> InSlotType;
typedef Slot1<void,P1> OutSlotType;
private:
typedef typename InSlotType::Callback Callback;
typedef Signal1<void,P1,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static void callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
data->obj->emit(p1);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
void emit(typename Trait<P1>::ref p1);
void operator()(typename Trait<P1>::ref p1)
{emit(p1);}
Signal1() {}
Signal1(const InSlotType &s) {connect(s);}
~Signal1() {}
};
// emit
template <class P1,class Marsh>
void Signal1<void,P1,Marsh>::
emit(typename Trait<P1>::ref p1)
{
if (!impl||impl->outgoing_.empty()) return;
List &out=impl->outgoing_;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
s.call(p1);
}
}
#endif
/****************************************************************
***** Signal 2
****************************************************************/
template <class R,class P1,class P2,typename Marsh=class Marshal<R> >
class Signal2:public Signal_
{
public:
typedef Slot2<R,P1,P2> InSlotType;
typedef Slot2<typename Marsh::OutType,P1,P2> OutSlotType;
private:
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef typename Marsh::OutType SType;
typedef R RType;
#else
typedef Trait<typename Marsh::OutType>::type SType;
typedef Trait<R>::type RType;
#endif
typedef typename InSlotType::Callback Callback;
typedef Signal2<R,P1,P2,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static SType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
return data->obj->emit(p1,p2);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=(typename OutSlotType::Func)callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2);
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
{return emit(p1,p2);}
Signal2() {}
Signal2(const InSlotType &s) {connect(s);}
~Signal2() {}
};
// emit
template <class R,class P1,class P2,class Marsh>
typename Signal2<R,P1,P2,Marsh>::SType Signal2<R,P1,P2,Marsh>::
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
{
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
List &out=impl->outgoing_;
Marsh rc;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
if (rc.marshal(s.call(p1,p2))) return rc.value();
}
return rc.value();
}
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class Marsh>
class Signal2<void,P1,P2,Marsh>
:public Signal_
{
public:
typedef Slot2<void,P1,P2> InSlotType;
typedef Slot2<void,P1,P2> OutSlotType;
private:
typedef typename InSlotType::Callback Callback;
typedef Signal2<void,P1,P2,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static void callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
data->obj->emit(p1,p2);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2);
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
{emit(p1,p2);}
Signal2() {}
Signal2(const InSlotType &s) {connect(s);}
~Signal2() {}
};
// emit
template <class P1,class P2,class Marsh>
void Signal2<void,P1,P2,Marsh>::
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
{
if (!impl||impl->outgoing_.empty()) return;
List &out=impl->outgoing_;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
s.call(p1,p2);
}
}
#endif
/****************************************************************
***** Signal 3
****************************************************************/
template <class R,class P1,class P2,class P3,typename Marsh=class Marshal<R> >
class Signal3:public Signal_
{
public:
typedef Slot3<R,P1,P2,P3> InSlotType;
typedef Slot3<typename Marsh::OutType,P1,P2,P3> OutSlotType;
private:
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef typename Marsh::OutType SType;
typedef R RType;
#else
typedef Trait<typename Marsh::OutType>::type SType;
typedef Trait<R>::type RType;
#endif
typedef typename InSlotType::Callback Callback;
typedef Signal3<R,P1,P2,P3,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static SType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
return data->obj->emit(p1,p2,p3);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=(typename OutSlotType::Func)callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3);
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
{return emit(p1,p2,p3);}
Signal3() {}
Signal3(const InSlotType &s) {connect(s);}
~Signal3() {}
};
// emit
template <class R,class P1,class P2,class P3,class Marsh>
typename Signal3<R,P1,P2,P3,Marsh>::SType Signal3<R,P1,P2,P3,Marsh>::
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
{
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
List &out=impl->outgoing_;
Marsh rc;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
if (rc.marshal(s.call(p1,p2,p3))) return rc.value();
}
return rc.value();
}
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class Marsh>
class Signal3<void,P1,P2,P3,Marsh>
:public Signal_
{
public:
typedef Slot3<void,P1,P2,P3> InSlotType;
typedef Slot3<void,P1,P2,P3> OutSlotType;
private:
typedef typename InSlotType::Callback Callback;
typedef Signal3<void,P1,P2,P3,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static void callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
data->obj->emit(p1,p2,p3);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3);
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
{emit(p1,p2,p3);}
Signal3() {}
Signal3(const InSlotType &s) {connect(s);}
~Signal3() {}
};
// emit
template <class P1,class P2,class P3,class Marsh>
void Signal3<void,P1,P2,P3,Marsh>::
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
{
if (!impl||impl->outgoing_.empty()) return;
List &out=impl->outgoing_;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
s.call(p1,p2,p3);
}
}
#endif
/****************************************************************
***** Signal 4
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,typename Marsh=class Marshal<R> >
class Signal4:public Signal_
{
public:
typedef Slot4<R,P1,P2,P3,P4> InSlotType;
typedef Slot4<typename Marsh::OutType,P1,P2,P3,P4> OutSlotType;
private:
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef typename Marsh::OutType SType;
typedef R RType;
#else
typedef Trait<typename Marsh::OutType>::type SType;
typedef Trait<R>::type RType;
#endif
typedef typename InSlotType::Callback Callback;
typedef Signal4<R,P1,P2,P3,P4,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
return data->obj->emit(p1,p2,p3,p4);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=(typename OutSlotType::Func)callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4);
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
{return emit(p1,p2,p3,p4);}
Signal4() {}
Signal4(const InSlotType &s) {connect(s);}
~Signal4() {}
};
// emit
template <class R,class P1,class P2,class P3,class P4,class Marsh>
typename Signal4<R,P1,P2,P3,P4,Marsh>::SType Signal4<R,P1,P2,P3,P4,Marsh>::
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
{
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
List &out=impl->outgoing_;
Marsh rc;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
if (rc.marshal(s.call(p1,p2,p3,p4))) return rc.value();
}
return rc.value();
}
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class Marsh>
class Signal4<void,P1,P2,P3,P4,Marsh>
:public Signal_
{
public:
typedef Slot4<void,P1,P2,P3,P4> InSlotType;
typedef Slot4<void,P1,P2,P3,P4> OutSlotType;
private:
typedef typename InSlotType::Callback Callback;
typedef Signal4<void,P1,P2,P3,P4,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
data->obj->emit(p1,p2,p3,p4);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4);
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
{emit(p1,p2,p3,p4);}
Signal4() {}
Signal4(const InSlotType &s) {connect(s);}
~Signal4() {}
};
// emit
template <class P1,class P2,class P3,class P4,class Marsh>
void Signal4<void,P1,P2,P3,P4,Marsh>::
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
{
if (!impl||impl->outgoing_.empty()) return;
List &out=impl->outgoing_;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
s.call(p1,p2,p3,p4);
}
}
#endif
/****************************************************************
***** Signal 5
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,typename Marsh=class Marshal<R> >
class Signal5:public Signal_
{
public:
typedef Slot5<R,P1,P2,P3,P4,P5> InSlotType;
typedef Slot5<typename Marsh::OutType,P1,P2,P3,P4,P5> OutSlotType;
private:
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef typename Marsh::OutType SType;
typedef R RType;
#else
typedef Trait<typename Marsh::OutType>::type SType;
typedef Trait<R>::type RType;
#endif
typedef typename InSlotType::Callback Callback;
typedef Signal5<R,P1,P2,P3,P4,P5,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
return data->obj->emit(p1,p2,p3,p4,p5);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=(typename OutSlotType::Func)callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
SType emit(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);
SType 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 emit(p1,p2,p3,p4,p5);}
Signal5() {}
Signal5(const InSlotType &s) {connect(s);}
~Signal5() {}
};
// emit
template <class R,class P1,class P2,class P3,class P4,class P5,class Marsh>
typename Signal5<R,P1,P2,P3,P4,P5,Marsh>::SType Signal5<R,P1,P2,P3,P4,P5,Marsh>::
emit(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 (!impl||impl->outgoing_.empty()) return Marsh::default_value();
List &out=impl->outgoing_;
Marsh rc;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
if (rc.marshal(s.call(p1,p2,p3,p4,p5))) return rc.value();
}
return rc.value();
}
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,class Marsh>
class Signal5<void,P1,P2,P3,P4,P5,Marsh>
:public Signal_
{
public:
typedef Slot5<void,P1,P2,P3,P4,P5> InSlotType;
typedef Slot5<void,P1,P2,P3,P4,P5> OutSlotType;
private:
typedef typename InSlotType::Callback Callback;
typedef Signal5<void,P1,P2,P3,P4,P5,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
data->obj->emit(p1,p2,p3,p4,p5);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
void emit(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 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)
{emit(p1,p2,p3,p4,p5);}
Signal5() {}
Signal5(const InSlotType &s) {connect(s);}
~Signal5() {}
};
// emit
template <class P1,class P2,class P3,class P4,class P5,class Marsh>
void Signal5<void,P1,P2,P3,P4,P5,Marsh>::
emit(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 (!impl||impl->outgoing_.empty()) return;
List &out=impl->outgoing_;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
s.call(p1,p2,p3,p4,p5);
}
}
#endif
/****************************************************************
***** Signal 6
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,typename Marsh=class Marshal<R> >
class Signal6:public Signal_
{
public:
typedef Slot6<R,P1,P2,P3,P4,P5,P6> InSlotType;
typedef Slot6<typename Marsh::OutType,P1,P2,P3,P4,P5,P6> OutSlotType;
private:
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef typename Marsh::OutType SType;
typedef R RType;
#else
typedef Trait<typename Marsh::OutType>::type SType;
typedef Trait<R>::type RType;
#endif
typedef typename InSlotType::Callback Callback;
typedef Signal6<R,P1,P2,P3,P4,P5,P6,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
return data->obj->emit(p1,p2,p3,p4,p5,p6);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=(typename OutSlotType::Func)callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
SType emit(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);
SType 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 emit(p1,p2,p3,p4,p5,p6);}
Signal6() {}
Signal6(const InSlotType &s) {connect(s);}
~Signal6() {}
};
// emit
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
typename Signal6<R,P1,P2,P3,P4,P5,P6,Marsh>::SType Signal6<R,P1,P2,P3,P4,P5,P6,Marsh>::
emit(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 (!impl||impl->outgoing_.empty()) return Marsh::default_value();
List &out=impl->outgoing_;
Marsh rc;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
if (rc.marshal(s.call(p1,p2,p3,p4,p5,p6))) return rc.value();
}
return rc.value();
}
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
class Signal6<void,P1,P2,P3,P4,P5,P6,Marsh>
:public Signal_
{
public:
typedef Slot6<void,P1,P2,P3,P4,P5,P6> InSlotType;
typedef Slot6<void,P1,P2,P3,P4,P5,P6> OutSlotType;
private:
typedef typename InSlotType::Callback Callback;
typedef Signal6<void,P1,P2,P3,P4,P5,P6,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
data->obj->emit(p1,p2,p3,p4,p5,p6);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
void emit(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 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)
{emit(p1,p2,p3,p4,p5,p6);}
Signal6() {}
Signal6(const InSlotType &s) {connect(s);}
~Signal6() {}
};
// emit
template <class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
void Signal6<void,P1,P2,P3,P4,P5,P6,Marsh>::
emit(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 (!impl||impl->outgoing_.empty()) return;
List &out=impl->outgoing_;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
s.call(p1,p2,p3,p4,p5,p6);
}
}
#endif
/****************************************************************
***** Signal 7
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,typename Marsh=class Marshal<R> >
class Signal7:public Signal_
{
public:
typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7> InSlotType;
typedef Slot7<typename Marsh::OutType,P1,P2,P3,P4,P5,P6,P7> OutSlotType;
private:
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef typename Marsh::OutType SType;
typedef R RType;
#else
typedef Trait<typename Marsh::OutType>::type SType;
typedef Trait<R>::type RType;
#endif
typedef typename InSlotType::Callback Callback;
typedef Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
return data->obj->emit(p1,p2,p3,p4,p5,p6,p7);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=(typename OutSlotType::Func)callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
SType emit(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);
SType 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 emit(p1,p2,p3,p4,p5,p6,p7);}
Signal7() {}
Signal7(const InSlotType &s) {connect(s);}
~Signal7() {}
};
// emit
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
typename Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh>::SType Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh>::
emit(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 (!impl||impl->outgoing_.empty()) return Marsh::default_value();
List &out=impl->outgoing_;
Marsh rc;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
if (rc.marshal(s.call(p1,p2,p3,p4,p5,p6,p7))) return rc.value();
}
return rc.value();
}
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
class Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh>
:public Signal_
{
public:
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> InSlotType;
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> OutSlotType;
private:
typedef typename InSlotType::Callback Callback;
typedef Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh> Self;
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
data->obj->emit(p1,p2,p3,p4,p5,p6,p7);
}
public:
OutSlotType slot()
{
SlotData* tmp=in_connect();
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=callback;
data.obj=this;
return tmp;
}
Connection connect(const InSlotType &s)
{
return out_connect(s.data());
}
void emit(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);
void 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)
{emit(p1,p2,p3,p4,p5,p6,p7);}
Signal7() {}
Signal7(const InSlotType &s) {connect(s);}
~Signal7() {}
};
// emit
template <class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
void Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh>::
emit(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 (!impl||impl->outgoing_.empty()) return;
List &out=impl->outgoing_;
SlotData *data;
List::Iterator i=out.begin();
while (i!=out.end())
{
data=((SlotDependent*)(i.node()))->parent();
++i;
Callback& s=(Callback&)(data->callback());
s.call(p1,p2,p3,p4,p5,p6,p7);
}
}
#endif
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#ifdef SIGC_QT
#define emit
#endif
#endif // SIGCXX_BASIC_SIGNAL_H

/programs/develop/libraries/menuetlibc/include/sigc++/bind.h
0,0 → 1,1429
// -*- c++ -*-
/* This is a generated file, do not edit. Generated from ../sigc++/macros/bind.h.m4 */
#ifndef SIGCXX_BIND_H
#define SIGCXX_BIND_H
/*
SigC::bind
-------------
bind() alters a Slot by fixing arguments to certain values.
Argument fixing starts from the last argument. The slot is
destroyed in the process and a new one is created, so references
holding onto the slot will no longer be valid.
Up to two arguments can be bound at a time with the default
header.
Simple Sample usage:
void f(int,int);
Slot2<void,int,int> s1=slot(f);
Slot1<void,int> s2=bind(s1,1); // s1 is invalid
s2(2); // call f with arguments 2,1
Multibinding usage:
void f(int,int);
Slot2<void,int,int> s1=slot(f);
Slot0<void> s2=bind(s1,1,2); // s1 is invalid
s2(); // call f with arguments 1,2
Type specified usage:
struct A {};
struct B :public A {};
B* b;
Slot0<void, A*> s1;
Slot0<void> s2=bind(s1, b); // B* converted to A*
*/
#include <sigc++/adaptor.h>
#include <sigc++/scope.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/****************************************************************
***** Adaptor Bind Slot 0 arguments, 1 hidden arguments
****************************************************************/
template <class R,
class C1>
struct AdaptorBindSlot0_1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot0<R> SlotType;
typedef Slot1<R,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class C1>
struct AdaptorBindSlot0_1
<void,
C1> : public AdaptorSlot_
{
typedef void RType;
typedef Slot0<void> SlotType;
typedef Slot1<void,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,
class R,
class C1>
inline
Slot0<R>
bind(const Slot1<R,C1> &s,
A1 a1)
{return AdaptorBindSlot0_1<R,
C1>::create(s.data(),a1);
}
/****************************************************************
***** Adaptor Bind Slot 1 arguments, 1 hidden arguments
****************************************************************/
template <class R,
class P1,
class C1>
struct AdaptorBindSlot1_1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot1<R,P1> SlotType;
typedef Slot2<R,P1,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,
class C1>
struct AdaptorBindSlot1_1
<void,P1,
C1> : public AdaptorSlot_
{
typedef void RType;
typedef Slot1<void,P1> SlotType;
typedef Slot2<void,P1,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,
class R,
class P1,
class C1>
inline
Slot1<R,P1>
bind(const Slot2<R,P1,C1> &s,
A1 a1)
{return AdaptorBindSlot1_1<R,
P1,
C1>::create(s.data(),a1);
}
/****************************************************************
***** Adaptor Bind Slot 2 arguments, 1 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,
class C1>
struct AdaptorBindSlot2_1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot2<R,P1,P2> SlotType;
typedef Slot3<R,P1,P2,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,
class C1>
struct AdaptorBindSlot2_1
<void,P1,P2,
C1> : public AdaptorSlot_
{
typedef void RType;
typedef Slot2<void,P1,P2> SlotType;
typedef Slot3<void,P1,P2,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,
class R,
class P1,class P2,
class C1>
inline
Slot2<R,P1,P2>
bind(const Slot3<R,P1,P2,C1> &s,
A1 a1)
{return AdaptorBindSlot2_1<R,
P1,P2,
C1>::create(s.data(),a1);
}
/****************************************************************
***** Adaptor Bind Slot 3 arguments, 1 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,class P3,
class C1>
struct AdaptorBindSlot3_1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot3<R,P1,P2,P3> SlotType;
typedef Slot4<R,P1,P2,P3,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,
class C1>
struct AdaptorBindSlot3_1
<void,P1,P2,P3,
C1> : public AdaptorSlot_
{
typedef void RType;
typedef Slot3<void,P1,P2,P3> SlotType;
typedef Slot4<void,P1,P2,P3,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,
class R,
class P1,class P2,class P3,
class C1>
inline
Slot3<R,P1,P2,P3>
bind(const Slot4<R,P1,P2,P3,C1> &s,
A1 a1)
{return AdaptorBindSlot3_1<R,
P1,P2,P3,
C1>::create(s.data(),a1);
}
/****************************************************************
***** Adaptor Bind Slot 4 arguments, 1 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,class P3,class P4,
class C1>
struct AdaptorBindSlot4_1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot4<R,P1,P2,P3,P4> SlotType;
typedef Slot5<R,P1,P2,P3,P4,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,
class C1>
struct AdaptorBindSlot4_1
<void,P1,P2,P3,P4,
C1> : public AdaptorSlot_
{
typedef void RType;
typedef Slot4<void,P1,P2,P3,P4> SlotType;
typedef Slot5<void,P1,P2,P3,P4,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,
class R,
class P1,class P2,class P3,class P4,
class C1>
inline
Slot4<R,P1,P2,P3,P4>
bind(const Slot5<R,P1,P2,P3,P4,C1> &s,
A1 a1)
{return AdaptorBindSlot4_1<R,
P1,P2,P3,P4,
C1>::create(s.data(),a1);
}
/****************************************************************
***** Adaptor Bind Slot 5 arguments, 1 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,class P3,class P4,class P5,
class C1>
struct AdaptorBindSlot5_1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot5<R,P1,P2,P3,P4,P5> SlotType;
typedef Slot6<R,P1,P2,P3,P4,P5,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,
class C1>
struct AdaptorBindSlot5_1
<void,P1,P2,P3,P4,P5,
C1> : public AdaptorSlot_
{
typedef void RType;
typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
typedef Slot6<void,P1,P2,P3,P4,P5,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,
class R,
class P1,class P2,class P3,class P4,class P5,
class C1>
inline
Slot5<R,P1,P2,P3,P4,P5>
bind(const Slot6<R,P1,P2,P3,P4,P5,C1> &s,
A1 a1)
{return AdaptorBindSlot5_1<R,
P1,P2,P3,P4,P5,
C1>::create(s.data(),a1);
}
/****************************************************************
***** Adaptor Bind Slot 6 arguments, 1 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,class P3,class P4,class P5,class P6,
class C1>
struct AdaptorBindSlot6_1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot6<R,P1,P2,P3,P4,P5,P6> SlotType;
typedef Slot7<R,P1,P2,P3,P4,P5,P6,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,class P6,
class C1>
struct AdaptorBindSlot6_1
<void,P1,P2,P3,P4,P5,P6,
C1> : public AdaptorSlot_
{
typedef void RType;
typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
typedef Slot7<void,P1,P2,P3,P4,P5,P6,C1> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
Node(C1 c1)
: c1_(c1)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,
node->c1_);
}
static SlotData* create(SlotData *s,C1 c1)
{
Node *node=new Node(c1);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,
class R,
class P1,class P2,class P3,class P4,class P5,class P6,
class C1>
inline
Slot6<R,P1,P2,P3,P4,P5,P6>
bind(const Slot7<R,P1,P2,P3,P4,P5,P6,C1> &s,
A1 a1)
{return AdaptorBindSlot6_1<R,
P1,P2,P3,P4,P5,P6,
C1>::create(s.data(),a1);
}
/****************************************************************
***** Adaptor Bind Slot 0 arguments, 2 hidden arguments
****************************************************************/
template <class R,
class C1,class C2>
struct AdaptorBindSlot0_2: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot0<R> SlotType;
typedef Slot2<R,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class C1,class C2>
struct AdaptorBindSlot0_2
<void,
C1,C2> : public AdaptorSlot_
{
typedef void RType;
typedef Slot0<void> SlotType;
typedef Slot2<void,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,class A2,
class R,
class C1,class C2>
inline
Slot0<R>
bind(const Slot2<R,C1,C2> &s,
A1 a1,A2 a2)
{return AdaptorBindSlot0_2<R,
C1,C2>::create(s.data(),a1,a2);
}
/****************************************************************
***** Adaptor Bind Slot 1 arguments, 2 hidden arguments
****************************************************************/
template <class R,
class P1,
class C1,class C2>
struct AdaptorBindSlot1_2: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot1<R,P1> SlotType;
typedef Slot3<R,P1,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,
class C1,class C2>
struct AdaptorBindSlot1_2
<void,P1,
C1,C2> : public AdaptorSlot_
{
typedef void RType;
typedef Slot1<void,P1> SlotType;
typedef Slot3<void,P1,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,class A2,
class R,
class P1,
class C1,class C2>
inline
Slot1<R,P1>
bind(const Slot3<R,P1,C1,C2> &s,
A1 a1,A2 a2)
{return AdaptorBindSlot1_2<R,
P1,
C1,C2>::create(s.data(),a1,a2);
}
/****************************************************************
***** Adaptor Bind Slot 2 arguments, 2 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,
class C1,class C2>
struct AdaptorBindSlot2_2: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot2<R,P1,P2> SlotType;
typedef Slot4<R,P1,P2,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,
class C1,class C2>
struct AdaptorBindSlot2_2
<void,P1,P2,
C1,C2> : public AdaptorSlot_
{
typedef void RType;
typedef Slot2<void,P1,P2> SlotType;
typedef Slot4<void,P1,P2,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,class A2,
class R,
class P1,class P2,
class C1,class C2>
inline
Slot2<R,P1,P2>
bind(const Slot4<R,P1,P2,C1,C2> &s,
A1 a1,A2 a2)
{return AdaptorBindSlot2_2<R,
P1,P2,
C1,C2>::create(s.data(),a1,a2);
}
/****************************************************************
***** Adaptor Bind Slot 3 arguments, 2 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,class P3,
class C1,class C2>
struct AdaptorBindSlot3_2: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot3<R,P1,P2,P3> SlotType;
typedef Slot5<R,P1,P2,P3,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,
class C1,class C2>
struct AdaptorBindSlot3_2
<void,P1,P2,P3,
C1,C2> : public AdaptorSlot_
{
typedef void RType;
typedef Slot3<void,P1,P2,P3> SlotType;
typedef Slot5<void,P1,P2,P3,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,class A2,
class R,
class P1,class P2,class P3,
class C1,class C2>
inline
Slot3<R,P1,P2,P3>
bind(const Slot5<R,P1,P2,P3,C1,C2> &s,
A1 a1,A2 a2)
{return AdaptorBindSlot3_2<R,
P1,P2,P3,
C1,C2>::create(s.data(),a1,a2);
}
/****************************************************************
***** Adaptor Bind Slot 4 arguments, 2 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,class P3,class P4,
class C1,class C2>
struct AdaptorBindSlot4_2: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot4<R,P1,P2,P3,P4> SlotType;
typedef Slot6<R,P1,P2,P3,P4,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,
class C1,class C2>
struct AdaptorBindSlot4_2
<void,P1,P2,P3,P4,
C1,C2> : public AdaptorSlot_
{
typedef void RType;
typedef Slot4<void,P1,P2,P3,P4> SlotType;
typedef Slot6<void,P1,P2,P3,P4,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,class A2,
class R,
class P1,class P2,class P3,class P4,
class C1,class C2>
inline
Slot4<R,P1,P2,P3,P4>
bind(const Slot6<R,P1,P2,P3,P4,C1,C2> &s,
A1 a1,A2 a2)
{return AdaptorBindSlot4_2<R,
P1,P2,P3,P4,
C1,C2>::create(s.data(),a1,a2);
}
/****************************************************************
***** Adaptor Bind Slot 5 arguments, 2 hidden arguments
****************************************************************/
template <class R,
class P1,class P2,class P3,class P4,class P5,
class C1,class C2>
struct AdaptorBindSlot5_2: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef Slot5<R,P1,P2,P3,P4,P5> SlotType;
typedef Slot7<R,P1,P2,P3,P4,P5,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,
class C1,class C2>
struct AdaptorBindSlot5_2
<void,P1,P2,P3,P4,P5,
C1,C2> : public AdaptorSlot_
{
typedef void RType;
typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
typedef Slot7<void,P1,P2,P3,P4,P5,C1,C2> InSlotType;
struct Node:public AdaptorNode
{
C1 c1_;
C2 c2_;
Node(C1 c1,C2 c2)
: c1_(c1),c2_(c2)
{ }
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,
node->c1_,node->c2_);
}
static SlotData* create(SlotData *s,C1 c1,C2 c2)
{
Node *node=new Node(c1,c2);
copy_callback(s,node);
CallData &data=reinterpret_cast<CallData&>(s->data_);
data.callback=&callback;
data.obj=node;
return s;
}
};
#endif
#endif
template <class A1,class A2,
class R,
class P1,class P2,class P3,class P4,class P5,
class C1,class C2>
inline
Slot5<R,P1,P2,P3,P4,P5>
bind(const Slot7<R,P1,P2,P3,P4,P5,C1,C2> &s,
A1 a1,A2 a2)
{return AdaptorBindSlot5_2<R,
P1,P2,P3,P4,P5,
C1,C2>::create(s.data(),a1,a2);
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/class_slot.h
0,0 → 1,318
// -*- c++ -*-
/* This is a generated file, do not edit. Generated from ../sigc++/macros/class_slot.h.m4 */
#ifndef SIGCXX_CLASS_SLOT_H
#define SIGCXX_CLASS_SLOT_H
/*
SigC::slot_class() (class)
-----------------------
slot_class() can be applied to a class method to form a Slot with a
profile equivelent to the method. At the same time an instance
of that class must be specified. This is an unsafe interface.
This does NOT require that the class be derived from SigC::Object.
However, the object should be static with regards to the signal system.
(allocated within the global scope.) If it is not and a connected
slot is call it will result in a seg fault. If the object must
be destroyed before the connected slots, all connections must
be disconnected by hand.
Sample usage:
struct A
{
void foo(int,int);
} a;
Slot2<void,int,int> s=slot_class(a,&A::foo);
*/
#include <sigc++/object_slot.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/****************************************************************
***** Class Slot 0
****************************************************************/
template <class R,class Obj>
struct ClassSlot0_:public ObjectSlot0_<R,Obj>
{
typedef ObjectSlot0_<R,Obj> Base;
typedef typename Base::InFunc InFunc;
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
return tmp;
}
};
template <class R,class Obj>
Slot0<R>
slot_class(Obj &obj,R (Obj::*func)())
{return ClassSlot0_<R,Obj>::create(&obj,func);
}
template <class R,class Obj>
Slot0<R>
slot_class(Obj *obj,R (Obj::*func)())
{return ClassSlot0_<R,Obj>::create(obj,func);
}
/****************************************************************
***** Class Slot 1
****************************************************************/
template <class R,class P1,class Obj>
struct ClassSlot1_:public ObjectSlot1_<R,P1,Obj>
{
typedef ObjectSlot1_<R,P1,Obj> Base;
typedef typename Base::InFunc InFunc;
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
return tmp;
}
};
template <class R,class P1,class Obj>
Slot1<R,P1>
slot_class(Obj &obj,R (Obj::*func)(P1))
{return ClassSlot1_<R,P1,Obj>::create(&obj,func);
}
template <class R,class P1,class Obj>
Slot1<R,P1>
slot_class(Obj *obj,R (Obj::*func)(P1))
{return ClassSlot1_<R,P1,Obj>::create(obj,func);
}
/****************************************************************
***** Class Slot 2
****************************************************************/
template <class R,class P1,class P2,class Obj>
struct ClassSlot2_:public ObjectSlot2_<R,P1,P2,Obj>
{
typedef ObjectSlot2_<R,P1,P2,Obj> Base;
typedef typename Base::InFunc InFunc;
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
return tmp;
}
};
template <class R,class P1,class P2,class Obj>
Slot2<R,P1,P2>
slot_class(Obj &obj,R (Obj::*func)(P1,P2))
{return ClassSlot2_<R,P1,P2,Obj>::create(&obj,func);
}
template <class R,class P1,class P2,class Obj>
Slot2<R,P1,P2>
slot_class(Obj *obj,R (Obj::*func)(P1,P2))
{return ClassSlot2_<R,P1,P2,Obj>::create(obj,func);
}
/****************************************************************
***** Class Slot 3
****************************************************************/
template <class R,class P1,class P2,class P3,class Obj>
struct ClassSlot3_:public ObjectSlot3_<R,P1,P2,P3,Obj>
{
typedef ObjectSlot3_<R,P1,P2,P3,Obj> Base;
typedef typename Base::InFunc InFunc;
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
return tmp;
}
};
template <class R,class P1,class P2,class P3,class Obj>
Slot3<R,P1,P2,P3>
slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3))
{return ClassSlot3_<R,P1,P2,P3,Obj>::create(&obj,func);
}
template <class R,class P1,class P2,class P3,class Obj>
Slot3<R,P1,P2,P3>
slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3))
{return ClassSlot3_<R,P1,P2,P3,Obj>::create(obj,func);
}
/****************************************************************
***** Class Slot 4
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class Obj>
struct ClassSlot4_:public ObjectSlot4_<R,P1,P2,P3,P4,Obj>
{
typedef ObjectSlot4_<R,P1,P2,P3,P4,Obj> Base;
typedef typename Base::InFunc InFunc;
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
return tmp;
}
};
template <class R,class P1,class P2,class P3,class P4,class Obj>
Slot4<R,P1,P2,P3,P4>
slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3,P4))
{return ClassSlot4_<R,P1,P2,P3,P4,Obj>::create(&obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class Obj>
Slot4<R,P1,P2,P3,P4>
slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3,P4))
{return ClassSlot4_<R,P1,P2,P3,P4,Obj>::create(obj,func);
}
/****************************************************************
***** Class Slot 5
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
struct ClassSlot5_:public ObjectSlot5_<R,P1,P2,P3,P4,P5,Obj>
{
typedef ObjectSlot5_<R,P1,P2,P3,P4,P5,Obj> Base;
typedef typename Base::InFunc InFunc;
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
return tmp;
}
};
template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
Slot5<R,P1,P2,P3,P4,P5>
slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3,P4,P5))
{return ClassSlot5_<R,P1,P2,P3,P4,P5,Obj>::create(&obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
Slot5<R,P1,P2,P3,P4,P5>
slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3,P4,P5))
{return ClassSlot5_<R,P1,P2,P3,P4,P5,Obj>::create(obj,func);
}
/****************************************************************
***** Class Slot 6
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
struct ClassSlot6_:public ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,Obj>
{
typedef ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,Obj> Base;
typedef typename Base::InFunc InFunc;
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
return tmp;
}
};
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
Slot6<R,P1,P2,P3,P4,P5,P6>
slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3,P4,P5,P6))
{return ClassSlot6_<R,P1,P2,P3,P4,P5,P6,Obj>::create(&obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
Slot6<R,P1,P2,P3,P4,P5,P6>
slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3,P4,P5,P6))
{return ClassSlot6_<R,P1,P2,P3,P4,P5,P6,Obj>::create(obj,func);
}
/****************************************************************
***** Class Slot 7
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
struct ClassSlot7_:public ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,Obj>
{
typedef ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,Obj> Base;
typedef typename Base::InFunc InFunc;
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
return tmp;
}
};
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
Slot7<R,P1,P2,P3,P4,P5,P6,P7>
slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3,P4,P5,P6,P7))
{return ClassSlot7_<R,P1,P2,P3,P4,P5,P6,P7,Obj>::create(&obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
Slot7<R,P1,P2,P3,P4,P5,P6,P7>
slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3,P4,P5,P6,P7))
{return ClassSlot7_<R,P1,P2,P3,P4,P5,P6,P7,Obj>::create(obj,func);
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/convert.h
0,0 → 1,671
// -*- c++ -*-
/* This is a generated file, do not edit. Generated from ../sigc++/macros/convert.h.m4 */
#ifndef SIGCXX_CONVERT_H
#define SIGCXX_CONVERT_H
/*
SigC::convert
-------------
convert() alters a Slot by assigning a conversion function
which can completely alter the parameter types of a slot.
Only convert functions for changing with same number of
arguments is compiled by default. See examples/custom_convert.h.m4
for details on how to build non standard ones.
Sample usage:
int my_string_to_char(Callback1<int,const char*> *d,const string &s)
int f(const char*);
string s=hello;
Slot1<int,const string &> s2=convert(slot(f),my_string_to_char);
s2(s);
*/
#include <sigc++/adaptor.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/****************************************************************
***** Adaptor Convert Slot 1
****************************************************************/
template <class R1,class P1,
class R2,class Q1>
struct AdaptorConvertSlot1_1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot1<R1,P1> SlotType;
typedef Slot1<R2,Q1> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1);
typedef R1 (*InFunc)(Callback*,P1);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
return (data->func)(data->obj,p1);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,
class R2,class Q1>
struct AdaptorConvertSlot1_1
<void,P1,
R2,Q1>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot1<void,P1> SlotType;
typedef Slot1<R2,Q1> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1);
typedef void (*InFunc)(Callback*,P1);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
(data->func)(data->obj,p1);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#endif
#endif
template <class R1,class P1,
class R2,class Q1>
Slot1<R1,P1>
convert(const Slot1<R2,Q1> &s,
R1 (*func)(Callback1<R2,Q1>*,P1))
{return AdaptorConvertSlot1_1<R1,P1,
R2,Q1>::create(s.obj(),func);
}
/****************************************************************
***** Adaptor Convert Slot 2
****************************************************************/
template <class R1,class P1,class P2,
class R2,class Q1,class Q2>
struct AdaptorConvertSlot2_2: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot2<R1,P1,P2> SlotType;
typedef Slot2<R2,Q1,Q2> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2);
typedef R1 (*InFunc)(Callback*,P1,P2);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
return (data->func)(data->obj,p1,p2);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,
class R2,class Q1,class Q2>
struct AdaptorConvertSlot2_2
<void,P1,P2,
R2,Q1,Q2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot2<void,P1,P2> SlotType;
typedef Slot2<R2,Q1,Q2> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2);
typedef void (*InFunc)(Callback*,P1,P2);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
(data->func)(data->obj,p1,p2);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#endif
#endif
template <class R1,class P1,class P2,
class R2,class Q1,class Q2>
Slot2<R1,P1,P2>
convert(const Slot2<R2,Q1,Q2> &s,
R1 (*func)(Callback2<R2,Q1,Q2>*,P1,P2))
{return AdaptorConvertSlot2_2<R1,P1,P2,
R2,Q1,Q2>::create(s.obj(),func);
}
/****************************************************************
***** Adaptor Convert Slot 3
****************************************************************/
template <class R1,class P1,class P2,class P3,
class R2,class Q1,class Q2,class Q3>
struct AdaptorConvertSlot3_3: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot3<R1,P1,P2,P3> SlotType;
typedef Slot3<R2,Q1,Q2,Q3> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3);
typedef R1 (*InFunc)(Callback*,P1,P2,P3);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
return (data->func)(data->obj,p1,p2,p3);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,
class R2,class Q1,class Q2,class Q3>
struct AdaptorConvertSlot3_3
<void,P1,P2,P3,
R2,Q1,Q2,Q3>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot3<void,P1,P2,P3> SlotType;
typedef Slot3<R2,Q1,Q2,Q3> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3);
typedef void (*InFunc)(Callback*,P1,P2,P3);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
(data->func)(data->obj,p1,p2,p3);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#endif
#endif
template <class R1,class P1,class P2,class P3,
class R2,class Q1,class Q2,class Q3>
Slot3<R1,P1,P2,P3>
convert(const Slot3<R2,Q1,Q2,Q3> &s,
R1 (*func)(Callback3<R2,Q1,Q2,Q3>*,P1,P2,P3))
{return AdaptorConvertSlot3_3<R1,P1,P2,P3,
R2,Q1,Q2,Q3>::create(s.obj(),func);
}
/****************************************************************
***** Adaptor Convert Slot 4
****************************************************************/
template <class R1,class P1,class P2,class P3,class P4,
class R2,class Q1,class Q2,class Q3,class Q4>
struct AdaptorConvertSlot4_4: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot4<R1,P1,P2,P3,P4> SlotType;
typedef Slot4<R2,Q1,Q2,Q3,Q4> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3,P4);
typedef R1 (*InFunc)(Callback*,P1,P2,P3,P4);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
return (data->func)(data->obj,p1,p2,p3,p4);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,
class R2,class Q1,class Q2,class Q3,class Q4>
struct AdaptorConvertSlot4_4
<void,P1,P2,P3,P4,
R2,Q1,Q2,Q3,Q4>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot4<void,P1,P2,P3,P4> SlotType;
typedef Slot4<R2,Q1,Q2,Q3,Q4> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3,P4);
typedef void (*InFunc)(Callback*,P1,P2,P3,P4);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
(data->func)(data->obj,p1,p2,p3,p4);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#endif
#endif
template <class R1,class P1,class P2,class P3,class P4,
class R2,class Q1,class Q2,class Q3,class Q4>
Slot4<R1,P1,P2,P3,P4>
convert(const Slot4<R2,Q1,Q2,Q3,Q4> &s,
R1 (*func)(Callback4<R2,Q1,Q2,Q3,Q4>*,P1,P2,P3,P4))
{return AdaptorConvertSlot4_4<R1,P1,P2,P3,P4,
R2,Q1,Q2,Q3,Q4>::create(s.obj(),func);
}
/****************************************************************
***** Adaptor Convert Slot 5
****************************************************************/
template <class R1,class P1,class P2,class P3,class P4,class P5,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5>
struct AdaptorConvertSlot5_5: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot5<R1,P1,P2,P3,P4,P5> SlotType;
typedef Slot5<R2,Q1,Q2,Q3,Q4,Q5> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3,P4,P5);
typedef R1 (*InFunc)(Callback*,P1,P2,P3,P4,P5);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
return (data->func)(data->obj,p1,p2,p3,p4,p5);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5>
struct AdaptorConvertSlot5_5
<void,P1,P2,P3,P4,P5,
R2,Q1,Q2,Q3,Q4,Q5>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
typedef Slot5<R2,Q1,Q2,Q3,Q4,Q5> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3,P4,P5);
typedef void (*InFunc)(Callback*,P1,P2,P3,P4,P5);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
(data->func)(data->obj,p1,p2,p3,p4,p5);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#endif
#endif
template <class R1,class P1,class P2,class P3,class P4,class P5,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5>
Slot5<R1,P1,P2,P3,P4,P5>
convert(const Slot5<R2,Q1,Q2,Q3,Q4,Q5> &s,
R1 (*func)(Callback5<R2,Q1,Q2,Q3,Q4,Q5>*,P1,P2,P3,P4,P5))
{return AdaptorConvertSlot5_5<R1,P1,P2,P3,P4,P5,
R2,Q1,Q2,Q3,Q4,Q5>::create(s.obj(),func);
}
/****************************************************************
***** Adaptor Convert Slot 6
****************************************************************/
template <class R1,class P1,class P2,class P3,class P4,class P5,class P6,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6>
struct AdaptorConvertSlot6_6: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot6<R1,P1,P2,P3,P4,P5,P6> SlotType;
typedef Slot6<R2,Q1,Q2,Q3,Q4,Q5,Q6> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3,P4,P5,P6);
typedef R1 (*InFunc)(Callback*,P1,P2,P3,P4,P5,P6);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
return (data->func)(data->obj,p1,p2,p3,p4,p5,p6);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,class P6,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6>
struct AdaptorConvertSlot6_6
<void,P1,P2,P3,P4,P5,P6,
R2,Q1,Q2,Q3,Q4,Q5,Q6>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
typedef Slot6<R2,Q1,Q2,Q3,Q4,Q5,Q6> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3,P4,P5,P6);
typedef void (*InFunc)(Callback*,P1,P2,P3,P4,P5,P6);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
(data->func)(data->obj,p1,p2,p3,p4,p5,p6);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#endif
#endif
template <class R1,class P1,class P2,class P3,class P4,class P5,class P6,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6>
Slot6<R1,P1,P2,P3,P4,P5,P6>
convert(const Slot6<R2,Q1,Q2,Q3,Q4,Q5,Q6> &s,
R1 (*func)(Callback6<R2,Q1,Q2,Q3,Q4,Q5,Q6>*,P1,P2,P3,P4,P5,P6))
{return AdaptorConvertSlot6_6<R1,P1,P2,P3,P4,P5,P6,
R2,Q1,Q2,Q3,Q4,Q5,Q6>::create(s.obj(),func);
}
/****************************************************************
***** Adaptor Convert Slot 7
****************************************************************/
template <class R1,class P1,class P2,class P3,class P4,class P5,class P6,class P7,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6,class Q7>
struct AdaptorConvertSlot7_7: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot7<R1,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef Slot7<R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3,P4,P5,P6,P7);
typedef R1 (*InFunc)(Callback*,P1,P2,P3,P4,P5,P6,P7);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
return (data->func)(data->obj,p1,p2,p3,p4,p5,p6,p7);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#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,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6,class Q7>
struct AdaptorConvertSlot7_7
<void,P1,P2,P3,P4,P5,P6,P7,
R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef Slot7<R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7> InSlotType;
typedef typename InSlotType::Callback Callback;
typedef RType (*Func) (Callback*,P1,P2,P3,P4,P5,P6,P7);
typedef void (*InFunc)(Callback*,P1,P2,P3,P4,P5,P6,P7);
typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
(data->func)(data->obj,p1,p2,p3,p4,p5,p6,p7);
}
static SlotData* create(SlotData *s,InFunc func)
{
SlotData* tmp=(SlotData*)s;
AdaptorNode *node=new AdaptorNode();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
data.obj=(Callback*)&(node->data_);
return tmp;
}
};
#endif
#endif
template <class R1,class P1,class P2,class P3,class P4,class P5,class P6,class P7,
class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6,class Q7>
Slot7<R1,P1,P2,P3,P4,P5,P6,P7>
convert(const Slot7<R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7> &s,
R1 (*func)(Callback7<R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7>*,P1,P2,P3,P4,P5,P6,P7))
{return AdaptorConvertSlot7_7<R1,P1,P2,P3,P4,P5,P6,P7,
R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7>::create(s.obj(),func);
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/func_slot.h
0,0 → 1,606
// -*- c++ -*-
/* This is a generated file, do not edit. Generated from ../sigc++/macros/func_slot.h.m4 */
#ifndef SIGCXX_FUNC_SLOT_H
#define SIGCXX_FUNC_SLOT_H
#include <sigc++/slot.h>
/*
SigC::slot() (function)
-----------------------
slot() can be applied to a function to form a Slot with a
profile equivelent to the function. To avoid warns be
sure to pass the address of the function.
Sample usage:
void foo(int,int);
Slot2<void,int,int> s=slot(&foo);
*/
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
// From which we build specific Slots and a set of
// functions for creating a slot of this type
/****************************************************************
***** Function Slot 0
****************************************************************/
template <class R>
struct FuncSlot0_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (*InFunc)();
typedef RType (*Func)();
typedef Slot0<R> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data)
{
return (((CallData*)data)->func)();
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <>
struct FuncSlot0_<void>
{
typedef void RType;
typedef void (*InFunc)();
typedef RType (*Func)();
typedef Slot0<void> SlotType;
typedef CallDataFunc<SlotType::Func,Func> CallData;
static RType callback(void* data)
{
(((CallData*)data)->func)();
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#endif
#endif
template <class R>
inline Slot0<R>
slot(R (*func)())
{
return FuncSlot0_<R>::create(func);
}
/****************************************************************
***** Function Slot 1
****************************************************************/
template <class R,class P1>
struct FuncSlot1_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (*InFunc)(P1);
typedef RType (*Func)(P1);
typedef Slot1<R,P1> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1)
{
return (((CallData*)data)->func)(p1);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1>
struct FuncSlot1_<void,P1>
{
typedef void RType;
typedef void (*InFunc)(P1);
typedef RType (*Func)(P1);
typedef Slot1<void,P1> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1)
{
(((CallData*)data)->func)(p1);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#endif
#endif
template <class R,class P1>
inline Slot1<R,P1>
slot(R (*func)(P1))
{
return FuncSlot1_<R,P1>::create(func);
}
/****************************************************************
***** Function Slot 2
****************************************************************/
template <class R,class P1,class P2>
struct FuncSlot2_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (*InFunc)(P1,P2);
typedef RType (*Func)(P1,P2);
typedef Slot2<R,P1,P2> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2)
{
return (((CallData*)data)->func)(p1,p2);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2>
struct FuncSlot2_<void,P1,P2>
{
typedef void RType;
typedef void (*InFunc)(P1,P2);
typedef RType (*Func)(P1,P2);
typedef Slot2<void,P1,P2> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2)
{
(((CallData*)data)->func)(p1,p2);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2>
inline Slot2<R,P1,P2>
slot(R (*func)(P1,P2))
{
return FuncSlot2_<R,P1,P2>::create(func);
}
/****************************************************************
***** Function Slot 3
****************************************************************/
template <class R,class P1,class P2,class P3>
struct FuncSlot3_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (*InFunc)(P1,P2,P3);
typedef RType (*Func)(P1,P2,P3);
typedef Slot3<R,P1,P2,P3> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3)
{
return (((CallData*)data)->func)(p1,p2,p3);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3>
struct FuncSlot3_<void,P1,P2,P3>
{
typedef void RType;
typedef void (*InFunc)(P1,P2,P3);
typedef RType (*Func)(P1,P2,P3);
typedef Slot3<void,P1,P2,P3> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3)
{
(((CallData*)data)->func)(p1,p2,p3);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3>
inline Slot3<R,P1,P2,P3>
slot(R (*func)(P1,P2,P3))
{
return FuncSlot3_<R,P1,P2,P3>::create(func);
}
/****************************************************************
***** Function Slot 4
****************************************************************/
template <class R,class P1,class P2,class P3,class P4>
struct FuncSlot4_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (*InFunc)(P1,P2,P3,P4);
typedef RType (*Func)(P1,P2,P3,P4);
typedef Slot4<R,P1,P2,P3,P4> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4)
{
return (((CallData*)data)->func)(p1,p2,p3,p4);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4>
struct FuncSlot4_<void,P1,P2,P3,P4>
{
typedef void RType;
typedef void (*InFunc)(P1,P2,P3,P4);
typedef RType (*Func)(P1,P2,P3,P4);
typedef Slot4<void,P1,P2,P3,P4> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4)
{
(((CallData*)data)->func)(p1,p2,p3,p4);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class P4>
inline Slot4<R,P1,P2,P3,P4>
slot(R (*func)(P1,P2,P3,P4))
{
return FuncSlot4_<R,P1,P2,P3,P4>::create(func);
}
/****************************************************************
***** Function Slot 5
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5>
struct FuncSlot5_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (*InFunc)(P1,P2,P3,P4,P5);
typedef RType (*Func)(P1,P2,P3,P4,P5);
typedef Slot5<R,P1,P2,P3,P4,P5> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
return (((CallData*)data)->func)(p1,p2,p3,p4,p5);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5>
struct FuncSlot5_<void,P1,P2,P3,P4,P5>
{
typedef void RType;
typedef void (*InFunc)(P1,P2,P3,P4,P5);
typedef RType (*Func)(P1,P2,P3,P4,P5);
typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
(((CallData*)data)->func)(p1,p2,p3,p4,p5);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class P4,class P5>
inline Slot5<R,P1,P2,P3,P4,P5>
slot(R (*func)(P1,P2,P3,P4,P5))
{
return FuncSlot5_<R,P1,P2,P3,P4,P5>::create(func);
}
/****************************************************************
***** Function Slot 6
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class P6>
struct FuncSlot6_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (*InFunc)(P1,P2,P3,P4,P5,P6);
typedef RType (*Func)(P1,P2,P3,P4,P5,P6);
typedef Slot6<R,P1,P2,P3,P4,P5,P6> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
return (((CallData*)data)->func)(p1,p2,p3,p4,p5,p6);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,class P6>
struct FuncSlot6_<void,P1,P2,P3,P4,P5,P6>
{
typedef void RType;
typedef void (*InFunc)(P1,P2,P3,P4,P5,P6);
typedef RType (*Func)(P1,P2,P3,P4,P5,P6);
typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
(((CallData*)data)->func)(p1,p2,p3,p4,p5,p6);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class P4,class P5,class P6>
inline Slot6<R,P1,P2,P3,P4,P5,P6>
slot(R (*func)(P1,P2,P3,P4,P5,P6))
{
return FuncSlot6_<R,P1,P2,P3,P4,P5,P6>::create(func);
}
/****************************************************************
***** Function Slot 7
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
struct FuncSlot7_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (*InFunc)(P1,P2,P3,P4,P5,P6,P7);
typedef RType (*Func)(P1,P2,P3,P4,P5,P6,P7);
typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
return (((CallData*)data)->func)(p1,p2,p3,p4,p5,p6,p7);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#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 FuncSlot7_<void,P1,P2,P3,P4,P5,P6,P7>
{
typedef void RType;
typedef void (*InFunc)(P1,P2,P3,P4,P5,P6,P7);
typedef RType (*Func)(P1,P2,P3,P4,P5,P6,P7);
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef CallDataFunc<typename SlotType::Func,Func> CallData;
static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
(((CallData*)data)->func)(p1,p2,p3,p4,p5,p6,p7);
}
static SlotData* create(InFunc func)
{
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.func=(Func)func;
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
inline Slot7<R,P1,P2,P3,P4,P5,P6,P7>
slot(R (*func)(P1,P2,P3,P4,P5,P6,P7))
{
return FuncSlot7_<R,P1,P2,P3,P4,P5,P6,P7>::create(func);
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif // SIGCXX_FUNC_SLOT_H

/programs/develop/libraries/menuetlibc/include/sigc++/generator.h
0,0 → 1,159
#ifndef SIGCXX_GENERATOR_H
#define SIGCXX_GENERATOR_H
#include <sigc++config.h>
#include <new>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
// 0
template <class T>
T* gen()
{return manage(new T());}
// 1
template <class T,class P1>
T* gen(const P1& p1)
{return manage(new T(p1));}
template <class T,class P1>
T* gen(P1& p1)
{return manage(new T(p1));}
// 2
template <class T,class P1,class P2>
T* gen(const P1& p1,const P2& p2)
{return manage(new T(p1,p2));}
template <class T,class P1,class P2>
T* gen(P1& p1,const P2& p2)
{return manage(new T(p1,p2));}
template <class T,class P1,class P2>
T* gen(const P1& p1,P2& p2)
{return manage(new T(p1,p2));}
template <class T,class P1,class P2>
T* gen(P1& p1,P2& p2)
{return manage(new T(p1,p2));}
// 3
template <class T,class P1,class P2,class P3>
T* gen(const P1& p1,const P2& p2,const P3& p3)
{return manage(new T(p1,p2,p3));}
template <class T,class P1,class P2,class P3>
T* gen(P1& p1,const P2& p2,const P3& p3)
{return manage(new T(p1,p2,p3));}
template <class T,class P1,class P2,class P3>
T* gen(const P1& p1,P2& p2,const P3& p3)
{return manage(new T(p1,p2,p3));}
template <class T,class P1,class P2,class P3>
T* gen(const P1& p1,const P2& p2,P3& p3)
{return manage(new T(p1,p2,p3));}
template <class T,class P1,class P2,class P3>
T* gen(const P1& p1,P2& p2,P3& p3)
{return manage(new T(p1,p2,p3));}
template <class T,class P1,class P2,class P3>
T* gen(P1& p1,const P2& p2,P3& p3)
{return manage(new T(p1,p2,p3));}
template <class T,class P1,class P2,class P3>
T* gen(P1& p1,P2& p2,const P3& p3)
{return manage(new T(p1,p2,p3));}
template <class T,class P1,class P2,class P3>
T* gen(P1& p1,P2& p2,P3& p3)
{return manage(new T(p1,p2,p3));}
// 4
template <class T,class P1,class P2,class P3,class P4>
T* gen(const P1& p1,const P2& p2,const P3& p3,const P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(P1& p1,const P2& p2,const P3& p3,const P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(const P1& p1,P2& p2,const P3& p3,const P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(const P1& p1,const P2& p2,P3& p3,const P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(const P1& p1,const P2& p2,const P3& p3,P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(const P1& p1,P2& p2,P3& p3,P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(P1& p1,const P2& p2,P3& p3,P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(P1& p1,P2& p2,const P3& p3,P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(P1& p1,P2& p2,P3& p3,const P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(const P1& p1,const P2& p2,P3& p3,P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(const P1& p1,P2& p2,const P3& p3,P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(const P1& p1,P2& p2,P3& p3,const P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(P1& p1,const P2& p2,const P3& p3,P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(P1& p1,const P2& p2,P3& p3,const P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(P1& p1,P2& p2,const P3& p3,const P4& p4)
{return manage(new T(p1,p2,p3,p4));}
template <class T,class P1,class P2,class P3,class P4>
T* gen(P1& p1,P2& p2,P3& p3,P4& p4)
{return manage(new T(p1,p2,p3,p4));}
//From here one we will just generate warnings
template <class T,class P1,class P2,class P3,class P4,class P5>
T* gen(P1& p1,P2& p2,P3& p3,P4& p4,P5& p5)
{return manage(new T(p1,p2,p3,p4,p5));}
template <class T,class P1,class P2,class P3,class P4,class P5,class P6>
T* gen(P1& p1,P2& p2,P3& p3,P4& p4,P5& p5,P6& p6)
{return manage(new T(p1,p2,p3,p4,p5,p6));}
template <class T,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
T* gen(P1& p1,P2& p2,P3& p3,P4& p4,P5& p5,P6& p6,P7& p7)
{return manage(new T(p1,p2,p3,p4,p5,p6,p7));}
#ifdef SIGC_CXX_NAMESPACES
} // namespace sigc
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/handle.h
0,0 → 1,113
#ifndef SIGCXX_HANDLE_H
#define SIGCXX_HANDLE_H
#include <sigc++config.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
// Signiture for Handles
template <class Obj,class Scope_>
class Handle
{
protected:
Scope_ scope_;
public:
// access
Obj* obj()
{
return static_cast<Obj*>(scope_.cache());
}
Obj* obj() const
{
return static_cast<Obj*>(scope_.cache());
}
bool connected() const
{return (scope_.object()!=0);}
operator Obj*()
{return (obj());}
operator Obj*() const
{return (obj());}
Obj& operator*() const
{return *(obj());}
Obj* operator->() const
{return (obj());}
Scope_& scope()
{return scope_;}
const Scope_& scope() const
{return scope_;}
void disconnect()
{scope_.disconnect(0);}
// copy
Handle& operator =(Obj* obj)
{scope_.set(obj,obj,true); return *this;}
Handle& operator =(Obj& obj)
{scope_.set(&obj,&obj,false); return *this;}
#ifndef SIGC_CXX_TEMPLATE_CCTOR
Handle& operator =(const Handle& handle)
{
Obj *o=handle.obj();
scope_.set(o,o,false);
return *this;
}
#endif
template <class Obj2,class Scope2>
Handle& operator = (const Handle<Obj2,Scope2>& handle)
{
Obj *o=handle.obj();
scope_.set(o,o,false);
return *this;
}
// construct
Handle():scope_() {}
Handle(Obj *obj):scope_() {scope_.set(obj,obj,true);}
Handle(Obj &obj):scope_() {scope_.set(&obj,&obj,false);}
#ifndef SIGC_CXX_TEMPLATE_CCTOR
Handle(const Handle& handle)
:scope_()
{
Obj *o=handle.obj();
scope_.set(o,o,false);
}
#endif
template <class Obj2,class Scope2>
Handle(const Handle<Obj2,Scope2>& handle)
:scope_()
{
Obj *o=handle.obj();
scope_.set(o,o,false);
}
};
#define HANDLE_CTORS(X,T,P) \
public: \
X(T *t):Handle<T,P>(t) {} \
X(T &t):Handle<T,P>(t) {} \
template <class T2,class P2> \
X(const Handle<T2,P2> &h):Handle<T,P>(h) {} \
X& operator =(T *t) \
{return Handle<T,P>::operator=(t);} \
X& operator =(T &t) \
{return Handle<T,P>::operator=(t);} \
template <class T2,class P2> \
X& operator =(const Handle<T2,P2> &t) \
{return Handle<T,P>::operator=(t);}
//template <class T>
// class Ref:public Handle<T,Scopes::RefCount>
// {
// HANDLE_CTORS(Ref,T,Scopes::RefCount)
// };
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/handle_system.h
0,0 → 1,4
#include <sigc++/object.h>
#include <sigc++/scope.h>
#include <sigc++/handle.h>

/programs/develop/libraries/menuetlibc/include/sigc++/marshal.h
0,0 → 1,205
#ifndef SIGCXX_MARSHALLER_H
#define SIGCXX_MARSHALLER_H
#include <sigc++config.h>
#ifndef SIGC_CXX_PARTIAL_SPEC
#include <sigc++/slot.h>
#endif
#ifdef SIGC_PTHREADS
#include <sigc++/thread.h>
#endif
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/*
All classes used to marshal return values should have the following
class SomeMarshal
{
// both typedefs must be defined.
typedef Type1 InType;
typedef Type2 OutType;
public:
// Return final return code.
OutType value();
// Captures return codes and returns TRUE to stop emittion.
bool marshal(const InType&);
SomeMarshal();
};
It is not necessary for the InType to match the OutType.
This is to allow for things like list capturing.
*/
/*******************************************************************
***** Marshal
*******************************************************************/
// A struct that holds an flag for determining
// if the return value is to be ignored.
class LIBSIGC_API RetCode
{
public:
static int check_ignore();
static void ignore();
};
// Basic Marshal class.
template <typename R>
class Marshal
{
public:
typedef R OutType;
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R InType;
protected:
typedef OutType OutType_;
#else
typedef Trait<R>::type InType;
protected:
typedef InType OutType_;
#endif
OutType_ value_;
public:
OutType_& value() {return value_;}
static OutType_ default_value()
#ifdef SIGC_CXX_INT_CTOR
{return OutType_();}
#else
{OutType_ r; new (&r) OutType_(); return r;}
#endif
// This captures return values. Return TRUE to stop emittion process.
bool marshal(const InType& newval)
{
if (!RetCode::check_ignore()) value_=newval;
return 0; // continue emittion process
};
Marshal()
#ifdef SIGC_CXX_INT_CTOR
:value_()
{RetCode::check_ignore();}
#else
{
RetCode::check_ignore();
new (&value_) OutType_();
}
#endif
};
#ifdef SIGC_CXX_SPECIALIZE_REFERENCES
// Basic Marshal class.
template <typename R>
class Marshal<R&>
{
public:
typedef R& OutType;
typedef R& InType;
R* value_;
OutType value() {return value_;}
static OutType default_value() {return Default;}
static R Default;
// This captures return values. Return TRUE to stop emittion process.
bool marshal(InType newval)
{
if (!RetCode::check_ignore()) value_=&newval;
return 0; // continue emittion process
};
Marshal()
:value_(&Default)
{RetCode::check_ignore();}
~Marshal()
{}
};
template <typename T> T Marshal<T&>::Default;
#endif
#ifdef SIGC_CXX_PARTIAL_SPEC
// dummy marshaller for void type.
template <>
class Marshal<void>
{
public:
Marshal()
{}
~Marshal()
{}
};
#endif
// starts with a fixed value
template <class R,R initial>
class FixedMarshal
{
public:
typedef R OutType;
typedef R InType;
R value_;
OutType& value() {return value_;}
static OutType default_value() { return initial; }
bool marshal(const InType& newval)
{
if (!RetCode::check_ignore()) value_=newval;
return 0; // continue emittion process
};
FixedMarshal()
:value_(initial)
{RetCode::check_ignore();}
~FixedMarshal()
{}
};
template <class R>
struct FastMarshal
{
typedef R OutType;
typedef R InType;
R value_;
OutType& value() {return value_;}
static OutType default_value()
#ifdef SIGC_CXX_INT_CTOR
{return R();}
#else
{R r; new (&r) R(); return r;}
#endif
bool marshal(const InType& newval)
{
value_=newval;
return 0; // continue emittion process
};
FastMarshal()
#ifdef SIGC_CXX_INT_CTOR
:value_()
{}
#else
{new (&value_) R();}
#endif
~FastMarshal()
{}
};
#ifdef SIGC_CXX_NAMESPACES
} // namespace sigc
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/object.h
0,0 → 1,153
// -*- c++ -*-
/*
* Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef SIGCXX_OBJECT_H
#define SIGCXX_OBJECT_H
#include <sigc++config.h>
#include <sigc++/scope.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
extern int sigc_micro_version;
extern int sigc_minor_version;
extern int sigc_major_version;
class Invalid_;
class LIBSIGC_API ObjectReferenced
{
friend class Reference;
friend class Scope;
friend class Invalid_;
#ifdef SIGC_CXX_FRIEND_TEMPLATES
template <class T>
friend T* manage(T*);
#endif
protected:
// count of current references
unsigned int obj_count_ :24;
// indicates object generated through an interface that marks dynamic
unsigned int obj_dynamic_ :1;
// indicates the pointed to scope is the owner
unsigned int obj_owned_ :1;
// indicates object not will delete when count reachs zero
unsigned int obj_floating_ :1;
// indicates the owned scope is surrendering ownership
unsigned int obj_transfer_ :1;
// indicates the object is doing a list clean up
unsigned int obj_invalid_ :1;
// indicates the object been destroyed
unsigned int obj_destroyed_ :1;
// indicates there is a weak reference
unsigned int obj_weak_ :1;
/*************************************************************/
#ifdef SIGC_CXX_FRIEND_TEMPLATES
protected:
#else
public:
#endif
// For the controller and scope
virtual void set_dynamic();
inline void set_sink() {obj_floating_=0;}
protected:
inline void register_ref(Reference *)
{
if (obj_transfer_)
{
obj_transfer_=0;
obj_owned_=0;
}
}
public:
virtual void reference();
virtual void unreference();
inline bool is_dynamic() {return obj_dynamic_;}
inline bool is_floating() {return obj_floating_;}
ObjectReferenced();
virtual ~ObjectReferenced();
};
class LIBSIGC_API ObjectScoped :public ObjectReferenced
{
friend class Scope;
typedef ScopeList List_;
private:
mutable List_ list_;
// interface for scopes
void register_scope(Scope *scope,const Scope *parent=0);
void unregister_scope(Scope *scope);
protected:
// This sets a very weak reference which is removed at next invalid
void set_weak();
public:
void register_data(ScopeNode* data);
// inform connections that object wishs to delete
void invalid(bool destroy=0);
ObjectScoped();
virtual ~ObjectScoped();
};
// There can only be one Scope_Object per any object
class LIBSIGC_API Object: public virtual ObjectScoped
{
public:
Object() {}
virtual ~Object();
};
// mark this a managable object
template <class T>
inline T* manage(T* t)
{
if (t) t->set_dynamic();
return t;
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/object_slot.h
0,0 → 1,818
// -*- c++ -*-
/* This is a generated file, do not edit. Generated from ../sigc++/macros/object_slot.h.m4 */
#ifndef SIGCXX_OBJECT_SLOT_H
#define SIGCXX_OBJECT_SLOT_H
/*
SigC::slot() (obj)
-----------------------
slot() can be applied to a object method to form a Slot with a
profile equivelent to the method. At the same time an instance
of that object must be specified. The object must be derived
from SigC::Object.
Sample usage:
struct A: public SigC::Object
{
void foo(int,int);
} a;
Slot2<void,int,int> s=slot(a,&A::foo);
*/
#include <sigc++/slot.h>
#include <sigc++/scope.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/****************************************************************
***** Object Slot 0
****************************************************************/
template <class R,class Obj>
struct ObjectSlot0_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (Obj::*InFunc)();
typedef RType (Obj::*Func)();
typedef Slot0<R> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
return ((data->obj)->*(data->func))();
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Obj>
struct ObjectSlot0_<void,Obj>
{
typedef void RType;
typedef void (Obj::*InFunc)();
typedef RType (Obj::*Func)();
typedef Slot0<void> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
((data->obj)->*(data->func))();
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#endif
#endif
template <class R,class O,class O2>
inline Slot0<R>
slot(O* &obj,R (O2::*func)())
{
return ObjectSlot0_<R,O2>
::create(obj,func);
}
template <class R,class O,class O2>
inline Slot0<R>
slot(O* const &obj,R (O2::*func)())
{
return ObjectSlot0_<R,O2>
::create(obj,func);
}
template <class R,class O,class O2>
inline Slot0<R>
slot(O &obj,R (O2::*func)())
{
return ObjectSlot0_<R,O2>
::create(&obj,func);
}
/****************************************************************
***** Object Slot 1
****************************************************************/
template <class R,class P1,class Obj>
struct ObjectSlot1_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (Obj::*InFunc)(P1);
typedef RType (Obj::*Func)(P1);
typedef Slot1<R,P1> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
return ((data->obj)->*(data->func))(p1);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class Obj>
struct ObjectSlot1_<void,P1,Obj>
{
typedef void RType;
typedef void (Obj::*InFunc)(P1);
typedef RType (Obj::*Func)(P1);
typedef Slot1<void,P1> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
((data->obj)->*(data->func))(p1);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#endif
#endif
template <class R,class P1,class O,class O2>
inline Slot1<R,P1>
slot(O* &obj,R (O2::*func)(P1))
{
return ObjectSlot1_<R,P1,O2>
::create(obj,func);
}
template <class R,class P1,class O,class O2>
inline Slot1<R,P1>
slot(O* const &obj,R (O2::*func)(P1))
{
return ObjectSlot1_<R,P1,O2>
::create(obj,func);
}
template <class R,class P1,class O,class O2>
inline Slot1<R,P1>
slot(O &obj,R (O2::*func)(P1))
{
return ObjectSlot1_<R,P1,O2>
::create(&obj,func);
}
/****************************************************************
***** Object Slot 2
****************************************************************/
template <class R,class P1,class P2,class Obj>
struct ObjectSlot2_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (Obj::*InFunc)(P1,P2);
typedef RType (Obj::*Func)(P1,P2);
typedef Slot2<R,P1,P2> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
return ((data->obj)->*(data->func))(p1,p2);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class Obj>
struct ObjectSlot2_<void,P1,P2,Obj>
{
typedef void RType;
typedef void (Obj::*InFunc)(P1,P2);
typedef RType (Obj::*Func)(P1,P2);
typedef Slot2<void,P1,P2> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
((data->obj)->*(data->func))(p1,p2);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class O,class O2>
inline Slot2<R,P1,P2>
slot(O* &obj,R (O2::*func)(P1,P2))
{
return ObjectSlot2_<R,P1,P2,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class O,class O2>
inline Slot2<R,P1,P2>
slot(O* const &obj,R (O2::*func)(P1,P2))
{
return ObjectSlot2_<R,P1,P2,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class O,class O2>
inline Slot2<R,P1,P2>
slot(O &obj,R (O2::*func)(P1,P2))
{
return ObjectSlot2_<R,P1,P2,O2>
::create(&obj,func);
}
/****************************************************************
***** Object Slot 3
****************************************************************/
template <class R,class P1,class P2,class P3,class Obj>
struct ObjectSlot3_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (Obj::*InFunc)(P1,P2,P3);
typedef RType (Obj::*Func)(P1,P2,P3);
typedef Slot3<R,P1,P2,P3> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
return ((data->obj)->*(data->func))(p1,p2,p3);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class Obj>
struct ObjectSlot3_<void,P1,P2,P3,Obj>
{
typedef void RType;
typedef void (Obj::*InFunc)(P1,P2,P3);
typedef RType (Obj::*Func)(P1,P2,P3);
typedef Slot3<void,P1,P2,P3> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
((data->obj)->*(data->func))(p1,p2,p3);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class O,class O2>
inline Slot3<R,P1,P2,P3>
slot(O* &obj,R (O2::*func)(P1,P2,P3))
{
return ObjectSlot3_<R,P1,P2,P3,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class O,class O2>
inline Slot3<R,P1,P2,P3>
slot(O* const &obj,R (O2::*func)(P1,P2,P3))
{
return ObjectSlot3_<R,P1,P2,P3,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class O,class O2>
inline Slot3<R,P1,P2,P3>
slot(O &obj,R (O2::*func)(P1,P2,P3))
{
return ObjectSlot3_<R,P1,P2,P3,O2>
::create(&obj,func);
}
/****************************************************************
***** Object Slot 4
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class Obj>
struct ObjectSlot4_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (Obj::*InFunc)(P1,P2,P3,P4);
typedef RType (Obj::*Func)(P1,P2,P3,P4);
typedef Slot4<R,P1,P2,P3,P4> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
return ((data->obj)->*(data->func))(p1,p2,p3,p4);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class Obj>
struct ObjectSlot4_<void,P1,P2,P3,P4,Obj>
{
typedef void RType;
typedef void (Obj::*InFunc)(P1,P2,P3,P4);
typedef RType (Obj::*Func)(P1,P2,P3,P4);
typedef Slot4<void,P1,P2,P3,P4> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
((data->obj)->*(data->func))(p1,p2,p3,p4);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class P4,class O,class O2>
inline Slot4<R,P1,P2,P3,P4>
slot(O* &obj,R (O2::*func)(P1,P2,P3,P4))
{
return ObjectSlot4_<R,P1,P2,P3,P4,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class O,class O2>
inline Slot4<R,P1,P2,P3,P4>
slot(O* const &obj,R (O2::*func)(P1,P2,P3,P4))
{
return ObjectSlot4_<R,P1,P2,P3,P4,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class O,class O2>
inline Slot4<R,P1,P2,P3,P4>
slot(O &obj,R (O2::*func)(P1,P2,P3,P4))
{
return ObjectSlot4_<R,P1,P2,P3,P4,O2>
::create(&obj,func);
}
/****************************************************************
***** Object Slot 5
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
struct ObjectSlot5_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (Obj::*InFunc)(P1,P2,P3,P4,P5);
typedef RType (Obj::*Func)(P1,P2,P3,P4,P5);
typedef Slot5<R,P1,P2,P3,P4,P5> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
return ((data->obj)->*(data->func))(p1,p2,p3,p4,p5);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,class Obj>
struct ObjectSlot5_<void,P1,P2,P3,P4,P5,Obj>
{
typedef void RType;
typedef void (Obj::*InFunc)(P1,P2,P3,P4,P5);
typedef RType (Obj::*Func)(P1,P2,P3,P4,P5);
typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
((data->obj)->*(data->func))(p1,p2,p3,p4,p5);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class P4,class P5,class O,class O2>
inline Slot5<R,P1,P2,P3,P4,P5>
slot(O* &obj,R (O2::*func)(P1,P2,P3,P4,P5))
{
return ObjectSlot5_<R,P1,P2,P3,P4,P5,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class O,class O2>
inline Slot5<R,P1,P2,P3,P4,P5>
slot(O* const &obj,R (O2::*func)(P1,P2,P3,P4,P5))
{
return ObjectSlot5_<R,P1,P2,P3,P4,P5,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class O,class O2>
inline Slot5<R,P1,P2,P3,P4,P5>
slot(O &obj,R (O2::*func)(P1,P2,P3,P4,P5))
{
return ObjectSlot5_<R,P1,P2,P3,P4,P5,O2>
::create(&obj,func);
}
/****************************************************************
***** Object Slot 6
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
struct ObjectSlot6_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (Obj::*InFunc)(P1,P2,P3,P4,P5,P6);
typedef RType (Obj::*Func)(P1,P2,P3,P4,P5,P6);
typedef Slot6<R,P1,P2,P3,P4,P5,P6> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
return ((data->obj)->*(data->func))(p1,p2,p3,p4,p5,p6);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
struct ObjectSlot6_<void,P1,P2,P3,P4,P5,P6,Obj>
{
typedef void RType;
typedef void (Obj::*InFunc)(P1,P2,P3,P4,P5,P6);
typedef RType (Obj::*Func)(P1,P2,P3,P4,P5,P6);
typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
((data->obj)->*(data->func))(p1,p2,p3,p4,p5,p6);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class O,class O2>
inline Slot6<R,P1,P2,P3,P4,P5,P6>
slot(O* &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6))
{
return ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class O,class O2>
inline Slot6<R,P1,P2,P3,P4,P5,P6>
slot(O* const &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6))
{
return ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class O,class O2>
inline Slot6<R,P1,P2,P3,P4,P5,P6>
slot(O &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6))
{
return ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,O2>
::create(&obj,func);
}
/****************************************************************
***** Object Slot 7
****************************************************************/
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
struct ObjectSlot7_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R RType;
#else
typedef typename Trait<R>::type RType;
#endif
typedef R (Obj::*InFunc)(P1,P2,P3,P4,P5,P6,P7);
typedef RType (Obj::*Func)(P1,P2,P3,P4,P5,P6,P7);
typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
return ((data->obj)->*(data->func))(p1,p2,p3,p4,p5,p6,p7);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#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,class Obj>
struct ObjectSlot7_<void,P1,P2,P3,P4,P5,P6,P7,Obj>
{
typedef void RType;
typedef void (Obj::*InFunc)(P1,P2,P3,P4,P5,P6,P7);
typedef RType (Obj::*Func)(P1,P2,P3,P4,P5,P6,P7);
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
((data->obj)->*(data->func))(p1,p2,p3,p4,p5,p6,p7);
}
static SlotData* create(Obj* obj,InFunc func)
{
if (!obj) return 0;
SlotData* tmp=manage(new SlotData());
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=obj;
data.func=(Func)func;
obj->register_data(tmp->receiver());
return tmp;
}
};
#endif
#endif
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class O,class O2>
inline Slot7<R,P1,P2,P3,P4,P5,P6,P7>
slot(O* &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6,P7))
{
return ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class O,class O2>
inline Slot7<R,P1,P2,P3,P4,P5,P6,P7>
slot(O* const &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6,P7))
{
return ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,O2>
::create(obj,func);
}
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class O,class O2>
inline Slot7<R,P1,P2,P3,P4,P5,P6,P7>
slot(O &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6,P7))
{
return ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,O2>
::create(&obj,func);
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/retbind.h
0,0 → 1,848
// -*- c++ -*-
/* This is a generated file, do not edit. Generated from ../sigc++/macros/retbind.h.m4 */
/* This was also shamelessly copied, hacked, munched, and carefully
* tweaked from KNelson's original bind.h.m4
* CJN 3.22.00
*/
#ifndef SIGCXX_RETBIND_H
#define SIGCXX_RETBIND_H
/*
SigC::retbind
-------------
retbind() alters a Slot by fixing the return value to certain values
Return value fixing ignores any slot return value. The slot is
destroyed in the process and a new one is created, so references
holding onto the slot will no longer be valid.
Typecasting may be necessary to match arguments between the
slot and the binding return value. Types must be an exact match.
To insure the proper type, the type can be explicitly specified
on template instantation.
Simple Sample usage:
void f(int,int);
Slot2<void,int,int> s1=slot(f);
Slot1<int,int,int> s2=retbind(s1,1); // s1 is invalid
cout << "s2: " << s2(2,1) << endl;
Type specified usage:
struct A {};
struct B :public A {};
B* b;
Slot1<void> s1;
Slot0<A*> s2=retbind<A*>(s1,b); // B* must be told to match A*
*/
#include <sigc++/adaptor.h>
#include <sigc++/scope.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/****************************************************************
***** Adaptor RetBind Slot 0 arguments
****************************************************************/
template <class Ret,class R>
struct AdaptorRetBindSlot0: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot0<Ret> SlotType;
typedef Slot0<R> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))();
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Ret>
struct AdaptorRetBindSlot0
<Ret,void> : public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot0<Ret> SlotType;
typedef Slot0<void> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))();
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class Ret,
class R>
Slot0<Ret>
retbind(const Slot0<R> &s,
Ret ret)
{return AdaptorRetBindSlot0<Ret,R>::create(s.data(),ret);
}
/****************************************************************
***** Adaptor RetBind Slot 1 arguments
****************************************************************/
template <class Ret,class R,
class P1>
struct AdaptorRetBindSlot1: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot1<Ret,P1> SlotType;
typedef Slot1<R,P1> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Ret,class P1>
struct AdaptorRetBindSlot1
<Ret,void,
P1> : public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot1<Ret,P1> SlotType;
typedef Slot1<void,P1> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class Ret,
class R,
class P1>
Slot1<Ret,P1>
retbind(const Slot1<R,P1> &s,
Ret ret)
{return AdaptorRetBindSlot1<Ret,R,
P1>::create(s.data(),ret);
}
/****************************************************************
***** Adaptor RetBind Slot 2 arguments
****************************************************************/
template <class Ret,class R,
class P1,class P2>
struct AdaptorRetBindSlot2: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot2<Ret,P1,P2> SlotType;
typedef Slot2<R,P1,P2> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Ret,class P1,class P2>
struct AdaptorRetBindSlot2
<Ret,void,
P1,P2> : public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot2<Ret,P1,P2> SlotType;
typedef Slot2<void,P1,P2> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class Ret,
class R,
class P1,class P2>
Slot2<Ret,P1,P2>
retbind(const Slot2<R,P1,P2> &s,
Ret ret)
{return AdaptorRetBindSlot2<Ret,R,
P1,P2>::create(s.data(),ret);
}
/****************************************************************
***** Adaptor RetBind Slot 3 arguments
****************************************************************/
template <class Ret,class R,
class P1,class P2,class P3>
struct AdaptorRetBindSlot3: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot3<Ret,P1,P2,P3> SlotType;
typedef Slot3<R,P1,P2,P3> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Ret,class P1,class P2,class P3>
struct AdaptorRetBindSlot3
<Ret,void,
P1,P2,P3> : public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot3<Ret,P1,P2,P3> SlotType;
typedef Slot3<void,P1,P2,P3> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class Ret,
class R,
class P1,class P2,class P3>
Slot3<Ret,P1,P2,P3>
retbind(const Slot3<R,P1,P2,P3> &s,
Ret ret)
{return AdaptorRetBindSlot3<Ret,R,
P1,P2,P3>::create(s.data(),ret);
}
/****************************************************************
***** Adaptor RetBind Slot 4 arguments
****************************************************************/
template <class Ret,class R,
class P1,class P2,class P3,class P4>
struct AdaptorRetBindSlot4: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot4<Ret,P1,P2,P3,P4> SlotType;
typedef Slot4<R,P1,P2,P3,P4> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Ret,class P1,class P2,class P3,class P4>
struct AdaptorRetBindSlot4
<Ret,void,
P1,P2,P3,P4> : public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot4<Ret,P1,P2,P3,P4> SlotType;
typedef Slot4<void,P1,P2,P3,P4> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class Ret,
class R,
class P1,class P2,class P3,class P4>
Slot4<Ret,P1,P2,P3,P4>
retbind(const Slot4<R,P1,P2,P3,P4> &s,
Ret ret)
{return AdaptorRetBindSlot4<Ret,R,
P1,P2,P3,P4>::create(s.data(),ret);
}
/****************************************************************
***** Adaptor RetBind Slot 5 arguments
****************************************************************/
template <class Ret,class R,
class P1,class P2,class P3,class P4,class P5>
struct AdaptorRetBindSlot5: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot5<Ret,P1,P2,P3,P4,P5> SlotType;
typedef Slot5<R,P1,P2,P3,P4,P5> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Ret,class P1,class P2,class P3,class P4,class P5>
struct AdaptorRetBindSlot5
<Ret,void,
P1,P2,P3,P4,P5> : public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot5<Ret,P1,P2,P3,P4,P5> SlotType;
typedef Slot5<void,P1,P2,P3,P4,P5> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class Ret,
class R,
class P1,class P2,class P3,class P4,class P5>
Slot5<Ret,P1,P2,P3,P4,P5>
retbind(const Slot5<R,P1,P2,P3,P4,P5> &s,
Ret ret)
{return AdaptorRetBindSlot5<Ret,R,
P1,P2,P3,P4,P5>::create(s.data(),ret);
}
/****************************************************************
***** Adaptor RetBind Slot 6 arguments
****************************************************************/
template <class Ret,class R,
class P1,class P2,class P3,class P4,class P5,class P6>
struct AdaptorRetBindSlot6: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot6<Ret,P1,P2,P3,P4,P5,P6> SlotType;
typedef Slot6<R,P1,P2,P3,P4,P5,P6> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Ret,class P1,class P2,class P3,class P4,class P5,class P6>
struct AdaptorRetBindSlot6
<Ret,void,
P1,P2,P3,P4,P5,P6> : public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot6<Ret,P1,P2,P3,P4,P5,P6> SlotType;
typedef Slot6<void,P1,P2,P3,P4,P5,P6> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class Ret,
class R,
class P1,class P2,class P3,class P4,class P5,class P6>
Slot6<Ret,P1,P2,P3,P4,P5,P6>
retbind(const Slot6<R,P1,P2,P3,P4,P5,P6> &s,
Ret ret)
{return AdaptorRetBindSlot6<Ret,R,
P1,P2,P3,P4,P5,P6>::create(s.data(),ret);
}
/****************************************************************
***** Adaptor RetBind Slot 7 arguments
****************************************************************/
template <class Ret,class R,
class P1,class P2,class P3,class P4,class P5,class P6,class P7>
struct AdaptorRetBindSlot7: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot7<Ret,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <class Ret,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
struct AdaptorRetBindSlot7
<Ret,void,
P1,P2,P3,P4,P5,P6,P7> : public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef Ret RType;
#else
typedef typename Trait<Ret>::type RType;
#endif
typedef Slot7<Ret,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> InSlotType;
struct Node:public AdaptorNode
{
Ret ret_;
};
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7);
return node->ret_;
}
static SlotData* create(SlotData *s,Ret ret)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
node->ret_ = ret;
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class Ret,
class R,
class P1,class P2,class P3,class P4,class P5,class P6,class P7>
Slot7<Ret,P1,P2,P3,P4,P5,P6,P7>
retbind(const Slot7<R,P1,P2,P3,P4,P5,P6,P7> &s,
Ret ret)
{return AdaptorRetBindSlot7<Ret,R,
P1,P2,P3,P4,P5,P6,P7>::create(s.data(),ret);
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/rettype.h
0,0 → 1,715
// -*- c++ -*-
/* This is a generated file, do not edit. Generated from ../sigc++/macros/rettype.h.m4 */
#ifndef SIGCXX_RETTYPE_H
#define SIGCXX_RETTYPE_H
/*
SigC::rettype
-------------
rettype() alters a Slot by changing the return type.
Only allowed conversions or conversions to void can properly
be implemented. The type must always be specified as a
template parameter.
Simple Sample usage:
int f(int);
Slot1<void,int> s1=rettype<void>(slot(&f));
Slot1<float,int> s2=rettype<float>(slot(&f));
*/
#include <sigc++/adaptor.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/****************************************************************
***** Adaptor Rettype Slot 0
****************************************************************/
template <class R1,
class R2>
struct AdaptorRettypeSlot0_
: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot0<R1> SlotType;
typedef Slot0<R2> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return RType(((typename InSlotType::Callback&)(node->data_))());
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class R2>
struct AdaptorRettypeSlot0_
<void,
R2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot0<void> SlotType;
typedef Slot0<R2> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))();
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class R1,class R2>
Slot0<R1>
rettype(const Slot0<R2> &s)
{return AdaptorRettypeSlot0_<R1,R2>::create(s.obj());
}
/****************************************************************
***** Adaptor Rettype Slot 1
****************************************************************/
template <class R1,
class P1,
class R2>
struct AdaptorRettypeSlot1_
: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot1<R1,P1> SlotType;
typedef Slot1<R2,P1> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return RType(((typename InSlotType::Callback&)(node->data_))(p1));
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class P1,
class R2>
struct AdaptorRettypeSlot1_
<void,
P1,
R2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot1<void,P1> SlotType;
typedef Slot1<R2,P1> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1);
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class R1,class R2,class P1>
Slot1<R1,P1>
rettype(const Slot1<R2,P1> &s)
{return AdaptorRettypeSlot1_<R1,
P1,R2>::create(s.obj());
}
/****************************************************************
***** Adaptor Rettype Slot 2
****************************************************************/
template <class R1,
class P1,class P2,
class R2>
struct AdaptorRettypeSlot2_
: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot2<R1,P1,P2> SlotType;
typedef Slot2<R2,P1,P2> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2));
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class P1,class P2,
class R2>
struct AdaptorRettypeSlot2_
<void,
P1,P2,
R2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot2<void,P1,P2> SlotType;
typedef Slot2<R2,P1,P2> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2);
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class R1,class R2,class P1,class P2>
Slot2<R1,P1,P2>
rettype(const Slot2<R2,P1,P2> &s)
{return AdaptorRettypeSlot2_<R1,
P1,P2,R2>::create(s.obj());
}
/****************************************************************
***** Adaptor Rettype Slot 3
****************************************************************/
template <class R1,
class P1,class P2,class P3,
class R2>
struct AdaptorRettypeSlot3_
: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot3<R1,P1,P2,P3> SlotType;
typedef Slot3<R2,P1,P2,P3> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3));
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class P1,class P2,class P3,
class R2>
struct AdaptorRettypeSlot3_
<void,
P1,P2,P3,
R2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot3<void,P1,P2,P3> SlotType;
typedef Slot3<R2,P1,P2,P3> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3);
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class R1,class R2,class P1,class P2,class P3>
Slot3<R1,P1,P2,P3>
rettype(const Slot3<R2,P1,P2,P3> &s)
{return AdaptorRettypeSlot3_<R1,
P1,P2,P3,R2>::create(s.obj());
}
/****************************************************************
***** Adaptor Rettype Slot 4
****************************************************************/
template <class R1,
class P1,class P2,class P3,class P4,
class R2>
struct AdaptorRettypeSlot4_
: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot4<R1,P1,P2,P3,P4> SlotType;
typedef Slot4<R2,P1,P2,P3,P4> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4));
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class P1,class P2,class P3,class P4,
class R2>
struct AdaptorRettypeSlot4_
<void,
P1,P2,P3,P4,
R2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot4<void,P1,P2,P3,P4> SlotType;
typedef Slot4<R2,P1,P2,P3,P4> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4);
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class R1,class R2,class P1,class P2,class P3,class P4>
Slot4<R1,P1,P2,P3,P4>
rettype(const Slot4<R2,P1,P2,P3,P4> &s)
{return AdaptorRettypeSlot4_<R1,
P1,P2,P3,P4,R2>::create(s.obj());
}
/****************************************************************
***** Adaptor Rettype Slot 5
****************************************************************/
template <class R1,
class P1,class P2,class P3,class P4,class P5,
class R2>
struct AdaptorRettypeSlot5_
: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot5<R1,P1,P2,P3,P4,P5> SlotType;
typedef Slot5<R2,P1,P2,P3,P4,P5> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5));
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class P1,class P2,class P3,class P4,class P5,
class R2>
struct AdaptorRettypeSlot5_
<void,
P1,P2,P3,P4,P5,
R2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
typedef Slot5<R2,P1,P2,P3,P4,P5> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5);
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class R1,class R2,class P1,class P2,class P3,class P4,class P5>
Slot5<R1,P1,P2,P3,P4,P5>
rettype(const Slot5<R2,P1,P2,P3,P4,P5> &s)
{return AdaptorRettypeSlot5_<R1,
P1,P2,P3,P4,P5,R2>::create(s.obj());
}
/****************************************************************
***** Adaptor Rettype Slot 6
****************************************************************/
template <class R1,
class P1,class P2,class P3,class P4,class P5,class P6,
class R2>
struct AdaptorRettypeSlot6_
: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot6<R1,P1,P2,P3,P4,P5,P6> SlotType;
typedef Slot6<R2,P1,P2,P3,P4,P5,P6> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6));
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#ifndef SIGC_CXX_VOID_RETURN
#ifdef SIGC_CXX_PARTIAL_SPEC
template <
class P1,class P2,class P3,class P4,class P5,class P6,
class R2>
struct AdaptorRettypeSlot6_
<void,
P1,P2,P3,P4,P5,P6,
R2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
typedef Slot6<R2,P1,P2,P3,P4,P5,P6> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6);
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class R1,class R2,class P1,class P2,class P3,class P4,class P5,class P6>
Slot6<R1,P1,P2,P3,P4,P5,P6>
rettype(const Slot6<R2,P1,P2,P3,P4,P5,P6> &s)
{return AdaptorRettypeSlot6_<R1,
P1,P2,P3,P4,P5,P6,R2>::create(s.obj());
}
/****************************************************************
***** Adaptor Rettype Slot 7
****************************************************************/
template <class R1,
class P1,class P2,class P3,class P4,class P5,class P6,class P7,
class R2>
struct AdaptorRettypeSlot7_
: public AdaptorSlot_
{
#ifdef SIGC_CXX_PARTIAL_SPEC
typedef R1 RType;
#else
typedef typename Trait<R1>::type RType;
#endif
typedef Slot7<R1,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef Slot7<R2,P1,P2,P3,P4,P5,P6,P7> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7));
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#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,
class R2>
struct AdaptorRettypeSlot7_
<void,
P1,P2,P3,P4,P5,P6,P7,
R2>
: public AdaptorSlot_
{
typedef void RType;
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
typedef Slot7<R2,P1,P2,P3,P4,P5,P6,P7> InSlotType;
typedef AdaptorNode Node;
typedef CallDataObj2<typename SlotType::Func,Node> CallData;
static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
{
CallData* data=(CallData*)d;
Node* node=data->obj;
((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7);
}
static SlotData* create(SlotData *s)
{
SlotData* tmp=(SlotData*)s;
Node *node=new Node();
copy_callback(tmp,node);
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
data.callback=&callback;
data.obj=node;
return tmp;
}
};
#endif
#endif
template <class R1,class R2,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
Slot7<R1,P1,P2,P3,P4,P5,P6,P7>
rettype(const Slot7<R2,P1,P2,P3,P4,P5,P6,P7> &s)
{return AdaptorRettypeSlot7_<R1,
P1,P2,P3,P4,P5,P6,P7,R2>::create(s.obj());
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/scope.h
0,0 → 1,292
// -*- c++ -*-
/*
* Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef SIGCXX_SCOPE_H
#define SIGCXX_SCOPE_H
#include <sigc++config.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
struct LIBSIGC_API ScopeNode
{
mutable ScopeNode *prev_;
mutable ScopeNode *next_;
// removes self from list
void remove_self();
// Called to inform the item that it is erased
virtual void erase();
// inform scopes that invalid requested.
virtual void disconnect(bool destroy=0);
ScopeNode()
#ifdef LIBSIGC_WIN32
{prev_=next_=this;}
#else
:prev_(this),next_(this) {}
#endif
virtual ~ScopeNode();
private:
ScopeNode& operator=(const ScopeNode&);
ScopeNode(const ScopeNode&);
};
struct LIBSIGC_API DataNode: public ScopeNode
{
virtual void erase();
virtual ~DataNode();
};
/*******************************************************************
***** Basis Scope
*******************************************************************/
class ObjectScoped;
class ObjectReferenced;
class Object;
class Scope;
class LIBSIGC_API Reference
{
protected:
mutable ObjectReferenced* obj_;
mutable void* cache_;
public:
void set_sink();
void init(ObjectReferenced* obj);
void set(ObjectReferenced* obj,void* cache=0,bool ptr=false);
Reference& operator=(ObjectReferenced *obj) { set(obj); return *this; }
Reference& operator=(ObjectReferenced &obj) { set(&obj); return *this; }
Reference& operator=(const Reference& ref) { set(ref.obj_); return *this; };
ObjectReferenced* object() const {return obj_;}
void* cache() const {return cache_;}
Reference():obj_(0) {}
Reference(ObjectReferenced &obj)
{init(&obj);}
Reference(const Reference& ref)
{init(ref.obj_);}
~Reference();
};
class LIBSIGC_API Scope:public ScopeNode
{
friend class ObjectScoped;
Scope& operator=(const Scope& scope);
Scope(const Scope& scope);
protected:
void set(ObjectScoped* obj,void* cache,bool ptr);
mutable ObjectScoped* obj_;
mutable void* cache_;
virtual void on_connect()=0;
virtual void erase();
void register_scope(ObjectScoped *);
void register_scope(const Scope *parent=0);
void unregister_scope();
public:
void reference();
void unreference();
void set_sink();
ObjectScoped* object() const {return (ObjectScoped*)(obj_);}
void* cache() const {return cache_;}
// Inform object it should invalidate its list.
void invalid();
Scope():obj_(0),cache_(0) {}
virtual ~Scope();
};
/******************************************************
**** Common Scopes
*******************************************************
Available Scopes:
Uncounted - non-reference
Limit - Limits the lifetime of object to this scope
Sinks object.
Extend - Extends the lifetime of the object to this scope
Sinks object.
LimitOwned - Conditionally limits the lifetime of object
Sinks object.
FuncRef - Extends the lifetime, without sink
(intended for functions)
Reference - Extends the lifetime, with sink
AutoPtr - Shorthand for auto_ptr like scope.
RefCount - Shorthand for ref_ptr like scope.
******************************************************/
struct Scopes
{
class LIBSIGC_API Uncounted:public Scope
{
Uncounted& operator=(const Uncounted&);
Uncounted(const Uncounted&);
public:
virtual void disconnect(bool level=0);
Uncounted():Scope() {}
virtual ~Uncounted();
};
class LIBSIGC_API Extend:public Scope
{
public:
Extend& operator=(const Extend&);
Extend(const Extend&);
protected:
virtual void on_connect();
virtual void erase();
public:
virtual void disconnect(bool level=0);
void set(ObjectScoped* obj,void* cache,bool ptr);
Extend():Scope() {}
virtual ~Extend();
};
class LIBSIGC_API Limit:public Scope
{
Limit& operator=(const Limit&);
Limit(const Limit&);
protected:
virtual void on_connect();
virtual void erase();
public:
virtual void disconnect(bool level=0);
void set(ObjectScoped* obj,void* cache,bool ptr);
Limit():Scope() {}
virtual ~Limit();
};
typedef Extend RefCount;
typedef Reference Lock;
};
/*************************************************************
***** Lists
*************************************************************/
// Stub for building polylists
// Iterator skeleton
struct LIBSIGC_API ScopeIterator_
{
typedef ScopeNode NodeType;
private:
NodeType *node_;
public:
inline NodeType* node() {return node_;}
inline const NodeType* node() const {return node_;}
inline NodeType& operator*()
{return *node_;
}
inline const NodeType& operator*() const
{return *node_;
}
inline bool operator==(const ScopeIterator_& i) const
{return node_==i.node_;
}
inline bool operator!=(const ScopeIterator_& i) const
{return node_!=i.node_;
}
inline ScopeIterator_& operator++()
{
if (node_)
node_=(NodeType*)node_->next_;
return *this;
}
ScopeIterator_ operator++(int)
{
ScopeIterator_ tmp=*this;
++*this;
return tmp;
}
ScopeIterator_& operator= (const ScopeIterator_& i)
{
node_=i.node_;
return *this;
}
ScopeIterator_(const ScopeIterator_ &n):node_(n.node_) {}
ScopeIterator_(NodeType *n):node_(n) {}
ScopeIterator_():node_(0) {}
};
class LIBSIGC_API ScopeList
{
public:
typedef ScopeNode NodeType;
typedef ScopeIterator_ Iterator;
ScopeNode node_;
inline Iterator begin() {return Iterator(node_.next_);}
inline Iterator end() {return Iterator(&node_);}
// insert item directly on list
Iterator insert_direct(Iterator pos,NodeType *n);
Iterator erase(Iterator pos);
void erase(Iterator start,Iterator stop)
{ while (start!=stop) start=erase(start); }
void swap_elements(Iterator p1,Iterator p2);
void clear()
{ erase(begin(),end()); }
bool empty() const {return node_.next_==&node_;}
ScopeList():node_() {}
~ScopeList() { clear(); }
private:
ScopeList(const ScopeList&);
};
#ifdef SIGC_CXX_NAMESPACES
} // namespace sigc
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/sigc++config.h
0,0 → 1,15
#ifndef _SIGC_CONFIG_H_
#define _SIGC_CONFIG_H_
#define SIGC_MAJOR_VERSION 0
#define SIGC_MINOR_VERSION 8
#define SIGC_MICRO_VERSION 2
#define SIGC_CXX_PARTIAL_SPEC 1 /**/
#define SIGC_CXX_MEMBER_FUNC_TEMPLATES 1 /**/
#define SIGC_CXX_MEMBER_CLASS_TEMPLATES 1 /**/
#define SIGC_CXX_MUTABLE 1 /**/
#define SIGC_CXX_TEMPLATE_CCTOR 1
#define LIBSIGC_API
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/signal_system.h
0,0 → 1,36
/*************************************************************************
***** A Signal Framework for C++
**************************************************************************
Copyright 1998-1999 Karl Nelson <kenelson@ece.ucdavis.edu>
Based off of ideas from Gtk-- signal system by Tero Pulkkinen.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*************************************************************************/
#ifndef SIGCXX_SIGNAL_SYSTEM_H
#define SIGCXX_SIGNAL_SYSTEM_H
#include <sigc++/slot.h>
#include <sigc++/object_slot.h>
#include <sigc++/func_slot.h>
#include <sigc++/basic_signal.h>
#if 0
#include <sigc++/signals.h>
#endif
#endif

/programs/develop/libraries/menuetlibc/include/sigc++/slot.h
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

/programs/develop/libraries/menuetlibc/include/sigc++/thread.h
0,0 → 1,242
// -*- c++ -*-
/*
* Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef SIGCXX_THREAD_H
#define SIGCXX_THREAD_H
#include <sigc++config.h>
#ifdef SIGC_PTHREADS
#ifdef SIGC_THREAD_IMPL
#include <pthread.h>
#else
#include <time.h>
#endif
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
namespace Threads
{
#else
#define Threads
#endif
#ifdef SIGC_THREAD_IMPL
#ifdef SIGC_PTHREAD_DCE
struct CondAttr { pthread_condattr_t impl_;};
struct MutexAttr { pthread_mutexattr_t impl_;};
struct ThreadAttr { pthread_attr_t impl_;};
#else
struct CondAttr { pthread_condattr_t* impl_;};
struct MutexAttr { pthread_mutexattr_t* impl_;};
struct ThreadAttr { pthread_attr_t* impl_;};
#endif
typedef pthread_mutex_t MutexImpl;
typedef pthread_cond_t CondImpl;
typedef pthread_key_t KeyImpl;
typedef pthread_t ThreadImpl;
#else
class CondAttr {unsigned char dummy[SIGC_PTHREAD_COND_ATTR];};
class CondImpl {unsigned char dummy[SIGC_PTHREAD_COND_IMPL];};
class MutexAttr {unsigned char dummy[SIGC_PTHREAD_MUTEX_ATTR];};
class MutexImpl {unsigned char dummy[SIGC_PTHREAD_MUTEX_IMPL];};
class ThreadAttr {unsigned char dummy[SIGC_PTHREAD_THREAD_ATTR];};
class ThreadImpl {unsigned char dummy[SIGC_PTHREAD_THREAD_IMPL];};
class KeyImpl {unsigned char dummy[SIGC_PTHREAD_KEY_IMPL];};
#endif
// Mutual Exclusion
class Mutex
{
typedef MutexImpl Impl;
private:
Impl mutex_;
int destroy();
public:
static MutexAttr Default;
#ifdef SIGC_THREAD_IMPL
operator Impl* () {return (Impl*)(&mutex_);}
#endif
Mutex(const MutexAttr attr=Default);
// (needs work)
~Mutex();
int lock();
int trylock();
int unlock();
};
// A lazy way to unlock at end of scope
struct MLock
{
Mutex &mutex_;
MLock(Mutex& mutex):mutex_(mutex) {mutex_.lock();}
~MLock() {mutex_.unlock();}
};
// Condition Variable
struct Condition
{
typedef CondImpl Impl;
private:
Impl cond_;
int destroy();
public:
static CondAttr Default;
#ifdef SIGC_THREAD_IMPL
operator Impl* () {return (Impl*)(&cond_);}
#endif
Condition(const CondAttr &attr=Default);
~Condition();
// restarts exactly one thread hung on condition
int signal();
// restarts all threads waiting on condition
int broadcast();
// unlocks a mutex while waiting on a condition, then reaquires lock.
int wait(Mutex &m);
// unlocks a mutex while waiting on a condition, then reaquires lock
// with a fixed maximum duration.
int wait(Mutex &m,struct timespec* spec);
};
// Integer Semaphore
struct Semaphore
{
int value_;
Condition sig_;
Mutex access_;
void up();
void down();
Semaphore(int value=1);
~Semaphore();
};
struct Private_
{
KeyImpl key_;
void* get();
void set(void *value);
void create(void (*dtor)(void*));
void destroy();
};
// Private is a thread split static.
template <class T>
class Private : private Private_
{
private:
static void dtor(void* v)
{
T* obj=(T*)v;
delete obj;
}
public:
T& operator =(const T& t)
{return (((T&)*this)=t);}
operator T& ()
{
T *value=(T*)get();
if (!value)
set((void*)(value=new T()));
return *(value);
}
Private() { create(&dtor); }
~Private() { destroy(); }
};
// int needs to initialized
template <>
class Private<int> : private Private_
{
private:
static void dtor(void* v)
{
int* obj=(int*)v;
delete obj;
}
public:
int& operator =(const int& t)
{return (((int&)*this)=t);}
operator int& ()
{
int *value=(int*)get();
if (!value)
set((void*)(value=new int(0)));
return *(value);
}
Private() { create(&dtor); }
~Private() { destroy(); }
};
struct Thread
{
protected:
typedef ThreadImpl Impl;
Impl thread_;
void* arg_;
ThreadAttr attr_;
static void* call_main_(void* obj);
public:
#ifdef SIGC_THREAD_IMPL
operator Impl* () {return &thread_;}
#endif
virtual void* main(void*)=0;
int detach();
static ThreadAttr Default;
// arg is for passing extra data to main, but never pass a
// local variable or address of local variable. Arg must
// be available throughout life of program.
int start(void* arg=0);
Thread(const ThreadAttr &attr=Default);
virtual ~Thread();
};
#ifdef SIGC_CXX_NAMESPACES
} /* namespace Threads */
} /* namespace SigC */
#endif
#endif /* SIGC_PTHREADS */
#endif /* SIGCXX_THREAD_H */

/programs/develop/libraries/menuetlibc/include/sigc++/type.h
0,0 → 1,63
// -*- c++ -*-
/*
* Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef SIGCXX_TYPE_H
#define SIGCXX_TYPE_H
#include <sigc++config.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif
/* some classes for making parameter passing easier */
#ifdef SIGC_CXX_SPECIALIZE_REFERENCES
template <typename T>
struct Trait
{
typedef const T& ref;
typedef T type;
};
template <typename T>
struct Trait<T&>
{
typedef T& ref;
typedef T& type;
};
#else
template <typename T>
struct Trait
{
typedef T ref; // VC++ does not support reference typedef
typedef T type;
};
#endif
template <>
struct Trait<void>:public Trait<int>
{};
#ifdef SIGC_CXX_NAMESPACES
}
#endif
#endif