1 /*
2 * Copyright (C) 2010 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23 * THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #ifndef WorkItem_h
27 #define WorkItem_h
28
29 #include <wtf/PassOwnPtr.h>
30
31 class WorkItem {
32 public:
33 template<typename C>
34 static PassOwnPtr<WorkItem> create(C*, void (C::*)());
35
36 template<typename C, typename T0>
37 static PassOwnPtr<WorkItem> create(C*, void (C::*)(T0), T0);
38
39 template<typename C, typename T0, typename T1>
40 static PassOwnPtr<WorkItem> create(C*, void (C::*)(T0, T1), T0, T1);
41
42 static PassOwnPtr<WorkItem> create(void (*)());
43
~WorkItem()44 virtual ~WorkItem() { }
45 virtual void execute() = 0;
46
47 protected:
WorkItem()48 WorkItem() { }
49
50 private:
51 WorkItem(const WorkItem&);
52 WorkItem& operator=(const WorkItem&);
53 };
54
55 template <typename C>
56 class MemberFunctionWorkItem0 : private WorkItem {
57 // We only allow WorkItem to create this.
58 friend class WorkItem;
59
60 typedef void (C::*FunctionType)();
61
MemberFunctionWorkItem0(C * ptr,FunctionType function)62 MemberFunctionWorkItem0(C* ptr, FunctionType function)
63 : m_ptr(ptr)
64 , m_function(function)
65 {
66 m_ptr->ref();
67 }
68
~MemberFunctionWorkItem0()69 ~MemberFunctionWorkItem0()
70 {
71 m_ptr->deref();
72 }
73
execute()74 virtual void execute()
75 {
76 (m_ptr->*m_function)();
77 }
78
79 C* m_ptr;
80 FunctionType m_function;
81 };
82
83 template<typename C, typename T0>
84 class MemberFunctionWorkItem1 : private WorkItem {
85 // We only allow WorkItem to create this.
86 friend class WorkItem;
87
88 typedef void (C::*FunctionType)(T0);
89
MemberFunctionWorkItem1(C * ptr,FunctionType function,T0 t0)90 MemberFunctionWorkItem1(C* ptr, FunctionType function, T0 t0)
91 : m_ptr(ptr)
92 , m_function(function)
93 , m_t0(t0)
94 {
95 m_ptr->ref();
96 }
97
~MemberFunctionWorkItem1()98 ~MemberFunctionWorkItem1()
99 {
100 m_ptr->deref();
101 }
102
execute()103 virtual void execute()
104 {
105 (m_ptr->*m_function)(m_t0);
106 }
107
108 C* m_ptr;
109 FunctionType m_function;
110 T0 m_t0;
111 };
112
113 template<typename C, typename T0, typename T1>
114 class MemberFunctionWorkItem2 : private WorkItem {
115 // We only allow WorkItem to create this.
116 friend class WorkItem;
117
118 typedef void (C::*FunctionType)(T0, T1);
119
MemberFunctionWorkItem2(C * ptr,FunctionType function,T0 t0,T1 t1)120 MemberFunctionWorkItem2(C* ptr, FunctionType function, T0 t0, T1 t1)
121 : m_ptr(ptr)
122 , m_function(function)
123 , m_t0(t0)
124 , m_t1(t1)
125 {
126 m_ptr->ref();
127 }
128
~MemberFunctionWorkItem2()129 ~MemberFunctionWorkItem2()
130 {
131 m_ptr->deref();
132 }
133
execute()134 virtual void execute()
135 {
136 (m_ptr->*m_function)(m_t0, m_t1);
137 }
138
139 C* m_ptr;
140 FunctionType m_function;
141 T0 m_t0;
142 T1 m_t1;
143 };
144
145 template<typename C>
create(C * ptr,void (C::* function)())146 PassOwnPtr<WorkItem> WorkItem::create(C* ptr, void (C::*function)())
147 {
148 return adoptPtr(static_cast<WorkItem*>(new MemberFunctionWorkItem0<C>(ptr, function)));
149 }
150
151 template<typename C, typename T0>
create(C * ptr,void (C::* function)(T0),T0 t0)152 PassOwnPtr<WorkItem> WorkItem::create(C* ptr, void (C::*function)(T0), T0 t0)
153 {
154 return adoptPtr(static_cast<WorkItem*>(new MemberFunctionWorkItem1<C, T0>(ptr, function, t0)));
155 }
156
157 template<typename C, typename T0, typename T1>
create(C * ptr,void (C::* function)(T0,T1),T0 t0,T1 t1)158 PassOwnPtr<WorkItem> WorkItem::create(C* ptr, void (C::*function)(T0, T1), T0 t0, T1 t1)
159 {
160 return adoptPtr(static_cast<WorkItem*>(new MemberFunctionWorkItem2<C, T0, T1>(ptr, function, t0, t1)));
161 }
162
163 class FunctionWorkItem0 : private WorkItem {
164 // We only allow WorkItem to create this.
165 friend class WorkItem;
166
167 typedef void (*FunctionType)();
168
FunctionWorkItem0(FunctionType function)169 FunctionWorkItem0(FunctionType function)
170 : m_function(function)
171 {
172 }
173
execute()174 virtual void execute()
175 {
176 (*m_function)();
177 }
178
179 FunctionType m_function;
180 };
181
create(void (* function)())182 inline PassOwnPtr<WorkItem> WorkItem::create(void (*function)())
183 {
184 return adoptPtr(static_cast<WorkItem*>(new FunctionWorkItem0(function)));
185 }
186
187 #endif // WorkItem_h
188