// Blocker.cpp

#include <new>

#include "Blocker.h"

// Data
struct Blocker::Data {
        Data()
                : semaphore(create_sem(0, "blocker")),
                  references(1),
                  userData(0)
        {
        }

        Data(sem_id semaphore)
                : semaphore(semaphore),
                  references(1)
        {
        }

        ~Data()
        {
                if (semaphore >= 0)
                        delete_sem(semaphore);
        }

        sem_id  semaphore;
        int32   references;
        int32   userData;
};

// constructor
Blocker::Blocker()
        : fData(new(std::nothrow) Data)
{
}

// constructor
Blocker::Blocker(sem_id semaphore)
        : fData(new(std::nothrow) Data(semaphore))
{
        if (!fData)
                delete_sem(semaphore);
}

// copy constructor
Blocker::Blocker(const Blocker& other)
        : fData(NULL)
{
        *this = other;
}

// destructor
Blocker::~Blocker()
{
        _Unset();
}

// InitCheck
status_t
Blocker::InitCheck() const
{
        if (!fData)
                return B_NO_MEMORY;
        return (fData->semaphore < 0 ? fData->semaphore : B_OK);
}

// PrepareForUse
status_t
Blocker::PrepareForUse()
{
        // check initialization
        if (!fData || fData->semaphore < 0)
                return B_NO_INIT;
        // get semaphore count
        int32 count;
        status_t error = get_sem_count(fData->semaphore, &count);
        if (error != B_OK)
                return error;
        // set the semaphore count to zero
        if (count > 0)
                error = acquire_sem_etc(fData->semaphore, count, B_RELATIVE_TIMEOUT, 0);
        else if (count < 0)
                error = release_sem_etc(fData->semaphore, -count, 0);
        return error;
}

// Block
status_t
Blocker::Block(int32* userData)
{
        if (!fData || fData->semaphore < 0)
                return B_NO_INIT;

        status_t error = acquire_sem(fData->semaphore);

        if (userData)
                *userData = fData->userData;

        return error;
}

// Unblock
status_t
Blocker::Unblock(int32 userData)
{
        if (!fData || fData->semaphore < 0)
                return B_NO_INIT;

        fData->userData = userData;

        return release_sem(fData->semaphore);
}

// =
Blocker&
Blocker::operator=(const Blocker& other)
{
        _Unset();
        fData = other.fData;
        if (fData)
                fData->references++;
        return *this;
}

// ==
bool
Blocker::operator==(const Blocker& other) const
{
        return (fData == other.fData);
}

// !=
bool
Blocker::operator!=(const Blocker& other) const
{
        return (fData != other.fData);
}

// _Unset
void
Blocker::_Unset()
{
        if (fData) {
                if (--fData->references == 0)
                        delete fData;
                fData = NULL;
        }
}