/*
 * namedLockPattern.cpp
 */

#include "referenceCountingLock.h"

namespace epics { namespace pvAccess {

using namespace epics::pvData;

ReferenceCountingLock::ReferenceCountingLock(): _references(1)
{
/*	pthread_mutexattr_t mutexAttribute;
	int32 retval = pthread_mutexattr_init(&mutexAttribute);
	if(retval != 0)
	{
		//string errMsg = "Error: pthread_mutexattr_init failed: " + string(strerror(retval));
		assert(false);
	}
	retval = pthread_mutexattr_settype(&mutexAttribute, PTHREAD_MUTEX_RECURSIVE);
	if(retval == 0)
	{
		retval = pthread_mutex_init(&_mutex, &mutexAttribute);
		if(retval != 0)
		{
			//string errMsg = "Error: pthread_mutex_init failed: " + string(strerror(retval));
			assert(false);
		}
	}
	else
	{
		//string errMsg = "Error: pthread_mutexattr_settype failed: " + string(strerror(retval));
		assert(false);
	}

	pthread_mutexattr_destroy(&mutexAttribute);*/
}

ReferenceCountingLock::~ReferenceCountingLock()
{
//	pthread_mutex_destroy(&_mutex);
}

bool ReferenceCountingLock::acquire(int64 msecs)
{
	_mutex.lock();
	return true;
/*	struct timespec deltatime;
	if(msecs > 0)
	{
		deltatime.tv_sec = msecs / 1000;
		deltatime.tv_nsec = (msecs % 1000) * 1000;
	}
	else
	{
		deltatime.tv_sec = 0;
		deltatime.tv_nsec = 0;
	}

	int32 retval = pthread_mutex_timedlock(&_mutex, &deltatime);
	if(retval == 0)
	{
		return true;
	}
	return false;
*/
}

void ReferenceCountingLock::release()
{
	_mutex.unlock();
/*	int retval = pthread_mutex_unlock(&_mutex);
	if(retval != 0)
	{
		//string errMsg = "Error: pthread_mutex_unlock failed: "  + string(strerror(retval));
		//TODO do something?
	}*/
}

int ReferenceCountingLock::increment()
{
	Lock guard(&_countMutex);
	++_references;
	return _references;
}

int ReferenceCountingLock::decrement()
{
	Lock guard(&_countMutex);
	--_references;
	return _references;
}

}}