libs/generic/callback.cpp

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #include "callback.h"
  23
  24 #if defined(_DEBUG) || defined(DOXYGEN)
  25
  26 namespace ExampleMemberCaller
  27 {
  28   // MemberCaller example
  29   class Integer
  30   {
  31   public:
  32     int value;
  33
  34     void printValue() const
  35     {
  36       // print this->value here;
  37     }
  38
  39     void setValue()
  40     {
  41       value = 3;
  42     }
  43     // a typedef to make things more readable
  44     typedef MemberCaller<Integer, &Integer::setValue> SetValueCaller;
  45   };
  46
  47   void example()
  48   {
  49     Integer foo = { 0 };
  50
  51     {
  52       Callback bar = ConstMemberCaller<Integer, &Integer::printValue>(foo);
  53
  54       // invoke the callback
  55       bar(); // foo.printValue()
  56     }
  57
  58
  59     {
  60       // use the typedef to improve readability
  61       Callback bar = Integer::SetValueCaller(foo);
  62
  63       // invoke the callback
  64       bar(); // foo.setValue()
  65     }
  66   }
  67   // end example
  68 }
  69
  70 namespace ExampleReferenceCaller
  71 {
  72   // ReferenceCaller example
  73   void Int_printValue(const int& value)
  74   {
  75     // print value here;
  76   }
  77
  78   void Int_setValue(int& value)
  79   {
  80     value = 3;
  81   }
  82
  83   // a typedef to make things more readable
  84   typedef ReferenceCaller<int, Int_setValue> IntSetValueCaller;
  85
  86   void example()
  87   {
  88     int foo = 0;
  89
  90     {
  91       Callback bar = ConstReferenceCaller<int, Int_printValue>(foo);
  92
  93       // invoke the callback
  94       bar(); // Int_printValue(foo)
  95     }
  96
  97
  98     {
  99       // use the typedef to improve readability
 100       Callback bar = IntSetValueCaller(foo);
 101
 102       // invoke the callback
 103       bar(); // Int_setValue(foo)
 104     }
 105   }
 106   // end example
 107 }
 108
 109 #endif
 110
 111 namespace
 112 {
 113   class A1
 114   {
 115   };
 116   class A2
 117   {
 118   };
 119   class A3
 120   {
 121   };
 122   class A4
 123   {
 124   };
 125
 126   class Test
 127   {
 128   public:
 129     void test0()
 130     {
 131     }
 132     typedef Member<Test, void, &Test::test0> Test0;
 133     typedef MemberCaller<Test, &Test::test0> Test0Caller;
 134     void test0const() const
 135     {
 136     }
 137     typedef ConstMember<Test, void, &Test::test0const> Test0Const;
 138     typedef ConstMemberCaller<Test, &Test::test0const> Test0ConstCaller;
 139     void test1(A1)
 140     {
 141     }
 142     typedef Member1<Test, A1, void, &Test::test1> Test1;
 143     typedef MemberCaller1<Test, A1, &Test::test1> Test1Caller;
 144     void test1const(A1) const
 145     {
 146     }
 147     typedef ConstMember1<Test, A1, void, &Test::test1const> Test1Const;
 148     typedef ConstMemberCaller1<Test, A1, &Test::test1const> Test1ConstCaller;
 149     void test2(A1, A2)
 150     {
 151     }
 152     typedef Member2<Test, A1, A2, void, &Test::test2> Test2;
 153     void test2const(A1, A2) const
 154     {
 155     }
 156     typedef ConstMember2<Test, A1, A2, void, &Test::test2const> Test2Const;
 157     void test3(A1, A2, A3)
 158     {
 159     }
 160     typedef Member3<Test, A1, A2, A3, void, &Test::test3> Test3;
 161     void test3const(A1, A2, A3) const
 162     {
 163     }
 164     typedef ConstMember3<Test, A1, A2, A3, void, &Test::test3const> Test3Const;
 165   };
 166
 167   void test0free()
 168   {
 169   }
 170   typedef FreeCaller<&test0free> Test0FreeCaller;
 171   void test1free(A1)
 172   {
 173   }
 174   typedef FreeCaller1<A1, &test1free> Test1FreeCaller;
 175   void test2free(A1, A2)
 176   {
 177   }
 178   typedef Function2<A1, A2, void, &test2free> Test2Free;
 179   void test3free(A1, A2, A3)
 180   {
 181   }
 182   typedef Function3<A1, A2, A3, void, &test3free> Test3Free;
 183
 184
 185   void test0(Test& test)
 186   {
 187   }
 188   typedef ReferenceCaller<Test, &test0> Test0Caller;
 189
 190   void test0const(const Test& test)
 191   {
 192   }
 193   typedef ConstReferenceCaller<Test, &test0const> Test0ConstCaller;
 194
 195   void test0p(Test* test)
 196   {
 197   }
 198   typedef PointerCaller<Test, &test0p> Test0PCaller;
 199
 200   void test0constp(const Test* test)
 201   {
 202   }
 203   typedef ConstPointerCaller<Test, &test0constp> Test0ConstPCaller;
 204
 205   void test1(Test& test, A1)
 206   {
 207   }
 208   typedef ReferenceCaller1<Test, A1, &test1> Test1Caller;
 209
 210   void test1const(const Test& test, A1)
 211   {
 212   }
 213   typedef ConstReferenceCaller1<Test, A1, &test1const> Test1ConstCaller;
 214
 215   void test1p(Test* test, A1)
 216   {
 217   }
 218   typedef PointerCaller1<Test, A1, &test1p> Test1PCaller;
 219
 220   void test1constp(const Test* test, A1)
 221   {
 222   }
 223   typedef ConstPointerCaller1<Test, A1, &test1constp> Test1ConstPCaller;
 224
 225   void test2(Test& test, A1, A2)
 226   {
 227   }
 228   typedef Function3<Test&, A1, A2, void, &test2> Test2;
 229
 230   void test3(Test& test, A1, A2, A3)
 231   {
 232   }
 233   typedef Function4<Test&, A1, A2, A3, void, &test3> Test3;
 234
 235   void instantiate()
 236   {
 237     Test test;
 238     const Test& testconst = test;
 239     {
 240       Callback a = Test0FreeCaller();
 241       Callback b = Test::Test0Caller(test);
 242       b = makeCallback0(Test::Test0(), test);
 243       Callback c = Test::Test0ConstCaller(testconst);
 244       c = makeCallback0(Test::Test0Const(), test);
 245       Callback d = Test0Caller(test);
 246       Callback e = Test0ConstCaller(testconst);
 247       Callback f = Test0PCaller(&test);
 248       Callback g = Test0ConstPCaller(&testconst);
 249       a();
 250       bool u = a != b;
 251     }
 252     {
 253       typedef Callback1<A1> TestCallback1;
 254       TestCallback1 a = Test1FreeCaller();
 255       TestCallback1 b = Test::Test1Caller(test);
 256       b = makeCallback1(Test::Test1(), test);
 257       TestCallback1 c = Test::Test1ConstCaller(testconst);
 258       c = makeCallback1(Test::Test1Const(), test);
 259       TestCallback1 d = Test1Caller(test);
 260       TestCallback1 e = Test1ConstCaller(testconst);
 261       TestCallback1 f = Test1PCaller(&test);
 262       TestCallback1 g = Test1ConstPCaller(&testconst);
 263       a(A1());
 264       bool u = a != b;
 265     }
 266     {
 267       typedef Callback2<A1, A2> TestCallback2;
 268       TestCallback2 a = makeStatelessCallback2(Test2Free());
 269       TestCallback2 b = makeCallback2(Test2(), test);
 270       TestCallback2 c = makeCallback2(Test::Test2(), test);
 271       TestCallback2 d = makeCallback2(Test::Test2Const(), test);
 272       a(A1(), A2());
 273       bool u = a != b;
 274     }
 275     {
 276       typedef Callback3<A1, A2, A3> TestCallback3;
 277       TestCallback3 a = makeStatelessCallback3(Test3Free());
 278       TestCallback3 b = makeCallback3(Test3(), test);
 279       TestCallback3 c = makeCallback3(Test::Test3(), test);
 280       TestCallback3 d = makeCallback3(Test::Test3Const(), test);
 281       a(A1(), A2(), A3());
 282       bool u = a != b;
 283     }
 284   }
 285 }