#include <ace/Future.h>
template<class T> class ACE_Future {
public:
ACE_Future (void);
ACE_Future (const ACE_Future<T> &r);
ACE_Future (const T &r);
~ACE_Future (void);
void operator = (const ACE_Future<T> &r);
int cancel (const T &r);
int cancel (void);
int operator == (const ACE_Future<T> &r) const;
int operator != (const ACE_Future<T> &r) const;
int set (const T &r);
int get (T &value, ACE_Time_Value *tv = 0);
operator T ();
int ready (void);
int attach (ACE_Future_Observer<T> *observer);
int detach (ACE_Future_Observer<T> *observer);
void dump (void) const;
ACE_Future_Rep<T> *get_rep (void);
ACE_ALLOC_HOOK_DECLARE;
private:
void *operator new (size_t nbytes);
void operator delete (void *);
void operator & ();
typedef ACE_Future_Rep<T> FUTURE_REP;
FUTURE_REP *future_rep_;
};
ACE_Future (void);
ACE_Future (const ACE_Future<T> &r);
this
and r
to the same
ACE_Future_Rep
. An ACE_Future_Rep
is created if necessary.
ACE_Future (const T &r);
ACE_Future
to point to the
result r
immediately.
~ACE_Future (void);
void operator = (const ACE_Future<T> &r);
this
and r
to the same
ACE_Future_Rep
. An ACE_Future_Rep
is created if necessary.
int cancel (const T &r);
ACE_Future
and assign the value r
. It is used if a
client does not want to wait for T
to be produced.
int cancel (void);
ACE_Future
. Put the future into its initial
state. Returns 0 on succes and -1 on failure. It is now possible
to reuse the ACE_FutureT
. But remember, the ACE_FutureT
is now bound to a new ACE_Future_RepT
.
int operator == (const ACE_Future<T> &r) const;
T
objects
point to the same ACE_Future_RepT
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;
int set (const T &r);
int get (T &value, ACE_Time_Value *tv = 0);
tv
time to get the value
. Note that tv
must be
specified in absolute time rather than relative time.
operator T ();
get
method should be
used instead since it separates the error value from the result,
and also permits timeouts.
int ready (void);
int attach (ACE_Future_Observer<T> *observer);
ACE_Future
). The update method of the specified subject will be
invoked with a copy of the associated ACE_Future
as input when
the result gets set. If the result is already set when this
method gets invoked, then the update method of the specified
subject will be invoked immediately.
Returns 0 if the observer is successfully attached, 1 if the observer is already attached, and -1 if failures occur.
int detach (ACE_Future_Observer<T> *observer);
ACE_Future_Rep
). The update method of the specified subject will
not be invoked when the ACE_Future_Reps
result gets set. Returns
1 if the specified observer was actually attached to the subject
prior to this call and 0 if was not.
Returns 0 if the observer was successfully detached, and -1 if the observer was not attached in the first place.
void dump (void) const;
ACE_Future_Rep<T> *get_rep (void);
ACE_Future_Rep
*. Note that this method should
rarely, if ever, be used and that modifying the undlerlying ACE_Future_Rep
*
should be done with extreme caution.
ACE_ALLOC_HOOK_DECLARE;
Andres.Kruse@cern.ch
,
Douglas C. Schmidt schmidt@cs.wustl.edu
,
Per Andersson Per.Andersson@hfera.ericsson.se
, and
John Tucker jtucker@infoglide.com