tesseract  4.1.1
tesscallback.h
Go to the documentation of this file.
1 // File: tesscallback.h
3 // Description: classes and functions to replace pointer-to-functions
4 // Author: Samuel Charron
5 //
6 // (C) Copyright 2006, Google Inc.
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 // http://www.apache.org/licenses/LICENSE-2.0
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
18 
19 #ifndef TESS_CALLBACK_SPECIALIZATIONS_H_
20 #define TESS_CALLBACK_SPECIALIZATIONS_H_
21 
22 class TessClosure {
23  public:
24  virtual ~TessClosure();
25  virtual void Run() = 0;
26 };
27 
28 template <class R>
30  public:
31  virtual ~TessResultCallback() = default;
32  virtual R Run() = 0;
33 };
34 
35 template <bool del, class R, class T>
37  public:
39  using MemberSignature = R (T::*)();
40 
41  private:
42  T* object_;
43  MemberSignature member_;
44 
45  public:
47  : object_(object), member_(member) {}
48 
49  R Run() override {
50  if (!del) {
51  R result = (object_->*member_)();
52  return result;
53  }
54  R result = (object_->*member_)();
55  // zero out the pointer to ensure segfault if used again
56  member_ = nullptr;
57  delete this;
58  return result;
59  }
60 };
61 
62 template <bool del, class T>
63 class _TessMemberResultCallback_0_0<del, void, T> : public TessClosure {
64  public:
65  using base = TessClosure;
66  using MemberSignature = void (T::*)();
67 
68  private:
69  T* object_;
70  MemberSignature member_;
71 
72  public:
74  : object_(object), member_(member) {}
75 
76  void Run() override {
77  if (!del) {
78  (object_->*member_)();
79  } else {
80  (object_->*member_)();
81  // zero out the pointer to ensure segfault if used again
82  member_ = nullptr;
83  delete this;
84  }
85  }
86 };
87 
88 #ifndef SWIG
89 template <class T1, class T2, class R>
91 NewTessCallback(T1* obj, R (T2::*member)()) {
92  return new _TessMemberResultCallback_0_0<true, R, T1>(obj, member);
93 }
94 #endif
95 
96 template <bool del, class R>
98  public:
100  using FunctionSignature = R (*)();
101 
102  private:
103  FunctionSignature function_;
104 
105  public:
107  : function_(function) {}
108 
109  virtual R Run() {
110  if (!del) {
111  R result = (*function_)();
112  return result;
113  }
114  R result = (*function_)();
115  // zero out the pointer to ensure segfault if used again
116  function_ = nullptr;
117  delete this;
118  return result;
119  }
120 };
121 
122 template <bool del>
123 class _TessFunctionResultCallback_0_0<del, void> : public TessClosure {
124  public:
125  using base = TessClosure;
126  using FunctionSignature = void (*)();
127 
128  private:
129  FunctionSignature function_;
130 
131  public:
133  : function_(function) {}
134 
135  void Run() override {
136  if (!del) {
137  (*function_)();
138  } else {
139  (*function_)();
140  // zero out the pointer to ensure segfault if used again
141  function_ = nullptr;
142  delete this;
143  }
144  }
145 };
146 
147 template <class R>
149  R (*function)()) {
150  return new _TessFunctionResultCallback_0_0<true, R>(function);
151 }
152 
153 // Specified by TR1 [4.7.2] Reference modifications.
154 template <class T>
156 template <typename T>
157 struct remove_reference {
158  using type = T;
159 };
160 template <typename T>
161 struct remove_reference<T&> {
162  using type = T;
163 };
164 
165 // Identity<T>::type is a typedef of T. Useful for preventing the
166 // compiler from inferring the type of an argument in templates.
167 template <typename T>
168 struct Identity {
169  using type = T;
170 };
171 
172 template <bool del, class R, class T, class P1, class P2, class P3, class P4,
173  class P5>
175  public:
177  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5) const;
178 
179  private:
180  const T* object_;
181  MemberSignature member_;
182  typename remove_reference<P1>::type p1_;
183  typename remove_reference<P2>::type p2_;
184  typename remove_reference<P3>::type p3_;
185  typename remove_reference<P4>::type p4_;
186  typename remove_reference<P5>::type p5_;
187 
188  public:
189  inline _ConstTessMemberResultCallback_5_0(const T* object,
190  MemberSignature member, P1 p1,
191  P2 p2, P3 p3, P4 p4, P5 p5)
192  : object_(object),
193  member_(member),
194  p1_(p1),
195  p2_(p2),
196  p3_(p3),
197  p4_(p4),
198  p5_(p5) {}
199 
200  R Run() override {
201  if (!del) {
202  R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_);
203  return result;
204  }
205  R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_);
206  // zero out the pointer to ensure segfault if used again
207  member_ = nullptr;
208  delete this;
209  return result;
210  }
211 };
212 
213 template <bool del, class T, class P1, class P2, class P3, class P4, class P5>
214 class _ConstTessMemberResultCallback_5_0<del, void, T, P1, P2, P3, P4, P5>
215  : public TessClosure {
216  public:
217  using base = TessClosure;
218  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5) const;
219 
220  private:
221  const T* object_;
222  MemberSignature member_;
223  typename remove_reference<P1>::type p1_;
224  typename remove_reference<P2>::type p2_;
225  typename remove_reference<P3>::type p3_;
226  typename remove_reference<P4>::type p4_;
227  typename remove_reference<P5>::type p5_;
228 
229  public:
230  inline _ConstTessMemberResultCallback_5_0(const T* object,
231  MemberSignature member, P1 p1,
232  P2 p2, P3 p3, P4 p4, P5 p5)
233  : object_(object),
234  member_(member),
235  p1_(p1),
236  p2_(p2),
237  p3_(p3),
238  p4_(p4),
239  p5_(p5) {}
240 
241  void Run() override {
242  if (!del) {
243  (object_->*member_)(p1_, p2_, p3_, p4_, p5_);
244  } else {
245  (object_->*member_)(p1_, p2_, p3_, p4_, p5_);
246  // zero out the pointer to ensure segfault if used again
247  member_ = nullptr;
248  delete this;
249  }
250  }
251 };
252 
253 #ifndef SWIG
254 template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
255  class P5>
256 inline typename _ConstTessMemberResultCallback_5_0<false, R, T1, P1, P2, P3, P4,
257  P5>::base*
259  R (T2::*member)(P1, P2, P3, P4, P5) const,
260  typename Identity<P1>::type p1,
261  typename Identity<P2>::type p2,
262  typename Identity<P3>::type p3,
263  typename Identity<P4>::type p4,
264  typename Identity<P5>::type p5) {
265  return new _ConstTessMemberResultCallback_5_0<false, R, T1, P1, P2, P3, P4,
266  P5>(obj, member, p1, p2, p3, p4,
267  p5);
268 }
269 #endif
270 
271 template <bool del, class R, class T, class P1, class P2, class P3, class P4,
272  class P5, class P6>
274  public:
276  using MemberSignature = R (T::*)(P1, P2, P3, P4, P5, P6) const;
277 
278  private:
279  const T* object_;
280  MemberSignature member_;
281  typename remove_reference<P1>::type p1_;
282  typename remove_reference<P2>::type p2_;
283  typename remove_reference<P3>::type p3_;
284  typename remove_reference<P4>::type p4_;
285  typename remove_reference<P5>::type p5_;
286  typename remove_reference<P6>::type p6_;
287 
288  public:
289  inline _ConstTessMemberResultCallback_6_0(const T* object,
290  MemberSignature member, P1 p1,
291  P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
292  : object_(object),
293  member_(member),
294  p1_(p1),
295  p2_(p2),
296  p3_(p3),
297  p4_(p4),
298  p5_(p5),
299  p6_(p6) {}
300 
301  R Run() override {
302  if (!del) {
303  R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_);
304  return result;
305  }
306  R result = (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_);
307  // zero out the pointer to ensure segfault if used again
308  member_ = nullptr;
309  delete this;
310  return result;
311  }
312 };
313 
314 template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
315  class P6>
316 class _ConstTessMemberResultCallback_6_0<del, void, T, P1, P2, P3, P4, P5, P6>
317  : public TessClosure {
318  public:
319  using base = TessClosure;
320  using MemberSignature = void (T::*)(P1, P2, P3, P4, P5, P6) const;
321 
322  private:
323  const T* object_;
324  MemberSignature member_;
325  typename remove_reference<P1>::type p1_;
326  typename remove_reference<P2>::type p2_;
327  typename remove_reference<P3>::type p3_;
328  typename remove_reference<P4>::type p4_;
329  typename remove_reference<P5>::type p5_;
330  typename remove_reference<P6>::type p6_;
331 
332  public:
333  inline _ConstTessMemberResultCallback_6_0(const T* object,
334  MemberSignature member, P1 p1,
335  P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
336  : object_(object),
337  member_(member),
338  p1_(p1),
339  p2_(p2),
340  p3_(p3),
341  p4_(p4),
342  p5_(p5),
343  p6_(p6) {}
344 
345  void Run() override {
346  if (!del) {
347  (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_);
348  } else {
349  (object_->*member_)(p1_, p2_, p3_, p4_, p5_, p6_);
350  // zero out the pointer to ensure segfault if used again
351  member_ = nullptr;
352  delete this;
353  }
354  }
355 };
356 
357 #ifndef SWIG
358 template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
359  class P5, class P6>
360 inline typename _ConstTessMemberResultCallback_6_0<false, R, T1, P1, P2, P3, P4,
361  P5, P6>::base*
363  const T1* obj, R (T2::*member)(P1, P2, P3, P4, P5, P6) const,
364  typename Identity<P1>::type p1, typename Identity<P2>::type p2,
365  typename Identity<P3>::type p3, typename Identity<P4>::type p4,
366  typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
367  return new _ConstTessMemberResultCallback_6_0<false, R, T1, P1, P2, P3, P4,
368  P5, P6>(obj, member, p1, p2, p3,
369  p4, p5, p6);
370 }
371 #endif
372 
373 template <class A1>
374 class TessCallback1 {
375  public:
376  virtual ~TessCallback1() = default;
377  virtual void Run(A1) = 0;
378 };
379 
380 template <class R, class A1>
382  public:
383  virtual ~TessResultCallback1() = default;
384  virtual R Run(A1) = 0;
385 };
386 
387 template <class A1, class A2>
389  public:
390  virtual ~TessCallback2() = default;
391  virtual void Run(A1, A2) = 0;
392 };
393 
394 template <class R, class A1, class A2>
395 class TessResultCallback2 {
396  public:
397  virtual ~TessResultCallback2() = default;
398  virtual R Run(A1, A2) = 0;
399 };
400 
401 template <class A1, class A2, class A3>
403  public:
404  virtual ~TessCallback3() = default;
405  virtual void Run(A1, A2, A3) = 0;
406 };
407 
408 template <class R, class A1, class A2, class A3>
410  public:
411  virtual ~TessResultCallback3() = default;
412  virtual R Run(A1, A2, A3) = 0;
413 };
414 
415 template <class A1, class A2, class A3, class A4>
417  public:
418  virtual ~TessCallback4() = default;
419  virtual void Run(A1, A2, A3, A4) = 0;
420 };
421 
422 template <class R, class A1, class A2, class A3, class A4>
424  public:
425  virtual ~TessResultCallback4() = default;
426  virtual R Run(A1, A2, A3, A4) = 0;
427 };
428 
429 template <bool del, class R, class T, class A1>
431  public:
433  using MemberSignature = R (T::*)(A1);
434 
435  private:
436  T* object_;
437  MemberSignature member_;
438 
439  public:
441  : object_(object), member_(member) {}
442 
443  R Run(A1 a1) override {
444  if (!del) {
445  R result = (object_->*member_)(a1);
446  return result;
447  }
448  R result = (object_->*member_)(a1);
449  // zero out the pointer to ensure segfault if used again
450  member_ = nullptr;
451  delete this;
452  return result;
453  }
454 };
455 
456 template <bool del, class T, class A1>
457 class _TessMemberResultCallback_0_1<del, void, T, A1>
458  : public TessCallback1<A1> {
459  public:
461  using MemberSignature = void (T::*)(A1);
462 
463  private:
464  T* object_;
465  MemberSignature member_;
466 
467  public:
469  : object_(object), member_(member) {}
470 
471  void Run(A1 a1) override {
472  if (!del) {
473  (object_->*member_)(a1);
474  } else {
475  (object_->*member_)(a1);
476  // zero out the pointer to ensure segfault if used again
477  member_ = nullptr;
478  delete this;
479  }
480  }
481 };
482 
483 #ifndef SWIG
484 template <class T1, class T2, class R, class A1>
486 NewPermanentTessCallback(T1* obj, R (T2::*member)(A1)) {
487  return new _TessMemberResultCallback_0_1<false, R, T1, A1>(obj, member);
488 }
489 #endif
490 
491 template <bool del, class R, class A1>
493  public:
495  using FunctionSignature = R (*)(A1);
496 
497  private:
498  FunctionSignature function_;
499 
500  public:
502  : function_(function) {}
503 
504  virtual R Run(A1 a1) {
505  if (!del) {
506  R result = (*function_)(a1);
507  return result;
508  }
509  R result = (*function_)(a1);
510  // zero out the pointer to ensure segfault if used again
511  function_ = nullptr;
512  delete this;
513  return result;
514  }
515 };
516 
517 template <bool del, class A1>
519  : public TessCallback1<A1> {
520  public:
522  using FunctionSignature = void (*)(A1);
523 
524  private:
525  FunctionSignature function_;
526 
527  public:
529  : function_(function) {}
530 
531  void Run(A1 a1) override {
532  if (!del) {
533  (*function_)(a1);
534  } else {
535  (*function_)(a1);
536  // zero out the pointer to ensure segfault if used again
537  function_ = nullptr;
538  delete this;
539  }
540  }
541 };
542 
543 template <class R, class A1>
545 NewPermanentTessCallback(R (*function)(A1)) {
547 }
548 
549 template <bool del, class R, class P1, class A1>
551  public:
553  using FunctionSignature = R (*)(P1, A1);
554 
555  private:
556  FunctionSignature function_;
557  typename remove_reference<P1>::type p1_;
558 
559  public:
561  : function_(function), p1_(p1) {}
562 
563  virtual R Run(A1 a1) {
564  if (!del) {
565  R result = (*function_)(p1_, a1);
566  return result;
567  }
568  R result = (*function_)(p1_, a1);
569  // zero out the pointer to ensure segfault if used again
570  function_ = nullptr;
571  delete this;
572  return result;
573  }
574 };
575 
576 template <bool del, class P1, class A1>
577 class _TessFunctionResultCallback_1_1<del, void, P1, A1>
578  : public TessCallback1<A1> {
579  public:
581  using FunctionSignature = void (*)(P1, A1);
582 
583  private:
584  FunctionSignature function_;
585  typename remove_reference<P1>::type p1_;
586 
587  public:
589  : function_(function), p1_(p1) {}
590 
591  void Run(A1 a1) override {
592  if (!del) {
593  (*function_)(p1_, a1);
594  } else {
595  (*function_)(p1_, a1);
596  // zero out the pointer to ensure segfault if used again
597  function_ = nullptr;
598  delete this;
599  }
600  }
601 };
602 
603 template <class R, class P1, class A1>
605 NewPermanentTessCallback(R (*function)(P1, A1),
606  typename Identity<P1>::type p1) {
607  return new _TessFunctionResultCallback_1_1<false, R, P1, A1>(function, p1);
608 }
609 
610 template <bool del, class R, class T, class A1, class A2>
612  : public TessResultCallback2<R, A1, A2> {
613  public:
615  using MemberSignature = R (T::*)(A1, A2) const;
616 
617  private:
618  const T* object_;
619  MemberSignature member_;
620 
621  public:
622  inline _ConstTessMemberResultCallback_0_2(const T* object,
623  MemberSignature member)
624  : object_(object), member_(member) {}
625 
626  R Run(A1 a1, A2 a2) override {
627  if (!del) {
628  R result = (object_->*member_)(a1, a2);
629  return result;
630  }
631  R result = (object_->*member_)(a1, a2);
632  // zero out the pointer to ensure segfault if used again
633  member_ = nullptr;
634  delete this;
635  return result;
636  }
637 };
638 
639 template <bool del, class T, class A1, class A2>
640 class _ConstTessMemberResultCallback_0_2<del, void, T, A1, A2>
641  : public TessCallback2<A1, A2> {
642  public:
644  using MemberSignature = void (T::*)(A1, A2) const;
645 
646  private:
647  const T* object_;
648  MemberSignature member_;
649 
650  public:
651  inline _ConstTessMemberResultCallback_0_2(const T* object,
652  MemberSignature member)
653  : object_(object), member_(member) {}
654 
655  virtual void Run(A1 a1, A2 a2) {
656  if (!del) {
657  (object_->*member_)(a1, a2);
658  } else {
659  (object_->*member_)(a1, a2);
660  // zero out the pointer to ensure segfault if used again
661  member_ = nullptr;
662  delete this;
663  }
664  }
665 };
666 
667 #ifndef SWIG
668 template <class T1, class T2, class R, class A1, class A2>
670 NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1, A2) const) {
672  member);
673 }
674 #endif
675 
676 template <bool del, class R, class T, class A1, class A2>
678  public:
680  using MemberSignature = R (T::*)(A1, A2);
681 
682  private:
683  T* object_;
684  MemberSignature member_;
685 
686  public:
688  : object_(object), member_(member) {}
689 
690  R Run(A1 a1, A2 a2) override {
691  if (!del) {
692  R result = (object_->*member_)(a1, a2);
693  return result;
694  }
695  R result = (object_->*member_)(a1, a2);
696  // zero out the pointer to ensure segfault if used again
697  member_ = nullptr;
698  delete this;
699  return result;
700  }
701 };
702 
703 template <bool del, class T, class A1, class A2>
704 class _TessMemberResultCallback_0_2<del, void, T, A1, A2>
705  : public TessCallback2<A1, A2> {
706  public:
708  using MemberSignature = void (T::*)(A1, A2);
709 
710  private:
711  T* object_;
712  MemberSignature member_;
713 
714  public:
716  : object_(object), member_(member) {}
717 
718  virtual void Run(A1 a1, A2 a2) {
719  if (!del) {
720  (object_->*member_)(a1, a2);
721  } else {
722  (object_->*member_)(a1, a2);
723  // zero out the pointer to ensure segfault if used again
724  member_ = nullptr;
725  delete this;
726  }
727  }
728 };
729 
730 #ifndef SWIG
731 template <class T1, class T2, class R, class A1, class A2>
733 NewPermanentTessCallback(T1* obj, R (T2::*member)(A1, A2)) {
735 }
736 #endif
737 
738 template <bool del, class R, class A1, class A2>
740  public:
742  using FunctionSignature = R (*)(A1, A2);
743 
744  private:
745  FunctionSignature function_;
746 
747  public:
749  : function_(function) {}
750 
751  R Run(A1 a1, A2 a2) override {
752  if (!del) {
753  R result = (*function_)(a1, a2);
754  return result;
755  }
756  R result = (*function_)(a1, a2);
757  // zero out the pointer to ensure segfault if used again
758  function_ = nullptr;
759  delete this;
760  return result;
761  }
762 };
763 
764 template <bool del, class A1, class A2>
765 class _TessFunctionResultCallback_0_2<del, void, A1, A2>
766  : public TessCallback2<A1, A2> {
767  public:
769  using FunctionSignature = void (*)(A1, A2);
770 
771  private:
772  FunctionSignature function_;
773 
774  public:
776  : function_(function) {}
777 
778  virtual void Run(A1 a1, A2 a2) {
779  if (!del) {
780  (*function_)(a1, a2);
781  } else {
782  (*function_)(a1, a2);
783  // zero out the pointer to ensure segfault if used again
784  function_ = nullptr;
785  delete this;
786  }
787  }
788 };
789 
790 template <class R, class A1, class A2>
792 NewPermanentTessCallback(R (*function)(A1, A2)) {
794 }
795 
796 template <bool del, class R, class T, class P1, class P2, class A1, class A2>
798  public:
800  using MemberSignature = R (T::*)(P1, P2, A1, A2);
801 
802  private:
803  T* object_;
804  MemberSignature member_;
805  typename remove_reference<P1>::type p1_;
806  typename remove_reference<P2>::type p2_;
807 
808  public:
809  inline _TessMemberResultCallback_2_2(T* object, MemberSignature member, P1 p1,
810  P2 p2)
811  : object_(object), member_(member), p1_(p1), p2_(p2) {}
812 
813  R Run(A1 a1, A2 a2) override {
814  if (!del) {
815  R result = (object_->*member_)(p1_, p2_, a1, a2);
816  return result;
817  }
818  R result = (object_->*member_)(p1_, p2_, a1, a2);
819  // zero out the pointer to ensure segfault if used again
820  member_ = nullptr;
821  delete this;
822  return result;
823  }
824 };
825 
826 #ifndef SWIG
827 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
828 inline
830  NewPermanentTessCallback(T1* obj, R (T2::*member)(P1, P2, A1, A2),
831  typename Identity<P1>::type p1,
832  typename Identity<P2>::type p2) {
834  obj, member, p1, p2);
835 }
836 #endif
837 
838 template <bool del, class R, class T, class A1, class A2, class A3>
840  : public TessResultCallback3<R, A1, A2, A3> {
841  public:
843  using MemberSignature = R (T::*)(A1, A2, A3) const;
844 
845  private:
846  const T* object_;
847  MemberSignature member_;
848 
849  public:
850  inline _ConstTessMemberResultCallback_0_3(const T* object,
851  MemberSignature member)
852  : object_(object), member_(member) {}
853 
854  R Run(A1 a1, A2 a2, A3 a3) override {
855  if (!del) {
856  R result = (object_->*member_)(a1, a2, a3);
857  return result;
858  }
859  R result = (object_->*member_)(a1, a2, a3);
860  // zero out the pointer to ensure segfault if used again
861  member_ = nullptr;
862  delete this;
863  return result;
864  }
865 };
866 
867 #ifndef SWIG
868 template <class T1, class T2, class R, class A1, class A2, class A3>
869 inline
871  NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1, A2, A3) const) {
873  obj, member);
874 }
875 #endif
876 
877 template <bool del, class R, class T, class A1, class A2, class A3, class A4>
879  : public TessResultCallback4<R, A1, A2, A3, A4> {
880  public:
882  using MemberSignature = R (T::*)(A1, A2, A3, A4);
883 
884  private:
885  T* object_;
886  MemberSignature member_;
887 
888  public:
890  : object_(object), member_(member) {}
891 
892  virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4) {
893  if (!del) {
894  R result = (object_->*member_)(a1, a2, a3, a4);
895  return result;
896  }
897  R result = (object_->*member_)(a1, a2, a3, a4);
898  // zero out the pointer to ensure segfault if used again
899  member_ = nullptr;
900  delete this;
901  return result;
902  }
903 };
904 
905 #ifndef SWIG
906 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
907 inline
909  NewPermanentTessCallback(T1* obj, R (T2::*member)(A1, A2, A3, A4)) {
911  obj, member);
912 }
913 #endif
914 
915 #endif // TESS_CALLBACK_SPECIALIZATIONS_H_
R(T::*)(P1, P2, P3, P4, P5) const MemberSignature
Definition: tesscallback.h:177
R(T::*)(A1, A2) MemberSignature
Definition: tesscallback.h:680
virtual R Run(A1)=0
_TessMemberResultCallback_0_4(T *object, MemberSignature member)
Definition: tesscallback.h:889
_TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
Definition: tesscallback.h:560
R(T::*)(P1, P2, A1, A2) MemberSignature
Definition: tesscallback.h:800
_TessFunctionResultCallback_0_0(FunctionSignature function)
Definition: tesscallback.h:132
_ConstTessMemberResultCallback_0_3(const T *object, MemberSignature member)
Definition: tesscallback.h:850
virtual ~TessResultCallback()=default
virtual ~TessCallback2()=default
virtual ~TessClosure()
TessResultCallback1< R, A1 > base
Definition: tesscallback.h:494
R Run(A1 a1, A2 a2) override
Definition: tesscallback.h:813
virtual void Run(A1, A2)=0
virtual ~TessCallback4()=default
TessResultCallback4< R, A1, A2, A3, A4 > base
Definition: tesscallback.h:881
virtual ~TessResultCallback4()=default
_TessFunctionResultCallback_0_0(FunctionSignature function)
Definition: tesscallback.h:106
virtual ~TessCallback1()=default
virtual R Run()=0
virtual ~TessResultCallback3()=default
virtual ~TessResultCallback2()=default
R(T::*)(A1, A2) const MemberSignature
Definition: tesscallback.h:615
virtual R Run(A1, A2)=0
virtual void Run()=0
_TessFunctionResultCallback_0_2(FunctionSignature function)
Definition: tesscallback.h:748
virtual ~TessResultCallback1()=default
TessResultCallback3< R, A1, A2, A3 > base
Definition: tesscallback.h:842
_ConstTessMemberResultCallback_0_2(const T *object, MemberSignature member)
Definition: tesscallback.h:651
_ConstTessMemberResultCallback_6_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
Definition: tesscallback.h:333
_TessMemberResultCallback_0_0(T *object, MemberSignature member)
Definition: tesscallback.h:73
TessResultCallback1< R, A1 > base
Definition: tesscallback.h:432
_TessMemberResultCallback_0_1(T *object, MemberSignature member)
Definition: tesscallback.h:440
TessResultCallback2< R, A1, A2 > base
Definition: tesscallback.h:679
_TessMemberResultCallback_0_0(T *object, MemberSignature member)
Definition: tesscallback.h:46
R Run(A1 a1, A2 a2, A3 a3) override
Definition: tesscallback.h:854
TessResultCallback2< R, A1, A2 > base
Definition: tesscallback.h:741
virtual R Run(A1, A2, A3, A4)=0
virtual void Run(A1, A2, A3, A4)=0
TessResultCallback2< R, A1, A2 > base
Definition: tesscallback.h:799
_TessFunctionResultCallback_0_1(FunctionSignature function)
Definition: tesscallback.h:528
_TessMemberResultCallback_0_2(T *object, MemberSignature member)
Definition: tesscallback.h:715
_ConstTessMemberResultCallback_5_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
Definition: tesscallback.h:230
_TessMemberResultCallback_0_0< true, R, T1 >::base * NewTessCallback(T1 *obj, R(T2::*member)())
Definition: tesscallback.h:91
R(T::*)(A1, A2, A3) const MemberSignature
Definition: tesscallback.h:843
_ConstTessMemberResultCallback_6_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
Definition: tesscallback.h:289
virtual void Run(A1)=0
_TessMemberResultCallback_0_2(T *object, MemberSignature member)
Definition: tesscallback.h:687
virtual ~TessCallback3()=default
_ConstTessMemberResultCallback_5_0< false, R, T1, P1, P2, P3, P4, P5 >::base * NewPermanentTessCallback(const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5) const, typename Identity< P1 >::type p1, typename Identity< P2 >::type p2, typename Identity< P3 >::type p3, typename Identity< P4 >::type p4, typename Identity< P5 >::type p5)
Definition: tesscallback.h:258
R Run(A1 a1, A2 a2) override
Definition: tesscallback.h:626
TessResultCallback1< R, A1 > base
Definition: tesscallback.h:552
_ConstTessMemberResultCallback_0_2(const T *object, MemberSignature member)
Definition: tesscallback.h:622
R(T::*)(A1, A2, A3, A4) MemberSignature
Definition: tesscallback.h:882
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
Definition: tesscallback.h:892
virtual void Run(A1, A2, A3)=0
_TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
Definition: tesscallback.h:588
R Run(A1 a1, A2 a2) override
Definition: tesscallback.h:751
R(T::*)(P1, P2, P3, P4, P5, P6) const MemberSignature
Definition: tesscallback.h:276
_ConstTessMemberResultCallback_5_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
Definition: tesscallback.h:189
virtual R Run(A1, A2, A3)=0
_TessMemberResultCallback_2_2(T *object, MemberSignature member, P1 p1, P2 p2)
Definition: tesscallback.h:809
_TessFunctionResultCallback_0_2(FunctionSignature function)
Definition: tesscallback.h:775
R Run(A1 a1, A2 a2) override
Definition: tesscallback.h:690
_TessMemberResultCallback_0_1(T *object, MemberSignature member)
Definition: tesscallback.h:468
_TessFunctionResultCallback_0_1(FunctionSignature function)
Definition: tesscallback.h:501
TessResultCallback2< R, A1, A2 > base
Definition: tesscallback.h:614