blob: eba011d1d26fa99866711b7f65f5c50f0956f80c (
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
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// Strategies.h
//
// = AUTHOR
// Doug Schmidt
//
// ============================================================================
#if !defined (ACE_STRATEGIES_H)
#define ACE_STRATEGIES_H
#include "ace/Event_Handler.h"
// Forward decls.
class ACE_Reactor;
class ACE_Export ACE_Notification_Strategy
{
// = TITLE
// Abstract class used for notifing an interested party
//
// = DESCRIPTION
// A vehicle for extending the behavior of ACE_Message_Queue wrt
// notification *without subclassing*. Thus, it's an example of
// the Bridge/Strategy patterns.
public:
ACE_Notification_Strategy (ACE_Event_Handler *eh,
ACE_Reactor_Mask mask);
virtual ~ACE_Notification_Strategy (void);
virtual int notify (void) = 0;
virtual int notify (ACE_Event_Handler *,
ACE_Reactor_Mask mask) = 0;
// Get/Set the event handler
ACE_Event_Handler *event_handler (void);
void event_handler (ACE_Event_Handler *eh);
// Get/Set the reactor mask
ACE_Reactor_Mask mask (void);
void mask (ACE_Reactor_Mask m);
protected:
ACE_Event_Handler *eh_;
ACE_Reactor_Mask mask_;
};
class ACE_Export ACE_Reactor_Notification_Strategy : public ACE_Notification_Strategy
{
// = TITLE
// Used to notify an ACE_Reactor
//
// = DESCRIPTION
// Integrates the ACE_Message_Queue notification into the
// ACE_Reactor::notify() method.
public:
ACE_Reactor_Notification_Strategy (ACE_Reactor *reactor,
ACE_Event_Handler *eh,
ACE_Reactor_Mask mask);
~ACE_Reactor_Notification_Strategy (void);
// Default dtor.
virtual int notify (void);
virtual int notify (ACE_Event_Handler *,
ACE_Reactor_Mask mask);
// Get/Set the reactor
ACE_Reactor *reactor (void);
void reactor (ACE_Reactor *r);
protected:
ACE_Reactor *reactor_;
};
class ACE_Export ACE_Connection_Recycling_Strategy
{
// = TITLE
// Defines the interface for a connection recycler.
public:
virtual ~ACE_Connection_Recycling_Strategy (void);
// Virtual Destructor
virtual int purge (const void *recycling_act) = 0;
// Remove from cache.
virtual int cache (const void *recycling_act) = 0;
// Add to cache.
virtual int mark_as_closed (const void *recycling_act) = 0;
// Mark as closed.
virtual int cleanup_hint (const void *recycling_act) = 0;
// Cleanup as hint.
protected:
ACE_Connection_Recycling_Strategy (void);
// Default ctor.
};
class ACE_Export ACE_Recyclable
{
public:
enum State
{
IDLE,
BUSY,
CLOSED,
UNKNOWN
};
virtual ~ACE_Recyclable (void);
// Destructor.
// = Set/Get the recyclable bit
State state (void) const;
void state (State new_state);
protected:
ACE_Recyclable (State initial_state);
// Protected constructor.
State state_;
// Our state.
};
class ACE_Export ACE_Hashable
{
public:
virtual ~ACE_Hashable (void);
// Destructor.
virtual u_long hash (void) const;
// Computes and returns hash value. This "caches" the hash value to
// improve performance.
protected:
ACE_Hashable (void);
// Protected constructor.
virtual u_long hash_i (void) const = 0;
// This is the method that actually performs the non-cached hash
// computation.
u_long hash_value_;
// Pre-computed hash-value.
};
class ACE_Export ACE_Refcountable
{
public:
virtual ~ACE_Refcountable (void);
// Destructor.
// = Increment/Decrement refcount
int increment (void);
int decrement (void);
int refcount (void) const;
// Returns the current refcount.
protected:
ACE_Refcountable (int refcount);
// Protected constructor.
int refcount_;
// Current refcount.
};
// This needs to come here to avoid circular dependencies.
#include "ace/Strategies_T.h"
#if defined (__ACE_INLINE__)
#include "ace/Strategies.i"
#endif /* __ACE_INLINE __ */
#endif /* ACE_STRATEGIES_H */
|
