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
|
// This may look like C, but it's really -*- C++ -*-
// $Id$
// ============================================================================
//
// = LIBRARY
// TAO
//
// = FILENAME
// UIOP_Connector.h
//
// = DESCRIPTION
// UIOP specific connector processing
//
// = AUTHOR
// Fred Kuhns <fredk@cs.wustl.edu>
// Ossama Othman <othman@cs.wustl.edu>
//
// ============================================================================
#ifndef TAO_UIOP_CONNECTOR_H
#define TAO_UIOP_CONNECTOR_H
#include "ace/pre.h"
#include "tao/Pluggable.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
# if TAO_HAS_UIOP == 1
#include "ace/Connector.h"
#include "ace/LSOCK_Connector.h"
#include "tao/UIOP_Connect.h"
#include "tao/Resource_Factory.h"
#if defined (TAO_USES_ROBUST_CONNECTION_MGMT)
#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ < 8
#define ACE_HAS_BROKEN_EXTENDED_TEMPLATES
#endif /* __GNUC__ */
#include "ace/Cached_Connect_Strategy_T.h"
#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */
typedef ACE_Strategy_Connector<TAO_UIOP_Client_Connection_Handler,
ACE_LSOCK_CONNECTOR>
TAO_UIOP_BASE_CONNECTOR;
// ****************************************************************
class TAO_Export TAO_UIOP_Connect_Creation_Strategy : public ACE_Creation_Strategy<TAO_UIOP_Client_Connection_Handler>
{
// = TITLE
// Helper creation strategy
//
// = DESCRIPTION
// Creates UIOP_Client_Connection_Handler objects but satisfies
// the interface required by the
// ACE_Creation_Strategy<TAO_UIOP_Client_Connection_Handler>
//
public:
TAO_UIOP_Connect_Creation_Strategy (ACE_Thread_Manager * = 0,
TAO_ORB_Core* orb_core = 0,
CORBA::Boolean flag = 0);
virtual int make_svc_handler (TAO_UIOP_Client_Connection_Handler *&sh);
// Makes TAO_UIOP_Client_Connection_Handlers
private:
TAO_ORB_Core* orb_core_;
// The ORB
CORBA::Boolean lite_flag_;
// Are we using lite?
};
// ****************************************************************
class TAO_Export TAO_UIOP_Connector : public TAO_Connector
{
// = TITLE
// UIOP-specific Connector bridge for pluggable protocols.
//
// = DESCRIPTION
//
public:
// = Initialization and termination methods.
TAO_UIOP_Connector (CORBA::Boolean flag = 0);
// Constructor.
// @@ Do we want to pass in the tag here or should it be statically
// defined?
// = The TAO_Connector methods, please check the documentation on
// Pluggable.h
int open (TAO_ORB_Core *orb_core);
int close (void);
int connect (TAO_Profile *profile,
TAO_Transport *&transport,
ACE_Time_Value *max_wait_time);
int preconnect (const char *preconnections);
TAO_Profile *create_profile (TAO_InputCDR& cdr);
virtual int check_prefix (const char *endpoint);
virtual char object_key_delimiter (void) const;
#if defined (TAO_USES_ROBUST_CONNECTION_MGMT)
virtual int purge_connections (void);
// Purge "old" connections.
#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */
protected:
// = More TAO_Connector methods, please check the documentation on
// Pluggable.h
virtual void make_profile (const char *endpoint,
TAO_Profile *&,
CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ());
#if defined (TAO_USES_ROBUST_CONNECTION_MGMT)
virtual int make_caching_strategy (void);
// According to the option specified, create the appropriate caching
// strategy used for purging unused connections from the connection
// cache.
#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */
public:
#if defined (TAO_USES_ROBUST_CONNECTION_MGMT)
// = Connection Caching Strategy.
typedef size_t TAO_ATTRIBUTES;
typedef ACE_Pair<TAO_UIOP_Client_Connection_Handler *,
TAO_ATTRIBUTES>
TAO_CACHED_HANDLER;
typedef ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr>
TAO_IADDR;
typedef ACE_Hash<TAO_IADDR> TAO_HASH_KEY;
typedef ACE_Equal_To<TAO_IADDR> TAO_COMPARE_KEYS;
typedef ACE_Hash_Map_Manager_Ex<TAO_IADDR,
TAO_CACHED_HANDLER,
TAO_HASH_KEY,
TAO_COMPARE_KEYS,
ACE_Null_Mutex>
TAO_HASH_MAP;
typedef ACE_Hash_Map_Iterator_Ex<TAO_IADDR,
TAO_CACHED_HANDLER,
TAO_HASH_KEY,
TAO_COMPARE_KEYS,
ACE_Null_Mutex>
TAO_HASH_MAP_ITERATOR;
typedef ACE_Hash_Map_Reverse_Iterator_Ex<TAO_IADDR,
TAO_CACHED_HANDLER,
TAO_HASH_KEY,
TAO_COMPARE_KEYS,
ACE_Null_Mutex>
TAO_HASH_MAP_REVERSE_ITERATOR;
typedef ACE_Refcounted_Recyclable_Handler_Caching_Utility<TAO_IADDR,
TAO_CACHED_HANDLER,
TAO_HASH_MAP,
TAO_HASH_MAP_ITERATOR,
TAO_ATTRIBUTES>
TAO_CACHING_UTILITY;
#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
typedef ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES,
TAO_CACHING_UTILITY>
TAO_CACHING_STRATEGY;
#else
typedef ACE_Caching_Strategy<TAO_ATTRIBUTES,
TAO_CACHING_UTILITY>
TAO_CACHING_STRATEGY;
#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
typedef ACE_Cached_Connect_Strategy_Ex<TAO_UIOP_Client_Connection_Handler,
ACE_LSOCK_CONNECTOR,
TAO_CACHING_STRATEGY,
TAO_ATTRIBUTES,
TAO_Cached_Connector_Lock>
TAO_CACHED_CONNECT_STRATEGY;
#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */
typedef ACE_NOOP_Creation_Strategy<TAO_UIOP_Client_Connection_Handler>
TAO_NULL_CREATION_STRATEGY;
typedef ACE_NOOP_Concurrency_Strategy<TAO_UIOP_Client_Connection_Handler>
TAO_NULL_ACTIVATION_STRATEGY;
private:
TAO_NULL_CREATION_STRATEGY null_creation_strategy_;
TAO_NULL_ACTIVATION_STRATEGY null_activation_strategy_;
TAO_UIOP_BASE_CONNECTOR base_connector_;
// The connector initiating connection requests for UIOP.
TAO_ORB_Core *orb_core_;
// ORB Core.
CORBA::Boolean lite_flag_;
// Do we need to use a GIOP_Lite for sending messages?
#if defined (TAO_USES_ROBUST_CONNECTION_MGMT)
TAO_CACHED_CONNECT_STRATEGY *cached_connect_strategy_;
// Cached connect strategy.
TAO_CACHING_STRATEGY *caching_strategy_;
// Caching strategy which decides the order of removal of entries
// from the connection cache.
#endif /* TAO_USES_ROBUST_CONNECTION_MGMT */
};
# endif /* TAO_HAS_UIOP == 1 */
#include "ace/post.h"
#endif /* TAO_UIOP_CONNECTOR_H */
|
