sleep_win.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** 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_ */