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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
// $Id$
#include "tao/corba.h"
#if !defined (__ACE_INLINE__)
#include "tao/Sequence.i"
#endif /* __ACE_INLINE__ */
// *************************************************************
// Operations for class TAO_Base_Sequence
// *************************************************************
TAO_Base_Sequence::~TAO_Base_Sequence (void)
{
}
void TAO_Base_Sequence::_shrink_buffer (CORBA::ULong, CORBA::ULong)
{
// default is no op.
}
// *************************************************************
// Operations for class TAO_Unbounded_Base_Sequence
// *************************************************************
TAO_Unbounded_Base_Sequence::~TAO_Unbounded_Base_Sequence (void)
{
}
// *************************************************************
// Operations for class TAO_Bounded_Base_Sequence
// *************************************************************
TAO_Bounded_Base_Sequence::~TAO_Bounded_Base_Sequence (void)
{
}
// *************************************************************
// Operations for class TAO_String_Manager
// *************************************************************
// assignment
TAO_String_Manager&
TAO_String_Manager::operator=(const TAO_String_Manager &rhs)
{
if (this == &rhs)
return *this;
if (this->release_)
{
CORBA::string_free (*this->ptr_);
*this->ptr_ = CORBA::string_dup (*rhs.ptr_);
}
else
{
*this->ptr_ = *rhs.ptr_;
}
return *this;
}
// assignment from char*
TAO_String_Manager &
TAO_String_Manager::operator= (const char * p)
{
if (this->release_)
{
CORBA::string_free (*this->ptr_);
*this->ptr_ = CORBA::string_dup (p);
}
else
{
// @@ TODO find out why was this cast needed.
*this->ptr_ = ACE_const_cast(char*,p);
}
return *this;
}
// *************************************************************
// constructor for unbounded seq
TAO_Unbounded_String_Sequence::
TAO_Unbounded_String_Sequence (CORBA::ULong maximum)
: TAO_Unbounded_Base_Sequence (maximum,
TAO_Unbounded_String_Sequence::allocbuf (maximum))
{
}
TAO_Unbounded_String_Sequence::
TAO_Unbounded_String_Sequence (const TAO_Unbounded_String_Sequence &rhs)
: TAO_Unbounded_Base_Sequence (rhs)
{
char* *tmp1 = TAO_Unbounded_String_Sequence::allocbuf (this->maximum_);
char* *tmp2 = ACE_reinterpret_cast (char **, rhs.buffer_);
for (CORBA::ULong i = 0; i < rhs.length_; ++i)
tmp1[i] = CORBA::string_dup (tmp2[i]);
this->buffer_ = tmp1;
}
TAO_Unbounded_String_Sequence::~TAO_Unbounded_String_Sequence (void)
{
this->_deallocate_buffer ();
}
TAO_Unbounded_String_Sequence&
TAO_Unbounded_String_Sequence::
operator= (const TAO_Unbounded_String_Sequence &rhs)
{
if (this == &rhs)
return *this;
if (this->release_)
{
char **tmp = ACE_reinterpret_cast (char **, this->buffer_);
for (CORBA::ULong i = 0; i < this->length_; ++i)
{
CORBA::string_free (tmp[i]);
tmp[i] = 0;
}
if (this->maximum_ < rhs.maximum_)
{
// free the older buffer
TAO_Unbounded_String_Sequence::freebuf (tmp);
this->buffer_ =
TAO_Unbounded_String_Sequence::allocbuf (rhs.maximum_);
}
}
else
this->buffer_ =
TAO_Unbounded_String_Sequence::allocbuf (rhs.maximum_);
TAO_Unbounded_Base_Sequence::operator= (rhs);
char **tmp1 = ACE_reinterpret_cast (char **, this->buffer_);
char **tmp2 = ACE_reinterpret_cast (char **, rhs.buffer_);
for (CORBA::ULong i=0; i < rhs.length_; ++i)
tmp1[i] = CORBA::string_dup (tmp2[i]);
return *this;
}
char* *
TAO_Unbounded_String_Sequence::allocbuf (CORBA::ULong nelems)
{
char* *buf = new char*[nelems];
for (CORBA::ULong i=0; i < nelems; i++)
buf[i] = 0;
return buf;
}
void
TAO_Unbounded_String_Sequence::freebuf (char* *buffer)
{
if (buffer == 0)
return;
// {orbos/97-05-15:16.11}
// The freebuf function ensures that the destructor for each element
// is called before the buffer is destroyed, except for string
// elements, which are freed using string_free(), and object
// reference elements, which are freed using release(). The freebuf
// function will ignore null pointers passed to it.
// @@ How are we supposed to implement that! We don't know the
// length of the buffer here.
// Mark the length in the first four bytes? For the moment we let
// that be.
delete[] buffer;
}
void
TAO_Unbounded_String_Sequence::_allocate_buffer (CORBA::ULong length)
{
char* *tmp = TAO_Unbounded_String_Sequence::allocbuf (length);
if (this->buffer_ != 0)
{
char* *old = ACE_reinterpret_cast (char **, this->buffer_);
for (CORBA::ULong i = 0; i < this->length_; ++i)
// Only call duplicate when we did not own the previous
// buffer, since after this method we own it we must also
// own the objects. If we already own the objects there is
// no need to copy them, if we did we would also have to
// remove the old instances.
if (!this->release_)
tmp [i] = CORBA::string_dup (old[i]);
else
tmp [i] = old[i];
if (this->release_)
delete[] old;
}
this->buffer_ = tmp;
}
void
TAO_Unbounded_String_Sequence::_deallocate_buffer (void)
{
if (this->buffer_ == 0 || this->release_ == 0)
return;
char **tmp = ACE_reinterpret_cast (char **, this->buffer_);
for (CORBA::ULong i = 0;
i < this->length_;
++i)
{
CORBA::string_free (tmp[i]);
tmp[i] = 0;
}
TAO_Unbounded_String_Sequence::freebuf (tmp);
this->buffer_ = 0;
}
void
TAO_Unbounded_String_Sequence::_shrink_buffer (CORBA::ULong nl,
CORBA::ULong ol)
{
char **tmp = ACE_reinterpret_cast (char **, this->buffer_);
for (CORBA::ULong i = nl; i < ol; ++i)
{
CORBA::string_free (tmp[i]);
tmp[i] = 0;
}
}
|
