RMI for C++

#ifndef _SF_PLATFORM_THREADS_THREADSPROXY_HPP_
#define _SF_PLATFORM_THREADS_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 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 &) {}
            void notify_one() {}
            void notify_all() {}
        };

    } // namespace Threads

} // namespace Platform

#endif // ! _UTIL_PLATFORM_BOOST_THREADSPROXY_HPP_