mutex_std_thread.h

#include "mutex.h"
#include "common_std_thread.h"
#include <iostream>
 
namespace cgv {
        namespace os {
 
unsigned& ref_debug_lock_counter()
{
        static unsigned counter = 0;
        return counter;
}
 
mutex& ref_debug_mutex()
{
        static mutex m;
        return m;
}
 
unsigned mutex::get_debug_lock_counter()
{
        return ref_debug_lock_counter();
}
 
mutex::mutex()
{
        Mutex*& m_ptr = ((Mutex*&) pmutex);
        m_ptr = new Mutex();
}
 
mutex::~mutex()
{
        Mutex*& m_ptr = ((Mutex*&) pmutex);
        delete m_ptr;
}
 
void mutex::lock()
{
        Mutex& m = *((Mutex*&) pmutex);
        m.lock();
}
 
void mutex::unlock()
{
        Mutex& m = *((Mutex*&) pmutex);
        m.unlock();
}
 
void mutex::debug_lock(const std::string& info)
{
        ref_debug_mutex().lock();
        std::cout << info << ": wait for lock [" << this << ":" << get_debug_lock_counter() << "]" << std::endl;
        ++ref_debug_lock_counter();
        ref_debug_mutex().unlock();
        lock();
        ref_debug_mutex().lock();
        std::cout << info << ": received lock [" << this << "]" << std::endl;
        ref_debug_mutex().unlock();
}
void mutex::debug_unlock(const std::string& info)
{
        unlock();
        ref_debug_mutex().lock();
        std::cout << info << ": unlock        [" << this << "]" << std::endl;
        ref_debug_mutex().unlock();
}
 
bool mutex::try_lock()
{
        Mutex& m = *((Mutex*&) pmutex);
        return m.try_lock();
}
 
condition_mutex::condition_mutex()
{
        Mutex& m = *((Mutex*&) pmutex);
        Condition*& c_ptr = (Condition*&) pcond;
        c_ptr = new Condition(m);
}
 
condition_mutex::~condition_mutex()
{
        Condition*& c_ptr = (Condition*&) pcond;
        delete c_ptr;
}
 
void condition_mutex::send_signal()
{
        Condition& c = *((Condition*&) pcond);
        c.cv.notify_one();
}
 
void condition_mutex::send_signal_with_lock()
{
        lock();
        send_signal();
        unlock();
}
 
void condition_mutex::broadcast_signal()
{
        Condition& c = *((Condition*&) pcond);
        c.cv.notify_all();
}
 
void condition_mutex::broadcast_signal_with_lock()
{
        lock();
        broadcast_signal();
        unlock();
}
 
        }
}