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$
// ============================================================================
//
// = LIBRARY
// TAO
//
// = FILENAME
// MProfile.h
//
// = DESCRIPTION
// Keep track of profile lists
//
// = AUTHOR
// Fred Kuhns <fredk@cs.wustl.edu>
//
// ============================================================================
#ifndef TAO_MPROFILE_H
#define TAO_MPROFILE_H
#include "tao/corbafwd.h"
#include "tao/Pluggable.h"
// @@ Fred, this definitions are of very little use, can you make them
// local to the Profile class so we don't pollute the global
// namespace
typedef TAO_Profile *TAO_Profile_ptr;
typedef CORBA::ULong TAO_PHandle;
class TAO_Export TAO_MProfile
{
// = TITLE
// This class implements the basic interface for supporting
// multiple profiles.
//
// = DESCRIPTION
// Multiple profiles can be treated either as a circular queue or
// a linear array of profiles.
//
// It is assumed that locking will only be required when a profile
// list is associated with a TAO_Stub. Thus when the
// TAO_Stub accepts ownership of an MProfile it also assumes
// responsibility for controling access (i.e. locking).
public:
// = Initalization and termination methods.
TAO_MProfile (CORBA::ULong sz);
TAO_MProfile (const TAO_MProfile &mprofiles);
// **NOTE: IF mprofiles->last_ > 0, THEN this->size_ will be set to
// mprofiles->last_. Otherwise this->size_ - mprofiles->size_.
// Furthermore, current_ is set back to 0! i.e. rewound.
// The reference count on any profiles in mprofiles is increment
// when their references (i.e. pointers) are copied.
TAO_MProfile& operator= (const TAO_MProfile& mprofiles);
// Assigment operator.
~TAO_MProfile (void);
// Destructor: decrements reference count on all references
// profiles!
int set (CORBA::ULong sz);
// Inits MProfile to hold sz TAO_Profiles.
// NOT THREAD SAFE
int set (const TAO_MProfile &mprofile);
// Inits this to the values of 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!!
// NOT THREAD SAFE
int grow (CORBA::ULong sz);
// increate the number of profiles this object can hold.
// NOT THREAD SAFE
TAO_Profile_ptr get_cnext (void);
// Treat as a circular list.
TAO_Profile_ptr get_next (void);
// Get next profile in list, return 0 at end of list.
TAO_Profile_ptr get_cprev (void);
// Assume a circular list of profiles.
TAO_Profile_ptr get_prev (void);
// Get previous profile, stop at beginning of list and return 0.
TAO_Profile_ptr get_current_profile (void);
// Return a pointer to the current profile, will not increment
// reference pointer.
TAO_Profile_ptr get_profile (TAO_PHandle handle);
// Return a pointer to the profile referenced by handle void.
// rem_profile (TAO_PHandle handle); let's wait.
TAO_PHandle get_current_handle (void);
// Returns the index for the current profile.
CORBA::ULong profile_count (void) const;
// Returns the number of profiles stored in the list (last_+1).
CORBA::ULong size (void) const;
// return the maximum number of profiles that can be stored in this
// container, (size_+1)
const TAO_Profile* get_profile (CORBA::ULong index) const;
// Return the profile at position <index>.
// If <index> is out of range it returns 0.
void rewind (void);
// Sets the current index back to 0.
int add_profile (TAO_Profile_ptr pfile);
// Return the index of this entry or -1 if it can not be added.
// reference count on profile in incremented!
int give_profile (TAO_Profile_ptr pfile);
// Return the index of this entry or -1 if it can not be added.
// this object assumes ownership of this profile!!
void forward_from (TAO_MProfile *mprofiles);
// Set a pointer to the MProfile whose 'current' TAO_Profile was
// forwarded This object is the set of forwarding profiles.
TAO_MProfile *forward_from (void);
// Returns a pointer to the profile which was forwarded.
CORBA::Boolean is_equivalent (TAO_MProfile *rhs,
CORBA::Environment &env);
// Returns true of there is at least one profile in first which
// is_equivalent with at least one profile in second. @@ FRED: The
// lost should be locked for this!
// Yes, the Stub object has been the only object that manipulated
// these list and thus it took care of locking. This is changing
// though so we may have to add a lock to this list. Althouch I
// really don't want to.
CORBA::ULong hash (CORBA::ULong max,
CORBA::Environment &env);
// use all registered profiles. The hash() method is called on each
// profile and the results are averaged together.
// @@ FRED: The list should be locked for this!
// See above comment.
protected:
TAO_Profile_ptr *pfiles (void) const;
// return the complete list of profiles, this object retains
// ownership!
private:
void cleanup (void);
// Helper method to implement the destructor
private:
TAO_MProfile *forward_from_;
// Used for chaning references when the current profile is
// forwarded. Note, this will only be valid for an MProfile which
// contains a list of forward_profiles for some initial or base
// profile. This is a backward reference to the profile list which
// received the relocate message. The actual profile what was
// forwarded will be forward_from_->get_current_profile ()
TAO_Profile_ptr *pfiles_;
// Actual list of profiles.
TAO_PHandle current_;
// Points to the next profile to be used. 0 ... size_
TAO_PHandle size_;
// Max size of array
TAO_PHandle last_;
// Index plus 1 of last valid entry! May be < size_.
};
#if defined (__ACE_INLINE__)
# include "tao/MProfile.i"
#endif /* __ACE_INLINE__ */
#endif /* TAO_MPROFILE_H */
|
