CTR-Pia  5.4.3
Game Communication Engine
 全て クラス ネームスペース 関数 変数 型定義 列挙型 列挙型の値 ページ
common_TimeSpan.h
1 /*--------------------------------------------------------------------------------*
2  Copyright (C)Nintendo All rights reserved.
3 
4  These coded instructions, statements, and computer programs contain proprietary
5  information of Nintendo and/or its licensed developers and are protected by
6  national and international copyright laws. They may not be disclosed to third
7  parties or copied or duplicated in any form, in whole or in part, without the
8  prior written consent of Nintendo.
9 
10  The content herein is highly confidential and should be handled accordingly.
11  *--------------------------------------------------------------------------------*/
12 
13 
14 #pragma once
15 
16 #include <nn/pia/common/common_RootObject.h>
17 
18 namespace nn
19 {
20 namespace pia
21 {
22 namespace common
23 {
24 
25 /*!
26  @brief 時間間隔を表す型です。単位はミリ秒です。
27  */
28 typedef int32_t TimeInterval;
29 
30 
31 class Time;
32 
33 /*!
34  @brief 時間の間隔を表すクラスです。ミリ秒単位の数値と型変換ができます。
35 
36  */
38 {
39 
40  friend class Time;
41 
42 public:
43  /*!
44  @brief デフォルトコンストラクタです。
45  */
47  : m_TickSpan(0)
48  {
49  }
50 
51 
52  /*!
53  @brief ミリ秒単位の数値で初期化するコンストラクタです。
54 
55  @param[in] msec 初期化する値をミリ秒単位の時間で指定します。
56  */
57  TimeSpan(int32_t msec)
58  {
59  SetFromMSec(msec);
60  }
61 
62 
63  /*!
64  @brief ミリ秒単位の数値で初期化するコンストラクタです。
65 
66  @param[in] msec 初期化する値をミリ秒単位の時間で指定します。
67  */
68  TimeSpan(int64_t msec)
69  {
70  SetFromMSec(msec);
71  }
72 
73 
74  /*!
75  @brief コピーコンストラクタです。
76 
77  @param[in] rhs 本インスタンスを初期化する値を持つ TimeSpan インスタンスです。
78  */
79  TimeSpan(const TimeSpan& rhs)
80  : m_TickSpan(rhs.m_TickSpan)
81  {
82  }
83 
84 
85  /*!
86  @brief 代入演算子です。
87 
88  @param[in] rhs 代入する TimeSpan です。
89 
90  @return 本インスタンスへの参照が返されます。
91  */
93  {
94  m_TickSpan = rhs.m_TickSpan;
95  return *this;
96  }
97 
98 
99  /*!
100  @brief ミリ秒単位の数値を代入する演算子です。
101 
102  @param[in] msec 秒単位の時間です。
103 
104  @return 本インスタンスへの参照が返されます。
105  */
106  TimeSpan& operator=(int32_t msec)
107  {
108  SetFromMSec(msec);
109  return *this;
110  }
111 
112 
113  /*!
114  @brief ミリ秒単位の数値を代入する演算子です。
115 
116  @param[in] msec 秒単位の時間です。
117 
118  @return 本インスタンスへの参照が返されます。
119  */
120  TimeSpan& operator=(int64_t msec)
121  {
122  SetFromMSec(msec);
123  return *this;
124  }
125 
126 
127  /*!
128  @brief 時間をミリ秒単位の int32_t 値へ変換する演算子です。
129 
130  @return ミリ秒単位の時間です。
131  */
132  operator int32_t() const
133  {
134  return GetMSec();
135  }
136 
137 
138  /*!
139  @brief 時間をミリ秒単位の int64_t 値へ変換する演算子です。
140 
141  @return ミリ秒単位の時間です。
142  */
143  operator int64_t() const
144  {
145  return GetMSecS64();
146  }
147 
148 
149  /*!
150  @brief 時間をミリ秒単位の int32_t 値でセットします。
151 
152  @param[in] msec ミリ秒単位の時間です。
153  */
154  void SetFromMSec(int32_t msec)
155  {
156  m_TickSpan = GetTicksPerMSec() * msec;
157  }
158 
159 
160  /*!
161  @brief 時間をミリ秒単位の int64_t 値でセットします。
162 
163  @param[in] msec ミリ秒単位の時間です。
164  */
165  void SetFromMSec(int64_t msec)
166  {
167  m_TickSpan = GetTicksPerMSec() * msec;
168  }
169 
170 
171  /*!
172  @brief 時間を秒単位の int32_t 値でセットします。
173 
174  @param[in] sec 秒単位の時間です。
175  */
176  void SetFromSec(int32_t sec)
177  {
178  m_TickSpan = GetTicksPerSec() * sec;
179  }
180 
181 
182  /*!
183  @brief 時間を秒単位の int64_t 値でセットします。
184 
185  @param[in] sec 秒単位の時間です。
186  */
187  void SetFromSec(int64_t sec)
188  {
189  m_TickSpan = GetTicksPerSec() * sec;
190  }
191 
192 
193  /*!
194  @brief 時間を秒単位の float 値でセットします。
195 
196  @param[in] sec 秒単位の時間です。
197  */
198  void SetFromSec(float sec)
199  {
200  m_TickSpan = static_cast<int64_t>(GetTicksPerSec() * sec);
201  }
202 
203 
204  /*!
205  @brief 時間をミリ秒単位の int32_t 値で取得します。
206 
207  @return ミリ秒単位の時間です。
208  */
209  int32_t GetMSec() const
210  {
211  return static_cast<int32_t>(m_TickSpan / GetTicksPerMSec());
212  }
213 
214  /*!
215  @cond PRIVATE
216  @brief 時間をマイクロ秒単位の int32_t 値で取得します。
217 
218  @return マイクロ秒単位の時間です。
219  */
220  int32_t GetUSec() const
221  {
222  return static_cast<int32_t>(m_TickSpan / GetTicksPerUSec());
223  }
224  //! @endcond
225 
226  /*!
227  @brief 時間をミリ秒単位 int64_t の値で取得します。
228 
229  @return ミリ秒単位の時間です。
230  */
231  int64_t GetMSecS64() const
232  {
233  return m_TickSpan / GetTicksPerMSec();
234  }
235 
236  /*!
237  @cond PRIVATE
238  @brief 時間をマイクロ秒単位 int64_t の値で取得します。
239 
240  @return マイクロ秒単位の時間です。
241  */
242  int64_t GetUSecS64() const
243  {
244  return m_TickSpan / GetTicksPerUSec();
245  }
246  //! @endcond
247 
248  /*!
249  @brief 時間を秒単位の int32_t 値で取得します。
250 
251  @return 秒単位の時間です。
252  */
253  int32_t GetSec() const
254  {
255  return static_cast<int32_t>(m_TickSpan / GetTicksPerSec());
256  }
257 
258 
259  /*!
260  @brief 時間を秒単位の int64_t 値で取得します。
261 
262  @return 秒単位の時間です。
263  */
264  int64_t GetSecS64() const
265  {
266  return m_TickSpan / GetTicksPerSec();
267  }
268 
269 
270  /*!
271  @brief 時間を秒単位の float 値で取得します。
272 
273  @return 秒単位の時間です。
274  */
275  float GetSecF32() const
276  {
277  return static_cast<float>(m_TickSpan) / static_cast<float>(GetTicksPerSec());
278  }
279 
280 
281  /*!
282  @brief 等値演算子です。二つのTimeSpanオブジェクトが同等と見なせるかどうかを判定します。
283 
284  @param[in] rhs 比較する TimeSpan です。
285 
286  @return 両者の表す時間が同じであれば true を、そうでなければ false を返します。
287  */
288  bool operator==(const TimeSpan& rhs) const
289  {
290  return (m_TickSpan == rhs.m_TickSpan);
291  }
292 
293 
294  /*!
295  @brief 等値演算子です。二つの TimeSpan オブジェクトが同等と見なせるかどうかを判定します。
296 
297  @param[in] rhs 比較するミリ秒単位の int32_t 値です。
298 
299  @return 両者の表す時間が同じであれば true を、そうでなければ false を返します。
300  */
301  bool operator==(int32_t rhs) const
302  {
303  return (*this == TimeSpan(rhs));
304  }
305 
306 
307  /*!
308  @brief 等値演算子です。二つの TimeSpan オブジェクトが同等と見なせるかどうかを判定します。
309 
310  @param[in] rhs 比較するミリ秒単位の int64_t 値です。
311 
312  @return 両者の表す時間が同じであれば true を、そうでなければ false を返します。
313  */
314  bool operator==(int64_t rhs) const
315  {
316  return (*this == TimeSpan(rhs));
317  }
318 
319 
320  /*!
321  @brief 等値演算子です。二つの TimeSpan オブジェクトが異なるかどうかを判定します。
322 
323  @param[in] rhs 比較する TimeSpan です。
324 
325  @return 両者の表す時間が異なれば true を、そうでなければ false を返します。
326  */
327  bool operator!=(const TimeSpan& rhs) const
328  {
329  return (m_TickSpan != rhs.m_TickSpan);
330  }
331 
332 
333  /*!
334  @brief 等値演算子です。二つの TimeSpan オブジェクトが異なるかどうかを判定します。
335 
336  @param[in] rhs 比較するミリ秒単位の int32_t 値です。
337 
338  @return 両者の表す時間が異なれば true を、そうでなければ false を返します。
339  */
340  bool operator!=(int32_t rhs) const
341  {
342  return (*this != TimeSpan(rhs));
343  }
344 
345 
346  /*!
347  @brief 等値演算子です。二つの TimeSpan オブジェクトが異なるかどうかを判定します。
348 
349  @param[in] rhs 比較するミリ秒単位の int64_t 値です。
350 
351  @return 両者の表す時間が異なれば true を、そうでなければ false を返します。
352  */
353  bool operator!=(int64_t rhs) const
354  {
355  return (*this != TimeSpan(rhs));
356  }
357 
358 
359  /*!
360  @brief 比較演算子です。自分の表す時間が短ければ true を、そうでなければ false を返します。
361 
362  @param[in] rhs 比較する TimeSpan です。
363 
364  @return 自分の表す時間が短ければ true を、そうでなければ false を返します。
365  */
366  bool operator<(const TimeSpan& rhs) const
367  {
368  return (m_TickSpan < rhs.m_TickSpan);
369  }
370 
371 
372  /*!
373  @brief 比較演算子です。自分の表す時間が短ければ true を、そうでなければ false を返します。
374 
375  @param[in] rhs 比較するミリ秒単位の int32_t 値です。
376 
377  @return 自分の表す時間が短ければ true を、そうでなければ false を返します。
378  */
379  bool operator<(int32_t rhs) const
380  {
381  return (*this < TimeSpan(rhs));
382  }
383 
384 
385  /*!
386  @brief 比較演算子です。自分の表す時間が短ければ true を、そうでなければ false を返します。
387 
388  @param[in] rhs 比較するミリ秒単位の int64_t 値です。
389 
390  @return 自分の表す時間が短ければ true を、そうでなければ false を返します。
391  */
392  bool operator<(int64_t rhs) const
393  {
394  return (*this < TimeSpan(rhs));
395  }
396 
397 
398  /*!
399  @brief 比較演算子です。自分の表す時間が短いか等しければ true を、そうでなければ false を返します。
400 
401  @param[in] rhs 比較する TimeSpan です。
402 
403  @return 自分の表す時間が短いか等しければ true を、そうでなければ false を返します。
404  */
405  bool operator<=(const TimeSpan& rhs) const
406  {
407  return (m_TickSpan <= rhs.m_TickSpan);
408  }
409 
410 
411  /*!
412  @brief 比較演算子です。自分の表す時間が短いか等しければ true を、そうでなければ false を返します。
413 
414  @param[in] rhs 比較するミリ秒単位の int32_t 値です。
415 
416  @return 自分の表す時間が短いか等しければ true を、そうでなければ false を返します。
417  */
418  bool operator<=(int32_t rhs) const
419  {
420  return (*this <= TimeSpan(rhs));
421  }
422 
423 
424  /*!
425  @brief 比較演算子です。自分の表す時間が短いか等しければ true を、そうでなければ false を返します。
426 
427  @param[in] rhs 比較するミリ秒単位の int64_t 値です。
428 
429  @return 自分の表す時間が短いか等しければ true を、そうでなければ false を返します。
430  */
431  bool operator<=(int64_t rhs) const
432  {
433  return (*this <= TimeSpan(rhs));
434  }
435 
436 
437  /*!
438  @brief 比較演算子です。自分の表す時間が長ければ true を、そうでなければ false を返します。
439 
440  @param[in] rhs 比較する TimeSpan です。
441 
442  @return 自分の表す時間が長ければ true を、そうでなければ false を返します。
443  */
444  bool operator>(const TimeSpan& rhs) const
445  {
446  return (m_TickSpan > rhs.m_TickSpan);
447  }
448 
449 
450  /*!
451  @brief 比較演算子です。自分の表す時間が長ければ true を、そうでなければ false を返します。
452 
453  @param[in] rhs 比較するミリ秒単位の int32_t 値です。
454 
455  @return 自分の表す時間が長ければ true を、そうでなければ false を返します。
456  */
457  bool operator>(int32_t rhs) const
458  {
459  return (*this > TimeSpan(rhs));
460  }
461 
462 
463  /*!
464  @brief 比較演算子です。自分の表す時間が長ければ true を、そうでなければ false を返します。
465 
466  @param[in] rhs 比較するミリ秒単位の int64_t 値です。
467 
468  @return 自分の表す時間が長ければ true を、そうでなければ false を返します。
469  */
470  bool operator>(int64_t rhs) const
471  {
472  return (*this > TimeSpan(rhs));
473  }
474 
475 
476  /*!
477  @brief 比較演算子です。自分の表す時間が長いか等しければ true を、そうでなければ false を返します。
478 
479  @param[in] rhs 比較する TimeSpan です。
480 
481  @return 自分の表す時間が長いか等しければ true を、そうでなければ false を返します。
482  */
483  bool operator>=(const TimeSpan& rhs) const
484  {
485  return (m_TickSpan >= rhs.m_TickSpan);
486  }
487 
488 
489  /*!
490  @brief 比較演算子です。自分の表す時間が長いか等しければ true を、そうでなければ false を返します。
491 
492  @param[in] rhs 比較するミリ秒単位の int32_t 値です。
493 
494  @return 自分の表す時間が長いか等しければ true を、そうでなければ false を返します。
495  */
496  bool operator>=(int32_t rhs) const
497  {
498  return (*this >= TimeSpan(rhs));
499  }
500 
501 
502  /*!
503  @brief 比較演算子です。自分の表す時間が長いか等しければ true を、そうでなければ false を返します。
504 
505  @param[in] rhs 比較するミリ秒単位の int64_t 値です。
506 
507  @return 自分の表す時間が長いか等しければ true を、そうでなければ false を返します。
508  */
509  bool operator>=(int64_t rhs) const
510  {
511  return (*this >= TimeSpan(rhs));
512  }
513 
514 
515  /*!
516  @brief 本インスタンスに時間を加算します。
517 
518  @param[in] rhs 加算する時間です。
519 
520  @return 本インスタンスへの参照が返されます。
521  */
523  {
524  m_TickSpan += rhs.m_TickSpan;
525  return *this;
526  }
527 
528 
529  /*!
530  @brief 本インスタンスに時間を減算します。
531 
532  @param[in] rhs 減算する時間です。
533 
534  @return 本インスタンスへの参照が返されます。
535  */
537  {
538  m_TickSpan -= rhs.m_TickSpan;
539  return *this;
540  }
541 
542 
543  /*!
544  @brief 本インスタンスに時間を加算した値をもつ TimeSpan を計算します。
545 
546  @param[in] rhs 加算する時間です。
547 
548  @return 加算された時間を表す Time です。
549  */
550  TimeSpan operator+(const TimeSpan& rhs) const
551  {
552  TimeSpan t;
553  t.m_TickSpan = m_TickSpan + rhs.m_TickSpan;
554  return t;
555  }
556 
557 
558  /*!
559  @brief 本インスタンスに時間を減算した値をもつ TimeSpan を計算します。
560 
561  @param[in] rhs 減算する時間です。
562 
563  @return 減算された時間を表す TimeSpan です。
564  */
565  TimeSpan operator-(const TimeSpan& rhs) const
566  {
567  TimeSpan t;
568  t.m_TickSpan = m_TickSpan - rhs.m_TickSpan;
569  return t;
570  }
571 
572 
573  /*!
574  @cond PRIVATE
575  @brief 生の Tick 値を取得します。
576 
577  @return 生の Tick 値です。
578  */
579  int64_t GetTick() const
580  {
581  return m_TickSpan;
582  }
583  //! @endcond
584 
585 
586  /*!
587  @cond PRIVATE
588  @brief 生の Tick 値を設定します。
589 
590  @param[in] tick 生の Tick 値です。
591  */
592  void SetTick(int64_t tick)
593  {
594  m_TickSpan = tick;
595  }
596  //! @endcond
597 
598 
599  /*!
600  @brief デバッグに有用な情報をプリントします。
601 
602  @param[in] flag トレースフラグの論理和。詳細は@ref TraceFlag 型を参照してください。
603  */
604  void Trace(uint64_t flag) const;
605 
606 private:
607  int64_t m_TickSpan;
608 
609  static const int64_t& GetTicksPerUSec();
610  static const int64_t& GetTicksPerMSec();
611  static const int64_t& GetTicksPerSec();
612 };
613 }
614 }
615 } // end of namespace nn::pia::common