avedit/ScopeLock.h at master · marlonext/avedit · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#pragma once

#include <Windows.h>

class CCS
{
public:
  CCS()
  {
    ::InitializeCriticalSection(&m_cs);
  }
  ~CCS()
  {
    ::DeleteCriticalSection(&m_cs);
  }

  void Wait()
  {
    ::EnterCriticalSection(&m_cs);
  }

  void Signal()
  {
    ::LeaveCriticalSection(&m_cs);
  }


private:

  CRITICAL_SECTION m_cs;
};

class CAutoLock
{
public:
  CAutoLock(CCS& cs)
    :m_cs(cs)
  {
    m_cs.Wait();
  }

  ~CAutoLock()
  {
    m_cs.Signal();
  }

private:
  CCS& m_cs;
};

// class PReadWriteMutex
// {
//   public:
//     PReadWriteMutex();
//     void StartRead();
//     void EndRead();
//     void StartWrite();
//     void EndWrite();
//
//   protected:
//     PSemaphore readerSemaphore;
//     PMutex     readerMutex;
//     unsigned   readerCount;
//     PMutex     starvationPreventer;
//
//     PSemaphore writerSemaphore;
//     PMutex     writerMutex;
//     unsigned   writerCount;
//
//     class Nest
//     {
//       Nest() { readerCount = writerCount = 0; }
//       unsigned readerCount;
//       unsigned writerCount;
//     };
//     PDictionary<POrdinalKey, Nest> nestedThreads;
//     PMutex                         nestingMutex;
//
//     Nest * GetNest() const;
//     Nest & StartNest();
//     void EndNest();
//     void InternalStartRead();
//     void InternalEndRead();
// };

class CMutexLock
{
public:
  CMutexLock()
  {
    m_hMutex = ::CreateMutex(nullptr, TRUE, nullptr);
  }

  ~CMutexLock()
  {
    ::CloseHandle(m_hMutex);
  }

  DWORD Wait()
  {
    return ::WaitForSingleObject(m_hMutex, INFINITE);
  }

  DWORD Wait(DWORD dwMillSecs)
  {
    return ::WaitForSingleObject(m_hMutex, dwMillSecs);
  }

  void Signal()
  {
    ::ReleaseMutex(m_hMutex);
  }

private:
  HANDLE m_hMutex;
};

class CReadLock
{
public:
  CReadLock(CMutexLock& lock)
    :m_lock(lock)
  {
    m_lock.Wait();
  }

  ~CReadLock()
  {
    m_lock.Signal();
  }

private:
  CMutexLock& m_lock;
};