Moved Tick types to internal namespace and added Duration typedefs.

The Tick (and subtypes) are only to be used to create Duration types.
To hide their interfaces from the user, they are now moved to internal.
Typedefs for ticked Durations are provided instead.

EMBB-422

base_cpp/include/embb/base/duration.h

@@ -46,6 +46,9 @@ namespace base {
  * Represents a relative time duration for a given tick type.
  *
  * \notthreadsafe
+ * \note The typedefs DurationSeconds, DurationMilliseconds,
+ *       DurationMicroseconds, and DurationNanoseconds provide directly usable
+ *       duration types.
  * \tparam Tick Possible tick types are Seconds, Milliseconds, Microseconds,
  *              Nanoseconds
  * \ingroup CPP_BASE_TIMEDURATION
@@ -271,6 +274,8 @@ Duration<Tick> operator+(
   return Duration<Tick>(lhs.Count() + rhs.Count());
 }
 
+namespace internal {
+
 /**
  * Base class for ticks.
  */
@@ -517,6 +522,33 @@ class Nanoseconds : public Tick {
   static unsigned long long Max();
 };
 
+} // namespace internal
+
+/**
+ * Duration with seconds tick.
+ *
+ * \ingroup CPP_BASE_TIMEDURATION
+ */
+typedef Duration<internal::Seconds> DurationSeconds;
+/**
+ * Duration with milliseconds tick.
+ *
+ * \ingroup CPP_BASE_TIMEDURATION
+ */
+typedef Duration<internal::Milliseconds> DurationMilliseconds;
+/**
+ * Duration with microseconds tick.
+ *
+ * \ingroup CPP_BASE_TIMEDURATION
+ */
+typedef Duration<internal::Microseconds> DurationMicroseconds;
+/**
+ * Duration with nanoseconds tick.
+ *
+ * \ingroup CPP_BASE_TIMEDURATION
+ */
+typedef Duration<internal::Nanoseconds> DurationNanoseconds;
+
 } // namespace base
 } // namespace embb
 

base_cpp/src/duration.cc

@@ -35,7 +35,7 @@
 namespace embb {
 namespace base {
 
-void Tick::CheckExceptions(int status, const char* msg) {
+void internal::Tick::CheckExceptions(int status, const char* msg) {
   switch (status) {
   case EMBB_SUCCESS: return;
   case EMBB_OVERFLOW: EMBB_THROW(OverflowException, msg);
@@ -44,16 +44,16 @@ void Tick::CheckExceptions(int status, const char* msg) {
   }
 }
 
-int Seconds::Set(embb_duration_t& duration, unsigned long long ticks) {
+int internal::Seconds::Set(embb_duration_t& duration, unsigned long long ticks) {
   return embb_duration_set_seconds(&duration, ticks);
 }
 
-void Seconds::SetAndCheck(embb_duration_t& duration, unsigned long long ticks) {
+void internal::Seconds::SetAndCheck(embb_duration_t& duration, unsigned long long ticks) {
   int status = Set(duration, ticks);
   CheckExceptions(status, "Setting duration from seconds");
 }
 
-unsigned long long Seconds::Get(const embb_duration_t& duration) {
+unsigned long long internal::Seconds::Get(const embb_duration_t& duration) {
   unsigned long long ticks = 0;
   int status = embb_duration_as_seconds(&duration, &ticks);
   assert(status == EMBB_SUCCESS);
@@ -61,25 +61,25 @@ unsigned long long Seconds::Get(const embb_duration_t& duration) {
   return ticks;
 }
 
-unsigned long long Seconds::Min() {
+unsigned long long internal::Seconds::Min() {
   return 1;
 }
 
-unsigned long long Seconds::Max() {
+unsigned long long internal::Seconds::Max() {
   return EMBB_DURATION_MAX_SECONDS;
 }
 
-int Milliseconds::Set(embb_duration_t& duration, unsigned long long ticks) {
+int internal::Milliseconds::Set(embb_duration_t& duration, unsigned long long ticks) {
   return embb_duration_set_milliseconds(&duration, ticks);
 }
 
-void Milliseconds::SetAndCheck(
+void internal::Milliseconds::SetAndCheck(
   embb_duration_t& duration, unsigned long long ticks) {
   int status = Set(duration, ticks);
   CheckExceptions(status, "Setting duration from milliseconds");
 }
 
-unsigned long long Milliseconds::Get(const embb_duration_t& duration) {
+unsigned long long internal::Milliseconds::Get(const embb_duration_t& duration) {
   unsigned long long ticks = 0;
   int status = embb_duration_as_milliseconds(&duration, &ticks);
   assert(status == EMBB_SUCCESS);
@@ -87,7 +87,7 @@ unsigned long long Milliseconds::Get(const embb_duration_t& duration) {
   return ticks;
 }
 
-unsigned long long Milliseconds::Min() {
+unsigned long long internal::Milliseconds::Min() {
 #if EMBB_DURATION_MIN_NANOSECONDS > 1000000
   assert(EMBB_DURATION_MIN_NANOSECONDS % 1000000 == 0);
   return EMBB_DURATION_MIN_NANOSECONDS / 1000000;
@@ -95,7 +95,7 @@ unsigned long long Milliseconds::Min() {
   return 1;
 }
 
-unsigned long long Milliseconds::Max() {
+unsigned long long internal::Milliseconds::Max() {
 #if EMBB_DURATION_MAX_SECONDS < ULLONG_MAX / 1000
   return ULLONG_MAX;
 #else
@@ -103,17 +103,17 @@ unsigned long long Milliseconds::Max() {
 #endif
 }
 
-int Microseconds::Set(embb_duration_t& duration, unsigned long long ticks) {
+int internal::Microseconds::Set(embb_duration_t& duration, unsigned long long ticks) {
   return embb_duration_set_microseconds(&duration, ticks);
 }
 
-void Microseconds::SetAndCheck(
+void internal::Microseconds::SetAndCheck(
   embb_duration_t& duration, unsigned long long ticks) {
   int status = Set(duration, ticks);
   CheckExceptions(status, "Setting duration from microseconds");
 }
 
-unsigned long long Microseconds::Get(const embb_duration_t& duration) {
+unsigned long long internal::Microseconds::Get(const embb_duration_t& duration) {
   unsigned long long ticks = 0;
 
   int status = embb_duration_as_microseconds(&duration, &ticks);
@@ -123,7 +123,7 @@ unsigned long long Microseconds::Get(const embb_duration_t& duration) {
   return ticks;
 }
 
-unsigned long long Microseconds::Min() {
+unsigned long long internal::Microseconds::Min() {
 #if EMBB_DURATION_MIN_NANOSECONDS > 1000
   assert(EMBB_DURATION_MIN_NANOSECONDS % 1000 == 0);
   return EMBB_DURATION_MIN_NANOSECONDS / 1000;
@@ -131,7 +131,7 @@ unsigned long long Microseconds::Min() {
   return 1;
 }
 
-unsigned long long Microseconds::Max() {
+unsigned long long internal::Microseconds::Max() {
 #if EMBB_DURATION_MAX_SECONDS < ULLONG_MAX / 1000000
   return ULLONG_MAX;
 #else
@@ -139,17 +139,17 @@ unsigned long long Microseconds::Max() {
 #endif
 }
 
-int Nanoseconds::Set(embb_duration_t& duration, unsigned long long ticks) {
+int internal::Nanoseconds::Set(embb_duration_t& duration, unsigned long long ticks) {
   return embb_duration_set_nanoseconds(&duration, ticks);
 }
 
-void Nanoseconds::SetAndCheck(
+void internal::Nanoseconds::SetAndCheck(
   embb_duration_t& duration, unsigned long long ticks) {
   int status = Set(duration, ticks);
   CheckExceptions(status, "Setting duration from microseconds");
 }
 
-unsigned long long Nanoseconds::Get(const embb_duration_t& duration) {
+unsigned long long internal::Nanoseconds::Get(const embb_duration_t& duration) {
   unsigned long long ticks = 0;
   int status = embb_duration_as_nanoseconds(&duration, &ticks);
   assert(status == EMBB_SUCCESS);
@@ -157,11 +157,11 @@ unsigned long long Nanoseconds::Get(const embb_duration_t& duration) {
   return ticks;
 }
 
-unsigned long long Nanoseconds::Min() {
+unsigned long long internal::Nanoseconds::Min() {
   return EMBB_DURATION_MIN_NANOSECONDS;
 }
 
-unsigned long long Nanoseconds::Max() {
+unsigned long long internal::Nanoseconds::Max() {
 #if EMBB_DURATION_MAX_SECONDS < ULLONG_MAX / 1000000000
   return ULLONG_MAX;
 #else

base_cpp/test/condition_var_test.cc

@@ -63,15 +63,15 @@ void ConditionVarTest::TestTimedWaitTimeouts() {
   PT_EXPECT_EQ(success, false);
 
   // Wait for a future timepoint
-  success = cond.WaitUntil(lock, Time(Duration<Milliseconds>(1)));
+  success = cond.WaitUntil(lock, Time(DurationMilliseconds(1)));
   PT_EXPECT_EQ(success, false);
 
   // Wait for a zero duration
-  success = cond.WaitFor(lock, Duration<Milliseconds>());
+  success = cond.WaitFor(lock, DurationMilliseconds());
   PT_EXPECT_EQ(success, false);
 
   // Wait for some duration
-  success = cond.WaitFor(lock, Duration<Milliseconds>(1));
+  success = cond.WaitFor(lock, DurationMilliseconds(1));
   PT_EXPECT_EQ(success, false);
 }
 
@@ -96,14 +96,14 @@ void ConditionVarTest::TestNotify() {
 
     cond_notify_.NotifyOne();
 
-    cond_wait_.WaitUntil(lock_wait, Time(Duration<Milliseconds>(1)));
+    cond_wait_.WaitUntil(lock_wait, Time(DurationMilliseconds(1)));
     while (embb_counter_get(&counter_) == 0)
     {}  // If hangs here signal has not succeeded
     PT_ASSERT_EQ_MSG(embb_counter_get(&counter_),
         static_cast<unsigned int>(1), "Only 1 thread notified");
     cond_notify_.NotifyAll();
 
-    cond_wait_.WaitUntil(lock_wait, Time(Duration<Milliseconds>(2)));
+    cond_wait_.WaitUntil(lock_wait, Time(DurationMilliseconds(2)));
 
     while (embb_counter_get(&counter_) !=
         static_cast<unsigned int>(num_threads_-1))

base_cpp/test/duration_test.cc

@@ -31,10 +31,10 @@ namespace base {
 namespace test {
 
 DurationTest::DurationTest() {
-  CreateUnit("Seconds").Add(&DurationTest::Test<Seconds>, this);
-  CreateUnit("Milliseconds").Add(&DurationTest::Test<Milliseconds>, this);
-  CreateUnit("Microseconds").Add(&DurationTest::Test<Microseconds>, this);
-  CreateUnit("Nanoseconds").Add(&DurationTest::Test<Nanoseconds>, this);
+  CreateUnit("Seconds").Add(&DurationTest::Test<internal::Seconds>, this);
+  CreateUnit("Milliseconds").Add(&DurationTest::Test<internal::Milliseconds>, this);
+  CreateUnit("Microseconds").Add(&DurationTest::Test<internal::Microseconds>, this);
+  CreateUnit("Nanoseconds").Add(&DurationTest::Test<internal::Nanoseconds>, this);
 }
 
 } // namespace test