blob: 1d0a13e057d7c6e343f436162e92b9bd4f9928af (
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
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// Future.h
//
// = AUTHOR
// Andres Kruse <Andres.Kruse@cern.ch> and Douglas C. Schmidt
// <schmidt@cs.wustl.edu>
//
// ============================================================================
#if !defined (ACE_FUTURE_H)
#define ACE_FUTURE_H
#include "ace/Synch.h"
#if defined (ACE_HAS_THREADS)
// Forward decl.
template <class T> class ACE_Future;
template <class T> class ACE_Future_Rep
// = TITLE
//
// ACE_Future_Rep<T>
//
// = DESCRIPTION
// An ACE_Future_Rep<T> object encapsules a pointer to an
// object of class T which is the result of an asynchronous
// method invocation. It is pointed to by ACE_Future<T> object[s]
// and only accessible through them.
{
friend class ACE_Future<T>;
private:
int set (const T &r);
// Set the result value.
int get (T &value, ACE_Time_Value *tv);
// Wait up to <tv> time to get the <value>.
operator T();
// Type conversion. will block forever until the
// result is available.
void dump (void) const;
// Dump the state of an object.
ACE_ALLOC_HOOK_DECLARE;
// Declare the dynamic allocation hooks.
// = constructor and destructor private
ACE_Future_Rep (void);
~ACE_Future_Rep (void);
int ready (void);
// Is result available?
T *value_;
// Pointer to the result.
ACE_Atomic_Op<ACE_Thread_Mutex, int> ref_count_;
// Reference count.
// = Condition variable and mutex that protect the <value_>.
ACE_Condition_Thread_Mutex value_ready_;
ACE_Thread_Mutex value_ready_mutex_;
};
template <class T> class ACE_Future
// = TITLE
// This class implements a ``single write, multiple read'' pattern
// that can be used to return results from asynchronous method
// invocations.
// = DESCRIPTION
{
public:
// = Initialization and termination methods.
ACE_Future (void);
// Constructor.
ACE_Future (const ACE_Future<T> &r);
// Copy constructor binds <this> and <r> to the same
// <ACE_Future_Rep>. An <ACE_Future_Rep> is created if necessary.
ACE_Future (const T &r);
// Constructor that initialises an <ACE_Future> to point to the
// result <r> immediately.
~ACE_Future (void);
// Destructor.
void operator = (const ACE_Future<T> &r);
// Assignment operator that binds <this> and <r> to the same
// <ACE_Future_Rep>. An <ACE_Future_Rep> is created if necessary.
int cancel (const T &r);
// Cancel an <ACE_Future> and assign the value <r>. It is used if a
// client does not want to wait for <T> to be produced.
int operator == (const ACE_Future<T> &r) const;
// Equality operator that returns 1 if both ACE_Future<T> objects
// point to the same ACE_Future_Rep<T> object. Attention: It also
// returns 1 if both objects have just been instantiated and not
// used yet.
int operator != (const ACE_Future<T> &r) const;
// Inequality operator, which is the opposite of equality.
int set (const T &r);
// Make the result available. Is used by the server thread to give
// the result to all waiting clients.
int get (T &value, ACE_Time_Value *tv = 0);
// Wait up to <tv> time to get the <value>.
operator T ();
// type conversion. obtain the result of the asynchronous method
// invocation. will block forever.
int ready (void);
// Check if the result is available.
void dump (void) const;
// Dump the state of an object.
ACE_ALLOC_HOOK_DECLARE;
// Declare the dynamic allocation hooks.
private:
ACE_Future_Rep<T> *create_rep_i (void) const;
// Create the <ACE_Future_Rep> object.
void* operator new (size_t nbytes);
// Do not allow new operator.
void operator delete(void *);
// Do not allow delete operator
void operator &();
// Do not allow address-of operator.
ACE_Future_Rep<T> *future_rep_;
// the ACE_Future_Rep
ACE_Thread_Mutex mutex_;
// Protect operations on the <Future>.
};
#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
#include "ace/Future.cpp"
#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
#pragma implementation ("Future.cpp")
#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
#endif /* ACE_HAS_THREADS */
#endif /* ACE_FUTURE_H */
|
