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

base_cpp/src/duration.cc

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

base_cpp/test/condition_var_test.cc

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

base_cpp/test/duration_test.cc

@@ -31,10 +31,10 @@ namespace base {
 namespace test {
 namespace test {
 
 
 DurationTest::DurationTest() {
 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
 } // namespace test