blob: 94d5d11495297e1d168e5f42871b9532e50b3d50 (
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
|
// -*- C++ -*-
//=============================================================================
/**
* @file Resource_Factory.h
*
* $Id$
*
* @author Chris CleelandCarlos O'Ryan
*/
//=============================================================================
#ifndef TAO_RESOURCE_FACTORY_H
#define TAO_RESOURCE_FACTORY_H
#include "ace/pre.h"
#include "ace/Service_Object.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "tao/TAO_Export.h"
#include "tao/Pluggable.h"
#include "tao/Protocol_Factory.h"
#include "tao/orbconf.h"
#include "ace/Unbounded_Set.h"
class TAO_Acceptor_Registry;
class TAO_Connector_Registry;
class TAO_Reactor_Registry;
class TAO_Priority_Mapping;
// ****************************************************************
class TAO_Export TAO_Protocol_Item
{
public:
/// creator method, the protocol name can only be set when the
/// object is created.
TAO_Protocol_Item (const ACE_CString &name);
/// destructor that deallocates the factory object if the
/// Protocol_Item retains ownership.
~TAO_Protocol_Item (void);
/// return a reference to the character representation of the protocol
/// factories name.
const ACE_CString &protocol_name (void);
/// return a pointer to the protocol factory.
TAO_Protocol_Factory *factory (void);
/// set the factory pointer's value.
void factory (TAO_Protocol_Factory *factory, int owner = 0);
private:
// Prohibited
ACE_UNIMPLEMENTED_FUNC (TAO_Protocol_Item (const TAO_Protocol_Item&))
ACE_UNIMPLEMENTED_FUNC (void operator= (const TAO_Protocol_Item&))
private:
/// protocol factory name.
ACE_CString name_;
/// pointer to factory object.
TAO_Protocol_Factory *factory_;
/// whether we own (and therefore have to delete) the factory object.
int factory_owner_;
};
// typedefs for containers containing the list of loaded protocol
// factories.
typedef ACE_Unbounded_Set<TAO_Protocol_Item*>
TAO_ProtocolFactorySet;
typedef ACE_Unbounded_Set_Iterator<TAO_Protocol_Item*>
TAO_ProtocolFactorySetItor;
// ****************************************************************
/**
* @class TAO_Resource_Factory
*
* @brief Factory which manufacturers resources for use by the ORB Core.
*
* This class is a factory/repository for critical ORB Core
* resources.
*/
class TAO_Export TAO_Resource_Factory : public ACE_Service_Object
{
public:
enum Caching_Strategy
{
// Least Recently Used
LRU,
// Least Frequently Used
LFU,
// First In First Out
FIFO,
// Dont use any strategy.
NOOP
};
// = Initialization and termination methods.
TAO_Resource_Factory (void);
virtual ~TAO_Resource_Factory (void);
// = Resource Retrieval
/// @@ Backwards compatibility, return 1 if the ORB core should use
/// TSS resources
virtual int use_tss_resources (void) const;
/// @@ Backwards compatibility, return 1 if the ORB core should use
/// Locked_Data_Blocks
virtual int use_locked_data_blocks (void) const;
/// Create the reactor holder, an strategy to control the number of
/// reactors in the ORB
virtual TAO_Reactor_Registry *get_reactor_registry (void);
/// Return an <ACE_Reactor> to be utilized.
virtual ACE_Reactor *get_reactor (void);
/// Reclaim reactor resources (e.g. deallocate, etc).
virtual void reclaim_reactor (ACE_Reactor *reactor);
/// return a reference to the acceptor registry.
virtual TAO_Acceptor_Registry *get_acceptor_registry (void);
/// Return an Connector to be utilized.
virtual TAO_Connector_Registry *get_connector_registry (void);
/// Access the input CDR allocators.
virtual ACE_Allocator* input_cdr_dblock_allocator (void);
virtual ACE_Allocator* input_cdr_buffer_allocator (void);
/// Access the output CDR allocators.
virtual ACE_Allocator* output_cdr_dblock_allocator (void);
virtual ACE_Allocator* output_cdr_buffer_allocator (void);
/**
* The protocol factory list is implemented in this class since
* a) it will be a global resource and
* b) it is initialized at start up and then not altered.
* Returns a container holding the list of loaded protocols.
*/
virtual TAO_ProtocolFactorySet *get_protocol_factories (void);
/**
* this method will loop through the protocol list and
* using the protocol name field this method will
* retrieve a pointer to the associated protocol factory
* from the service configurator. It is assumed
* that only one thread will call this method at ORB initialization.
* NON-THREAD-SAFE
*/
virtual int init_protocol_factories (void);
/// This accesses the connection caching strategy we use for managing
/// purging of unused entries from the connection cache on demnad.
virtual Caching_Strategy connection_caching_strategy_type (void) const;
/// This denotes the amount of entries to remove from the connection
/// cache.
virtual double purge_percentage (void) const;
/// Configure the priority mapping for the ORB
virtual TAO_Priority_Mapping *get_priority_mapping (void);
virtual int get_parser_names (char **&names,
int &number_of_names);
/// Creates the lock for the lock needed in the Cache Map
virtual ACE_Lock *create_cached_connection_lock (void);
protected:
/**
* Loads the default protocols. This method is used so that the
* advanced_resource.cpp can call the one in default_resource.cpp
* without calling unnecessary functions.
*/
virtual int load_default_protocols (void);
};
#include "ace/post.h"
#endif /* TAO_RESOURCE_FACTORY_H */
|
