#ifndef INCLUDE_UTIL_PLATFORM_BOOST_THREADSPROXY_HPP
#define INCLUDE_UTIL_PLATFORM_BOOST_THREADSPROXY_HPP
// Single-threaded proxy for boost threads
#include <memory>
namespace Platform {
namespace Threads {
class thread {
public:
template<typename T> thread( T &t) { /*t();*/ }
template<typename T> thread(const T &t) { /*const_cast<T &>(t)();*/ }
void join() {}
};
class thread_group {
public:
template<typename T> thread *create_thread(const T &t) { const_cast<T &>(t)(); return NULL; }
void add_thread(thread *) {}
void remove_thread(thread *) {}
void join_all() {}
};
template<typename T>
struct thread_specific_ptr {
typedef std::auto_ptr<T> Val;
};
struct lock_t {
template<typename T1> lock_t(const T1 &) {}
template<typename T1, typename T2> lock_t(const T1 &, const T2 &t2) {}
bool locked() { return true; }
void lock() {}
void unlock() {}
};
struct mutex { typedef lock_t scoped_lock; };
struct recursive_mutex { typedef lock_t scoped_lock; };
struct recursive_try_mutex { typedef lock_t scoped_lock; typedef lock_t scoped_try_lock; };
struct try_mutex { typedef lock_t scoped_lock; typedef lock_t scoped_try_lock; };
enum read_write_scheduling_policy {
writer_priority,
reader_priority,
alternating_many_reads,
alternating_single_read
};
struct read_write_mutex {
read_write_mutex(read_write_scheduling_policy) {}
typedef lock_t scoped_read_lock;
typedef lock_t scoped_write_lock;
typedef lock_t scoped_read_write_lock;
};
struct condition {
condition() {}
template<typename T> void wait(const T &) {}
template<typename T> bool timed_wait(const T &t, int timeoutMs) { return true; }
void notify_one() {}
void notify_all() {}
};
} // namespace Threads
} // namespace Platform
#endif // ! INCLUDE_UTIL_PLATFORM_BOOST_THREADSPROXY_HPP