Merge pull request #4 from External/feature/retry_for

Feature to retry_for a given amount of time

Author: linkineo

pre/retry_for.hpp

@@ -0,0 +1,70 @@
+#ifndef PRE_RETRY_FOR_HPP
+#define PRE_RETRY_FOR_HPP
+
+#include <cassert>
+#include <functional>
+#include <chrono>
+#include <thread>
+
+namespace pre {
+
+
+  inline namespace retry_v1 {
+
+    /**
+     * \brief Sometimes you need to retry some operations, as it's normal that they may fail.
+     *        Typically an IO error is not always a real error, as the media may 
+     *        be known to be instable (e.g. airwaves communication, speaking over 
+     *        serial line when remote device is busy...)
+     *
+     *        Typically if there are many retries tried out without any pause in between, the
+     *        operation may still fail, as the main reason for something not to reply is to be
+     *        busy. Therefore this function allows you to specify blackout time as well as a
+     *        complete retry time.
+     *
+     *        **Preconditions**: blackout_step must be a multiple of total_time.
+     *
+     * \param total_time Total time allowed for retrying.
+     * \param time_step Wait time between retries.
+     * \param retried_func Callback retried returning true on success, false on error.
+     *
+     * \return Whether the callback succeeded or not.
+     */
+    template< class Rep, class Period >
+    inline bool retry_for(
+        const std::chrono::duration<Rep, Period>& total_time,
+        const std::chrono::duration<Rep, Period>& time_step,
+        std::function<bool (void)> retried_func) {
+      assert(time_step.count()!=0);
+      assert(total_time.count() >= time_step.count());
+
+      size_t iterations = total_time.count() / time_step.count();
+      for(size_t p=0; p <iterations; p++) {
+        if(retried_func()) { return true; }
+        std::this_thread::sleep_for(time_step);
+      }
+      return false;
+    }
+
+    /**
+     * \brief Equivalent to :
+     *        sleep_for(initial_blackout); pre::retry_for(total_time, time_step, retried_func);
+     *  
+     *        Please see [pre::retry_for](@ref pre::retry_for(const std::chrono::duration<Rep, Period>&, 
+     *          const std::chrono::duration<Rep, Period>& , std::function<bool (void)>)).
+     */
+    template< class Rep, class Period >
+    inline bool retry_for(
+        const std::chrono::duration<Rep, Period>& total_time,
+        const std::chrono::duration<Rep, Period>& time_step,
+        const std::chrono::duration<Rep, Period>& initial_blackout,
+        std::function<bool (void)> retried_func) {
+      std::this_thread::sleep_for(initial_blackout);
+      return retry_for(total_time, time_step, retried_func);
+    }
+
+  }
+
+}
+
+#endif

pre/variant/get_trait.hpp

@@ -38,7 +38,7 @@ namespace pre { namespace variant {
 
       template< class U >
       Result operator()(const U&) const { 
-        return typename TraitMetafunction<U>::type{};
+        return TraitMetafunction<U>::type::value;
       }
 
 

test/CMakeLists.txt

@@ -19,6 +19,11 @@ function(add_unit_test)
 
 endfunction(add_unit_test) 
 
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  # Disable auto_ptr errors
+  add_definitions(-Wno-deprecated-declarations) 
+endif()
+
 ## Multithreading support
 find_package(Threads REQUIRED)
 
@@ -67,3 +72,6 @@ add_unit_test(NAME function_traits_test
   ${Boost_LIBRARIES}
   ${platform_specific_lib})
 
+add_unit_test(NAME retry_for
+  LIBS ${CMAKE_THREAD_LIBS_INIT}
+  ${Boost_LIBRARIES})

test/retry_for.cpp

@@ -0,0 +1,33 @@
+#define BOOST_TEST_MODULE retry_for_test 
+#include <boost/test/included/unit_test.hpp>
+
+#include <pre/retry_for.hpp>
+#include <pre/chrono/chrono_suffixes.hpp>
+
+BOOST_AUTO_TEST_CASE (retry_for_testing) {
+  using namespace pre::chrono::std;
+
+  size_t times = 0;
+  auto im_happy_only_after_5times = [&times]() {
+    ++times;
+    std::cout << times << ": I'm " << ((times >= 5) ? "happy" : "unhappy") << std::endl; 
+    return (times >= 5);
+  };
+
+
+  {
+    times = 0;
+    auto start = std::chrono::steady_clock::now();
+    pre::retry_for(5_sec, 1_sec, im_happy_only_after_5times);
+
+    BOOST_REQUIRE((std::chrono::steady_clock::now() - start) > 4_sec);
+  }
+
+  {
+    times = 0;
+    auto start = std::chrono::steady_clock::now();
+    pre::retry_for(5_ms, 1_ms, 200_ms, im_happy_only_after_5times);
+
+    BOOST_REQUIRE((std::chrono::steady_clock::now() - start) > 200_ms);
+  }
+}