Deliver/include/ScopeLock.h

#pragma once
#include <pthread.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <cstring>
#include <cerrno>
#include <iostream>
#include <cassert>

class CCriticalSec {
public:
    CCriticalSec() {
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
        int result = pthread_mutex_init(&m_mutex, &attr);
        pthread_mutexattr_destroy(&attr);

        if (result != 0) {
            std::cerr << "pthread_mutex_init failed: " << strerror(result) << std::endl;
            assert(false);
        }
    }

    ~CCriticalSec() {
        int result = pthread_mutex_destroy(&m_mutex);
        if (result != 0) {
            std::cerr << "pthread_mutex_destroy failed: " << strerror(result) << std::endl;
        }
    }

    void Lock() {
        int result = pthread_mutex_lock(&m_mutex);
        if (result != 0) {
            std::cerr << "pthread_mutex_lock failed: " << strerror(result) << std::endl;
            assert(false);
        }
    }

    void Unlock() {
        int result = pthread_mutex_unlock(&m_mutex);
        if (result != 0) {
            std::cerr << "pthread_mutex_unlock failed: " << strerror(result) << std::endl;
            assert(false);
        }
    }

private:
    pthread_mutex_t m_mutex;
};

class CScopeLock {
public:
    explicit CScopeLock(CCriticalSec& cs) : m_cs(cs) {
        m_cs.Lock();
    }

    ~CScopeLock() {
        m_cs.Unlock();
    }

    // ½ûÖ¹¿½±´ºÍ¸³Öµ
    CScopeLock(const CScopeLock&) = delete;
    CScopeLock& operator=(const CScopeLock&) = delete;

private:
    CCriticalSec& m_cs;
};