value = 3;
}
// a typedef to make things more readable
-typedef MemberCaller<Integer, &Integer::setValue> SetValueCaller;
+typedef MemberCaller<Integer, void(), &Integer::setValue> SetValueCaller;
};
void example(){
Integer foo = { 0 };
{
- Callback bar = ConstMemberCaller<Integer, &Integer::printValue>( foo );
+ Callback<void()> bar = ConstMemberCaller<Integer, void(), &Integer::printValue>( foo );
// invoke the callback
bar(); // foo.printValue()
{
// use the typedef to improve readability
- Callback bar = Integer::SetValueCaller( foo );
+ Callback<void()> bar = Integer::SetValueCaller( foo );
// invoke the callback
bar(); // foo.setValue()
}
// a typedef to make things more readable
-typedef ReferenceCaller<int, Int_setValue> IntSetValueCaller;
+typedef ReferenceCaller<int, void(), Int_setValue> IntSetValueCaller;
void example(){
int foo = 0;
{
- Callback bar = ConstReferenceCaller<int, Int_printValue>( foo );
+ Callback<void()> bar = ConstReferenceCaller<int, void(), Int_printValue>( foo );
// invoke the callback
bar(); // Int_printValue(foo)
{
// use the typedef to improve readability
- Callback bar = IntSetValueCaller( foo );
+ Callback<void()> bar = IntSetValueCaller( foo );
// invoke the callback
bar(); // Int_setValue(foo)
public:
void test0(){
}
-typedef Member<Test, void, &Test::test0> Test0;
-typedef MemberCaller<Test, &Test::test0> Test0Caller;
+typedef Member<Test, void(), &Test::test0> Test0;
+typedef MemberCaller<Test, void(), &Test::test0> Test0Caller;
void test0const() const {
}
-typedef ConstMember<Test, void, &Test::test0const> Test0Const;
-typedef ConstMemberCaller<Test, &Test::test0const> Test0ConstCaller;
+typedef ConstMember<Test, void(), &Test::test0const> Test0Const;
+typedef ConstMemberCaller<Test, void(), &Test::test0const> Test0ConstCaller;
void test1( A1 ){
}
-typedef Member1<Test, A1, void, &Test::test1> Test1;
-typedef MemberCaller1<Test, A1, &Test::test1> Test1Caller;
+typedef Member<Test, void(A1), &Test::test1> Test1;
+typedef MemberCaller<Test, void(A1), &Test::test1> Test1Caller;
void test1const( A1 ) const {
}
-typedef ConstMember1<Test, A1, void, &Test::test1const> Test1Const;
-typedef ConstMemberCaller1<Test, A1, &Test::test1const> Test1ConstCaller;
+typedef ConstMember<Test, void(A1), &Test::test1const> Test1Const;
+typedef ConstMemberCaller<Test, void(A1), &Test::test1const> Test1ConstCaller;
void test2( A1, A2 ){
}
-typedef Member2<Test, A1, A2, void, &Test::test2> Test2;
+typedef Member<Test, void(A1, A2), &Test::test2> Test2;
void test2const( A1, A2 ) const {
}
-typedef ConstMember2<Test, A1, A2, void, &Test::test2const> Test2Const;
+typedef ConstMember<Test, void(A1, A2), &Test::test2const> Test2Const;
void test3( A1, A2, A3 ){
}
-typedef Member3<Test, A1, A2, A3, void, &Test::test3> Test3;
+typedef Member<Test, void(A1, A2, A3), &Test::test3> Test3;
void test3const( A1, A2, A3 ) const {
}
-typedef ConstMember3<Test, A1, A2, A3, void, &Test::test3const> Test3Const;
+typedef ConstMember<Test, void(A1, A2, A3), &Test::test3const> Test3Const;
};
void test0free(){
}
-typedef FreeCaller<&test0free> Test0FreeCaller;
+typedef FreeCaller<void(), &test0free> Test0FreeCaller;
void test1free( A1 ){
}
-typedef FreeCaller1<A1, &test1free> Test1FreeCaller;
+typedef FreeCaller<void(A1), &test1free> Test1FreeCaller;
void test2free( A1, A2 ){
}
-typedef Function2<A1, A2, void, &test2free> Test2Free;
+typedef Function<void(A1, A2), &test2free> Test2Free;
void test3free( A1, A2, A3 ){
}
-typedef Function3<A1, A2, A3, void, &test3free> Test3Free;
+typedef Function<void(A1, A2, A3), &test3free> Test3Free;
void test0( Test& test ){
}
-typedef ReferenceCaller<Test, &test0> Test0Caller;
+typedef ReferenceCaller<Test, void(), &test0> Test0Caller;
void test0const( const Test& test ){
}
-typedef ConstReferenceCaller<Test, &test0const> Test0ConstCaller;
+typedef ConstReferenceCaller<Test, void(), &test0const> Test0ConstCaller;
void test0p( Test* test ){
}
-typedef PointerCaller<Test, &test0p> Test0PCaller;
+typedef PointerCaller<Test, void(), &test0p> Test0PCaller;
void test0constp( const Test* test ){
}
-typedef ConstPointerCaller<Test, &test0constp> Test0ConstPCaller;
+typedef ConstPointerCaller<Test, void(), &test0constp> Test0ConstPCaller;
void test1( Test& test, A1 ){
}
-typedef ReferenceCaller1<Test, A1, &test1> Test1Caller;
+typedef ReferenceCaller<Test, void(A1), &test1> Test1Caller;
void test1const( const Test& test, A1 ){
}
-typedef ConstReferenceCaller1<Test, A1, &test1const> Test1ConstCaller;
+typedef ConstReferenceCaller<Test, void(A1), &test1const> Test1ConstCaller;
void test1p( Test* test, A1 ){
}
-typedef PointerCaller1<Test, A1, &test1p> Test1PCaller;
+typedef PointerCaller<Test, void(A1), &test1p> Test1PCaller;
void test1constp( const Test* test, A1 ){
}
-typedef ConstPointerCaller1<Test, A1, &test1constp> Test1ConstPCaller;
+typedef ConstPointerCaller<Test, void(A1), &test1constp> Test1ConstPCaller;
void test2( Test& test, A1, A2 ){
}
-typedef Function3<Test&, A1, A2, void, &test2> Test2;
+typedef Function<void(Test&, A1, A2), &test2> Test2;
void test3( Test& test, A1, A2, A3 ){
}
-typedef Function4<Test&, A1, A2, A3, void, &test3> Test3;
+typedef Function<void(Test&, A1, A2, A3), &test3> Test3;
void instantiate(){
Test test;
const Test& testconst = test;
{
- Callback a = Test0FreeCaller();
- Callback b = Test::Test0Caller( test );
- b = makeCallback0( Test::Test0(), test );
- Callback c = Test::Test0ConstCaller( testconst );
- c = makeCallback0( Test::Test0Const(), test );
+ Callback<void()> a = Test0FreeCaller();
+ Callback<void()> b = Test::Test0Caller( test );
+ b = makeCallback( Test::Test0(), test );
+ Callback<void()> c = Test::Test0ConstCaller( testconst );
+ c = makeCallback( Test::Test0Const(), test );
Test0Caller{ test };
Test0ConstCaller{ testconst };
Test0PCaller{ &test };
bool u = a != b;
}
{
- typedef Callback1<A1> TestCallback1;
+ typedef Callback<void(A1)> TestCallback1;
TestCallback1 a = Test1FreeCaller();
TestCallback1 b = Test::Test1Caller( test );
- b = makeCallback1( Test::Test1(), test );
+ b = makeCallback( Test::Test1(), test );
TestCallback1 c = Test::Test1ConstCaller( testconst );
- c = makeCallback1( Test::Test1Const(), test );
+ c = makeCallback( Test::Test1Const(), test );
Test1Caller{ test };
Test1ConstCaller{ testconst };
Test1PCaller{ &test };
bool u = a != b;
}
{
- typedef Callback2<A1, A2> TestCallback2;
- TestCallback2 a = makeStatelessCallback2( Test2Free() );
- TestCallback2 b = makeCallback2( Test2(), test );
- makeCallback2( Test::Test2(), test );
- makeCallback2( Test::Test2Const(), test );
+ typedef Callback<void(A1, A2)> TestCallback2;
+ TestCallback2 a = makeStatelessCallback( Test2Free() );
+ TestCallback2 b = makeCallback( Test2(), test );
+ makeCallback( Test::Test2(), test );
+ makeCallback( Test::Test2Const(), test );
a( A1(), A2() );
bool u = a != b;
}
{
- typedef Callback3<A1, A2, A3> TestCallback3;
- TestCallback3 a = makeStatelessCallback3( Test3Free() );
- TestCallback3 b = makeCallback3( Test3(), test );
- makeCallback3( Test::Test3(), test );
- makeCallback3( Test::Test3Const(), test );
+ typedef Callback<void(A1, A2, A3)> TestCallback3;
+ TestCallback3 a = makeStatelessCallback( Test3Free() );
+ TestCallback3 b = makeCallback( Test3(), test );
+ makeCallback( Test::Test3(), test );
+ makeCallback( Test::Test3Const(), test );
a( A1(), A2(), A3() );
bool u = a != b;
}
projects / xonotic / netradiant.git / blobdiff