WebSVN – Kolibri OS – Blame – /programs/develop/libraries/menuetlibc/include/sigc++/rettype.h

Rev	Author	Line No.	Line
4973	right-hear	1	// -- c++ --
		2	/* This is a generated file, do not edit. Generated from ../sigc++/macros/rettype.h.m4 */
		3
		4	#ifndef SIGCXX_RETTYPE_H
		5	#define SIGCXX_RETTYPE_H
		6
		7	/*
		8	SigC::rettype
		9	-------------
		10	rettype() alters a Slot by changing the return type.
		11
		12	Only allowed conversions or conversions to void can properly
		13	be implemented. The type must always be specified as a
		14	template parameter.
		15
		16	Simple Sample usage:
		17
		18	int f(int);
		19
		20	Slot1 s1=rettype(slot(&f));
		21	Slot1 s2=rettype(slot(&f));
		22
		23	*/
		24
		25	#include
		26
		27	#ifdef SIGC_CXX_NAMESPACES
		28	namespace SigC
		29	{
		30	#endif
		31
		32
		33
		34
		35
		36
		37
		38
		39
		40
		41
		42	/****************************************************************
		43	***** Adaptor Rettype Slot 0
		44	****************************************************************/
		45	template
		46	class R2>
		47	struct AdaptorRettypeSlot0_
		48	: public AdaptorSlot_
		49	{
		50	#ifdef SIGC_CXX_PARTIAL_SPEC
		51	typedef R1 RType;
		52	#else
		53	typedef typename Trait::type RType;
		54	#endif
		55	typedef Slot0 SlotType;
		56	typedef Slot0 InSlotType;
		57	typedef AdaptorNode Node;
		58	typedef CallDataObj2 CallData;
		59
		60	static RType callback(void* d)
		61	{
		62	CallData* data=(CallData*)d;
		63	Node* node=data->obj;
		64	return RType(((typename InSlotType::Callback&)(node->data_))());
		65	}
		66	static SlotData* create(SlotData *s)
		67	{
		68	SlotData* tmp=(SlotData*)s;
		69	Node *node=new Node();
		70	copy_callback(tmp,node);
		71	CallData &data=reinterpret_cast(tmp->data_);
		72	data.callback=&callback;
		73	data.obj=node;
		74	return tmp;
		75	}
		76	};
		77
		78
		79	#ifndef SIGC_CXX_VOID_RETURN
		80	#ifdef SIGC_CXX_PARTIAL_SPEC
		81	template <
		82	class R2>
		83	struct AdaptorRettypeSlot0_
		84
		85	R2>
		86	: public AdaptorSlot_
		87	{
		88	typedef void RType;
		89	typedef Slot0 SlotType;
		90	typedef Slot0 InSlotType;
		91	typedef AdaptorNode Node;
		92	typedef CallDataObj2 CallData;
		93
		94	static RType callback(void* d)
		95	{
		96	CallData* data=(CallData*)d;
		97	Node* node=data->obj;
		98	((typename InSlotType::Callback&)(node->data_))();
		99	}
		100	static SlotData* create(SlotData *s)
		101	{
		102	SlotData* tmp=(SlotData*)s;
		103	Node *node=new Node();
		104	copy_callback(tmp,node);
		105	CallData &data=reinterpret_cast(tmp->data_);
		106	data.callback=&callback;
		107	data.obj=node;
		108	return tmp;
		109	}
		110	};
		111
		112	#endif
		113	#endif
		114
		115
		116	template
		117	Slot0
		118	rettype(const Slot0 &s)
		119	{return AdaptorRettypeSlot0_::create(s.obj());
		120	}
		121
		122	/****************************************************************
		123	***** Adaptor Rettype Slot 1
		124	****************************************************************/
		125	template
		126	class P1,
		127	class R2>
		128	struct AdaptorRettypeSlot1_
		129	: public AdaptorSlot_
		130	{
		131	#ifdef SIGC_CXX_PARTIAL_SPEC
		132	typedef R1 RType;
		133	#else
		134	typedef typename Trait::type RType;
		135	#endif
		136	typedef Slot1 SlotType;
		137	typedef Slot1 InSlotType;
		138	typedef AdaptorNode Node;
		139	typedef CallDataObj2 CallData;
		140
		141	static RType callback(void* d,P1 p1)
		142	{
		143	CallData* data=(CallData*)d;
		144	Node* node=data->obj;
		145	return RType(((typename InSlotType::Callback&)(node->data_))(p1));
		146	}
		147	static SlotData* create(SlotData *s)
		148	{
		149	SlotData* tmp=(SlotData*)s;
		150	Node *node=new Node();
		151	copy_callback(tmp,node);
		152	CallData &data=reinterpret_cast(tmp->data_);
		153	data.callback=&callback;
		154	data.obj=node;
		155	return tmp;
		156	}
		157	};
		158
		159
		160	#ifndef SIGC_CXX_VOID_RETURN
		161	#ifdef SIGC_CXX_PARTIAL_SPEC
		162	template <
		163	class P1,
		164	class R2>
		165	struct AdaptorRettypeSlot1_
		166
		167	P1,
		168	R2>
		169	: public AdaptorSlot_
		170	{
		171	typedef void RType;
		172	typedef Slot1 SlotType;
		173	typedef Slot1 InSlotType;
		174	typedef AdaptorNode Node;
		175	typedef CallDataObj2 CallData;
		176
		177	static RType callback(void* d,P1 p1)
		178	{
		179	CallData* data=(CallData*)d;
		180	Node* node=data->obj;
		181	((typename InSlotType::Callback&)(node->data_))(p1);
		182	}
		183	static SlotData* create(SlotData *s)
		184	{
		185	SlotData* tmp=(SlotData*)s;
		186	Node *node=new Node();
		187	copy_callback(tmp,node);
		188	CallData &data=reinterpret_cast(tmp->data_);
		189	data.callback=&callback;
		190	data.obj=node;
		191	return tmp;
		192	}
		193	};
		194
		195	#endif
		196	#endif
		197
		198
		199	template
		200	Slot1
		201	rettype(const Slot1 &s)
		202	{return AdaptorRettypeSlot1_
		203	P1,R2>::create(s.obj());
		204	}
		205
		206	/****************************************************************
		207	***** Adaptor Rettype Slot 2
		208	****************************************************************/
		209	template
		210	class P1,class P2,
		211	class R2>
		212	struct AdaptorRettypeSlot2_
		213	: public AdaptorSlot_
		214	{
		215	#ifdef SIGC_CXX_PARTIAL_SPEC
		216	typedef R1 RType;
		217	#else
		218	typedef typename Trait::type RType;
		219	#endif
		220	typedef Slot2 SlotType;
		221	typedef Slot2 InSlotType;
		222	typedef AdaptorNode Node;
		223	typedef CallDataObj2 CallData;
		224
		225	static RType callback(void* d,P1 p1,P2 p2)
		226	{
		227	CallData* data=(CallData*)d;
		228	Node* node=data->obj;
		229	return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2));
		230	}
		231	static SlotData* create(SlotData *s)
		232	{
		233	SlotData* tmp=(SlotData*)s;
		234	Node *node=new Node();
		235	copy_callback(tmp,node);
		236	CallData &data=reinterpret_cast(tmp->data_);
		237	data.callback=&callback;
		238	data.obj=node;
		239	return tmp;
		240	}
		241	};
		242
		243
		244	#ifndef SIGC_CXX_VOID_RETURN
		245	#ifdef SIGC_CXX_PARTIAL_SPEC
		246	template <
		247	class P1,class P2,
		248	class R2>
		249	struct AdaptorRettypeSlot2_
		250
		251	P1,P2,
		252	R2>
		253	: public AdaptorSlot_
		254	{
		255	typedef void RType;
		256	typedef Slot2 SlotType;
		257	typedef Slot2 InSlotType;
		258	typedef AdaptorNode Node;
		259	typedef CallDataObj2 CallData;
		260
		261	static RType callback(void* d,P1 p1,P2 p2)
		262	{
		263	CallData* data=(CallData*)d;
		264	Node* node=data->obj;
		265	((typename InSlotType::Callback&)(node->data_))(p1,p2);
		266	}
		267	static SlotData* create(SlotData *s)
		268	{
		269	SlotData* tmp=(SlotData*)s;
		270	Node *node=new Node();
		271	copy_callback(tmp,node);
		272	CallData &data=reinterpret_cast(tmp->data_);
		273	data.callback=&callback;
		274	data.obj=node;
		275	return tmp;
		276	}
		277	};
		278
		279	#endif
		280	#endif
		281
		282
		283	template
		284	Slot2
		285	rettype(const Slot2 &s)
		286	{return AdaptorRettypeSlot2_
		287	P1,P2,R2>::create(s.obj());
		288	}
		289
		290	/****************************************************************
		291	***** Adaptor Rettype Slot 3
		292	****************************************************************/
		293	template
		294	class P1,class P2,class P3,
		295	class R2>
		296	struct AdaptorRettypeSlot3_
		297	: public AdaptorSlot_
		298	{
		299	#ifdef SIGC_CXX_PARTIAL_SPEC
		300	typedef R1 RType;
		301	#else
		302	typedef typename Trait::type RType;
		303	#endif
		304	typedef Slot3 SlotType;
		305	typedef Slot3 InSlotType;
		306	typedef AdaptorNode Node;
		307	typedef CallDataObj2 CallData;
		308
		309	static RType callback(void* d,P1 p1,P2 p2,P3 p3)
		310	{
		311	CallData* data=(CallData*)d;
		312	Node* node=data->obj;
		313	return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3));
		314	}
		315	static SlotData* create(SlotData *s)
		316	{
		317	SlotData* tmp=(SlotData*)s;
		318	Node *node=new Node();
		319	copy_callback(tmp,node);
		320	CallData &data=reinterpret_cast(tmp->data_);
		321	data.callback=&callback;
		322	data.obj=node;
		323	return tmp;
		324	}
		325	};
		326
		327
		328	#ifndef SIGC_CXX_VOID_RETURN
		329	#ifdef SIGC_CXX_PARTIAL_SPEC
		330	template <
		331	class P1,class P2,class P3,
		332	class R2>
		333	struct AdaptorRettypeSlot3_
		334
		335	P1,P2,P3,
		336	R2>
		337	: public AdaptorSlot_
		338	{
		339	typedef void RType;
		340	typedef Slot3 SlotType;
		341	typedef Slot3 InSlotType;
		342	typedef AdaptorNode Node;
		343	typedef CallDataObj2 CallData;
		344
		345	static RType callback(void* d,P1 p1,P2 p2,P3 p3)
		346	{
		347	CallData* data=(CallData*)d;
		348	Node* node=data->obj;
		349	((typename InSlotType::Callback&)(node->data_))(p1,p2,p3);
		350	}
		351	static SlotData* create(SlotData *s)
		352	{
		353	SlotData* tmp=(SlotData*)s;
		354	Node *node=new Node();
		355	copy_callback(tmp,node);
		356	CallData &data=reinterpret_cast(tmp->data_);
		357	data.callback=&callback;
		358	data.obj=node;
		359	return tmp;
		360	}
		361	};
		362
		363	#endif
		364	#endif
		365
		366
		367	template
		368	Slot3
		369	rettype(const Slot3 &s)
		370	{return AdaptorRettypeSlot3_
		371	P1,P2,P3,R2>::create(s.obj());
		372	}
		373
		374	/****************************************************************
		375	***** Adaptor Rettype Slot 4
		376	****************************************************************/
		377	template
		378	class P1,class P2,class P3,class P4,
		379	class R2>
		380	struct AdaptorRettypeSlot4_
		381	: public AdaptorSlot_
		382	{
		383	#ifdef SIGC_CXX_PARTIAL_SPEC
		384	typedef R1 RType;
		385	#else
		386	typedef typename Trait::type RType;
		387	#endif
		388	typedef Slot4 SlotType;
		389	typedef Slot4 InSlotType;
		390	typedef AdaptorNode Node;
		391	typedef CallDataObj2 CallData;
		392
		393	static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
		394	{
		395	CallData* data=(CallData*)d;
		396	Node* node=data->obj;
		397	return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4));
		398	}
		399	static SlotData* create(SlotData *s)
		400	{
		401	SlotData* tmp=(SlotData*)s;
		402	Node *node=new Node();
		403	copy_callback(tmp,node);
		404	CallData &data=reinterpret_cast(tmp->data_);
		405	data.callback=&callback;
		406	data.obj=node;
		407	return tmp;
		408	}
		409	};
		410
		411
		412	#ifndef SIGC_CXX_VOID_RETURN
		413	#ifdef SIGC_CXX_PARTIAL_SPEC
		414	template <
		415	class P1,class P2,class P3,class P4,
		416	class R2>
		417	struct AdaptorRettypeSlot4_
		418
		419	P1,P2,P3,P4,
		420	R2>
		421	: public AdaptorSlot_
		422	{
		423	typedef void RType;
		424	typedef Slot4 SlotType;
		425	typedef Slot4 InSlotType;
		426	typedef AdaptorNode Node;
		427	typedef CallDataObj2 CallData;
		428
		429	static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
		430	{
		431	CallData* data=(CallData*)d;
		432	Node* node=data->obj;
		433	((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4);
		434	}
		435	static SlotData* create(SlotData *s)
		436	{
		437	SlotData* tmp=(SlotData*)s;
		438	Node *node=new Node();
		439	copy_callback(tmp,node);
		440	CallData &data=reinterpret_cast(tmp->data_);
		441	data.callback=&callback;
		442	data.obj=node;
		443	return tmp;
		444	}
		445	};
		446
		447	#endif
		448	#endif
		449
		450
		451	template
		452	Slot4
		453	rettype(const Slot4 &s)
		454	{return AdaptorRettypeSlot4_
		455	P1,P2,P3,P4,R2>::create(s.obj());
		456	}
		457
		458	/****************************************************************
		459	***** Adaptor Rettype Slot 5
		460	****************************************************************/
		461	template
		462	class P1,class P2,class P3,class P4,class P5,
		463	class R2>
		464	struct AdaptorRettypeSlot5_
		465	: public AdaptorSlot_
		466	{
		467	#ifdef SIGC_CXX_PARTIAL_SPEC
		468	typedef R1 RType;
		469	#else
		470	typedef typename Trait::type RType;
		471	#endif
		472	typedef Slot5 SlotType;
		473	typedef Slot5 InSlotType;
		474	typedef AdaptorNode Node;
		475	typedef CallDataObj2 CallData;
		476
		477	static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
		478	{
		479	CallData* data=(CallData*)d;
		480	Node* node=data->obj;
		481	return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5));
		482	}
		483	static SlotData* create(SlotData *s)
		484	{
		485	SlotData* tmp=(SlotData*)s;
		486	Node *node=new Node();
		487	copy_callback(tmp,node);
		488	CallData &data=reinterpret_cast(tmp->data_);
		489	data.callback=&callback;
		490	data.obj=node;
		491	return tmp;
		492	}
		493	};
		494
		495
		496	#ifndef SIGC_CXX_VOID_RETURN
		497	#ifdef SIGC_CXX_PARTIAL_SPEC
		498	template <
		499	class P1,class P2,class P3,class P4,class P5,
		500	class R2>
		501	struct AdaptorRettypeSlot5_
		502
		503	P1,P2,P3,P4,P5,
		504	R2>
		505	: public AdaptorSlot_
		506	{
		507	typedef void RType;
		508	typedef Slot5 SlotType;
		509	typedef Slot5 InSlotType;
		510	typedef AdaptorNode Node;
		511	typedef CallDataObj2 CallData;
		512
		513	static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
		514	{
		515	CallData* data=(CallData*)d;
		516	Node* node=data->obj;
		517	((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5);
		518	}
		519	static SlotData* create(SlotData *s)
		520	{
		521	SlotData* tmp=(SlotData*)s;
		522	Node *node=new Node();
		523	copy_callback(tmp,node);
		524	CallData &data=reinterpret_cast(tmp->data_);
		525	data.callback=&callback;
		526	data.obj=node;
		527	return tmp;
		528	}
		529	};
		530
		531	#endif
		532	#endif
		533
		534
		535	template
		536	Slot5
		537	rettype(const Slot5 &s)
		538	{return AdaptorRettypeSlot5_
		539	P1,P2,P3,P4,P5,R2>::create(s.obj());
		540	}
		541
		542	/****************************************************************
		543	***** Adaptor Rettype Slot 6
		544	****************************************************************/
		545	template
		546	class P1,class P2,class P3,class P4,class P5,class P6,
		547	class R2>
		548	struct AdaptorRettypeSlot6_
		549	: public AdaptorSlot_
		550	{
		551	#ifdef SIGC_CXX_PARTIAL_SPEC
		552	typedef R1 RType;
		553	#else
		554	typedef typename Trait::type RType;
		555	#endif
		556	typedef Slot6 SlotType;
		557	typedef Slot6 InSlotType;
		558	typedef AdaptorNode Node;
		559	typedef CallDataObj2 CallData;
		560
		561	static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
		562	{
		563	CallData* data=(CallData*)d;
		564	Node* node=data->obj;
		565	return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6));
		566	}
		567	static SlotData* create(SlotData *s)
		568	{
		569	SlotData* tmp=(SlotData*)s;
		570	Node *node=new Node();
		571	copy_callback(tmp,node);
		572	CallData &data=reinterpret_cast(tmp->data_);
		573	data.callback=&callback;
		574	data.obj=node;
		575	return tmp;
		576	}
		577	};
		578
		579
		580	#ifndef SIGC_CXX_VOID_RETURN
		581	#ifdef SIGC_CXX_PARTIAL_SPEC
		582	template <
		583	class P1,class P2,class P3,class P4,class P5,class P6,
		584	class R2>
		585	struct AdaptorRettypeSlot6_
		586
		587	P1,P2,P3,P4,P5,P6,
		588	R2>
		589	: public AdaptorSlot_
		590	{
		591	typedef void RType;
		592	typedef Slot6 SlotType;
		593	typedef Slot6 InSlotType;
		594	typedef AdaptorNode Node;
		595	typedef CallDataObj2 CallData;
		596
		597	static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
		598	{
		599	CallData* data=(CallData*)d;
		600	Node* node=data->obj;
		601	((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6);
		602	}
		603	static SlotData* create(SlotData *s)
		604	{
		605	SlotData* tmp=(SlotData*)s;
		606	Node *node=new Node();
		607	copy_callback(tmp,node);
		608	CallData &data=reinterpret_cast(tmp->data_);
		609	data.callback=&callback;
		610	data.obj=node;
		611	return tmp;
		612	}
		613	};
		614
		615	#endif
		616	#endif
		617
		618
		619	template
		620	Slot6
		621	rettype(const Slot6 &s)
		622	{return AdaptorRettypeSlot6_
		623	P1,P2,P3,P4,P5,P6,R2>::create(s.obj());
		624	}
		625
		626	/****************************************************************
		627	***** Adaptor Rettype Slot 7
		628	****************************************************************/
		629	template
		630	class P1,class P2,class P3,class P4,class P5,class P6,class P7,
		631	class R2>
		632	struct AdaptorRettypeSlot7_
		633	: public AdaptorSlot_
		634	{
		635	#ifdef SIGC_CXX_PARTIAL_SPEC
		636	typedef R1 RType;
		637	#else
		638	typedef typename Trait::type RType;
		639	#endif
		640	typedef Slot7 SlotType;
		641	typedef Slot7 InSlotType;
		642	typedef AdaptorNode Node;
		643	typedef CallDataObj2 CallData;
		644
		645	static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
		646	{
		647	CallData* data=(CallData*)d;
		648	Node* node=data->obj;
		649	return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7));
		650	}
		651	static SlotData* create(SlotData *s)
		652	{
		653	SlotData* tmp=(SlotData*)s;
		654	Node *node=new Node();
		655	copy_callback(tmp,node);
		656	CallData &data=reinterpret_cast(tmp->data_);
		657	data.callback=&callback;
		658	data.obj=node;
		659	return tmp;
		660	}
		661	};
		662
		663
		664	#ifndef SIGC_CXX_VOID_RETURN
		665	#ifdef SIGC_CXX_PARTIAL_SPEC
		666	template <
		667	class P1,class P2,class P3,class P4,class P5,class P6,class P7,
		668	class R2>
		669	struct AdaptorRettypeSlot7_
		670
		671	P1,P2,P3,P4,P5,P6,P7,
		672	R2>
		673	: public AdaptorSlot_
		674	{
		675	typedef void RType;
		676	typedef Slot7 SlotType;
		677	typedef Slot7 InSlotType;
		678	typedef AdaptorNode Node;
		679	typedef CallDataObj2 CallData;
		680
		681	static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
		682	{
		683	CallData* data=(CallData*)d;
		684	Node* node=data->obj;
		685	((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7);
		686	}
		687	static SlotData* create(SlotData *s)
		688	{
		689	SlotData* tmp=(SlotData*)s;
		690	Node *node=new Node();
		691	copy_callback(tmp,node);
		692	CallData &data=reinterpret_cast(tmp->data_);
		693	data.callback=&callback;
		694	data.obj=node;
		695	return tmp;
		696	}
		697	};
		698
		699	#endif
		700	#endif
		701
		702
		703	template
		704	Slot7
		705	rettype(const Slot7 &s)
		706	{return AdaptorRettypeSlot7_
		707	P1,P2,P3,P4,P5,P6,P7,R2>::create(s.obj());
		708	}
		709
		710
		711	#ifdef SIGC_CXX_NAMESPACES
		712	} // namespace
		713	#endif
		714
		715	#endif

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/menuetlibc/include/sigc++/rettype.h – Rev 4973