ICU-64232.0.1.tar.gz

[apple/icu.git] / icuSources / common / mutex.h

diff --git a/icuSources/common/mutex.h b/icuSources/common/mutex.h
index db546bc2ffa364e5e474b8e269c09b8112bf520d..55768fbe12ebdd83b6cb47e41c5bfbb2ed15a0e0 100644 (file)
--- a/icuSources/common/mutex.h
+++ b/icuSources/common/mutex.h
@@ -1,7 +1,9 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
 /*
 ******************************************************************************
 *
-*   Copyright (C) 1997-2001, International Business Machines
+*   Copyright (C) 1997-2013, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ******************************************************************************
@@ -26,58 +28,51 @@
 
 U_NAMESPACE_BEGIN
 
-//----------------------------------------------------------------------------
-// Code within this library which accesses protected data
-// should instantiate a Mutex object while doing so. You should make your own 
-// private mutex where possible.
-
-// For example:
-// 
-// UMTX myMutex;
-// 
-// int InitializeMyMutex()
-// {
-//    umtx_init( &myMutex );
-//    return 0;
-// }
-// 
-// static int initializeMyMutex = InitializeMyMutex();
-//
-// void Function(int arg1, int arg2)
-// {
-//    static Object* foo; // Shared read-write object
-//    Mutex mutex(&myMutex);  // or no args for the global lock
-//    foo->Method();
-//    // When 'mutex' goes out of scope and gets destroyed here, the lock is released
-// }
-//
-// Note:  Do NOT use the form 'Mutex mutex();' as that merely forward-declares a function
-//        returning a Mutex. This is a common mistake which silently slips through the
-//        compiler!!
-//
+/**
+  * Mutex is a helper class for convenient locking and unlocking of a UMutex.
+  *
+  * Creating a local scope Mutex will lock a UMutex, holding the lock until the Mutex
+  * goes out of scope.
+  *
+  *  If no UMutex is specified, the ICU global mutex is implied.
+  *
+  *  For example:
+  *
+  *  UMutex *myMutex() {
+  *    static UMutex *m = STATIC_NEW(UMutex);
+  *    return m;
+  *  }
+  *
+  *  void Function(int arg1, int arg2)
+  *  {
+  *     static Object* foo;      // Shared read-write object
+  *     Mutex mutex(myMutex());  // or no args for the global lock
+  *     foo->Method();
+  *     // When 'mutex' goes out of scope and gets destroyed here, the lock is released
+  *  }
+  *
+  *  Note:  Do NOT use the form 'Mutex mutex();' as that merely forward-declares a function
+  *         returning a Mutex. This is a common mistake which silently slips through the
+  *         compiler!!
+  */
 
 class U_COMMON_API Mutex : public UMemory {
 public:
-  inline Mutex(UMTX *mutex = NULL);
-  inline ~Mutex();
+    Mutex(UMutex *mutex = nullptr) : fMutex(mutex) {
+        umtx_lock(fMutex);
+    };
+    ~Mutex() {
+        umtx_unlock(fMutex);
+    };
 
-private:
-  UMTX   *fMutex;
+    Mutex(const Mutex &other) = delete; // forbid assigning of this class
+    Mutex &operator=(const Mutex &other) = delete; // forbid copying of this class
+    void *operator new(size_t s) = delete;  // forbid heap allocation. Locals only.
 
-  Mutex(const Mutex &other); // forbid copying of this class
-  Mutex &operator=(const Mutex &other); // forbid copying of this class
+private:
+    UMutex   *fMutex;
 };
 
-inline Mutex::Mutex(UMTX *mutex)
-  : fMutex(mutex)
-{
-  umtx_lock(fMutex);
-}
-
-inline Mutex::~Mutex()
-{
-  umtx_unlock(fMutex);
-}
 
 U_NAMESPACE_END