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()() ecl_assert_throw_decl(StandardException);
        Duration duration() { return Duration(required.tv_sec,required.tv_nsec); }

        void operator()(const unsigned long &seconds) ecl_assert_throw_decl(StandardException);
        void operator()(const Duration &duration) ecl_assert_throw_decl(StandardException);

private:
    TimeStructure required, remaining;
};

class ecl_time_PUBLIC MilliSleep {
public:
        MilliSleep(const unsigned long &milliseconds = 0);

        virtual ~MilliSleep() {}

        void operator()() ecl_assert_throw_decl(StandardException);
        Duration duration() { return Duration(required.tv_sec,required.tv_nsec); }

        void operator()(const unsigned long &milliseconds) ecl_assert_throw_decl(StandardException);
private:
    TimeStructure required, remaining;
};

class ecl_time_PUBLIC MicroSleep {
public:
        MicroSleep(const unsigned long &microseconds = 0);

        virtual ~MicroSleep() {}


        void operator()() ecl_assert_throw_decl(StandardException);
        Duration duration() { return Duration(required.tv_sec,required.tv_nsec); }
        void operator()(const unsigned long &micro_seconds) ecl_assert_throw_decl(StandardException);
private:
    TimeStructure required, remaining;
};

class ecl_time_PUBLIC NanoSleep {
public:
        NanoSleep(const unsigned long &nanoseconds = 0);

        virtual ~NanoSleep() {}


        void operator()() ecl_assert_throw_decl(StandardException);
        Duration duration() { return Duration(required.tv_sec,required.tv_nsec); }
        void operator()(const unsigned long &nanoseconds) ecl_assert_throw_decl(StandardException);
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_ */