Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.

1 files changed, 57 insertions, 57 deletions

diff --git a/library/cpp/threading/skip_list/compare.h b/library/cpp/threading/skip_list/compare.h
index 336582a1b8..ac98b3e1ce 100644
--- a/library/cpp/threading/skip_list/compare.h
+++ b/library/cpp/threading/skip_list/compare.h
@@ -4,74 +4,74 @@
 #include <util/str_stl.h>
 
 namespace NThreading {
-    namespace NImpl { 
-        Y_HAS_MEMBER(compare); 
-        Y_HAS_MEMBER(Compare); 
+    namespace NImpl {
+        Y_HAS_MEMBER(compare);
+        Y_HAS_MEMBER(Compare);
 
         template <typename T>
-        inline int CompareImpl(const T& l, const T& r) { 
-            if (l < r) { 
-                return -1; 
-            } else if (r < l) { 
-                return +1; 
-            } else { 
-                return 0; 
-            } 
+        inline int CompareImpl(const T& l, const T& r) {
+            if (l < r) {
+                return -1;
+            } else if (r < l) {
+                return +1;
+            } else {
+                return 0;
+            }
         }
 
-        template <bool val> 
-        struct TSmallCompareSelector { 
-            template <typename T> 
-            static inline int Compare(const T& l, const T& r) { 
-                return CompareImpl(l, r); 
-            } 
-        }; 
+        template <bool val>
+        struct TSmallCompareSelector {
+            template <typename T>
+            static inline int Compare(const T& l, const T& r) {
+                return CompareImpl(l, r);
+            }
+        };
 
-        template <> 
-        struct TSmallCompareSelector<true> { 
-            template <typename T> 
-            static inline int Compare(const T& l, const T& r) { 
-                return l.compare(r); 
-            } 
-        }; 
+        template <>
+        struct TSmallCompareSelector<true> {
+            template <typename T>
+            static inline int Compare(const T& l, const T& r) {
+                return l.compare(r);
+            }
+        };
 
-        template <bool val> 
-        struct TBigCompareSelector { 
-            template <typename T> 
-            static inline int Compare(const T& l, const T& r) { 
+        template <bool val>
+        struct TBigCompareSelector {
+            template <typename T>
+            static inline int Compare(const T& l, const T& r) {
                 return TSmallCompareSelector<THascompare<T>::value>::Compare(l, r);
-            } 
-        }; 
- 
-        template <> 
-        struct TBigCompareSelector<true> { 
-            template <typename T> 
-            static inline int Compare(const T& l, const T& r) { 
-                return l.Compare(r); 
-            } 
-        }; 
- 
+            }
+        };
+
+        template <>
+        struct TBigCompareSelector<true> {
+            template <typename T>
+            static inline int Compare(const T& l, const T& r) {
+                return l.Compare(r);
+            }
+        };
+
         template <typename T>
         struct TCompareSelector: public TBigCompareSelector<THasCompare<T>::value> {
-        }; 
-    } 
+        };
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Generic compare function
 
-    //////////////////////////////////////////////////////////////////////////////// 
-    // Generic compare function 
- 
     template <typename T>
-    inline int Compare(const T& l, const T& r) { 
-        return NImpl::TCompareSelector<T>::Compare(l, r); 
-    } 
- 
-    //////////////////////////////////////////////////////////////////////////////// 
-    // Generic compare functor 
- 
-    template <typename T> 
-    struct TCompare { 
-        inline int operator()(const T& l, const T& r) const { 
-            return Compare(l, r); 
-        } 
+    inline int Compare(const T& l, const T& r) {
+        return NImpl::TCompareSelector<T>::Compare(l, r);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Generic compare functor
+
+    template <typename T>
+    struct TCompare {
+        inline int operator()(const T& l, const T& r) const {
+            return Compare(l, r);
+        }
     };
 
 }