← Back to branch summary

~ubuntu-branches/ubuntu/wily/cxxtools/wily-proposed

« back to all changes in this revision

Viewing changes to include/cxxtools/invokable.tpp

  • Committer: Bazaar Package Importer
  • Author(s): Kari Pahula
  • Date: 2008-06-16 12:24:28 UTC
  • mfrom: (3.1.3 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080616122428-7bllgyt1358u779r
Tags: 1.4.8-2
Made libcxxtools-dev depend on libcxxtools6, not libcxxtools5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/cxxtools/invokable.tpp
 
1
// BEGIN_Invokable 10
 
2
/**
 
3
Invokable is a type which can be "called" via
 
4
the invoke() member. It serves as a base type
 
5
for other types in the Pt signals/slots framework.
 
6
*/
 
7
template <class A1 = Void, class A2 = Void, class A3 = Void, class A4 = Void, class A5 = Void, class A6 = Void, class A7 = Void, class A8 = Void, class A9 = Void, class A10 = Void>
 
8
class Invokable {
 
9
    public:
 
10
        /** Does nothing. Does not throw. */
 
11
        virtual ~Invokable()
 
12
        {}
 
13
 
 
14
        /** Behaviour is determined by subclass implementations. */
 
15
        virtual void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const = 0;
 
16
};
 
17
// END_Invokable 10
 
18
// BEGIN_Invokable 9
 
19
// specialization
 
20
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
 
21
class Invokable<A1,A2,A3,A4,A5,A6,A7,A8,A9,Void> {
 
22
    public:
 
23
        /** Does nothing. Does not throw. */
 
24
        virtual ~Invokable()
 
25
        {}
 
26
 
 
27
        /** Behaviour is determined by subclass implementations. */
 
28
        virtual void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const = 0;
 
29
};
 
30
// END_Invokable 9
 
31
// BEGIN_Invokable 8
 
32
// specialization
 
33
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
 
34
class Invokable<A1,A2,A3,A4,A5,A6,A7,A8,Void,Void> {
 
35
    public:
 
36
        /** Does nothing. Does not throw. */
 
37
        virtual ~Invokable()
 
38
        {}
 
39
 
 
40
        /** Behaviour is determined by subclass implementations. */
 
41
        virtual void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const = 0;
 
42
};
 
43
// END_Invokable 8
 
44
// BEGIN_Invokable 7
 
45
// specialization
 
46
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
 
47
class Invokable<A1,A2,A3,A4,A5,A6,A7,Void,Void,Void> {
 
48
    public:
 
49
        /** Does nothing. Does not throw. */
 
50
        virtual ~Invokable()
 
51
        {}
 
52
 
 
53
        /** Behaviour is determined by subclass implementations. */
 
54
        virtual void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const = 0;
 
55
};
 
56
// END_Invokable 7
 
57
// BEGIN_Invokable 6
 
58
// specialization
 
59
template <class A1, class A2, class A3, class A4, class A5, class A6>
 
60
class Invokable<A1,A2,A3,A4,A5,A6,Void,Void,Void,Void> {
 
61
    public:
 
62
        /** Does nothing. Does not throw. */
 
63
        virtual ~Invokable()
 
64
        {}
 
65
 
 
66
        /** Behaviour is determined by subclass implementations. */
 
67
        virtual void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const = 0;
 
68
};
 
69
// END_Invokable 6
 
70
// BEGIN_Invokable 5
 
71
// specialization
 
72
template <class A1, class A2, class A3, class A4, class A5>
 
73
class Invokable<A1,A2,A3,A4,A5,Void,Void,Void,Void,Void> {
 
74
    public:
 
75
        /** Does nothing. Does not throw. */
 
76
        virtual ~Invokable()
 
77
        {}
 
78
 
 
79
        /** Behaviour is determined by subclass implementations. */
 
80
        virtual void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const = 0;
 
81
};
 
82
// END_Invokable 5
 
83
// BEGIN_Invokable 4
 
84
// specialization
 
85
template <class A1, class A2, class A3, class A4>
 
86
class Invokable<A1,A2,A3,A4,Void,Void,Void,Void,Void,Void> {
 
87
    public:
 
88
        /** Does nothing. Does not throw. */
 
89
        virtual ~Invokable()
 
90
        {}
 
91
 
 
92
        /** Behaviour is determined by subclass implementations. */
 
93
        virtual void invoke(A1 a1, A2 a2, A3 a3, A4 a4) const = 0;
 
94
};
 
95
// END_Invokable 4
 
96
// BEGIN_Invokable 3
 
97
// specialization
 
98
template <class A1, class A2, class A3>
 
99
class Invokable<A1,A2,A3,Void,Void,Void,Void,Void,Void,Void> {
 
100
    public:
 
101
        /** Does nothing. Does not throw. */
 
102
        virtual ~Invokable()
 
103
        {}
 
104
 
 
105
        /** Behaviour is determined by subclass implementations. */
 
106
        virtual void invoke(A1 a1, A2 a2, A3 a3) const = 0;
 
107
};
 
108
// END_Invokable 3
 
109
// BEGIN_Invokable 2
 
110
// specialization
 
111
template <class A1, class A2>
 
112
class Invokable<A1,A2,Void,Void,Void,Void,Void,Void,Void,Void> {
 
113
    public:
 
114
        /** Does nothing. Does not throw. */
 
115
        virtual ~Invokable()
 
116
        {}
 
117
 
 
118
        /** Behaviour is determined by subclass implementations. */
 
119
        virtual void invoke(A1 a1, A2 a2) const = 0;
 
120
};
 
121
// END_Invokable 2
 
122
// BEGIN_Invokable 1
 
123
// specialization
 
124
template <class A1>
 
125
class Invokable<A1,Void,Void,Void,Void,Void,Void,Void,Void,Void> {
 
126
    public:
 
127
        /** Does nothing. Does not throw. */
 
128
        virtual ~Invokable()
 
129
        {}
 
130
 
 
131
        /** Behaviour is determined by subclass implementations. */
 
132
        virtual void invoke(A1 a1) const = 0;
 
133
};
 
134
// END_Invokable 1
 
135
// BEGIN_Invokable 0
 
136
// specialization
 
137
template <>
 
138
class Invokable<Void,Void,Void,Void,Void,Void,Void,Void,Void,Void> {
 
139
    public:
 
140
        /** Does nothing. Does not throw. */
 
141
        virtual ~Invokable()
 
142
        {}
 
143
 
 
144
        /** Behaviour is determined by subclass implementations. */
 
145
        virtual void invoke() const = 0;
 
146
};
 
147
// END_Invokable 0