#ifndef READ_WRITE_MUTEX_HPP
#define READ_WRITE_MUTEX_HPP

//  read_write_mutex.hpp
//
//  (C) Copyright 2005 Anthony Williams 
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

#include <boost/thread/once.hpp>
#include <boost/detail/interlocked.hpp>
#include <windows.h>

namespace boost
{
#define BOOST_RW_MUTEX_INIT {BOOST_ONCE_INIT}

    class read_write_mutex
    {
        static const long unlocked_state=0;
        static const long reading_state=1;
        static const long writing_state=2;
        static const long upgrading_state=3;
        static const long reading_with_upgradeable_state=4;
        static const long acquiring_reading_state=5;
        static const long releasing_reading_state=6;
        static const long releasing_reading_with_upgradeable_state=7;
    public:
        boost::once_flag flag;
        long active_pending_flag;
        void* active_pending;
        long mutex_state_flag;
        void* mutex_state_sem;
        long reader_count;

    private:
        
        struct initializer
        {
            read_write_mutex* self;
            
            initializer(read_write_mutex* self_):
                self(self_)
            {}
            void operator()()
            {
                self->active_pending_flag=0;
                self->active_pending=CreateSemaphore(NULL,0,1,NULL);
                self->mutex_state_sem=CreateSemaphore(NULL,0,1,NULL);
                self->reader_count=0;
                self->mutex_state_flag=unlocked_state;
            }
        };
        
        void initialize()
        {
            boost::call_once(initializer(this),flag);
        }

        void release_mutex_state_sem()
        {
            ReleaseSemaphore(mutex_state_sem,1,NULL);
        }

        void acquire_mutex_state_sem()
        {
            BOOST_WAIT_FOR_SINGLE_OBJECT(mutex_state_sem,BOOST_INFINITE);
        }

        template<unsigned array_size>
        long enter_new_state(long const (&old_states)[array_size],long new_state)
        {
            bool release_if_blocked=false;
            while(true)
            {
                for(unsigned i=0;i<array_size;++i)
                {
                    if(BOOST_INTERLOCKED_COMPARE_EXCHANGE(&mutex_state_flag,new_state,old_states[i])==old_states[i])
                    {
                        return old_states[i];
                    }
                }
                if(release_if_blocked)
                {
                    release_mutex_state_sem();
                }
                acquire_mutex_state_sem();
                release_if_blocked=true;
            }
        }

        void acquire_active_pending()
        {
            bool release_if_blocked=false;
            while(BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_pending_flag,1,0))
            {
                if(release_if_blocked)
                {
                    release_active_pending();
                }
                BOOST_WAIT_FOR_SINGLE_OBJECT(active_pending,BOOST_INFINITE);
                release_if_blocked=true;
            }
        }

        void release_active_pending()
        {
            ReleaseSemaphore(active_pending,1,NULL);
        }
        

        void lock_acquired()
        {
            BOOST_INTERLOCKED_EXCHANGE(&active_pending_flag,0);
            release_active_pending();
        }

    public:

        ~read_write_mutex()
        {
            BOOST_CLOSE_HANDLE(mutex_state_sem);
            BOOST_CLOSE_HANDLE(active_pending);
        }
        
        void acquire_read_lock()
        {
            initialize();
            acquire_active_pending();

            long const old_states[]={
                unlocked_state,reading_state,reading_with_upgradeable_state
            };
            
            long const previous_state=enter_new_state(old_states,acquiring_reading_state);
            BOOST_INTERLOCKED_INCREMENT(&reader_count);
            long const new_state=(previous_state==reading_with_upgradeable_state)?
                reading_with_upgradeable_state:reading_state;
            BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,new_state);
            lock_acquired();
        }

        void release_read_lock()
        {
            long const old_states[]={
                reading_state,reading_with_upgradeable_state
            };
            long const previous_state=enter_new_state(old_states,releasing_reading_state);
            bool const last_reader=!BOOST_INTERLOCKED_DECREMENT(&reader_count);
            long const new_state=(previous_state==reading_with_upgradeable_state)?
                reading_with_upgradeable_state:
                (last_reader?unlocked_state:reading_state);
            BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,new_state);
            release_mutex_state_sem();
        }

        void acquire_write_lock()
        {
            initialize();
            acquire_active_pending();
            long const old_states[]={
                unlocked_state
            };
            
            enter_new_state(old_states,writing_state);
            lock_acquired();
        }
        
        void release_write_lock()
        {
            BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,unlocked_state);
            release_mutex_state_sem();
        }

        void acquire_upgradeable_lock()
        {
            initialize();
            acquire_active_pending();
            long const old_states[]={
                unlocked_state,reading_state
            };
            enter_new_state(old_states,reading_with_upgradeable_state);
            lock_acquired();
        }
        
        void release_upgradeable_lock()
        {
            BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,releasing_reading_with_upgradeable_state);
            long const new_state=reader_count?reading_state:unlocked_state;
            BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,new_state);
            release_mutex_state_sem();
        }

        void upgrade_upgradeable_lock()
        {
            bool acquired=false;
            bool release_if_blocked=false;
            while(!acquired)
            {
                BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,upgrading_state);
                if(!BOOST_INTERLOCKED_COMPARE_EXCHANGE(&reader_count,0,0))
                {
                    BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,writing_state);
                    acquired=true;
                }
                else
                {
                    BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,reading_with_upgradeable_state);
                    if(release_if_blocked)
                    {
                        release_mutex_state_sem();
                    }
                    acquire_mutex_state_sem();
                    release_if_blocked=true;
                }
            }
        }
    };

    class read_lock
    {
        read_write_mutex& mutex;
    public:
        read_lock(read_write_mutex& mutex_):
            mutex(mutex_)
        {
            mutex.acquire_read_lock();
        }
        ~read_lock()
        {
            mutex.release_read_lock();
        }
    };

    class upgradeable_lock
    {
        friend class write_lock;
        read_write_mutex& mutex;
        bool upgraded;
    public:
        upgradeable_lock(read_write_mutex& mutex_):
            mutex(mutex_),upgraded(false)
        {
            mutex.acquire_upgradeable_lock();
        }
        ~upgradeable_lock()
        {
            if(!upgraded)
            {
                mutex.release_upgradeable_lock();
            }
        }
    };
    
    class write_lock
    {
        read_write_mutex& mutex;
    public:
        write_lock(read_write_mutex& mutex_):
            mutex(mutex_)
        {
            mutex.acquire_write_lock();
        }
        write_lock(upgradeable_lock& upgradeable):
            mutex(upgradeable.mutex)
        {
            mutex.upgrade_upgradeable_lock();
            upgradeable.upgraded=true;
        }
        ~write_lock()
        {
            mutex.release_write_lock();
        }
    };
   
}

#endif