summaryrefslogtreecommitdiff
path: root/ACE/ace/Reverse_Lock_T.h
diff options
context:
space:
mode:
Diffstat (limited to 'ACE/ace/Reverse_Lock_T.h')
-rw-r--r--ACE/ace/Reverse_Lock_T.h149
1 files changed, 149 insertions, 0 deletions
diff --git a/ACE/ace/Reverse_Lock_T.h b/ACE/ace/Reverse_Lock_T.h
new file mode 100644
index 00000000000..5bd1d3a6b8f
--- /dev/null
+++ b/ACE/ace/Reverse_Lock_T.h
@@ -0,0 +1,149 @@
+// -*- C++ -*-
+
+//==========================================================================
+/**
+ * @file Reverse_Lock_T.h
+ *
+ * $Id$
+ *
+ * Moved from Synch.h.
+ *
+ * @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
+ */
+//==========================================================================
+
+#ifndef ACE_REVERSE_LOCK_T_H
+#define ACE_REVERSE_LOCK_T_H
+#include /**/ "ace/pre.h"
+
+#include "ace/Lock.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
+/**
+ * @namespace ACE_Acquire_Method
+ *
+ * @brief An enum namespace.
+ *
+ * These enums should have been inside the reverse lock class, but
+ * some lame compilers cannot handle enums inside template classes.
+ *
+ * The METHOD_TYPE is used to indicate which acquire() method will be
+ * called on the real lock when the release() method is called on the
+ * reverse lock. REGULAR indicated the acquire() method, READ
+ * indicates the acquire_read() method, and WRITE indicates the
+ * acquire_write() method. Note that the try_*() methods are not
+ * represented here because we have to make sure that the release()
+ * method on the reverse lock acquires a lock on the real lock.
+ **/
+namespace ACE_Acquire_Method
+{
+ enum METHOD_TYPE
+ {
+ ACE_REGULAR,
+ ACE_READ,
+ ACE_WRITE
+ };
+}
+
+#if defined (ACE_LYNXOS_MAJOR) && (ACE_LYNXOS_MAJOR < 4)
+ using namespace ACE_Acquire_Method;
+#endif
+
+/**
+ * @class ACE_Reverse_Lock
+ *
+ * @brief A reverse (or anti) lock.
+ *
+ * This is an interesting adapter class that changes a lock into
+ * a reverse lock, i.e., <acquire> on this class calls <release>
+ * on the lock, and <release> on this class calls <acquire> on
+ * the lock.
+ * One motivation for this class is when we temporarily want to
+ * release a lock (which we have already acquired) but then
+ * reacquire it soon after. An alternative design would be to
+ * add a Anti_Guard or Reverse_Guard class which would <release>
+ * on construction and <acquire> destruction. However, there
+ * are *many* varieties of the Guard class and this design
+ * choice would lead to at least 6 new classes. One new
+ * ACE_Reverse_Lock class seemed more reasonable.
+ */
+template <class ACE_LOCKING_MECHANISM>
+class ACE_Reverse_Lock : public ACE_Lock
+{
+public:
+
+ typedef ACE_LOCKING_MECHANISM ACE_LOCK;
+
+ // = Initialization/Finalization methods.
+
+ /// Constructor. All locking requests will be forwarded to <lock>.
+#if defined (ACE_LYNXOS_MAJOR) && (ACE_LYNXOS_MAJOR < 4)
+ // Make LynxOS 3.x buggy compiler happy
+ ACE_Reverse_Lock (ACE_LOCKING_MECHANISM &lock,
+ METHOD_TYPE acquire_method = ACE_REGULAR);
+#else
+ ACE_Reverse_Lock (ACE_LOCKING_MECHANISM &lock,
+ ACE_Acquire_Method::METHOD_TYPE acquire_method = ACE_Acquire_Method::ACE_REGULAR);
+#endif
+
+ /// Destructor. If <lock_> was not passed in by the user, it will be
+ /// deleted.
+ virtual ~ACE_Reverse_Lock (void);
+
+ // = Lock accessors.
+ /// Release the lock.
+ virtual int acquire (void);
+
+ /// Release the lock.
+ virtual int tryacquire (void);
+
+ /// Acquire the lock.
+ virtual int release (void);
+
+ /// Release the lock.
+ virtual int acquire_read (void);
+
+ /// Release the lock.
+ virtual int acquire_write (void);
+
+ /// Release the lock.
+ virtual int tryacquire_read (void);
+
+ /// Release the lock.
+ virtual int tryacquire_write (void);
+
+ /// Release the lock.
+ virtual int tryacquire_write_upgrade (void);
+
+ /// Explicitly destroy the lock.
+ virtual int remove (void);
+
+private:
+ /// The concrete locking mechanism that all the methods delegate to.
+ ACE_LOCKING_MECHANISM &lock_;
+
+ /// This indicates what kind of acquire method will be called.
+ ACE_Acquire_Method::METHOD_TYPE acquire_method_;
+};
+
+ACE_END_VERSIONED_NAMESPACE_DECL
+
+#if defined (__ACE_INLINE__)
+#include "ace/Reverse_Lock_T.inl"
+#endif /* __ACE_INLINE__ */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "ace/Reverse_Lock_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Reverse_Lock_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include /**/ "ace/post.h"
+#endif /* ACE_REVERSE_LOCK_T_H */