tesseract 4.1.1
Loading...
Searching...
No Matches
tesscallback.h
Go to the documentation of this file.
1
2// 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
23 public:
24 virtual ~TessClosure();
25 virtual void Run() = 0;
26};
27
28template <class R>
30 public:
31 virtual ~TessResultCallback() = default;
32 virtual R Run() = 0;
33};
34
35template <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
62template <bool del, class T>
63class _TessMemberResultCallback_0_0<del, void, T> : public TessClosure {
64 public:
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
89template <class T1, class T2, class R>
91NewTessCallback(T1* obj, R (T2::*member)()) {
92 return new _TessMemberResultCallback_0_0<true, R, T1>(obj, member);
93}
94#endif
95
96template <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
122template <bool del>
124 public:
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
147template <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.
154template <class T>
155struct remove_reference;
156template <typename T>
158 using type = T;
159};
160template <typename 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.
167template <typename T>
168struct Identity {
169 using type = T;
170};
171
172template <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:
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
213template <bool del, class T, class P1, class P2, class P3, class P4, class P5>
214class _ConstTessMemberResultCallback_5_0<del, void, T, P1, P2, P3, P4, P5>
215 : public TessClosure {
216 public:
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:
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
254template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
255 class P5>
256inline 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
271template <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:
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
314template <bool del, class T, class P1, class P2, class P3, class P4, class P5,
315 class P6>
316class _ConstTessMemberResultCallback_6_0<del, void, T, P1, P2, P3, P4, P5, P6>
317 : public TessClosure {
318 public:
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:
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
358template <class T1, class T2, class R, class P1, class P2, class P3, class P4,
359 class P5, class P6>
360inline 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
373template <class A1>
375 public:
376 virtual ~TessCallback1() = default;
377 virtual void Run(A1) = 0;
378};
379
380template <class R, class A1>
382 public:
383 virtual ~TessResultCallback1() = default;
384 virtual R Run(A1) = 0;
385};
386
387template <class A1, class A2>
389 public:
390 virtual ~TessCallback2() = default;
391 virtual void Run(A1, A2) = 0;
392};
393
394template <class R, class A1, class A2>
396 public:
397 virtual ~TessResultCallback2() = default;
398 virtual R Run(A1, A2) = 0;
399};
400
401template <class A1, class A2, class A3>
403 public:
404 virtual ~TessCallback3() = default;
405 virtual void Run(A1, A2, A3) = 0;
406};
407
408template <class R, class A1, class A2, class A3>
410 public:
411 virtual ~TessResultCallback3() = default;
412 virtual R Run(A1, A2, A3) = 0;
413};
414
415template <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
422template <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
429template <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
456template <bool del, class T, class A1>
457class _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
484template <class T1, class T2, class R, class A1>
486NewPermanentTessCallback(T1* obj, R (T2::*member)(A1)) {
488}
489#endif
490
491template <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
517template <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
543template <class R, class A1>
545NewPermanentTessCallback(R (*function)(A1)) {
547}
548
549template <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
576template <bool del, class P1, class A1>
577class _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
603template <class R, class P1, class A1>
605NewPermanentTessCallback(R (*function)(P1, A1),
606 typename Identity<P1>::type p1) {
608}
609
610template <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:
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
639template <bool del, class T, class A1, class A2>
640class _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:
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
668template <class T1, class T2, class R, class A1, class A2>
670NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1, A2) const) {
672 member);
673}
674#endif
675
676template <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
703template <bool del, class T, class A1, class A2>
704class _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
731template <class T1, class T2, class R, class A1, class A2>
733NewPermanentTessCallback(T1* obj, R (T2::*member)(A1, A2)) {
735}
736#endif
737
738template <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
764template <bool del, class A1, class A2>
765class _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
790template <class R, class A1, class A2>
792NewPermanentTessCallback(R (*function)(A1, A2)) {
794}
795
796template <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
827template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
828inline
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
838template <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:
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
868template <class T1, class T2, class R, class A1, class A2, class A3>
869inline
871 NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1, A2, A3) const) {
873 obj, member);
874}
875#endif
876
877template <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
906template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
907inline
909 NewPermanentTessCallback(T1* obj, R (T2::*member)(A1, A2, A3, A4)) {
911 obj, member);
912}
913#endif
914
915#endif // TESS_CALLBACK_SPECIALIZATIONS_H_
_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
_TessMemberResultCallback_0_0< true, R, T1 >::base * NewTessCallback(T1 *obj, R(T2::*member)())
Definition: tesscallback.h:91
virtual ~TessResultCallback2()=default
virtual R Run(A1, A2)=0
virtual void Run(A1)=0
virtual ~TessCallback1()=default
virtual void Run()=0
virtual ~TessClosure()
virtual ~TessResultCallback()=default
virtual R Run()=0
_TessMemberResultCallback_0_0(T *object, MemberSignature member)
Definition: tesscallback.h:46
_TessMemberResultCallback_0_0(T *object, MemberSignature member)
Definition: tesscallback.h:73
_TessFunctionResultCallback_0_0(FunctionSignature function)
Definition: tesscallback.h:106
_TessFunctionResultCallback_0_0(FunctionSignature function)
Definition: tesscallback.h:132
_ConstTessMemberResultCallback_5_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
Definition: tesscallback.h:189
R(T::*)(P1, P2, P3, P4, P5) const MemberSignature
Definition: tesscallback.h:177
_ConstTessMemberResultCallback_5_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
Definition: tesscallback.h:230
R(T::*)(P1, P2, P3, P4, P5, P6) const MemberSignature
Definition: tesscallback.h:276
_ConstTessMemberResultCallback_6_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
Definition: tesscallback.h:289
_ConstTessMemberResultCallback_6_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
Definition: tesscallback.h:333
virtual R Run(A1)=0
virtual ~TessResultCallback1()=default
virtual ~TessCallback2()=default
virtual void Run(A1, A2)=0
virtual ~TessCallback3()=default
virtual void Run(A1, A2, A3)=0
virtual ~TessResultCallback3()=default
virtual R Run(A1, A2, A3)=0
virtual void Run(A1, A2, A3, A4)=0
virtual ~TessCallback4()=default
virtual ~TessResultCallback4()=default
virtual R Run(A1, A2, A3, A4)=0
TessResultCallback1< R, A1 > base
Definition: tesscallback.h:432
_TessMemberResultCallback_0_1(T *object, MemberSignature member)
Definition: tesscallback.h:440
_TessMemberResultCallback_0_1(T *object, MemberSignature member)
Definition: tesscallback.h:468
_TessFunctionResultCallback_0_1(FunctionSignature function)
Definition: tesscallback.h:501
TessResultCallback1< R, A1 > base
Definition: tesscallback.h:494
_TessFunctionResultCallback_0_1(FunctionSignature function)
Definition: tesscallback.h:528
_TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
Definition: tesscallback.h:560
TessResultCallback1< R, A1 > base
Definition: tesscallback.h:552
_TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
Definition: tesscallback.h:588
TessResultCallback2< R, A1, A2 > base
Definition: tesscallback.h:614
R Run(A1 a1, A2 a2) override
Definition: tesscallback.h:626
R(T::*)(A1, A2) const MemberSignature
Definition: tesscallback.h:615
_ConstTessMemberResultCallback_0_2(const T *object, MemberSignature member)
Definition: tesscallback.h:622
_ConstTessMemberResultCallback_0_2(const T *object, MemberSignature member)
Definition: tesscallback.h:651
R Run(A1 a1, A2 a2) override
Definition: tesscallback.h:690
TessResultCallback2< R, A1, A2 > base
Definition: tesscallback.h:679
_TessMemberResultCallback_0_2(T *object, MemberSignature member)
Definition: tesscallback.h:687
R(T::*)(A1, A2) MemberSignature
Definition: tesscallback.h:680
_TessMemberResultCallback_0_2(T *object, MemberSignature member)
Definition: tesscallback.h:715
R Run(A1 a1, A2 a2) override
Definition: tesscallback.h:751
TessResultCallback2< R, A1, A2 > base
Definition: tesscallback.h:741
_TessFunctionResultCallback_0_2(FunctionSignature function)
Definition: tesscallback.h:748
_TessFunctionResultCallback_0_2(FunctionSignature function)
Definition: tesscallback.h:775
R Run(A1 a1, A2 a2) override
Definition: tesscallback.h:813
R(T::*)(P1, P2, A1, A2) MemberSignature
Definition: tesscallback.h:800
_TessMemberResultCallback_2_2(T *object, MemberSignature member, P1 p1, P2 p2)
Definition: tesscallback.h:809
TessResultCallback2< R, A1, A2 > base
Definition: tesscallback.h:799
TessResultCallback3< R, A1, A2, A3 > base
Definition: tesscallback.h:842
R Run(A1 a1, A2 a2, A3 a3) override
Definition: tesscallback.h:854
R(T::*)(A1, A2, A3) const MemberSignature
Definition: tesscallback.h:843
_ConstTessMemberResultCallback_0_3(const T *object, MemberSignature member)
Definition: tesscallback.h:850
TessResultCallback4< R, A1, A2, A3, A4 > base
Definition: tesscallback.h:881
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
Definition: tesscallback.h:892
_TessMemberResultCallback_0_4(T *object, MemberSignature member)
Definition: tesscallback.h:889
R(T::*)(A1, A2, A3, A4) MemberSignature
Definition: tesscallback.h:882