blob: 993cc36de11c63d28038b87c8ced1c525a239223 (
plain)
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
|
// -*- C++ -*-
//=============================================================================
/**
* @file Cache_Entries.h
*
* $Id$
*
*
* @author Bala Natarajan <bala@cs.wustl.edu>
*/
//=============================================================================
#ifndef TAO_CACHE_ENTRIES_H
#define TAO_CACHE_ENTRIES_H
#include /**/ "ace/pre.h"
#include "tao/Transport_Descriptor_Interface.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
class TAO_Transport;
#ifdef index
# undef index
#endif /* index */
namespace TAO
{
/// States of a recyclable object.
/// @@todo: A lifecycle needs to be designed. It can wait for
/// sometime.
enum Cache_Entries_State
{
/// Idle and can be purged.
ENTRY_IDLE_AND_PURGABLE,
/// Idle but cannot be purged.
ENTRY_IDLE_BUT_NOT_PURGABLE,
/// Can be purged, but is not idle (mostly for debugging).
ENTRY_PURGABLE_BUT_NOT_IDLE,
/// Busy (i.e., cannot be recycled or purged).
ENTRY_BUSY,
/// Closed.
ENTRY_CLOSED,
/// Unknown state.
ENTRY_UNKNOWN
};
/**
* @class Cache_IntId
*
* @brief Helper class for TAO_Transport_Cache_Manager
*
* Helper class that wraps the <value> part of the Map or
* table holding the Transport state.: unifies data items, so
* they can be stored together as a <value> for a <key> in a
* table holding the state of the Transport Cache.
*/
class TAO_Export Cache_IntId
{
public:
/// Constructor.
Cache_IntId (void);
/// Constructor.
Cache_IntId (TAO_Transport *transport);
/// Copy constructor.
Cache_IntId (const Cache_IntId & rhs);
/// Destructor.
~Cache_IntId (void);
/// Assignment operator (does copy memory).
Cache_IntId& operator= (const Cache_IntId &rhs);
/// Equality comparison operator (must match both id_ and kind_).
bool operator== (const Cache_IntId &rhs) const;
/// Inequality comparison operator.
bool operator!= (const Cache_IntId &rhs) const;
/// Return the underlying transport
TAO_Transport *transport (void);
/// Return the underlying transport
const TAO_Transport *transport (void) const;
/// Set <recycle_state>.
void recycle_state (Cache_Entries_State new_state);
/// Get <recycle_state>.
Cache_Entries_State recycle_state (void);
/// Relinquish ownership of the TAO_Transport object associated with
/// this Cache_IntId.
/**
* @note This method should go away once the
* Transport_Cache_Map_Manager is improved so that it returns
* TAO_Transport objects when performing a find() operation.
* This method really only exists to get around inadequacies
* in the Transport_Cache_Map_Manager interface.
*/
TAO_Transport *relinquish_transport (void);
private:
/// The transport that needs to be cached.
TAO_Transport *transport_;
/// The state of the handle
Cache_Entries_State recycle_state_;
};
/**
* @class Cache_ExtId
*
* @brief Helper class for TAO_Transport_Cache_Manager: unifies
* several data items, so they can be stored together as a
* <value> for a <key> in a hash table holding the state of the
* Transport Cache.
*/
class TAO_Export Cache_ExtId
{
public:
/// Constructor.
Cache_ExtId (void);
/// Constructor.
Cache_ExtId (TAO_Transport_Descriptor_Interface *prop);
/// Copy constructor.
Cache_ExtId (const Cache_ExtId & rhs);
/// Destructor.
~Cache_ExtId (void);
// = Assignment and comparison operators.
/// Assignment operator (does copy memory).
Cache_ExtId& operator= (const Cache_ExtId &rhs);
/// Equality comparison operator (must match both id_ and kind_).
bool operator== (const Cache_ExtId &rhs) const;
/// Inequality comparison operator.
bool operator!= (const Cache_ExtId &rhs) const;
/// <hash> function is required in order for this class to be usable by
/// ACE_Hash_Map_Manager_Ex.
u_long hash (void) const;
/// Make a deep copy of the underlying pointer
void duplicate (void);
/// Return the index value
CORBA::ULong index (void) const;
/// Set the index value. This calls should not be used by any users
/// but for the TAO_Transport_Cache_Manager class.
void index (CORBA::ULong index);
/// Increment the index value
void incr_index (void);
// = Accessors
/// Get the underlying the property pointer
TAO_Transport_Descriptor_Interface *property (void) const;
private:
/// A property object that we represent.
TAO_Transport_Descriptor_Interface *transport_property_;
/// Do we need to delete transport_property?
CORBA::Boolean is_delete_;
/**
* This is a supplementary index. Would be set to zero by
* default. Would be altered by the Transport_Cache of TAO. Please
* see the documentation of TAO_Transport_Cache_Manager for
* details.
*/
CORBA::ULong index_;
};
}
TAO_END_VERSIONED_NAMESPACE_DECL
#if defined (__ACE_INLINE__)
# include "tao/Cache_Entries.inl"
#endif /* __ACE_INLINE__ */
#include /**/ "ace/post.h"
#endif /* TAO_CACHE_ENTRIES_H */
|
