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
|
// This may look like C, but it's really -*- C++ -*-
// $Id$
#include "tao/MProfile.h"
#include "tao/Pluggable.h"
ACE_RCSID(tao, MProfile, "$Id$")
#if !defined (__ACE_INLINE__)
# include "tao/MProfile.i"
#endif /* __ACE_INLINE__ */
void
TAO_MProfile::cleanup (void)
{
if (this->pfiles_ != 0)
{
for (TAO_PHandle i = 0; i < this->last_; ++i)
if (this->pfiles_[i])
this->pfiles_[i]->_decr_refcnt ();
}
delete [] this->pfiles_;
this->pfiles_ = 0;
this->current_ = 0;
this->size_ = 0;
this->last_ = 0;
}
int
TAO_MProfile::set (CORBA::ULong sz)
{
if (sz == 0)
{
this->cleanup ();
return 0;
}
// See if we already have an existing profile list or if we need to
// get ridof what we have. @@ Fred, please be consistent with your
// use of this-> as a prefix for data members.
if (this->size_ != 0)
{
// Release all of our profiles.
for (TAO_PHandle h = 0;
h < this->size_;
h++)
if (this->pfiles_[h])
{
this->pfiles_[h]->_decr_refcnt ();
this->pfiles_[h] = 0;
}
// Next see if we can reuse our profile list memory
if (this->size_ != sz)
{
// we cant reuse memory since the array sized are different!
// @@ Fred: if sz < this->size_ you could avoid this memory
// allocation, you only need another flag to keep the
// "capacity".
delete [] this->pfiles_;
ACE_NEW_RETURN (this->pfiles_,
TAO_Profile_ptr[sz],
-1);
}
}
else
// first time, initialize!
ACE_NEW_RETURN (this->pfiles_,
TAO_Profile_ptr [sz],
-1);
this->size_ = sz;
this->last_ = 0;
this->current_ = 0;
#if 0
// @@ Fred: this does *not* work, the literal 0 is the null pointer,
// but the bit representation may be something else.
ACE_OS::memset (this->pfiles_,
0,
sizeof (TAO_Profile_ptr) * sz);
#else
for (TAO_PHandle i = 0; i != this->size_; ++i)
this->pfiles_[i] = 0;
#endif
// @@ since we are being reset, get rid of forward references!
// if (forward_from_)
// delete forward_from_;
return this->size_;
}
int
TAO_MProfile::set (const TAO_MProfile &mprofile)
{
// NOTE: We use mprofile->last_ instead of mprofile->size_ to set
// this->size_. This is so we can use set () to trim a profile
// list!!
this->set (mprofile.last_);
// set indexes ...
this->last_ = mprofile.last_;
// These are set in set (ULong);
// this->current_ = 0;
// this->forward_from_ = 0;
// Now reference all profiles.
for (TAO_PHandle h = 0; h < this->size_; h++)
{
this->pfiles_[h] = mprofile.pfiles_[h];
if (this->pfiles_[h] != 0)
this->pfiles_[h]->_incr_refcnt ();
}
//
// @@ Fred: here was a gross violation of the invariants for this
// class: if the forward_from_ is owned by us (we call delete all
// the time on it) we cannot share it with mprofile.
//
// if (mprofile->forward_from_)
// this->forward_from_ = mprofile->forward_from_;
return 1;
}
int
TAO_MProfile::add_profile (TAO_Profile *pfile)
{
// skip by the used slots
if (last_ == size_) // full!
return -1;
pfiles_[last_++] = pfile;
if (pfile && pfile->_incr_refcnt () == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Unable to increment reference count in add_profile!\n"),
-1);
return last_ - 1;
}
CORBA::Boolean
TAO_MProfile::is_equivalent (TAO_MProfile *first,
TAO_MProfile *second,
CORBA::Environment &env)
{
// Two profile lists are equivalent iff at least one of the profiles
// form the first list is_equivalent to at least one of the profiles
// from the second list!!
TAO_Profile_ptr *pfiles1 = first->pfiles ();
TAO_Profile_ptr *pfiles2 = second->pfiles ();
TAO_PHandle first_cnt = first->profile_count ();
TAO_PHandle second_cnt = second->profile_count ();
for (TAO_PHandle h1 = 0; h1 < first_cnt;h1++)
for (TAO_PHandle h2 = 0; h2 < second_cnt; h2++ )
if (pfiles1[h1]->is_equivalent (pfiles2[h2], env))
return 1;
return 0;
}
CORBA::ULong
TAO_MProfile::hash (CORBA::ULong max, CORBA::Environment &env)
{
CORBA::ULong hashval = 0;
if (last_ == 0)
return 0;
for (TAO_PHandle h=0; h < last_ ; h++)
hashval += pfiles_[h]->hash (max, env);
// The above hash function return an ULong between 0 and max here we
// simply take the average value and round.
return hashval / last_;
}
|
