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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// cos
//
// = FILENAME
// CC_LockSet.cpp
//
// = AUTHOR
// Torben Worm <tworm@cs.wustl.edu>
//
// ============================================================================
#include "CC_LockSet.h"
// Default constructor. We cannot create the lock at this point
// because we are not locking anything, and we do not know the mode of
// the lock. In a full fledged version the lock set (implementation)
// will be instantiated here
CC_LockSet::CC_LockSet (void)
: lock_ (0),
related_lockset_ (0)
{
// Do nothing
}
// Constructor used to create related lock sets.
CC_LockSet::CC_LockSet (CosConcurrencyControl::LockSet_ptr related)
: lock_ (0),
related_lockset_ (related)
{
// Do nothing
}
// Destructor. Remove the lock if it exists. In a later version the
// lock set must be removed here. Actually if all locks have been
// unlocked no lock instances should exist at this point.
CC_LockSet::~CC_LockSet (void)
{
if (lock_!=0)
delete lock_;
lock_ = 0;
}
// Locks the lock in the desired mode. Blocks until success. In a
// later version the lock set should be searched for incompatible
// locks.
void
CC_LockSet::lock (CosConcurrencyControl::lock_mode mode,
CORBA::Environment &_env)
{
ACE_DEBUG ((LM_DEBUG, "CC_LockSet::lock\n"));
if (lock_ == 0)
{
ACE_NEW (lock_, CC_Lock (mode));
if (errno == ENOMEM)
{
_env.clear ();
_env.exception (new CORBA::NO_MEMORY (CORBA::COMPLETED_NO));
_env.print_exception ("CC_Lock::lock ()");
}
}
TAO_TRY
{
lock_->lock (TAO_TRY_ENV);
TAO_CHECK_ENV;
}
TAO_CATCHANY
{
TAO_RETHROW;
}
TAO_ENDTRY;
}
// Tries to lock. If it is not possible false is returned. Comments
// for lock holds for later version.
CORBA::Boolean
CC_LockSet::try_lock (CosConcurrencyControl::lock_mode mode,
CORBA::Environment &_env)
{
CORBA::Boolean success = CORBA::B_TRUE;
ACE_DEBUG ((LM_DEBUG,
"CC_LockSet::try_lock\n"));
TAO_TRY
{
success = lock_->try_lock (TAO_TRY_ENV);
TAO_CHECK_ENV;
}
TAO_CATCHANY
{
TAO_RETHROW_RETURN (CORBA::B_FALSE);
}
TAO_ENDTRY;
return success;
}
// Drops the specified lock. In this simple case we have only one lock
// at any time so we just drop that lock.
void
CC_LockSet::unlock (CosConcurrencyControl::lock_mode mode,
CORBA::Environment &_env)
{
ACE_DEBUG ((LM_DEBUG,
"CC_LockSet::unlock\n"));
TAO_TRY
{
lock_->unlock (TAO_TRY_ENV);
TAO_CHECK_ENV;
}
TAO_CATCHANY
{
TAO_RETHROW;
}
TAO_ENDTRY;
}
// Changes the mode of a held lock. In this version we deal with only
// one type of lock (in reality) and therefore the type is of no
// meaning.
void
CC_LockSet::change_mode (CosConcurrencyControl::lock_mode held_mode,
CosConcurrencyControl::lock_mode new_mode,
CORBA::Environment &_env)
{
ACE_DEBUG ((LM_DEBUG,
"CC_LockSet::change_mode\n"));
TAO_TRY
{
lock_->change_mode (new_mode, TAO_TRY_ENV);
TAO_CHECK_ENV;
}
TAO_CATCHANY
{
TAO_RETHROW;
}
TAO_ENDTRY;
}
|
