1 /*---------------------------------------------------------------------------*
2 Project: Horizon
3 File: os_Timer.h
4
5 Copyright (C)2009 Nintendo Co., Ltd. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Rev: 33841 $
14 *---------------------------------------------------------------------------*/
15
16 /* Please see man pages for details
17
18
19 */
20
21 #ifndef NN_OS_OS_TIMER_H_
22 #define NN_OS_OS_TIMER_H_
23
24 #include <nn/types.h>
25 #include <nn/Handle.h>
26 #include <nn/Result.h>
27 #include <nn/os/os_Synchronization.h>
28 #include <nn/fnd/fnd_TimeSpan.h>
29
30 #include <nn/util/util_Result.h>
31
32 #ifdef __cplusplus
33
34 namespace nn{ namespace os {
35
36 /* Please see man pages for details
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53 */
54 class Timer : public WaitObject
55 {
56 public:
57
58 /* Please see man pages for details
59
60
61
62
63
64
65 */
66 explicit Timer(bool isManualReset);
67
Timer()68 Timer() {}
69
70 /* Please see man pages for details
71
72
73
74
75
76
77
78
79 */
80 void Initialize(bool isManualReset);
81
82 /* Please see man pages for details
83
84
85
86
87
88
89
90
91 */
92 nn::Result TryInitialize(bool isManualReset);
93
94 /* Please see man pages for details
95
96
97
98
99 */
Finalize()100 void Finalize() { WaitObject::Finalize(); }
101
102 /* Please see man pages for details
103
104 */
~Timer()105 ~Timer() {}
106
107 /* Please see man pages for details
108
109
110
111
112
113 */
114 void StartOneShot(nn::fnd::TimeSpan timeSpan);
115
116 /* Please see man pages for details
117
118
119
120
121
122
123
124 */
125 void StartPeriodic(nn::fnd::TimeSpan first, nn::fnd::TimeSpan interval);
126
127 /* Please see man pages for details
128
129
130
131 */
132 void Signal();
133
134 /* Please see man pages for details
135
136
137
138
139
140
141 */
Wait()142 void Wait() { this->WaitOne(); }
143
144 /* Please see man pages for details
145
146
147
148 */
149 void Stop();
150
151 /* Please see man pages for details
152
153
154
155
156
157 */
158 void ClearSignal();
159
160 private:
161
162 Result TryInitializeImpl(bool isManualReset);
163 void StartImpl(nn::fnd::TimeSpan first, nn::fnd::TimeSpan interval);
164
165 };
166
167 // Inline implementation
168
TryInitializeImpl(bool isManualReset)169 inline Result Timer::TryInitializeImpl(bool isManualReset)
170 {
171 Handle handle;
172 NN_UTIL_RETURN_IF_FAILED(nn::svc::CreateTimer(&handle, isManualReset));
173 this->SetHandle(handle);
174 return ResultSuccess();
175 }
176
Initialize(bool isManualReset)177 inline void Timer::Initialize(bool isManualReset)
178 {
179 NN_ERR_THROW_FATAL(TryInitializeImpl(isManualReset));
180 }
181
TryInitialize(bool isManualReset)182 inline nn::Result Timer::TryInitialize(bool isManualReset)
183 {
184 Result result = TryInitializeImpl(isManualReset);
185 if (result.GetSummary() == Result::SUMMARY_OUT_OF_RESOURCE)
186 {
187 return result;
188 }
189 NN_ERR_THROW_FATAL(result);
190 return result;
191 }
192
Timer(bool isManualReset)193 inline Timer::Timer(bool isManualReset)
194 {
195 Initialize(isManualReset);
196 }
197
StartImpl(nn::fnd::TimeSpan initial,nn::fnd::TimeSpan interval)198 inline void Timer::StartImpl(nn::fnd::TimeSpan initial, nn::fnd::TimeSpan interval)
199 {
200 NN_ERR_THROW_FATAL(nn::svc::SetTimer(GetHandle(), initial.GetNanoSeconds(), interval.GetNanoSeconds()));
201 }
202
StartPeriodic(nn::fnd::TimeSpan initial,nn::fnd::TimeSpan interval)203 inline void Timer::StartPeriodic(nn::fnd::TimeSpan initial, nn::fnd::TimeSpan interval)
204 {
205 NN_TASSERT_(interval > 0);
206 this->StartImpl(initial, interval);
207 }
208
StartOneShot(nn::fnd::TimeSpan initial)209 inline void Timer::StartOneShot(nn::fnd::TimeSpan initial)
210 {
211 this->StartImpl(initial, 0);
212 }
213
Signal()214 inline void Timer::Signal()
215 {
216 this->StartOneShot(0);
217 }
218
Stop()219 inline void Timer::Stop()
220 {
221 NN_ERR_THROW_FATAL(nn::svc::CancelTimer(GetHandle()));
222 }
223
ClearSignal()224 inline void Timer::ClearSignal()
225 {
226 NN_ERR_THROW_FATAL(nn::svc::ClearTimer(GetHandle()));
227 }
228
229 }} // namesapce nn::os
230
231 #endif // __cplusplus
232
233 // C declarations follow
234
235 #include <nn/util/detail/util_CLibImpl.h>
236
237 /* Please see man pages for details
238
239
240
241
242
243
244
245
246 */
247
248 /* Please see man pages for details
249
250
251
252 */
253
254 NN_UTIL_DETAIL_CLIBIMPL_DEFINE_BUFFER_CLASS(nnosTimer, nn::os::Timer, 4, u32);
255 NN_UTIL_DETAIL_CLIBIMPL_DECLARE_CONVERSION(nnosTimerToWaitObject, nnosTimer, nnosWaitObject);
256 NN_UTIL_DETAIL_CLIBIMPL_DECLARE_CONVERSION(nnosWaitObjectToTimer, nnosWaitObject, nnosTimer);
257
258
259 /* Please see man pages for details
260
261 */
262 NN_EXTERN_C void nnosTimerInitialize(nnosTimer* this_, bool isManualReset);
263
264 /* Please see man pages for details
265
266 */
267 NN_EXTERN_C bool nnosTimerTryInitialize(nnosTimer* this_, bool isManualReset);
268
269 /* Please see man pages for details
270
271 */
272 NN_EXTERN_C void nnosTimerStartPeriodic(nnosTimer* this_, s64 first, s64 interval);
273
274 /* Please see man pages for details
275
276 */
277 NN_EXTERN_C void nnosTimerStartOneShot(nnosTimer* this_, s64 time);
278
279 /* Please see man pages for details
280
281 */
282 NN_EXTERN_C void nnosTimerWait(nnosTimer* this_);
283
284 /* Please see man pages for details
285
286 */
287 NN_EXTERN_C void nnosTimerStop(nnosTimer* this_);
288
289 /* Please see man pages for details
290
291 */
292 NN_EXTERN_C void nnosTimerClearSignal(nnosTimer* this_);
293
294 /* Please see man pages for details
295
296 */
297 NN_EXTERN_C void nnosTimerFinalize(nnosTimer* this_);
298
299 /* Please see man pages for details
300
301 */
302 NN_EXTERN_C void nnosTimerSignal(nnosTimer* this_);
303
304 /*
305
306
307
308 */
309
310 #endif
311
312