---

ACE_Future_Rep Class Template Reference

#include <Future.h>

Collaboration diagram for ACE_Future_Rep:

[legend]List of all members.

Private Types
typedef ACE_Future_Observer< T >	OBSERVER
typedef ACE_Unbounded_Set< OBSERVER * >	OBSERVER_COLLECTION
Private Methods
int	set (const T &r, ACE_Future< T > &caller)
int	get (T &value, ACE_Time_Value *tv) const
	Wait up to <tv> time to get the <value>. Note that <tv> must be specified in absolute time rather than relative time. More...
int	attach (ACE_Future_Observer< T > *observer, ACE_Future< T > &caller)
int	detach (ACE_Future_Observer< T > *observer)
	operator T ()
void	dump (void) const
	Dump the state of an object. More...
int	ready (void) const
	Is result available? More...
	ACE_Future_Rep (void)
	~ACE_Future_Rep (void)
Static Private Methods
ACE_Future_Rep< T > *	internal_create (void)
	Allocate a new ACE_Future_Rep<T> instance, returning NULL if it cannot be created. More...
ACE_Future_Rep< T > *	create (void)
	Create a ACE_Future_Rep<T> and initialize the reference count. More...
ACE_Future_Rep< T > *	attach (ACE_Future_Rep< T > *&rep)
void	detach (ACE_Future_Rep< T > *&rep)
void	assign (ACE_Future_Rep< T > *&rep, ACE_Future_Rep< T > *new_rep)
Private Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks. More...
T *	value_
	Pointer to the result. More...
int	ref_count_
	Reference count. More...
OBSERVER_COLLECTION	observer_collection_
	Keep a list of ACE_Future_Observers unread by client's reader thread. More...
ACE_Thread_Mutex	value_ready_mutex_
ACE_Condition_Thread_Mutex	value_ready_
Friends
class	ACE_Future< T >

template<class T>
class ACE_Future_Rep< T >

---

Member Typedef Documentation

template<class T> typedef ACE_Future_Observer<T> ACE_Future_Rep::OBSERVER [private]

Definition at line 207 of file Future.h.

template<class T> typedef ACE_Unbounded_Set<OBSERVER *> ACE_Future_Rep::OBSERVER_COLLECTION [private]

Definition at line 210 of file Future.h.

---

Constructor & Destructor Documentation

template<class T> ACE_Future_Rep< T >::ACE_Future_Rep (  void    )  [private]

Definition at line 139 of file Future.cpp. : value_ (0), ref_count_ (0), value_ready_ (this->value_ready_mutex_) { }

template<class T> ACE_Future_Rep< T >::~ACE_Future_Rep (  void    )  [private]

Definition at line 147 of file Future.cpp. References value_. { delete this->value_; }

---

Member Function Documentation

template<class T> void ACE_Future_Rep< T >::assign (  ACE_Future_Rep< T > *&    rep, ACE_Future_Rep< T > *    new_rep )  [static, private]

Decreases the rep's reference count and deletes rep if there are no more references to rep. Then assigns new_rep to rep. Precondition (rep != 0 && new_rep != 0) Definition at line 117 of file Future.cpp. References ACE_ASSERT, ACE_GUARD, ACE_MT, ref_count_, and value_ready_mutex_. { ACE_ASSERT (rep != 0); ACE_ASSERT (new_rep != 0); // Use value_ready_mutex_ for both condition and ref count management ACE_MT (ACE_GUARD (ACE_Thread_Mutex, r_mon, rep->value_ready_mutex_)); ACE_Future_Rep<T>* old = rep; rep = new_rep; // detached old last for exception safety if (old->ref_count_-- == 0) { ACE_MT (r_mon.release ()); // We do not need the lock when deleting the representation. // There should be no side effects from deleting rep and we don // not want to release a deleted mutex. delete old; } }

template<class T> ACE_Future_Rep< T > * ACE_Future_Rep< T >::attach (  ACE_Future_Rep< T > *&    rep )  [static, private]

Increase the reference count and return argument. Uses the attribute "value_ready_mutex_" to synchronize reference count updating. Precondition (rep != 0). Definition at line 90 of file Future.cpp. References ACE_ASSERT, ACE_MT, ref_count_, and value_ready_mutex_. { ACE_ASSERT (rep != 0); // Use value_ready_mutex_ for both condition and ref count management ACE_MT (ACE_Guard<ACE_Thread_Mutex> r_mon (rep->value_ready_mutex_)); ++rep->ref_count_; return rep; }

template<class T> int ACE_Future_Rep< T >::attach (  ACE_Future_Observer< T > *    observer, ACE_Future< T > &    caller )  [private]

Attaches the specified observer to a subject (i.e., the <ACE_Future_Rep>). The update method of the specified subject will be invoked with a copy of the written-to <ACE_Future> as input when the result gets set. Returns 0 if the observer is successfully attached, 1 if the observer is already attached, and -1 if failures occur. Definition at line 225 of file Future.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_Unbounded_Set< OBSERVER * >::insert, observer_collection_, ACE_Future_Observer::update, and value_. Referenced by ACE_Future::attach. { ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->value_ready_mutex_, -1)); // Otherwise, create a new result value. Note the use of the // Double-checked locking pattern to avoid corrupting the list. int result = 1; // If the value is already produced, then notify observer if (this->value_ == 0) result = this->observer_collection_.insert (observer); else observer->update (caller); return result; }

template<class T> ACE_Future_Rep< T > * ACE_Future_Rep< T >::create (  void    )  [static, private]

Create a ACE_Future_Rep<T> and initialize the reference count. Definition at line 75 of file Future.cpp. References ACE_ASSERT, ACE_throw_bad_alloc, and internal_create. { // Yes set ref count to zero. ACE_Future_Rep<T> *temp = internal_create (); #if defined (ACE_NEW_THROWS_EXCEPTIONS) if (temp == 0) ACE_throw_bad_alloc; #else ACE_ASSERT (temp != 0); #endif /* ACE_NEW_THROWS_EXCEPTIONS */ return temp; }

template<class T> void ACE_Future_Rep< T >::detach (  ACE_Future_Rep< T > *&    rep )  [static, private]

Decreases the reference count and deletes rep if there are no more references to rep. Precondition (rep != 0) Definition at line 100 of file Future.cpp. References ACE_ASSERT, ACE_GUARD, ACE_MT, ref_count_, and value_ready_mutex_. { ACE_ASSERT (rep != 0); // Use value_ready_mutex_ for both condition and ref count management ACE_MT (ACE_GUARD (ACE_Thread_Mutex, r_mon, rep->value_ready_mutex_)); if (rep->ref_count_-- == 0) { ACE_MT (r_mon.release ()); // We do not need the lock when deleting the representation. // There should be no side effects from deleting rep and we don // not want to release a deleted mutex. delete rep; } }

template<class T> int ACE_Future_Rep< T >::detach (  ACE_Future_Observer< T > *    observer )  [private]

Detaches the specified observer from a subject (i.e., the <ACE_Future_Rep>). The update method of the specified subject will not be invoked when the <ACE_Future_Rep>s 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. Definition at line 245 of file Future.cpp. References ACE_GUARD_RETURN, ACE_MT, observer_collection_, and ACE_Unbounded_Set< OBSERVER * >::remove. Referenced by ACE_Future::detach. { ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->value_ready_mutex_, -1)); // Remove all occurrences of the specified observer from this // objects hash map. return this->observer_collection_.remove (observer); }

template<class T> void ACE_Future_Rep< T >::dump (  void    )  const [private]

Dump the state of an object. Definition at line 45 of file Future.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_Thread_Mutex::dump, ACE_Condition_Thread_Mutex::dump, LM_DEBUG, LM_INFO, value_, value_ready_, and value_ready_mutex_. Referenced by ACE_Future::dump. { ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, "ref_count_ = %d\n", (int) this->ref_count_)); ACE_DEBUG ((LM_INFO,"value_: \n")); if (this->value_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT (" (NON-NULL)\n"))); else ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT (" (NULL)\n"))); ACE_DEBUG ((LM_INFO,"value_ready_: \n")); this->value_ready_.dump (); ACE_DEBUG ((LM_INFO,"value_ready_mutex_: \n")); this->value_ready_mutex_.dump (); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); }

template<class T> int ACE_Future_Rep< T >::get (  T &    value, ACE_Time_Value *    tv )  const [private]

Wait up to <tv> time to get the <value>. Note that <tv> must be specified in absolute time rather than relative time. Definition at line 200 of file Future.cpp. References ACE_GUARD_RETURN, ACE_MT, and value_. Referenced by ACE_Future::get. { // If the value is already produced, return it. if (this->value_ == 0) { ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, ACE_const_cast (ACE_Thread_Mutex &, this->value_ready_mutex_), -1)); // If the value is not yet defined we must block until the // producer writes to it. while (this->value_ == 0) // Perform a timed wait. if ((ACE_const_cast (ACE_Condition_Thread_Mutex &, this->value_ready_)).wait (tv) == -1) return -1; // Destructor releases the lock. } value = *this->value_; return 0; }

template<class T> ACE_Future_Rep< T > * ACE_Future_Rep< T >::internal_create (  void    )  [static, private]

Allocate a new ACE_Future_Rep<T> instance, returning NULL if it cannot be created. Definition at line 65 of file Future.cpp. References ACE_NEW_RETURN. Referenced by create. { ACE_Future_Rep<T> *temp = 0; ACE_NEW_RETURN (temp, ACE_Future_Rep<T> (), 0); return temp; }

template<class T> ACE_Future_Rep< T >::operator T (    )  [private]

Type conversion. will block forever until the result is available. Note that this method is going away in a subsequent release since it doesn't distinguish between failure results and success results (exceptions should be used, but they aren't portable...). The <get> method should be used instead since it separates the error value from the result, and also permits timeouts. Definition at line 255 of file Future.cpp. References ACE_GUARD_RETURN, ACE_MT, value_, value_ready_, and ACE_Condition_Thread_Mutex::wait. { // If the value is already produced, return it. if (this->value_ == 0) { // Constructor of ace_mon acquires the mutex. ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->value_ready_mutex_, 0)); // If the value is not yet defined we must block until the // producer writes to it. // Wait ``forever.'' while (this->value_ == 0) if (this->value_ready_.wait () == -1) // What to do in this case since we've got to indicate // failure somehow? Exceptions would be nice, but they're // not portable... return 0; // Destructor releases the mutex } return *this->value_; }

template<class T> int ACE_Future_Rep< T >::ready (  void    )  const [private]

Is result available? Definition at line 153 of file Future.cpp. References value_. Referenced by ACE_Future::ready. { return this->value_ != 0; }

template<class T> int ACE_Future_Rep< T >::set (  const T &    r, ACE_Future< T > &    caller )  [private]

Set the result value. The specified <caller> represents the future that invoked this <set> method, which is used to notify the list of future observers. Returns 0 for success, -1 on error. This function only has an effect the first time it is called for the object. Subsequent calls return 0 (success) but have no effect. Definition at line 159 of file Future.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_NEW_RETURN, ACE_TYPENAME, ACE_Unbounded_Set< OBSERVER * >::begin, ACE_Condition_Thread_Mutex::broadcast, ACE_Unbounded_Set< OBSERVER * >::end, observer_collection_, ACE_Future_Observer::update, value_, and value_ready_. Referenced by ACE_Future::ACE_Future, ACE_Future::cancel, and ACE_Future::set. { // If the value is already produced, ignore it... if (this->value_ == 0) { ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->value_ready_mutex_, -1)); // Otherwise, create a new result value. Note the use of the // Double-checked locking pattern to avoid multiple allocations. if (this->value_ == 0) // Still no value, so proceed { ACE_NEW_RETURN (this->value_, T (r), -1); // Remove and notify all subscribed observers. ACE_TYPENAME OBSERVER_COLLECTION::iterator iterator = this->observer_collection_.begin (); ACE_TYPENAME OBSERVER_COLLECTION::iterator end = this->observer_collection_.end (); while (iterator != end) { OBSERVER *observer = *iterator++; observer->update (caller); } // Signal all the waiting threads. return this->value_ready_.broadcast (); } // Destructor releases the lock. } return 0; }

---

Friends And Related Function Documentation

template<class T> friend class ACE_Future< T > [friend]

Definition at line 103 of file Future.h.

---

Member Data Documentation

template<class T> ACE_Future_Rep::ACE_ALLOC_HOOK_DECLARE [private]

Declare the dynamic allocation hooks. Definition at line 157 of file Future.h.

template<class T> OBSERVER_COLLECTION ACE_Future_Rep::observer_collection_ [private]

Keep a list of ACE_Future_Observers unread by client's reader thread. Definition at line 213 of file Future.h. Referenced by attach, detach, and set.

template<class T> int ACE_Future_Rep::ref_count_ [private]

Reference count. Definition at line 204 of file Future.h. Referenced by assign, attach, and detach.

template<class T> T* ACE_Future_Rep::value_ [private]

Pointer to the result. Definition at line 201 of file Future.h. Referenced by attach, dump, get, operator T, ready, set, and ~ACE_Future_Rep.

template<class T> ACE_Condition_Thread_Mutex ACE_Future_Rep::value_ready_ [private]

Definition at line 217 of file Future.h. Referenced by dump, operator T, and set.

template<class T> ACE_Thread_Mutex ACE_Future_Rep::value_ready_mutex_ [private]

Definition at line 216 of file Future.h. Referenced by assign, attach, detach, and dump.

---

The documentation for this class was generated from the following files:

• Future.h
• Future.cpp

---