updatelock.hpp

j2me is based on j2mepolish, client & server for mobile application.

//         Copyright E骾n O'Callaghan 2006 - 2008.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#ifndef WTLX_UPDATELOCK_HPP_INCLUDED
#define WTLX_UPDATELOCK_HPP_INCLUDED

#include <boost/thread/thread.hpp>
#include <boost/thread/recursive_mutex.hpp>

#include "event_logger.hpp"

namespace WTLx
{
	
typedef boost::recursive_mutex mutex_t;

template<class T>
class mutex_update_lock
{
public:
	mutex_update_lock(T& window) :
		window_(window),
		lock_(window_.mutex_)
	{
		++window_.update_lock_;

		window_.LockWindowUpdate(true);
	}
	
	~mutex_update_lock()
	{
		if (!--window_.update_lock_)
			unlock();
	}
	
	void unlock()
	{
		window_.LockWindowUpdate(false);
//		window_.InvalidateRect(NULL, true);
	}
	
private:
	T& window_;

	mutex_t::scoped_try_lock lock_;
};

template<class T>
class try_update_lock
{
public:
	try_update_lock(T& window) :
		window_(window),
		locked_(false)
	{
		mutex_t::scoped_lock lock(window_.mutex_);

		if (0 == window_.update_lock_++)
		{
			logger.post(new event_type(event_logger::dev, L"Try Updated Locked."));

			locked_ =  true;
//			window_.LockWindowUpdate(true);
		}
	}
	
	~try_update_lock()
	{
		mutex_t::scoped_lock lock(window_.mutex_);

		if (locked_ && !--window_.update_lock_)
			unlock();
	}
	
	void unlock()
	{
		logger.post(new event_type(event_logger::dev, L"Try Updated Unlocked."));

//		window_.LockWindowUpdate(false);
//		window_.InvalidateRect(NULL, true);
	}
	
	operator bool() const { return locked_; }
	
private:
	T& window_;	
	bool locked_;
};

template<class T>
class notification_lock
{
public:
	notification_lock(T& window) :
		window_(window),
		locked_(false)
	{
		mutex_t::scoped_lock lock(window_.mutex_);
		++window_.notify_lock_;

		if (window_.notify_lock_ == 1)
		{
//			logger.post(new event_type(event_logger::info, 
//					boost::wformat(L"Notification locked %1%") % window_.notify_lock_));
			locked_ =  true;
		}
	}
	
	~notification_lock()
	{
		mutex_t::scoped_lock lock(window_.mutex_);
		--window_.notify_lock_;

		if (window_.notify_lock_ == 0)
			unlock();
	}
	
	void unlock()
	{
//		logger.post(new event_type(event_logger::info, 
//			boost::wformat(L"Notification unlocked %1%") % window_.notify_lock_));
	}
	
	operator bool() const { return locked_; }
	
private:
	T& window_;	
	bool locked_;
};

template<typename Base>
class update_lockable
{
public:
	update_lockable() :
		update_lock_(0),
		notify_lock_(0)
	{}

	bool test_notification_lock()
	{
		//mutex_t::scoped_lock lock(mutex_);

		//logger.post(new event_type(event_logger::info, 
		//	boost::wformat(L"Notification lock state %1%") % notify_lock_));

		return (notify_lock_ == 0);
	}

private:
	mutable int update_lock_;
	mutable int notify_lock_;
	mutable mutex_t mutex_;
//	friend class mutex_update_lock<Base>;	
//	friend class try_update_lock<Base>;	

	friend class notification_lock<Base>;
};

}

#endif