summaryrefslogtreecommitdiff
path: root/ace/Future.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'ace/Future.cpp')
-rw-r--r--ace/Future.cpp425
1 files changed, 0 insertions, 425 deletions
diff --git a/ace/Future.cpp b/ace/Future.cpp
deleted file mode 100644
index f70f8df83bb..00000000000
--- a/ace/Future.cpp
+++ /dev/null
@@ -1,425 +0,0 @@
-// $Id$
-
-#ifndef ACE_FUTURE_CPP
-#define ACE_FUTURE_CPP
-
-#include "ace/Future.h"
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-# pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-ACE_RCSID (ace, Future, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-template <class T>
-ACE_Future_Holder<T>::ACE_Future_Holder (void)
-{
-}
-
-template <class T>
-ACE_Future_Holder<T>::ACE_Future_Holder (const ACE_Future<T> &item)
- : item_ (item)
-{
-}
-
-template <class T>
-ACE_Future_Holder<T>::~ACE_Future_Holder (void)
-{
-}
-
-template <class T>
-ACE_Future_Observer<T>::ACE_Future_Observer (void)
-{
-}
-
-template <class T>
-ACE_Future_Observer<T>::~ACE_Future_Observer (void)
-{
-}
-
-// Dump the state of an object.
-
-template <class T> void
-ACE_Future_Rep<T>::dump (void) const
-{
- 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
- ACE_DEBUG ((LM_DEBUG, ACE_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> ACE_Future_Rep<T> *
-ACE_Future_Rep<T>::create (void)
-{
- // Yes set ref count to zero.
- return new ACE_Future_Rep<T> ();
-}
-
-template <class T> ACE_Future_Rep<T> *
-ACE_Future_Rep<T>::attach (ACE_Future_Rep<T>*& rep)
-{
- 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> void
-ACE_Future_Rep<T>::detach (ACE_Future_Rep<T>*& rep)
-{
- 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> void
-ACE_Future_Rep<T>::assign (ACE_Future_Rep<T>*& rep, ACE_Future_Rep<T>* new_rep)
-{
- 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 (void)
- : value_ (0),
- ref_count_ (0),
- value_ready_ (this->value_ready_mutex_)
-{
-}
-
-template <class T>
-ACE_Future_Rep<T>::~ACE_Future_Rep (void)
-{
- delete this->value_;
-}
-
-template <class T> int
-ACE_Future_Rep<T>::ready (void)
-{
- return this->value_ != 0;
-}
-
-template <class T> int
-ACE_Future_Rep<T>::set (const T &r,
- ACE_Future<T> &caller)
-{
- // 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)
- 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 ();
-
- for (;
- iterator != end;
- ++iterator)
- {
- OBSERVER *observer = *iterator;
- observer->update (caller);
- }
-
- // Signal all the waiting threads.
- return this->value_ready_.broadcast ();
-
- // Destructor releases the lock.
- }
- return 0;
-}
-
-template <class T> int
-ACE_Future_Rep<T>::get (T &value,
- ACE_Time_Value *tv)
-{
- // If the value is already produced, return it.
- if (this->value_ == 0)
- {
- ACE_MT (ACE_GUARD_RETURN (ACE_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> int
-ACE_Future_Rep<T>::attach (ACE_Future_Observer<T> *observer,
- ACE_Future<T> &caller)
-{
- 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> int
-ACE_Future_Rep<T>::detach (ACE_Future_Observer<T> *observer)
-{
- 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>
-ACE_Future_Rep<T>::operator T ()
-{
- // 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>
-ACE_Future<T>::ACE_Future (void)
- : future_rep_ (FUTURE_REP::create ())
-{
-}
-
-template <class T>
-ACE_Future<T>::ACE_Future (const ACE_Future<T> &r)
- : future_rep_ (FUTURE_REP::attach (((ACE_Future<T> &) r).future_rep_))
-{
-}
-
-template <class T>
-ACE_Future<T>::ACE_Future (const T &r)
- : future_rep_ (FUTURE_REP::create ())
-{
- ACE_DEBUG ((LM_DEBUG,
- ACE_TEXT (" (%t) funny constructor\n")));
- this->future_rep_->set (r,
- *this);
-}
-
-template <class T>
-ACE_Future<T>::~ACE_Future (void)
-{
- FUTURE_REP::detach (future_rep_);
-}
-
-template <class T> int
-ACE_Future<T>::operator== (const ACE_Future<T> &r) const
-{
- return r.future_rep_ == this->future_rep_;
-}
-
-template <class T> int
-ACE_Future<T>::operator!= (const ACE_Future<T> &r) const
-{
- return r.future_rep_ != this->future_rep_;
-}
-
-template <class T> int
-ACE_Future<T>::cancel (const T &r)
-{
- this->cancel ();
- return this->future_rep_->set (r,
- *this);
-}
-
-template <class T> int
-ACE_Future<T>::cancel (void)
-{
- // If this ACE_Future is already attached to a ACE_Future_Rep,
- // detach it (maybe delete the ACE_Future_Rep).
- FUTURE_REP::assign (this->future_rep_,
- FUTURE_REP::create ());
- return 0;
-}
-
-template <class T> int
-ACE_Future<T>::set (const T &r)
-{
- // Give the pointer to the result to the ACE_Future_Rep.
- return this->future_rep_->set (r,
- *this);
-}
-
-template <class T> int
-ACE_Future<T>::ready (void)
-{
- // We're ready if the ACE_Future_rep is ready...
- return this->future_rep_->ready ();
-}
-
-template <class T> int
-ACE_Future<T>::get (T &value,
- ACE_Time_Value *tv)
-{
- // We return the ACE_Future_rep.
- return this->future_rep_->get (value, tv);
-}
-
-template <class T> int
-ACE_Future<T>::attach (ACE_Future_Observer<T> *observer)
-{
- return this->future_rep_->attach (observer, *this);
-}
-
-template <class T> int
-ACE_Future<T>::detach (ACE_Future_Observer<T> *observer)
-{
- return this->future_rep_->detach (observer);
-}
-
-template <class T>
-ACE_Future<T>::operator T ()
-{
- // note that this will fail (and COREDUMP!)
- // if future_rep_ == 0 !
- //
- // but...
- // this is impossible unless somebody is so stupid to
- // try something like this:
- //
- // Future<T> futT;
- // T t;
- // t = futT;
-
- // perform type conversion on Future_Rep.
- return *future_rep_;
-}
-
-template <class T> void
-ACE_Future<T>::operator = (const ACE_Future<T> &rhs)
-{
- // assignment:
- //
- // bind <this> to the same <ACE_Future_Rep> as <r>.
-
- // This will work if &r == this, by first increasing the ref count
- ACE_Future<T> &r = (ACE_Future<T> &) rhs;
- FUTURE_REP::assign (this->future_rep_,
- FUTURE_REP::attach (r.future_rep_));
-}
-
-template <class T> void
-ACE_Future<T>::dump (void) const
-{
- ACE_DEBUG ((LM_DEBUG,
- ACE_BEGIN_DUMP, this));
-
- if (this->future_rep_)
- this->future_rep_->dump ();
-
- ACE_DEBUG ((LM_DEBUG,
- ACE_END_DUMP));
-}
-
-template <class T> ACE_Future_Rep<T> *
-ACE_Future<T>::get_rep ()
-{
- return this->future_rep_;
-}
-
-template <class T> void *
-ACE_Future<T>::operator new (size_t)
-{
- ACE_throw_bad_alloc;
-#if defined (__HP_aCC)
- return 0;
-#endif /* 0 */
-}
-
-template <class T> void
-ACE_Future<T>::operator delete (void *)
-{
-}
-
-template <class T> void
-ACE_Future<T>::operator & ()
-{
-}
-
-#endif /* ACE_HAS_THREADS */
-#endif /* ACE_FUTURE_CPP */