Updated using defined types instead of std::uint types.

Author: colinrg

Date.hpp

@@ -17,7 +17,7 @@ limitations under the License.
 #ifndef OCL_GUARD_DATETIME_DATE_HPP
 #define OCL_GUARD_DATETIME_DATE_HPP
 
-#include <stdint.h>
+#include <cstdint>
 
 namespace ocl
 {
@@ -29,13 +29,13 @@ class Date
 {
 // Types.
 public:
-    typedef uint32_t size_type;
-    typedef int32_t diff_type;
-    typedef uint8_t day_type;
-    typedef uint8_t day_of_week_type;
-    typedef uint8_t month_type;
-    typedef uint16_t year_type;
-    typedef uint32_t serialize_type;
+    typedef std::uint32_t size_type;
+    typedef std::int32_t diff_type;
+    typedef std::uint8_t day_type;
+    typedef std::uint8_t day_of_week_type;
+    typedef std::uint8_t month_type;
+    typedef std::uint16_t year_type;
+    typedef std::uint32_t serialize_type;
 
 // Constants.
 public:
@@ -92,9 +92,9 @@ class Date
     /// Convert date to a 32-bit value that can be ordered and stored.
     static serialize_type Serialize(day_type day, month_type month, year_type year) throw()
     {
-        uint32_t date = day;
-        date |= static_cast<uint32_t>(month) << 8U;
-        date |= static_cast<uint32_t>(year) << 16U;
+        serialize_type date = day;
+        date |= static_cast<serialize_type>(month) << 8U;
+        date |= static_cast<serialize_type>(year) << 16U;
         return date;
     }
 
@@ -540,7 +540,7 @@ class Date
     }
 
     /// Create Date object from an unsigned 32-bit value.
-    Date(uint32_t date) throw()
+    Date(serialize_type date) throw()
     {
         Deserialize(date, m_day, m_month, m_year);
     }
@@ -909,8 +909,8 @@ class Date
 
     int Compare(Date const& date) const throw()
     {
-        uint32_t d1 = Serialize();
-        uint32_t d2 = date.Serialize();
+        serialize_type d1 = Serialize();
+        serialize_type d2 = date.Serialize();
         return d1 > d2 ? 1 : (d1 < d2 ? -1 : 0);
     }
 

internal/TimeDefines.hpp

@@ -17,7 +17,7 @@ limitations under the License.
 #ifndef OCL_GUARD_DATETIME_INTERNAL_TIMEDEFINES_HPP
 #define OCL_GUARD_DATETIME_INTERNAL_TIMEDEFINES_HPP
 
-#include <stdint.h>
+#include <cstdint>
 
 namespace ocl
 {
@@ -28,27 +28,27 @@ class TimeDefines
 public:
     // Size types when converting into values larger than the limit
     // stored within a time period.
-    typedef uint64_t nanosecond_size_type;
-    typedef int64_t  nanosecond_diff_type;
-    typedef uint64_t microsecond_size_type;
-    typedef int64_t  microsecond_diff_type;
-    typedef uint32_t millisecond_size_type;
-    typedef int32_t  millisecond_diff_type;
-    typedef uint32_t second_size_type;
-    typedef int32_t  second_diff_type;
-    typedef uint32_t minute_size_type;
-    typedef int32_t  minute_diff_type;
-    typedef uint32_t hour_size_type;
-    typedef int32_t  hour_diff_type;
+    typedef std::uint64_t nanosecond_size_type;
+    typedef std::int64_t  nanosecond_diff_type;
+    typedef std::uint64_t microsecond_size_type;
+    typedef std::int64_t  microsecond_diff_type;
+    typedef std::uint32_t millisecond_size_type;
+    typedef std::int32_t  millisecond_diff_type;
+    typedef std::uint32_t second_size_type;
+    typedef std::int32_t  second_diff_type;
+    typedef std::uint32_t minute_size_type;
+    typedef std::int32_t  minute_diff_type;
+    typedef std::uint32_t hour_size_type;
+    typedef std::int32_t  hour_diff_type;
 
     /// Types for hours, minutes, seconds, milliseconds and nanoseconds,
     // that don't exceed their limit within a time period.
-    typedef uint32_t nanosecond_type;
-    typedef uint32_t microsecond_type;
-    typedef uint16_t millisecond_type;
-    typedef uint8_t second_type;
-    typedef uint8_t minute_type;
-    typedef uint8_t hour_type;
+    typedef std::uint32_t nanosecond_type;
+    typedef std::uint32_t microsecond_type;
+    typedef std::uint16_t millisecond_type;
+    typedef std::uint8_t second_type;
+    typedef std::uint8_t minute_type;
+    typedef std::uint8_t hour_type;
 
 // Constants.
 public:

internal/internalTimeMs.hpp

@@ -19,7 +19,7 @@ limitations under the License.
 
 #include "TimeDefines.hpp"
 #include "TimePrecision.hpp"
-#include <stdint.h>
+#include <cstdint>
 
 namespace ocl
 {
@@ -31,7 +31,7 @@ class InternalTimeMs : public TimeDefines
 public:
     typedef millisecond_size_type size_type;
     typedef millisecond_diff_type diff_type;
-    typedef uint32_t              serialize_type;
+    typedef std::uint32_t         serialize_type;
     typedef millisecond_type      smallest_unit_type;
 
 // Constants.
@@ -254,9 +254,9 @@ class InternalTimeMs : public TimeDefines
     serialize_type Serialize() const throw()
     {
         serialize_type serialize_time = m_milliseconds;
-        serialize_time |= static_cast<uint32_t>(m_seconds) << 8U;
-        serialize_time |= static_cast<uint32_t>(m_minutes) << 16U;
-        serialize_time |= static_cast<uint32_t>(m_hours) << 24U;
+        serialize_time |= static_cast<serialize_type>(m_seconds) << 8U;
+        serialize_time |= static_cast<serialize_type>(m_minutes) << 16U;
+        serialize_time |= static_cast<serialize_type>(m_hours) << 24U;
         return serialize_time;
     }
 
@@ -316,7 +316,7 @@ class InternalTimeMs : public TimeDefines
 private:
     /// Milliseconds are stored as a 10 bit value, 8 bits in m_milliseconds
     /// and 2 bits in the top 2 bits of m_seconds.
-    typedef uint8_t millisecond_internal_type;
+    typedef std::uint8_t millisecond_internal_type;
 
     /// Masks for handling m_milliseconds and m_seconds.
     /// m_seconds bottom two bits contain the top two bits of the 10 bits used for milliseconds.

internal/internalTimeNs.hpp

@@ -19,7 +19,7 @@ limitations under the License.
 
 #include "TimeDefines.hpp"
 #include "TimePrecision.hpp"
-#include <stdint.h>
+#include <cstdint>
 
 namespace ocl
 {
@@ -31,7 +31,7 @@ class InternalTimeNs : public TimeDefines
 public:
     typedef nanosecond_size_type size_type;
     typedef nanosecond_diff_type diff_type;
-    typedef uint64_t             serialize_type;
+    typedef std::uint64_t        serialize_type;
     typedef nanosecond_type      smallest_unit_type;
 
 // Constants.