/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef _RW_LOCK_MANAGER_H
#define _RW_LOCK_MANAGER_H

#include <Locker.h>

#include <util/DoublyLinkedList.h>


namespace BPrivate {


class RWLockManager;


class RWLockable {
public:
                                                                RWLockable();

private:
        struct Waiter : DoublyLinkedListLinkImpl<Waiter> {
                Waiter(bool writer)
                        :
                        thread(find_thread(NULL)),
                        writer(writer),
                        queued(false)
                {
                }

                thread_id               thread;
                status_t                status;
                bool                    writer;
                bool                    queued;
        };

        typedef DoublyLinkedList<Waiter> WaiterList;

        friend class RWLockManager;

private:
                                thread_id               fOwner;
                                int32                   fOwnerCount;
                                int32                   fReaderCount;
                                WaiterList              fWaiters;
};


class RWLockManager {
public:
                                                                RWLockManager();
                                                                ~RWLockManager();

                        status_t                        Init()          { return fLock.InitCheck(); }

                        bool                            Lock()          { return fLock.Lock(); }
                        void                            Unlock()        { return fLock.Unlock(); }

                        bool                            ReadLock(RWLockable* lockable);
                        bool                            TryReadLock(RWLockable* lockable);
                        status_t                        ReadLockWithTimeout(RWLockable* lockable,
                                                                        bigtime_t timeout);
                        void                            ReadUnlock(RWLockable* lockable);

                        bool                            WriteLock(RWLockable* lockable);
                        bool                            TryWriteLock(RWLockable* lockable);
                        status_t                        WriteLockWithTimeout(RWLockable* lockable,
                                                                        bigtime_t timeout);
                        void                            WriteUnlock(RWLockable* lockable);

        inline  bool                            GenericLock(bool write, RWLockable* lockable);
        inline  bool                            TryGenericLock(bool write,
                                                                        RWLockable* lockable);
        inline  status_t                        GenericLockWithTimeout(bool write,
                                                                        RWLockable* lockable, bigtime_t timeout);
        inline  void                            GenericUnlock(bool write, RWLockable* lockable);

private:
                        status_t                        _Wait(RWLockable* lockable, bool writer,
                                                                        bigtime_t timeout);
                        void                            _Unblock(RWLockable* lockable);

private:
                        BLocker                         fLock;
};


inline bool
RWLockManager::GenericLock(bool write, RWLockable* lockable)
{
        return write ? WriteLock(lockable) : ReadLock(lockable);
}


inline bool
RWLockManager::TryGenericLock(bool write, RWLockable* lockable)
{
        return write ? TryWriteLock(lockable) : TryReadLock(lockable);
}


inline status_t
RWLockManager::GenericLockWithTimeout(bool write, RWLockable* lockable,
        bigtime_t timeout)
{
        return write
                ? WriteLockWithTimeout(lockable, timeout)
                : ReadLockWithTimeout(lockable, timeout);
}


inline void
RWLockManager::GenericUnlock(bool write, RWLockable* lockable)
{
        if (write)
                WriteUnlock(lockable);
        else
                ReadUnlock(lockable);
}


}       // namespace BPrivate


using BPrivate::RWLockable;
using BPrivate::RWLockManager;


#endif  // _RW_LOCK_MANAGER_H