Restoring authorship annotation for <heretic@yandex-team.ru>. Commit 1 of 2.

1 files changed, 95 insertions, 95 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h
index aba5d58dc3..f50c0b8e48 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h
@@ -34,7 +34,7 @@
 #ifndef ABSL_BASE_THREAD_ANNOTATIONS_H_
 #define ABSL_BASE_THREAD_ANNOTATIONS_H_
 
-#include "y_absl/base/attributes.h"
+#include "y_absl/base/attributes.h" 
 #include "y_absl/base/config.h"
 // TODO(mbonadei): Remove after the backward compatibility period.
 #include "y_absl/base/internal/thread_annotations.h"  // IWYU pragma: export
@@ -56,11 +56,11 @@
 //     int p1_ ABSL_GUARDED_BY(mu_);
 //     ...
 //   };
-#if ABSL_HAVE_ATTRIBUTE(guarded_by)
-#define ABSL_GUARDED_BY(x) __attribute__((guarded_by(x)))
-#else
-#define ABSL_GUARDED_BY(x)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(guarded_by) 
+#define ABSL_GUARDED_BY(x) __attribute__((guarded_by(x))) 
+#else 
+#define ABSL_GUARDED_BY(x) 
+#endif 
 
 // ABSL_PT_GUARDED_BY()
 //
@@ -82,11 +82,11 @@
 //   // `q_`, guarded by `mu1_`, points to a shared memory location that is
 //   // guarded by `mu2_`:
 //   int *q_ ABSL_GUARDED_BY(mu1_) ABSL_PT_GUARDED_BY(mu2_);
-#if ABSL_HAVE_ATTRIBUTE(pt_guarded_by)
-#define ABSL_PT_GUARDED_BY(x) __attribute__((pt_guarded_by(x)))
-#else
-#define ABSL_PT_GUARDED_BY(x)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(pt_guarded_by) 
+#define ABSL_PT_GUARDED_BY(x) __attribute__((pt_guarded_by(x))) 
+#else 
+#define ABSL_PT_GUARDED_BY(x) 
+#endif 
 
 // ABSL_ACQUIRED_AFTER() / ABSL_ACQUIRED_BEFORE()
 //
@@ -103,17 +103,17 @@
 //
 //   Mutex m1_;
 //   Mutex m2_ ABSL_ACQUIRED_AFTER(m1_);
-#if ABSL_HAVE_ATTRIBUTE(acquired_after)
-#define ABSL_ACQUIRED_AFTER(...) __attribute__((acquired_after(__VA_ARGS__)))
-#else
-#define ABSL_ACQUIRED_AFTER(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(acquired_after) 
+#define ABSL_ACQUIRED_AFTER(...) __attribute__((acquired_after(__VA_ARGS__))) 
+#else 
+#define ABSL_ACQUIRED_AFTER(...) 
+#endif 
 
-#if ABSL_HAVE_ATTRIBUTE(acquired_before)
-#define ABSL_ACQUIRED_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__)))
-#else
-#define ABSL_ACQUIRED_BEFORE(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(acquired_before) 
+#define ABSL_ACQUIRED_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__))) 
+#else 
+#define ABSL_ACQUIRED_BEFORE(...) 
+#endif 
 
 // ABSL_EXCLUSIVE_LOCKS_REQUIRED() / ABSL_SHARED_LOCKS_REQUIRED()
 //
@@ -138,50 +138,50 @@
 //
 //   void foo() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... }
 //   void bar() const ABSL_SHARED_LOCKS_REQUIRED(mu1, mu2) { ... }
-#if ABSL_HAVE_ATTRIBUTE(exclusive_locks_required)
-#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) \
-  __attribute__((exclusive_locks_required(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(exclusive_locks_required) 
+#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) \ 
+  __attribute__((exclusive_locks_required(__VA_ARGS__))) 
+#else 
+#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) 
+#endif 
 
-#if ABSL_HAVE_ATTRIBUTE(shared_locks_required)
+#if ABSL_HAVE_ATTRIBUTE(shared_locks_required) 
 #define ABSL_SHARED_LOCKS_REQUIRED(...) \
-  __attribute__((shared_locks_required(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_LOCKS_REQUIRED(...)
-#endif
+  __attribute__((shared_locks_required(__VA_ARGS__))) 
+#else 
+#define ABSL_SHARED_LOCKS_REQUIRED(...) 
+#endif 
 
 // ABSL_LOCKS_EXCLUDED()
 //
 // Documents the locks acquired in the body of the function. These locks
 // cannot be held when calling this function (as Abseil's `Mutex` locks are
 // non-reentrant).
-#if ABSL_HAVE_ATTRIBUTE(locks_excluded)
-#define ABSL_LOCKS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__)))
-#else
-#define ABSL_LOCKS_EXCLUDED(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(locks_excluded) 
+#define ABSL_LOCKS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__))) 
+#else 
+#define ABSL_LOCKS_EXCLUDED(...) 
+#endif 
 
 // ABSL_LOCK_RETURNED()
 //
 // Documents a function that returns a mutex without acquiring it.  For example,
 // a public getter method that returns a pointer to a private mutex should
 // be annotated with ABSL_LOCK_RETURNED.
-#if ABSL_HAVE_ATTRIBUTE(lock_returned)
-#define ABSL_LOCK_RETURNED(x) __attribute__((lock_returned(x)))
-#else
-#define ABSL_LOCK_RETURNED(x)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(lock_returned) 
+#define ABSL_LOCK_RETURNED(x) __attribute__((lock_returned(x))) 
+#else 
+#define ABSL_LOCK_RETURNED(x) 
+#endif 
 
 // ABSL_LOCKABLE
 //
 // Documents if a class/type is a lockable type (such as the `Mutex` class).
-#if ABSL_HAVE_ATTRIBUTE(lockable)
-#define ABSL_LOCKABLE __attribute__((lockable))
-#else
-#define ABSL_LOCKABLE
-#endif
+#if ABSL_HAVE_ATTRIBUTE(lockable) 
+#define ABSL_LOCKABLE __attribute__((lockable)) 
+#else 
+#define ABSL_LOCKABLE 
+#endif 
 
 // ABSL_SCOPED_LOCKABLE
 //
@@ -190,43 +190,43 @@
 // acquired, and the destructor should use `UNLOCK_FUNCTION()` with no
 // arguments; the analysis will assume that the destructor unlocks whatever the
 // constructor locked.
-#if ABSL_HAVE_ATTRIBUTE(scoped_lockable)
-#define ABSL_SCOPED_LOCKABLE __attribute__((scoped_lockable))
-#else
-#define ABSL_SCOPED_LOCKABLE
-#endif
+#if ABSL_HAVE_ATTRIBUTE(scoped_lockable) 
+#define ABSL_SCOPED_LOCKABLE __attribute__((scoped_lockable)) 
+#else 
+#define ABSL_SCOPED_LOCKABLE 
+#endif 
 
 // ABSL_EXCLUSIVE_LOCK_FUNCTION()
 //
 // Documents functions that acquire a lock in the body of a function, and do
 // not release it.
-#if ABSL_HAVE_ATTRIBUTE(exclusive_lock_function)
-#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...) \
-  __attribute__((exclusive_lock_function(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(exclusive_lock_function) 
+#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...) \ 
+  __attribute__((exclusive_lock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...) 
+#endif 
 
 // ABSL_SHARED_LOCK_FUNCTION()
 //
 // Documents functions that acquire a shared (reader) lock in the body of a
 // function, and do not release it.
-#if ABSL_HAVE_ATTRIBUTE(shared_lock_function)
+#if ABSL_HAVE_ATTRIBUTE(shared_lock_function) 
 #define ABSL_SHARED_LOCK_FUNCTION(...) \
-  __attribute__((shared_lock_function(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_LOCK_FUNCTION(...)
-#endif
+  __attribute__((shared_lock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_SHARED_LOCK_FUNCTION(...) 
+#endif 
 
 // ABSL_UNLOCK_FUNCTION()
 //
 // Documents functions that expect a lock to be held on entry to the function,
 // and release it in the body of the function.
-#if ABSL_HAVE_ATTRIBUTE(unlock_function)
-#define ABSL_UNLOCK_FUNCTION(...) __attribute__((unlock_function(__VA_ARGS__)))
-#else
-#define ABSL_UNLOCK_FUNCTION(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(unlock_function) 
+#define ABSL_UNLOCK_FUNCTION(...) __attribute__((unlock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_UNLOCK_FUNCTION(...) 
+#endif 
 
 // ABSL_EXCLUSIVE_TRYLOCK_FUNCTION() / ABSL_SHARED_TRYLOCK_FUNCTION()
 //
@@ -236,49 +236,49 @@
 // success, or `false` for functions that return `false` on success. The second
 // argument specifies the mutex that is locked on success. If unspecified, this
 // mutex is assumed to be `this`.
-#if ABSL_HAVE_ATTRIBUTE(exclusive_trylock_function)
+#if ABSL_HAVE_ATTRIBUTE(exclusive_trylock_function) 
 #define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
-  __attribute__((exclusive_trylock_function(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...)
-#endif
+  __attribute__((exclusive_trylock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...) 
+#endif 
 
-#if ABSL_HAVE_ATTRIBUTE(shared_trylock_function)
-#define ABSL_SHARED_TRYLOCK_FUNCTION(...) \
-  __attribute__((shared_trylock_function(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_TRYLOCK_FUNCTION(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(shared_trylock_function) 
+#define ABSL_SHARED_TRYLOCK_FUNCTION(...) \ 
+  __attribute__((shared_trylock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_SHARED_TRYLOCK_FUNCTION(...) 
+#endif 
 
 // ABSL_ASSERT_EXCLUSIVE_LOCK() / ABSL_ASSERT_SHARED_LOCK()
 //
 // Documents functions that dynamically check to see if a lock is held, and fail
 // if it is not held.
-#if ABSL_HAVE_ATTRIBUTE(assert_exclusive_lock)
+#if ABSL_HAVE_ATTRIBUTE(assert_exclusive_lock) 
 #define ABSL_ASSERT_EXCLUSIVE_LOCK(...) \
-  __attribute__((assert_exclusive_lock(__VA_ARGS__)))
-#else
-#define ABSL_ASSERT_EXCLUSIVE_LOCK(...)
-#endif
+  __attribute__((assert_exclusive_lock(__VA_ARGS__))) 
+#else 
+#define ABSL_ASSERT_EXCLUSIVE_LOCK(...) 
+#endif 
 
-#if ABSL_HAVE_ATTRIBUTE(assert_shared_lock)
+#if ABSL_HAVE_ATTRIBUTE(assert_shared_lock) 
 #define ABSL_ASSERT_SHARED_LOCK(...) \
-  __attribute__((assert_shared_lock(__VA_ARGS__)))
-#else
-#define ABSL_ASSERT_SHARED_LOCK(...)
-#endif
+  __attribute__((assert_shared_lock(__VA_ARGS__))) 
+#else 
+#define ABSL_ASSERT_SHARED_LOCK(...) 
+#endif 
 
 // ABSL_NO_THREAD_SAFETY_ANALYSIS
 //
 // Turns off thread safety checking within the body of a particular function.
 // This annotation is used to mark functions that are known to be correct, but
 // the locking behavior is more complicated than the analyzer can handle.
-#if ABSL_HAVE_ATTRIBUTE(no_thread_safety_analysis)
+#if ABSL_HAVE_ATTRIBUTE(no_thread_safety_analysis) 
 #define ABSL_NO_THREAD_SAFETY_ANALYSIS \
-  __attribute__((no_thread_safety_analysis))
-#else
-#define ABSL_NO_THREAD_SAFETY_ANALYSIS
-#endif
+  __attribute__((no_thread_safety_analysis)) 
+#else 
+#define ABSL_NO_THREAD_SAFETY_ANALYSIS 
+#endif 
 
 //------------------------------------------------------------------------------
 // Tool-Supplied Annotations
@@ -317,7 +317,7 @@ namespace base_internal {
 
 // Takes a reference to a guarded data member, and returns an unguarded
 // reference.
-// Do not use this function directly, use ABSL_TS_UNCHECKED_READ instead.
+// Do not use this function directly, use ABSL_TS_UNCHECKED_READ instead. 
 template <typename T>
 inline const T& ts_unchecked_read(const T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
   return v;