/********************************************************************
	created:	24:11:2003   14:49
	filename: 	policy.hpp
	author:		Matt Hurd
	
	purpose:	
*********************************************************************/

#ifndef POLICY_HPP_20031124
#define POLICY_HPP_20031124

#include <cassert>

#include <boost/thread/thread.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/thread/rw_mutex.hpp>
    
#include "atomic.hpp"

namespace synch {

    struct lock_priority
    {
        enum type
        {
            exclusive,
            shared,
            interleaved
        };
    };

    static boost::rw_scheduling_policy convert( lock_priority::type lp )
    {
        switch(lp) {
            case lock_priority::exclusive:
                return boost::sp_writer_priority;
            case lock_priority::shared:
                return boost::sp_reader_priority;
            case lock_priority::interleaved:
                return boost::sp_alternating_single_reads;
        }
        assert(false);
    }

    static lock_priority::type convert( boost::rw_scheduling_policy sp )
    {
        switch(sp) {
            case boost::sp_writer_priority:
                return lock_priority::exclusive;
            case boost::sp_reader_priority:
                return lock_priority::shared;
            case boost::sp_alternating_single_reads:
                return lock_priority::interleaved;

            // not sure we shouldn't just assert on this one
            case boost::sp_alternating_many_reads:
                return lock_priority::interleaved;
        }
        assert(false);
    }

    struct lock_status
    {
        enum type
        {
            shared,
            exclusive
        };
    };

    static boost::rw_lock_state convert( lock_status::type ls )
    {
        switch(ls) 
        {
            case lock_status::shared :
                return boost::SHARED_LOCK;
            case lock_status::exclusive:
                return boost::EXCL_LOCK;
        }
        assert(false);
    }

    static lock_status::type convert( boost::rw_lock_state ls )
    {
        switch(ls) 
        {
            case boost::SHARED_LOCK :
                return lock_status::shared;
            case boost::EXCL_LOCK:
                return lock_status::exclusive;
        }
        assert(false);
    }


    template<class Mutex>
    struct null_lock
    {
        null_lock( Mutex& m, lock_status::type ls = lock_status::exclusive ) {}
        bool try_lock() {}
        bool timed_lock(const boost::xtime &) {}

    private:
        null_lock (const null_lock&);
        null_lock& operator= (const null_lock&);
    };


    template<class Mutex>
    struct simple_lock
    {
        simple_lock( Mutex& m, lock_status::type ls = lock_status::exclusive) : lock_(m) {}
        bool try_lock() { return lock_.try_lock(); }
        bool timed_lock(const boost::xtime &xt ) { return timed_lock.timed_lock(xt); }

    private:
        simple_lock (const simple_lock&);
        simple_lock& operator= (const simple_lock&);

    private:
        typename Mutex::scoped_lock lock_;
    };


    template<class Mutex>
    struct shareable_lock 
    {
        shareable_lock( Mutex& m, lock_status::type ls = lock_status::exclusive) : lock_(m,convert(ls)) {}
        bool try_lock() { return lock_.try_lock(); }
        bool timed_lock(const boost::xtime &xt ) { return timed_lock.timed_lock(xt); }
    private:
        shareable_lock (const shareable_lock&);
        shareable_lock& operator= (const shareable_lock&);

    private:
        typename Mutex::scoped_rw_lock lock_;

    };


    struct no_synch
    {
        struct nil_mutex 
        {
            nil_mutex( lock_priority::type lp = lock_priority::exclusive ) {}
            ~nil_mutex() {}
        };

        typedef nil_mutex mutex;
        typedef nil_mutex try_mutex;
        typedef nil_mutex timed_mutex;

        typedef null_lock<mutex> lock;
        typedef null_lock<try_mutex> try_lock;
        typedef null_lock<timed_mutex> timed_lock;

        
        typedef atomic_op_simple atomic_op;
    };

    struct simple
    {
    protected:
        struct adapted_mutex : public boost::mutex
        {
            adapted_mutex( lock_priority::type lp = lock_priority::exclusive ) {}
            ~adapted_mutex() {}
        };

        struct adapted_try_mutex : public boost::try_mutex
        {
            adapted_try_mutex( lock_priority::type lp = lock_priority::exclusive ) {}
            ~adapted_try_mutex() {}
        };

        struct adapted_timed_mutex : public boost::timed_mutex
        {
            adapted_timed_mutex( lock_priority::type lp = lock_priority::exclusive ) {}
            ~adapted_timed_mutex() {}
        };

    public:
        typedef adapted_mutex               mutex;
        typedef adapted_try_mutex           try_mutex;
        typedef adapted_timed_mutex         timed_mutex;

        typedef simple_lock<mutex>          lock;
        typedef simple_lock<try_mutex>      try_lock;
        typedef simple_lock<timed_mutex>    timed_lock;

        typedef atomic_op_interlocked atomic_op;
    };

    struct recursive
    {
    protected:
        struct adapted_mutex : public boost::recursive_mutex
        {
            adapted_mutex( lock_priority::type lp = lock_priority::exclusive ) {}
            ~adapted_mutex() {}
        };

        struct adapted_try_mutex : public boost::recursive_try_mutex
        {
            adapted_try_mutex( lock_priority::type lp = lock_priority::exclusive ) {}
            ~adapted_try_mutex() {}
        };

        struct adapted_timed_mutex : public boost::recursive_timed_mutex
        {
            adapted_timed_mutex( lock_priority::type lp = lock_priority::exclusive ) {}
            ~adapted_timed_mutex() {}
        };

    public:
        typedef adapted_mutex mutex;
        typedef adapted_try_mutex try_mutex;
        typedef adapted_timed_mutex timed_mutex;

        typedef simple_lock<mutex> lock;
        typedef simple_lock<try_mutex> try_lock;
        typedef simple_lock<timed_mutex> timed_lock;

        typedef atomic_op_interlocked atomic_op;
    };


    struct shareable
    {
    protected:
        struct adapted_mutex : public boost::rw_mutex
        {
            adapted_mutex( lock_priority::type lp = lock_priority::exclusive ) 
                : rw_mutex( convert( lp) ) {}
                ~adapted_mutex() {}
        };

        struct adapted_try_mutex : public boost::try_rw_mutex
        {
            adapted_try_mutex( lock_priority::type lp = lock_priority::exclusive ) 
                : try_rw_mutex( convert( lp) ) {}
                ~adapted_try_mutex() {}
        };

        struct adapted_timed_mutex : public boost::timed_rw_mutex
        {
            adapted_timed_mutex( lock_priority::type lp = lock_priority::exclusive )
                : timed_rw_mutex( convert( lp) ) {}
                ~adapted_timed_mutex() {}
        };

    public:
        typedef adapted_mutex mutex;
        typedef adapted_try_mutex try_mutex;
        typedef adapted_timed_mutex timed_mutex;

        typedef shareable_lock<mutex> lock;
        typedef shareable_lock<try_mutex> try_lock;
        typedef shareable_lock<timed_mutex> timed_lock;

        typedef atomic_op_interlocked atomic_op;

    };

}

#endif