driver.hh

Go to the documentation of this file.

#ifndef TAMER_DRIVER_HH
#define TAMER_DRIVER_HH 1
/* Copyright (c) 2007-2015, Eddie Kohler
 * Copyright (c) 2007, Regents of the University of California
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, subject to the conditions
 * listed in the Tamer LICENSE file. These conditions include: you must
 * preserve this copyright notice, and you cannot mention the copyright
 * holders in advertising related to the Software without their permission.
 * The Software is provided WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED. This
 * notice is a summary of the Tamer LICENSE file; the license in that file is
 * legally binding.
 */
#include <tamer/xdriver.hh>
namespace tamer {

 
enum init_flags {
    init_tamer = 1,
    init_libevent = 2,
    init_libev = 4,
    init_sigpipe = 0x1000,
    init_strict = 0x2000,
    init_no_epoll = 0x4000
};

bool initialize(int flags = 0);

void cleanup();
 
enum time_type_t {
    time_normal,
    time_virtual
};
 
void set_time_type(time_type_t tt);

inline const timeval& recent() {
    if (tamerpriv::need_recent) {
        tamerpriv::recent = now();
        tamerpriv::need_recent = false;
    }
    return tamerpriv::recent;
}

inline void set_recent() {
    tamerpriv::need_recent = true;
}

inline double dtime(const timeval tv) {
    return tv.tv_sec + tv.tv_usec / 1000000.;
}

inline double dnow() {
    return dtime(now());
}

inline double drecent() {
    return dtime(recent());
}

inline void loop(loop_flags flags) {
    driver::main->loop(flags);
}

inline void loop() {
    driver::main->loop(loop_forever);
}

inline void once() {
    driver::main->loop(loop_once);
}

inline void break_loop() {
    driver::main->break_loop();
}

inline void at_fd_read(int fd, event<> e) {
    driver::main->at_fd(fd, fd_read, e);
}
 
inline void at_fd_read(int fd, event<int> e) {
    driver::main->at_fd(fd, fd_read, e);
}

inline void at_fd_write(int fd, event<> e) {
    driver::main->at_fd(fd, fd_write, e);
}
 
inline void at_fd_write(int fd, event<int> e) {
    driver::main->at_fd(fd, fd_write, e);
}

inline void at_fd_shutdown(int fd, event<> e) {
    driver::main->at_fd(fd, fd_hangup, e);
}

inline void at_time(const timeval &expiry, event<> e, bool bg = false) {
    driver::main->at_time(expiry, e, bg);
}

inline void at_time(double expiry, event<> e, bool bg = false) {
    driver::main->at_time(expiry, e, bg);
}

inline void at_delay(const timeval &delay, event<> e, bool bg = false) {
    driver::main->at_delay(delay, e, bg);
}

inline void at_delay(double delay, event<> e, bool bg = false) {
    driver::main->at_delay(delay, e, bg);
}

inline void at_delay_sec(int delay, event<> e, bool bg = false) {
    driver::main->at_delay_sec(delay, e, bg);
}

inline void at_delay_msec(int delay, event<> e, bool bg = false) {
    driver::main->at_delay_msec(delay, e, bg);
}

inline void at_delay_usec(int delay, event<> e, bool bg = false) {
    driver::main->at_delay_usec(delay, e, bg);
}

inline void at_signal(int signo, event<> e) {
    driver::at_signal(signo, e);
}

inline void at_asap(event<> e) {
    driver::main->at_asap(e);
}

inline void at_preblock(event<> e) {
    driver::main->at_preblock(e);
}
 
namespace tamerpriv { extern time_type_t time_type; }
} // namespace tamer
#endif /* TAMER_DRIVER_HH */