ACE_Future_Rep< T > Class Template Reference

ACE_Future_Rep<T>. More...

#include <Future.h>

Collaboration diagram for ACE_Future_Rep< T >:

[legend]List of all members.

Protected Member Functions
	~ACE_Future_Rep (void)
Private Types
typedef ACE_Future_Observer< T >	OBSERVER
typedef ACE_Unbounded_Set< OBSERVER * >	OBSERVER_COLLECTION
Private Member Functions
int	set (const T &r, ACE_Future< T > &caller)
int	get (T &value, ACE_Time_Value *tv) const
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.
int	ready (void) const
	Is result available?
	ACE_Future_Rep (void)
Static Private Member Functions
ACE_Future_Rep< T > *	internal_create (void)
ACE_Future_Rep< T > *	create (void)
	Create a ACE_Future_Rep<T> and initialize the reference count.
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.
T *	value_
	Pointer to the result.
int	ref_count_
	Reference count.
OBSERVER_COLLECTION	observer_collection_
	Keep a list of ACE_Future_Observers unread by client's reader thread.
ACE_Recursive_Thread_Mutex	value_ready_mutex_
ACE_Condition_Recursive_Thread_Mutex	value_ready_
Friends
class	ACE_Future< T >

---

Detailed Description

template<class T>
class ACE_Future_Rep< T >

ACE_Future_Rep<T>.

For internal use only.

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.

Definition at line 104 of file Future.h.

---

Member Typedef Documentation

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

Definition at line 211 of file Future.h. Referenced by ACE_Future_Rep< T >::set().

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

Definition at line 214 of file Future.h.

---

Constructor & Destructor Documentation

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

Definition at line 148 of file Future.cpp. : value_ (0), ref_count_ (0), value_ready_ (value_ready_mutex_) { }

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

Definition at line 156 of file Future.cpp. { 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 126 of file Future.cpp. References ACE_ASSERT, ACE_GUARD, ACE_Future_Rep< T >::ref_count_, and ACE_Future_Rep< T >::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_Recursive_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 99 of file Future.cpp. References ACE_ASSERT, ACE_Future_Rep< T >::ref_count_, and ACE_Future_Rep< T >::value_ready_mutex_. { ACE_ASSERT (rep != 0); // Use value_ready_mutex_ for both condition and ref count management ACE_MT (ACE_Guard<ACE_Recursive_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 ). 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 234 of file Future.cpp. References ACE_GUARD_RETURN, ACE_Unbounded_Set< T >::insert(), ACE_Future_Rep< T >::observer_collection_, and ACE_Future_Observer< T >::update(). Referenced by ACE_Future< T >::attach(). { ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_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 84 of file Future.cpp. References ACE_ASSERT, ACE_throw_bad_alloc, and ACE_Future_Rep< T >::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 109 of file Future.cpp. References ACE_ASSERT, ACE_GUARD, ACE_Future_Rep< T >::ref_count_, and ACE_Future_Rep< T >::value_ready_mutex_. { ACE_ASSERT (rep != 0); // Use value_ready_mutex_ for both condition and ref count management ACE_MT (ACE_GUARD (ACE_Recursive_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 ). The update method of the specified subject will not be invoked when the 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 254 of file Future.cpp. References ACE_GUARD_RETURN, ACE_Future_Rep< T >::observer_collection_, and ACE_Unbounded_Set< T >::remove(). Referenced by ACE_Future< T >::detach(). { ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_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 50 of file Future.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_TEXT, LM_DEBUG, LM_INFO, ACE_Future_Rep< T >::value_ready_, and ACE_Future_Rep< T >::value_ready_mutex_. Referenced by ACE_Future< T >::dump(). { #if defined (ACE_HAS_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_TEXT (" (NON-NULL)\n"))); else //FUZZ: disable check_for_NULL ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (NULL)\n"))); //FUZZ: enable check_for_NULL 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)); #endif /* ACE_HAS_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 209 of file Future.cpp. References ACE_GUARD_RETURN, and ACE_Future_Rep< T >::value_ready_. Referenced by ACE_Future< T >::get(). { // If the value is already produced, return it. if (this->value_ == 0) { ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, 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 (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 74 of file Future.cpp. References ACE_NEW_RETURN. Referenced by ACE_Future_Rep< T >::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 method should be used instead since it separates the error value from the result, and also permits timeouts. Definition at line 264 of file Future.cpp. References ACE_GUARD_RETURN, and ACE_Future_Rep< T >::value_ready_. { // 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_Recursive_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 162 of file Future.cpp. Referenced by ACE_Future< T >::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 represents the future that invoked this 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 168 of file Future.cpp. References ACE_GUARD_RETURN, ACE_NEW_RETURN, ACE_Unbounded_Set< T >::begin(), ACE_Unbounded_Set< T >::end(), ACE_Future_Rep< T >::OBSERVER, ACE_Future_Rep< T >::observer_collection_, ACE_Future_Observer< T >::update(), and ACE_Future_Rep< T >::value_ready_. Referenced by ACE_Future< T >::ACE_Future(), ACE_Future< T >::cancel(), and ACE_Future< T >::set(). { // If the value is already produced, ignore it... if (this->value_ == 0) { ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_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. typename OBSERVER_COLLECTION::iterator iterator = this->observer_collection_.begin (); 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 107 of file Future.h.

---

Member Data Documentation

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

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

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

Keep a list of ACE_Future_Observers unread by client's reader thread. Definition at line 217 of file Future.h. Referenced by ACE_Future_Rep< T >::attach(), ACE_Future_Rep< T >::detach(), and ACE_Future_Rep< T >::set().

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

Reference count. Definition at line 208 of file Future.h. Referenced by ACE_Future_Rep< T >::assign(), ACE_Future_Rep< T >::attach(), and ACE_Future_Rep< T >::detach().

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

Pointer to the result. Definition at line 205 of file Future.h.

template<class T> ACE_Condition_Recursive_Thread_Mutex ACE_Future_Rep< T >::value_ready_ [mutable, private]

Definition at line 221 of file Future.h. Referenced by ACE_Future_Rep< T >::dump(), ACE_Future_Rep< T >::get(), ACE_Future_Rep< T >::operator T(), and ACE_Future_Rep< T >::set().

template<class T> ACE_Recursive_Thread_Mutex ACE_Future_Rep< T >::value_ready_mutex_ [mutable, private]

Definition at line 220 of file Future.h. Referenced by ACE_Future_Rep< T >::assign(), ACE_Future_Rep< T >::attach(), ACE_Future_Rep< T >::detach(), and ACE_Future_Rep< T >::dump().

---

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

• Future.h
• Future.cpp

---