// Copyright (C) 2001-2003

// William E. Kempf

//

//  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)

#ifndef BOOST_XLOCK_WEK070601_HPP

#define BOOST_XLOCK_WEK070601_HPP

#include <boost/thread/detail/config.hpp>

#include <boost/utility.hpp>

#include <boost/thread/exceptions.hpp>

namespace boost {

class condition;

struct xtime;

namespace detail { namespace thread {

template <typename Mutex>

class lock_ops : private noncopyable

{

private:

    lock_ops() { }

public:

    typedef typename Mutex::cv_state lock_state;

    static void lock(Mutex& m)

    {

        m.do_lock();

    }

    static bool trylock(Mutex& m)

    {

        return m.do_trylock();

    }

    static bool timedlock(Mutex& m, const xtime& xt)

    {

        return m.do_timedlock(xt);

    }

    static void unlock(Mutex& m)

    {

        m.do_unlock();

    }

    static void lock(Mutex& m, lock_state& state)

    {

        m.do_lock(state);

    }

    static void unlock(Mutex& m, lock_state& state)

    {

        m.do_unlock(state);

    }

};

template <typename Mutex>

class scoped_lock : private noncopyable

{

public:

    typedef Mutex mutex_type;

    explicit scoped_lock(Mutex& mx, bool initially_locked=true)

        : m_mutex(mx), m_locked(false)

    {

        if (initially_locked) lock();

    }

    ~scoped_lock()

    {

        if (m_locked) unlock();

    }

    void lock()

    {

        if (m_locked) throw lock_error();

        lock_ops<Mutex>::lock(m_mutex);

        m_locked = true;

    }

    void unlock()

    {

        if (!m_locked) throw lock_error();

        lock_ops<Mutex>::unlock(m_mutex);

        m_locked = false;

    }

    bool locked() const { return m_locked; }

    operator const void*() const { return m_locked ? this : 0; }

private:

    friend class boost::condition;

    Mutex& m_mutex;

    bool m_locked;

};

template <typename TryMutex>

class scoped_try_lock : private noncopyable

{

public:

    typedef TryMutex mutex_type;

    explicit scoped_try_lock(TryMutex& mx)

        : m_mutex(mx), m_locked(false)

    {

        try_lock();

    }

    scoped_try_lock(TryMutex& mx, bool initially_locked)

        : m_mutex(mx), m_locked(false)

    {

        if (initially_locked) lock();

    }

    ~scoped_try_lock()

    {

        if (m_locked) unlock();

    }

    void lock()

    {

        if (m_locked) throw lock_error();

        lock_ops<TryMutex>::lock(m_mutex);

        m_locked = true;

    }

    bool try_lock()

    {

        if (m_locked) throw lock_error();

        return (m_locked = lock_ops<TryMutex>::trylock(m_mutex));

    }

    void unlock()

    {

        if (!m_locked) throw lock_error();

        lock_ops<TryMutex>::unlock(m_mutex);

        m_locked = false;

    }

    bool locked() const { return m_locked; }

    operator const void*() const { return m_locked ? this : 0; }

private:

    friend class boost::condition;

    TryMutex& m_mutex;

    bool m_locked;

};

template <typename TimedMutex>

class scoped_timed_lock : private noncopyable

{

public:

    typedef TimedMutex mutex_type;

    scoped_timed_lock(TimedMutex& mx, const xtime& xt)

        : m_mutex(mx), m_locked(false)

    {

        timed_lock(xt);

    }

    scoped_timed_lock(TimedMutex& mx, bool initially_locked)

        : m_mutex(mx), m_locked(false)

    {

        if (initially_locked) lock();

    }

    ~scoped_timed_lock()

    {

        if (m_locked) unlock();

    }

    void lock()

    {

        if (m_locked) throw lock_error();

        lock_ops<TimedMutex>::lock(m_mutex);

        m_locked = true;

    }

    bool try_lock()

    {

        if (m_locked) throw lock_error();

        return (m_locked = lock_ops<TimedMutex>::trylock(m_mutex));

    }

    bool timed_lock(const xtime& xt)

    {

        if (m_locked) throw lock_error();

        return (m_locked = lock_ops<TimedMutex>::timedlock(m_mutex, xt));

    }

    void unlock()

    {

        if (!m_locked) throw lock_error();

        lock_ops<TimedMutex>::unlock(m_mutex);

        m_locked = false;

    }

    bool locked() const { return m_locked; }

    operator const void*() const { return m_locked ? this : 0; }

private:

    friend class boost::condition;

    TimedMutex& m_mutex;

    bool m_locked;

};

} // namespace thread

} // namespace detail

} // namespace boost

#endif // BOOST_XLOCK_WEK070601_HPP

// Change Log:

//    8 Feb 01  WEKEMPF Initial version.

//   22 May 01  WEKEMPF Modified to use xtime for time outs.

//   30 Jul 01  WEKEMPF Moved lock types into boost::detail::thread. Renamed

//                      some types. Added locked() methods.