/*
 * 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()
{
}