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();
}
 
    }
}