.. _program_listing_file__tmp_ws_src_ecl_core_ecl_time_include_ecl_time_sleep_win.hpp:

Program Listing for File sleep_win.hpp
======================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_ecl_core_ecl_time_include_ecl_time_sleep_win.hpp>` (``/tmp/ws/src/ecl_core/ecl_time/include/ecl/time/sleep_win.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   /*****************************************************************************
   ** Ifdefs
   *****************************************************************************/
   
   #ifndef ECL_TIME_SLEEP_WIN_HPP_
   #define ECL_TIME_SLEEP_WIN_HPP_
   
   /*****************************************************************************
   ** Platform Check
   *****************************************************************************/
   
   #include <ecl/config.hpp>
   #if defined(ECL_IS_WIN32)
   
   /*****************************************************************************
   ** Includes
   *****************************************************************************/
   
   #include <sstream>
   #include <time.h>
   #include <errno.h>
   #include <ecl/config/macros.hpp>
   #include <ecl/exceptions/macros.hpp>
   #include <ecl/exceptions/standard_exception.hpp>
   #include <ecl/time_lite.hpp>
   #include "duration.hpp"
   #include "macros.hpp"
   
   /*****************************************************************************
   ** Namespaces
   *****************************************************************************/
   
   namespace ecl {
   
   /*****************************************************************************
   ** Interface [Sleep]
   *****************************************************************************/
   class ecl_time_PUBLIC Sleep {
   public:
       Sleep(const Duration &duration);
       Sleep(const unsigned long &seconds = 0);
       virtual ~Sleep() {}
   
       void operator()();
       Duration duration() { return Duration(required.tv_sec,required.tv_nsec); }
   
       void operator()(const unsigned long &seconds);
       void operator()(const Duration &duration);
   
   private:
       TimeStructure required, remaining;
   };
   
   class ecl_time_PUBLIC MilliSleep {
   public:
       MilliSleep(const unsigned long &milliseconds = 0);
   
       virtual ~MilliSleep() {}
   
       void operator()();
       Duration duration() { return Duration(required.tv_sec,required.tv_nsec); }
   
       void operator()(const unsigned long &milliseconds);
   private:
       TimeStructure required, remaining;
   };
   
   class ecl_time_PUBLIC MicroSleep {
   public:
       MicroSleep(const unsigned long &microseconds = 0);
   
       virtual ~MicroSleep() {}
   
   
       void operator()();
       Duration duration() { return Duration(required.tv_sec,required.tv_nsec); }
       void operator()(const unsigned long &micro_seconds);
   private:
       TimeStructure required, remaining;
   };
   
   class ecl_time_PUBLIC NanoSleep {
   public:
       NanoSleep(const unsigned long &nanoseconds = 0);
   
       virtual ~NanoSleep() {}
   
   
       void operator()();
       Duration duration() { return Duration(required.tv_sec,required.tv_nsec); }
       void operator()(const unsigned long &nanoseconds);
   private:
       TimeStructure required, remaining;
   };
   
   
   } // namespace ecl
   
   /*****************************************************************************
   ** Interface [Exceptions][Sleeper Classes]
   *****************************************************************************/
   
   #if defined(ECL_HAS_EXCEPTIONS)
   namespace ecl {
   namespace time {
   
   
   /*****************************************************************************
   ** Interface [Sleep Exceptions]
   *****************************************************************************/
   inline ecl::StandardException throwSleepException(const char* loc ) {
       int error_result = errno;
       switch (error_result) {
           case ( EINTR  ) : return StandardException(loc, ecl::InterruptedError, "Interrupted the sleep.");
           case ( EINVAL ) : return StandardException(loc, ecl::InvalidInputError, "Specified value was negative or exceeded resolution range.\n\n            Sleep: [N/A]\n            MilliSleep: [0-1000]\n            MicroSleep: [0-1x10^6]\n            NanoSleep: [0-1x10^9]\n");
           case ( EFAULT ) : return StandardException(loc, ecl::MemoryError, "Memory error.");
           default         :
           {
               std::ostringstream ostream;
               ostream << "Unknown error " << error_result << ": " << strerror(error_result) << ".";
               return StandardException(loc, UnknownError, ostream.str());
           }
       }
   
   }
   
   
   }; // namespace time
   } // namespace ecl
   #endif
   
   #endif /* ECL_IS_WIN32 */
   #endif /* ECL_TIME_SLEEP_WIN_HPP_ */