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

4 files changed, 55 insertions, 55 deletions

diff --git a/util/draft/date.cpp b/util/draft/date.cpp
index a290c460505..2ad2989c9e5 100644
--- a/util/draft/date.cpp
+++ b/util/draft/date.cpp
@@ -17,23 +17,23 @@ time_t GetDateStart(time_t ts) {
     return mktime(&dateTm);
 }
 
-static time_t ParseDate(const char* date, const char* format) {
+static time_t ParseDate(const char* date, const char* format) { 
     tm dateTm;
     memset(&dateTm, 0, sizeof(tm));
     if (!strptime(date, format, &dateTm)) {
-        ythrow yexception() << "Invalid date string and format: " << date << ", " << format;
+        ythrow yexception() << "Invalid date string and format: " << date << ", " << format; 
     }
     return mktime(&dateTm);
 }
 
-static time_t ParseDate(const char* dateStr) {
+static time_t ParseDate(const char* dateStr) { 
     if (strlen(dateStr) != 8) {
-        ythrow yexception() << "Invalid date string: " << dateStr;
+        ythrow yexception() << "Invalid date string: " << dateStr; 
     }
-
-    return ParseDate(dateStr, "%Y%m%d");
-}
-
+ 
+    return ParseDate(dateStr, "%Y%m%d"); 
+} 
+ 
 template <>
 TDate FromStringImpl<TDate>(const char* data, size_t len) {
     return TDate(ParseDate(TString(data, len).data()));
@@ -56,9 +56,9 @@ TDate::TDate(time_t ts)
 
 TDate::TDate(const TString& date, const TString& format)
     : Timestamp(GetDateStart(ParseDate(date.data(), format.data())))
-{
-}
-
+{ 
+} 
+ 
 TDate::TDate(unsigned year, unsigned month, unsigned monthDay) {
     tm dateTm;
     Zero(dateTm);
diff --git a/util/draft/date.h b/util/draft/date.h
index e3eb616fe5d..2a9cbc39971 100644
--- a/util/draft/date.h
+++ b/util/draft/date.h
@@ -3,7 +3,7 @@
 #include <util/stream/output.h>
 #include <util/stream/input.h>
 #include <util/generic/string.h>
-#include <util/datetime/constants.h>
+#include <util/datetime/constants.h> 
 
 #include <ctime>
 
@@ -43,31 +43,31 @@ public:
     TString ToStroka(const char* format = "%Y%m%d") const;
 
     TDate& operator++() {
-        Timestamp = GetDateStart(Timestamp + 3 * (SECONDS_IN_DAY / 2));
+        Timestamp = GetDateStart(Timestamp + 3 * (SECONDS_IN_DAY / 2)); 
         return *this;
     }
 
     TDate& operator--() {
-        Timestamp = GetDateStart(Timestamp - SECONDS_IN_DAY / 2);
+        Timestamp = GetDateStart(Timestamp - SECONDS_IN_DAY / 2); 
         return *this;
     }
 
     TDate& operator+=(unsigned days) {
-        Timestamp = GetDateStart(Timestamp + days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2);
+        Timestamp = GetDateStart(Timestamp + days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2); 
         return *this;
     }
 
     TDate& operator-=(unsigned days) {
-        Timestamp = GetDateStart(Timestamp - days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2);
+        Timestamp = GetDateStart(Timestamp - days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2); 
         return *this;
     }
 
     TDate operator+(unsigned days) const {
-        return TDate(Timestamp + days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2);
+        return TDate(Timestamp + days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2); 
     }
 
     TDate operator-(unsigned days) const {
-        return TDate(Timestamp - days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2);
+        return TDate(Timestamp - days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2); 
     }
 
     unsigned GetWeekDay() const; // days since Sunday
@@ -113,7 +113,7 @@ inline int operator-(const TDate& left, const TDate& right) {
     if (left < right) {
         return -(right - left);
     }
-    return static_cast<int>((left.Timestamp + SECONDS_IN_DAY / 2 - right.Timestamp) / SECONDS_IN_DAY);
+    return static_cast<int>((left.Timestamp + SECONDS_IN_DAY / 2 - right.Timestamp) / SECONDS_IN_DAY); 
 }
 
 inline IInputStream& operator>>(IInputStream& left, TDate& right) {
diff --git a/util/draft/date_ut.cpp b/util/draft/date_ut.cpp
index 8c33a6c1cfd..223fa4e41c0 100644
--- a/util/draft/date_ut.cpp
+++ b/util/draft/date_ut.cpp
@@ -24,13 +24,13 @@ Y_UNIT_TEST_SUITE(TDateTest) {
             UNIT_ASSERT_EQUAL(d.ToStroka("____%Y__%m____%d"), "____2005__06____03");
             UNIT_ASSERT_EQUAL(d.GetStartUTC(), 1117756800);
         }
-        {
-            TDate d("2011-02-15", "%Y-%m-%d");
-            UNIT_ASSERT_EQUAL(d.GetYear(), 2011);
-            UNIT_ASSERT_EQUAL(d.GetMonth(), 2);
-            UNIT_ASSERT_EQUAL(d.GetMonthDay(), 15);
-            UNIT_ASSERT_EQUAL(d.ToStroka("%Y%m%d"), "20110215");
+        { 
+            TDate d("2011-02-15", "%Y-%m-%d"); 
+            UNIT_ASSERT_EQUAL(d.GetYear(), 2011); 
+            UNIT_ASSERT_EQUAL(d.GetMonth(), 2); 
+            UNIT_ASSERT_EQUAL(d.GetMonthDay(), 15); 
+            UNIT_ASSERT_EQUAL(d.ToStroka("%Y%m%d"), "20110215"); 
             UNIT_ASSERT_EQUAL(d.GetStartUTC(), 1297728000);
-        }
+        } 
     }
 }
diff --git a/util/draft/enum.h b/util/draft/enum.h
index 18002b7df20..c65f54357c4 100644
--- a/util/draft/enum.h
+++ b/util/draft/enum.h
@@ -3,7 +3,7 @@
 #include <bitset>
 
 #include <util/generic/strbuf.h>
-#include <util/stream/str.h>
+#include <util/stream/str.h> 
 #include <util/string/cast.h>
 #include <util/string/split.h>
 #include <utility>
@@ -12,11 +12,11 @@ class TEnumNotFoundException: public yexception {
 };
 
 #define EnumFromString(key, entries) EnumFromStringImpl(key, entries, Y_ARRAY_SIZE(entries))
-#define EnumFromStringWithSize(key, entries, size) EnumFromStringImpl(key, entries, size)
+#define EnumFromStringWithSize(key, entries, size) EnumFromStringImpl(key, entries, size) 
 #define FindEnumFromString(key, entries) FindEnumFromStringImpl(key, entries, Y_ARRAY_SIZE(entries))
-#define FindEnumFromStringWithSize(key, entries, size) FindEnumFromStringImpl(key, entries, size)
+#define FindEnumFromStringWithSize(key, entries, size) FindEnumFromStringImpl(key, entries, size) 
 #define EnumToString(key, entries) EnumToStringImpl(key, entries, Y_ARRAY_SIZE(entries))
-#define EnumToStringWithSize(key, entries, size) EnumToStringImpl(key, entries, size)
+#define EnumToStringWithSize(key, entries, size) EnumToStringImpl(key, entries, size) 
 #define PrintEnumItems(entries) PrintEnumItemsImpl(entries, Y_ARRAY_SIZE(entries))
 
 template <class K1, class K2, class V>
@@ -80,39 +80,39 @@ const K* EnumToStringImpl(V value, const std::pair<K, V>* entries, size_t arrayS
 
 ///////////////////////////////////
 
-template <class B>
-inline void SetEnumFlagsForEmptySpec(B& flags, bool allIfEmpty) {
-    if (allIfEmpty) {
-        flags.set();
-    } else {
-        flags.reset();
-    }
-}
-
+template <class B> 
+inline void SetEnumFlagsForEmptySpec(B& flags, bool allIfEmpty) { 
+    if (allIfEmpty) { 
+        flags.set(); 
+    } else { 
+        flags.reset(); 
+    } 
+} 
+ 
 // all set by default
 template <class E, size_t N, size_t B>
 inline void SetEnumFlags(const std::pair<const char*, E> (&str2Enum)[N], TStringBuf optSpec,
                          std::bitset<B>& flags, bool allIfEmpty = true) {
     if (optSpec.empty()) {
-        SetEnumFlagsForEmptySpec(flags, allIfEmpty);
-    } else {
-        flags.reset();
-        for (const auto& it : StringSplitter(optSpec).Split(',')) {
+        SetEnumFlagsForEmptySpec(flags, allIfEmpty); 
+    } else { 
+        flags.reset(); 
+        for (const auto& it : StringSplitter(optSpec).Split(',')) { 
             E e = *EnumFromStringImpl(ToString(it.Token()).data(), str2Enum, N);
-            flags.set(e);
+            flags.set(e); 
         }
-    }
-}
-
-template <class E, size_t B>
+    } 
+} 
+ 
+template <class E, size_t B> 
 inline void SetEnumFlags(const std::pair<const char*, E>* str2Enum, TStringBuf optSpec,
-                         std::bitset<B>& flags, const size_t size,
+                         std::bitset<B>& flags, const size_t size, 
                          bool allIfEmpty = true) {
-    if (optSpec.empty()) {
-        SetEnumFlagsForEmptySpec(flags, allIfEmpty);
+    if (optSpec.empty()) { 
+        SetEnumFlagsForEmptySpec(flags, allIfEmpty); 
     } else {
         flags.reset();
-        for (const auto& it : StringSplitter(optSpec).Split(',')) {
+        for (const auto& it : StringSplitter(optSpec).Split(',')) { 
             E e = *EnumFromStringImpl(ToString(it.Token()).data(), str2Enum, size);
             flags.set(e);
         }
@@ -123,13 +123,13 @@ inline void SetEnumFlags(const std::pair<const char*, E>* str2Enum, TStringBuf o
 template <class E, size_t B>
 inline void SetEnumFlags(TStringBuf optSpec, std::bitset<B>& flags, bool allIfEmpty = true) {
     if (optSpec.empty()) {
-        SetEnumFlagsForEmptySpec(flags, allIfEmpty);
+        SetEnumFlagsForEmptySpec(flags, allIfEmpty); 
     } else {
         flags.reset();
-        for (const auto& it : StringSplitter(optSpec).Split(',')) {
+        for (const auto& it : StringSplitter(optSpec).Split(',')) { 
             E e;
             if (!TryFromString(it.Token(), e))
-                ythrow yexception() << "Unknown enum value '" << it.Token() << "'";
+                ythrow yexception() << "Unknown enum value '" << it.Token() << "'"; 
             flags.set((size_t)e);
         }
     }