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
|
/* $Id$ */
#ifndef __PJPP_LOCK_H__
#define __PJPP_LOCK_H__
#include <pj++/types.hpp>
#include <pj/lock.h>
#include <pj++/pool.hpp>
//////////////////////////////////////////////////////////////////////////////
// Lock object.
//
class Pj_Lock : public Pj_Object
{
public:
//
// Constructor.
//
explicit Pj_Lock(pj_lock_t *lock)
: lock_(lock)
{
}
//
// Destructor.
//
~Pj_Lock()
{
if (lock_)
pj_lock_destroy(lock_);
}
//
// Get pjlib compatible lock object.
//
pj_lock_t *pj_lock_t_()
{
return lock_;
}
//
// acquire lock.
//
pj_status_t acquire()
{
return pj_lock_acquire(lock_);
}
//
// release lock,.
//
pj_status_t release()
{
return pj_lock_release(lock_);
}
protected:
pj_lock_t *lock_;
};
//////////////////////////////////////////////////////////////////////////////
// Null lock object.
//
class Pj_Null_Lock : public Pj_Lock
{
public:
//
// Default constructor.
//
explicit Pj_Null_Lock(Pj_Pool *pool, const char *name = NULL)
: Pj_Lock(NULL)
{
pj_lock_create_null_mutex(pool->pool_(), name, &lock_);
}
};
//////////////////////////////////////////////////////////////////////////////
// Simple mutex lock object.
//
class Pj_Simple_Mutex_Lock : public Pj_Lock
{
public:
//
// Default constructor.
//
explicit Pj_Simple_Mutex_Lock(Pj_Pool *pool, const char *name = NULL)
: Pj_Lock(NULL)
{
pj_lock_create_simple_mutex(pool->pool_(), name, &lock_);
}
};
//////////////////////////////////////////////////////////////////////////////
// Recursive mutex lock object.
//
class Pj_Recursive_Mutex_Lock : public Pj_Lock
{
public:
//
// Default constructor.
//
explicit Pj_Recursive_Mutex_Lock(Pj_Pool *pool, const char *name = NULL)
: Pj_Lock(NULL)
{
pj_lock_create_recursive_mutex(pool->pool_(), name, &lock_);
}
};
//////////////////////////////////////////////////////////////////////////////
// Semaphore lock object.
//
class Pj_Semaphore_Lock : public Pj_Lock
{
public:
//
// Default constructor.
//
explicit Pj_Semaphore_Lock(Pj_Pool *pool,
unsigned max=PJ_MAXINT32,
unsigned initial=0,
const char *name=NULL)
: Pj_Lock(NULL)
{
pj_lock_create_semaphore(pool->pool_(), name, initial, max, &lock_);
}
};
#endif /* __PJPP_LOCK_H__ */
|
