/*
 * Copyright 2013-2014, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include "JobQueue.h"

#include <PthreadMutexLocker.h>


// #pragma mark - JobQueue


JobQueue::JobQueue()
        :
        fMutexInitialized(false),
        fNewJobConditionInitialized(false),
        fJobs(),
        fClosed(false)
{
}


JobQueue::~JobQueue()
{
        if (fMutexInitialized) {
                PthreadMutexLocker mutexLocker(fMutex);
                while (Job* job = fJobs.RemoveHead())
                        job->ReleaseReference();
        }

        if (fNewJobConditionInitialized)
                pthread_cond_destroy(&fNewJobCondition);

        if (fMutexInitialized)
                pthread_mutex_destroy(&fMutex);
}


status_t
JobQueue::Init()
{
        status_t error = pthread_mutex_init(&fMutex, NULL);
        if (error != B_OK)
                return error;
        fMutexInitialized = true;

        error = pthread_cond_init(&fNewJobCondition, NULL);
        if (error != B_OK)
                return error;
        fNewJobConditionInitialized = true;

        return B_OK;
}


void
JobQueue::Close()
{
        if (fMutexInitialized && fNewJobConditionInitialized) {
                PthreadMutexLocker mutexLocker(fMutex);
                fClosed = true;
                pthread_cond_broadcast(&fNewJobCondition);
        }
}


bool
JobQueue::QueueJob(Job* job)
{
        PthreadMutexLocker mutexLocker(fMutex);
        if (fClosed)
                return false;

        fJobs.Add(job);
        job->AcquireReference();

        pthread_cond_signal(&fNewJobCondition);
        return true;
}


Job*
JobQueue::DequeueJob()
{
        PthreadMutexLocker mutexLocker(fMutex);

        while (!fClosed) {
                Job* job = fJobs.RemoveHead();
                if (job != NULL)
                        return job;

                if (!fClosed)
                        pthread_cond_wait(&fNewJobCondition, &fMutex);
        }

        return NULL;
}


void
JobQueue::DeleteJobs(Filter* filter)
{
        PthreadMutexLocker mutexLocker(fMutex);

        for (JobList::Iterator it = fJobs.GetIterator(); Job* job = it.Next();) {
                if (filter->FilterJob(job)) {
                        it.Remove();
                        delete job;
                }
        }
}


// #pragma mark - Filter


JobQueue::Filter::~Filter()
{
}