Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 1 of 2.

1 files changed, 128 insertions, 128 deletions

diff --git a/contrib/libs/re2/util/mutex.h b/contrib/libs/re2/util/mutex.h
index 158046bb5c..6619daa4c4 100644
--- a/contrib/libs/re2/util/mutex.h
+++ b/contrib/libs/re2/util/mutex.h
@@ -1,15 +1,15 @@
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_MUTEX_H_
-#define UTIL_MUTEX_H_
-
-/*
- * A simple mutex wrapper, supporting locks and read-write locks.
- * You should assume the locks are *not* re-entrant.
- */
-
+// Copyright 2007 The RE2 Authors.  All Rights Reserved. 
+// Use of this source code is governed by a BSD-style 
+// license that can be found in the LICENSE file. 
+ 
+#ifndef UTIL_MUTEX_H_ 
+#define UTIL_MUTEX_H_ 
+ 
+/* 
+ * A simple mutex wrapper, supporting locks and read-write locks. 
+ * You should assume the locks are *not* re-entrant. 
+ */ 
+ 
 #ifdef _WIN32
 // Requires Windows Vista or Windows Server 2008 at minimum.
 #include <windows.h>
@@ -17,55 +17,55 @@
 #define MUTEX_IS_WIN32_SRWLOCK
 #endif
 #else
-#ifndef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE 200809L
-#endif
-#include <unistd.h>
-#if defined(_POSIX_READER_WRITER_LOCKS) && _POSIX_READER_WRITER_LOCKS > 0
-#define MUTEX_IS_PTHREAD_RWLOCK
-#endif
-#endif
-
+#ifndef _POSIX_C_SOURCE 
+#define _POSIX_C_SOURCE 200809L 
+#endif 
+#include <unistd.h> 
+#if defined(_POSIX_READER_WRITER_LOCKS) && _POSIX_READER_WRITER_LOCKS > 0 
+#define MUTEX_IS_PTHREAD_RWLOCK 
+#endif 
+#endif 
+ 
 #if defined(MUTEX_IS_WIN32_SRWLOCK)
 typedef SRWLOCK MutexType;
 #elif defined(MUTEX_IS_PTHREAD_RWLOCK)
-#include <pthread.h>
-#include <stdlib.h>
-typedef pthread_rwlock_t MutexType;
-#else
-#include <mutex>
-typedef std::mutex MutexType;
-#endif
-
-namespace re2 {
-
-class Mutex {
- public:
-  inline Mutex();
-  inline ~Mutex();
-  inline void Lock();    // Block if needed until free then acquire exclusively
-  inline void Unlock();  // Release a lock acquired via Lock()
-  // Note that on systems that don't support read-write locks, these may
-  // be implemented as synonyms to Lock() and Unlock().  So you can use
-  // these for efficiency, but don't use them anyplace where being able
-  // to do shared reads is necessary to avoid deadlock.
-  inline void ReaderLock();   // Block until free or shared then acquire a share
-  inline void ReaderUnlock(); // Release a read share of this Mutex
-  inline void WriterLock() { Lock(); }     // Acquire an exclusive lock
-  inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock()
-
- private:
-  MutexType mutex_;
-
-  // Catch the error of writing Mutex when intending MutexLock.
-  Mutex(Mutex *ignored);
-
-  Mutex(const Mutex&) = delete;
-  Mutex& operator=(const Mutex&) = delete;
-};
-
+#include <pthread.h> 
+#include <stdlib.h> 
+typedef pthread_rwlock_t MutexType; 
+#else 
+#include <mutex> 
+typedef std::mutex MutexType; 
+#endif 
+ 
+namespace re2 { 
+ 
+class Mutex { 
+ public: 
+  inline Mutex(); 
+  inline ~Mutex(); 
+  inline void Lock();    // Block if needed until free then acquire exclusively 
+  inline void Unlock();  // Release a lock acquired via Lock() 
+  // Note that on systems that don't support read-write locks, these may 
+  // be implemented as synonyms to Lock() and Unlock().  So you can use 
+  // these for efficiency, but don't use them anyplace where being able 
+  // to do shared reads is necessary to avoid deadlock. 
+  inline void ReaderLock();   // Block until free or shared then acquire a share 
+  inline void ReaderUnlock(); // Release a read share of this Mutex 
+  inline void WriterLock() { Lock(); }     // Acquire an exclusive lock 
+  inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock() 
+ 
+ private: 
+  MutexType mutex_; 
+ 
+  // Catch the error of writing Mutex when intending MutexLock. 
+  Mutex(Mutex *ignored); 
+ 
+  Mutex(const Mutex&) = delete; 
+  Mutex& operator=(const Mutex&) = delete; 
+}; 
+ 
 #if defined(MUTEX_IS_WIN32_SRWLOCK)
-
+ 
 Mutex::Mutex()             : mutex_(SRWLOCK_INIT) { }
 Mutex::~Mutex()            { }
 void Mutex::Lock()         { AcquireSRWLockExclusive(&mutex_); }
@@ -75,74 +75,74 @@ void Mutex::ReaderUnlock() { ReleaseSRWLockShared(&mutex_); }
 
 #elif defined(MUTEX_IS_PTHREAD_RWLOCK)
 
-#define SAFE_PTHREAD(fncall)    \
-  do {                          \
-    if ((fncall) != 0) abort(); \
-  } while (0)
-
-Mutex::Mutex()             { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); }
-Mutex::~Mutex()            { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); }
-void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); }
-void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
-void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); }
-void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
-
-#undef SAFE_PTHREAD
-
-#else
-
-Mutex::Mutex()             { }
-Mutex::~Mutex()            { }
-void Mutex::Lock()         { mutex_.lock(); }
-void Mutex::Unlock()       { mutex_.unlock(); }
-void Mutex::ReaderLock()   { Lock(); }  // C++11 doesn't have std::shared_mutex.
-void Mutex::ReaderUnlock() { Unlock(); }
-
-#endif
-
-// --------------------------------------------------------------------------
-// Some helper classes
-
-// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
-class MutexLock {
- public:
-  explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); }
-  ~MutexLock() { mu_->Unlock(); }
- private:
-  Mutex * const mu_;
-
-  MutexLock(const MutexLock&) = delete;
-  MutexLock& operator=(const MutexLock&) = delete;
-};
-
-// ReaderMutexLock and WriterMutexLock do the same, for rwlocks
-class ReaderMutexLock {
- public:
-  explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); }
-  ~ReaderMutexLock() { mu_->ReaderUnlock(); }
- private:
-  Mutex * const mu_;
-
-  ReaderMutexLock(const ReaderMutexLock&) = delete;
-  ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
-};
-
-class WriterMutexLock {
- public:
-  explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); }
-  ~WriterMutexLock() { mu_->WriterUnlock(); }
- private:
-  Mutex * const mu_;
-
-  WriterMutexLock(const WriterMutexLock&) = delete;
-  WriterMutexLock& operator=(const WriterMutexLock&) = delete;
-};
-
-// Catch bug where variable name is omitted, e.g. MutexLock (&mu);
-#define MutexLock(x) static_assert(false, "MutexLock declaration missing variable name")
-#define ReaderMutexLock(x) static_assert(false, "ReaderMutexLock declaration missing variable name")
-#define WriterMutexLock(x) static_assert(false, "WriterMutexLock declaration missing variable name")
-
-}  // namespace re2
-
-#endif  // UTIL_MUTEX_H_
+#define SAFE_PTHREAD(fncall)    \ 
+  do {                          \ 
+    if ((fncall) != 0) abort(); \ 
+  } while (0) 
+ 
+Mutex::Mutex()             { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); } 
+Mutex::~Mutex()            { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); } 
+void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); } 
+void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); } 
+void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); } 
+void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); } 
+ 
+#undef SAFE_PTHREAD 
+ 
+#else 
+ 
+Mutex::Mutex()             { } 
+Mutex::~Mutex()            { } 
+void Mutex::Lock()         { mutex_.lock(); } 
+void Mutex::Unlock()       { mutex_.unlock(); } 
+void Mutex::ReaderLock()   { Lock(); }  // C++11 doesn't have std::shared_mutex. 
+void Mutex::ReaderUnlock() { Unlock(); } 
+ 
+#endif 
+ 
+// -------------------------------------------------------------------------- 
+// Some helper classes 
+ 
+// MutexLock(mu) acquires mu when constructed and releases it when destroyed. 
+class MutexLock { 
+ public: 
+  explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); } 
+  ~MutexLock() { mu_->Unlock(); } 
+ private: 
+  Mutex * const mu_; 
+ 
+  MutexLock(const MutexLock&) = delete; 
+  MutexLock& operator=(const MutexLock&) = delete; 
+}; 
+ 
+// ReaderMutexLock and WriterMutexLock do the same, for rwlocks 
+class ReaderMutexLock { 
+ public: 
+  explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); } 
+  ~ReaderMutexLock() { mu_->ReaderUnlock(); } 
+ private: 
+  Mutex * const mu_; 
+ 
+  ReaderMutexLock(const ReaderMutexLock&) = delete; 
+  ReaderMutexLock& operator=(const ReaderMutexLock&) = delete; 
+}; 
+ 
+class WriterMutexLock { 
+ public: 
+  explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); } 
+  ~WriterMutexLock() { mu_->WriterUnlock(); } 
+ private: 
+  Mutex * const mu_; 
+ 
+  WriterMutexLock(const WriterMutexLock&) = delete; 
+  WriterMutexLock& operator=(const WriterMutexLock&) = delete; 
+}; 
+ 
+// Catch bug where variable name is omitted, e.g. MutexLock (&mu); 
+#define MutexLock(x) static_assert(false, "MutexLock declaration missing variable name") 
+#define ReaderMutexLock(x) static_assert(false, "ReaderMutexLock declaration missing variable name") 
+#define WriterMutexLock(x) static_assert(false, "WriterMutexLock declaration missing variable name") 
+ 
+}  // namespace re2 
+ 
+#endif  // UTIL_MUTEX_H_