ChangeLogTag:Fri Dec 8 10:34:32 2000 Douglas C. Schmidt <schmidt@ace.cs.wustl.edu>

1 files changed, 170 insertions, 0 deletions

diff --git a/ace/Refcounted_Auto_Ptr.i b/ace/Refcounted_Auto_Ptr.i
new file mode 100644
index 00000000000..a712d373175
--- /dev/null
+++ b/ace/Refcounted_Auto_Ptr.i
@@ -0,0 +1,170 @@
+/* -*- C++ -*- */
+// $Id$
+
+// Refcounted_Auto_Ptr.i
+
+#include "Synch_T.h"
+
+template <class X, class ACE_LOCK> inline ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> *
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::create (X *p)
+{
+  // Yes set ref count to zero.
+  return new ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> (p);
+}
+
+template <class X, class ACE_LOCK> inline ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> *
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::attach (ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>*& rep)
+{
+  ACE_ASSERT (rep != 0);
+
+  ACE_GUARD_RETURN (ACE_LOCK, guard, rep->lock_, rep);
+
+  ++rep->ref_count_;
+
+  return rep;
+}
+
+template <class X, class ACE_LOCK> inline void
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::detach (ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>*& rep)
+{
+  ACE_ASSERT (rep != 0);
+
+  ACE_GUARD (ACE_LOCK, guard, rep->lock_);
+
+  if (rep->ref_count_-- == 0)
+    // 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 X, class ACE_LOCK> inline void
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::assign (ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>*& rep,
+                                                  ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>* new_rep)
+{
+  ACE_ASSERT (rep != 0);
+  ACE_ASSERT (new_rep != 0);
+
+  ACE_GUARD (ACE_LOCK, guard, rep->lock_);
+
+  ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> *old = rep;
+  rep = new_rep;
+
+  // detached old last for exception safety
+  if(old->ref_count_-- == 0)
+    // 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 X, class ACE_LOCK> inline
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr_Rep (X *p)
+  : ptr_ (p),
+    ref_count_ (0)
+{
+}
+
+template <class X, class ACE_LOCK> inline
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr_Rep (void)
+{
+}
+
+template<class X, class ACE_LOCK> inline X *
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::release (void)
+{
+  ACE_GUARD_RETURN (ACE_LOCK, guard, this->lock_, 0);
+
+  return this->ptr_.release ();
+}
+
+template<class X, class ACE_LOCK> inline void
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::reset (X *p)
+{
+  ACE_GUARD (ACE_LOCK, guard, this->lock_);
+
+  this->ptr_.reset (p);
+}
+
+template <class X, class ACE_LOCK> inline X *
+ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::get (void)
+{
+  ACE_GUARD_RETURN (ACE_LOCK, guard, this->lock_, 0);
+
+  return this->ptr_.get ();
+}
+
+template <class X, class ACE_LOCK> inline
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr (X *p)
+  : rep_ (AUTO_REFCOUNTED_PTR_REP::create (p))
+{
+}
+
+template <class X, class ACE_LOCK> inline
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r)
+  : rep_ (AUTO_REFCOUNTED_PTR_REP::attach (((ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &) r).rep_))
+{
+}
+
+template <class X, class ACE_LOCK> inline
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr (void)
+{
+  AUTO_REFCOUNTED_PTR_REP::detach (rep_);
+}
+
+template <class X, class ACE_LOCK> inline int
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator== (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r) const
+{
+  return r.rep_ == this->rep_;
+}
+
+template <class X, class ACE_LOCK> inline int
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator!= (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r) const
+{
+  return r.rep_ != this->rep_;
+}
+
+template <class X, class ACE_LOCK> inline X *
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator-> (void) const
+{
+    return this->rep_->get();
+}
+
+template<class X, class ACE_LOCK> inline X &
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator *() const
+{
+  return *this->rep_->get ();
+}
+
+template <class X, class ACE_LOCK> inline X*
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::get (void)
+{
+  // We return the ACE_Future_rep.
+  return this->rep_->get ();
+}
+
+template<class X, class ACE_LOCK> inline X *
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::release (void)
+{
+  return this->rep_->release ();
+}
+
+template<class X, class ACE_LOCK> inline void
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::reset (X *p)
+{
+  this->rep_->reset (p);
+}
+
+template <class X, class ACE_LOCK> inline void
+ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator = (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &rhs)
+{
+  // assignment:
+  //
+  //  bind <this> to the same <ACE_Refcounted_Auto_Ptr_Rep> as <r>.
+
+  // This will work if &r == this, by first increasing the ref count
+  ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r = (ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &) rhs;
+  AUTO_REFCOUNTED_PTR_REP::assign (this->rep_,
+                                   AUTO_REFCOUNTED_PTR_REP::attach (r.rep_));
+}
+