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

3 files changed, 456 insertions, 456 deletions

diff --git a/library/cpp/deprecated/split/split_iterator.cpp b/library/cpp/deprecated/split/split_iterator.cpp
index 32262d25bd..88790475a6 100644
--- a/library/cpp/deprecated/split/split_iterator.cpp
+++ b/library/cpp/deprecated/split/split_iterator.cpp
@@ -1,112 +1,112 @@
 #include "split_iterator.h"
 
 #include <util/system/yassert.h>
-
+ 
 #include <cctype>
 #include <cstring>
 #include <cstdlib>
 
-/****************** TSplitDelimiters2 ******************/
-
+/****************** TSplitDelimiters2 ******************/ 
+ 
 TSplitDelimiters::TSplitDelimiters(const char* s) {
-    memset(Delims, 0, sizeof(Delims));
-    while (*s)
+    memset(Delims, 0, sizeof(Delims)); 
+    while (*s) 
         Delims[(ui8) * (s++)] = true;
-}
-
-/****************** TSplitBase ******************/
+} 
+ 
+/****************** TSplitBase ******************/ 
 TSplitBase::TSplitBase(const char* str, size_t length)
     : Str(str)
     , Len(length)
-{
-}
-
+{ 
+} 
+ 
 TSplitBase::TSplitBase(const TString& s)
     : Str(s.data())
     , Len(s.size())
-{
-}
-
-/****************** TDelimitersSplit ******************/
-
+{ 
+} 
+ 
+/****************** TDelimitersSplit ******************/ 
+ 
 TDelimitersSplit::TDelimitersSplit(const char* str, size_t length, const TSplitDelimiters& delimiters)
     : TSplitBase(str, length)
     , Delimiters(delimiters)
-{
-}
-
+{ 
+} 
+ 
 TDelimitersSplit::TDelimitersSplit(const TString& s, const TSplitDelimiters& delimiters)
     : TSplitBase(s)
     , Delimiters(delimiters)
-{
-}
-
+{ 
+} 
+ 
 size_t TDelimitersSplit::Begin() const {
-    size_t pos = 0;
+    size_t pos = 0; 
     while ((pos < Len) && Delimiters.IsDelimiter(Str[pos]))
-        ++pos;
-    return pos;
-}
-
+        ++pos; 
+    return pos; 
+} 
+ 
 TSizeTRegion TDelimitersSplit::Next(size_t& pos) const {
-    size_t begin = pos;
+    size_t begin = pos; 
     while ((pos < Len) && !Delimiters.IsDelimiter(Str[pos]))
-        ++pos;
-    TSizeTRegion result(begin, pos);
-
+        ++pos; 
+    TSizeTRegion result(begin, pos); 
+ 
     while ((pos < Len) && Delimiters.IsDelimiter(Str[pos]))
-        ++pos;
-
-    return result;
-}
+        ++pos; 
 
+    return result; 
+} 
+ 
 TDelimitersSplit::TIterator TDelimitersSplit::Iterator() const {
-    return TIterator(*this);
-}
-
-/****************** TDelimitersStrictSplit ******************/
-
+    return TIterator(*this); 
+} 
+ 
+/****************** TDelimitersStrictSplit ******************/ 
+ 
 TDelimitersStrictSplit::TDelimitersStrictSplit(const char* str, size_t length, const TSplitDelimiters& delimiters)
     : TSplitBase(str, length)
     , Delimiters(delimiters)
-{
-}
-
+{ 
+} 
+ 
 TDelimitersStrictSplit::TDelimitersStrictSplit(const TString& s, const TSplitDelimiters& delimiters)
     : TSplitBase(s)
     , Delimiters(delimiters)
-{
-}
-
+{ 
+} 
+ 
 TDelimitersStrictSplit::TIterator TDelimitersStrictSplit::Iterator() const {
-    return TIterator(*this);
-}
-
+    return TIterator(*this); 
+} 
+ 
 TSizeTRegion TDelimitersStrictSplit::Next(size_t& pos) const {
-    size_t begin = pos;
+    size_t begin = pos; 
     while ((pos < Len) && !Delimiters.IsDelimiter(Str[pos]))
-        ++pos;
-    TSizeTRegion result(begin, pos);
-
-    if (pos < Len)
-        ++pos;
-
-    return result;
-}
-
+        ++pos; 
+    TSizeTRegion result(begin, pos); 
+ 
+    if (pos < Len) 
+        ++pos; 
+ 
+    return result; 
+} 
+ 
 size_t TDelimitersStrictSplit::Begin() const {
-    return 0;
-}
-
-/****************** TScreenedDelimitersSplit ******************/
-
+    return 0; 
+} 
+ 
+/****************** TScreenedDelimitersSplit ******************/ 
+ 
 TScreenedDelimitersSplit::TScreenedDelimitersSplit(const TString& s, const TSplitDelimiters& delimiters, const TSplitDelimiters& screens)
-    : TSplitBase(s)
-    , Delimiters(delimiters)
-    , Screens(screens)
-{
-}
-
+    : TSplitBase(s) 
+    , Delimiters(delimiters) 
+    , Screens(screens) 
+{ 
+} 
+ 
 TScreenedDelimitersSplit::TScreenedDelimitersSplit(const char* str, size_t length, const TSplitDelimiters& delimiters, const TSplitDelimiters& screens)
     : TSplitBase(str, length)
     , Delimiters(delimiters)
@@ -114,174 +114,174 @@ TScreenedDelimitersSplit::TScreenedDelimitersSplit(const char* str, size_t lengt
 {
 }
 
-TScreenedDelimitersSplit::TIterator TScreenedDelimitersSplit::Iterator() const {
-    return TIterator(*this);
-}
-
-TSizeTRegion TScreenedDelimitersSplit::Next(size_t& pos) const {
-    size_t begin = pos;
-    bool screened = false;
-    while (pos < Len) {
-        if (Screens.IsDelimiter(Str[pos]))
-            screened = !screened;
-        if (Delimiters.IsDelimiter(Str[pos]) && !screened)
-            break;
-        ++pos;
-    }
-    TSizeTRegion result(begin, pos);
-
-    if (pos < Len)
-        ++pos;
-
-    return result;
-}
-
-size_t TScreenedDelimitersSplit::Begin() const {
-    return 0;
-}
-
-/****************** TDelimitersSplitWithoutTags ******************/
-
+TScreenedDelimitersSplit::TIterator TScreenedDelimitersSplit::Iterator() const { 
+    return TIterator(*this); 
+} 
+ 
+TSizeTRegion TScreenedDelimitersSplit::Next(size_t& pos) const { 
+    size_t begin = pos; 
+    bool screened = false; 
+    while (pos < Len) { 
+        if (Screens.IsDelimiter(Str[pos])) 
+            screened = !screened; 
+        if (Delimiters.IsDelimiter(Str[pos]) && !screened) 
+            break; 
+        ++pos; 
+    } 
+    TSizeTRegion result(begin, pos); 
+ 
+    if (pos < Len) 
+        ++pos; 
+ 
+    return result; 
+} 
+ 
+size_t TScreenedDelimitersSplit::Begin() const { 
+    return 0; 
+} 
+ 
+/****************** TDelimitersSplitWithoutTags ******************/ 
+ 
 TDelimitersSplitWithoutTags::TDelimitersSplitWithoutTags(const char* str, size_t length, const TSplitDelimiters& delimiters)
     : TSplitBase(str, length)
     , Delimiters(delimiters)
-{
-}
-
+{ 
+} 
+ 
 TDelimitersSplitWithoutTags::TDelimitersSplitWithoutTags(const TString& s, const TSplitDelimiters& delimiters)
     : TSplitBase(s)
     , Delimiters(delimiters)
-{
-}
-
+{ 
+} 
+ 
 size_t TDelimitersSplitWithoutTags::SkipTag(size_t pos) const {
     Y_ASSERT('<' == Str[pos]);
-    while ((pos < Len) && ('>' != Str[pos]))
-        ++pos;
-    return pos + 1;
-}
-
+    while ((pos < Len) && ('>' != Str[pos])) 
+        ++pos; 
+    return pos + 1; 
+} 
+ 
 size_t TDelimitersSplitWithoutTags::SkipDelimiters(size_t pos) const {
     while (true) {
         while ((pos < Len) && Delimiters.IsDelimiter(Str[pos]) && ('<' != Str[pos]))
-            ++pos;
+            ++pos; 
         if (pos < Len) {
-            if ('<' != Str[pos])
-                break;
-            else
-                pos = SkipTag(pos);
+            if ('<' != Str[pos]) 
+                break; 
+            else 
+                pos = SkipTag(pos); 
         } else
-            break;
-    }
-    return pos;
-}
-
+            break; 
+    } 
+    return pos; 
+} 
+ 
 size_t TDelimitersSplitWithoutTags::Begin() const {
-    size_t pos = 0;
-    pos = SkipDelimiters(pos);
-    return pos;
-}
-
+    size_t pos = 0; 
+    pos = SkipDelimiters(pos); 
+    return pos; 
+} 
+ 
 TSizeTRegion TDelimitersSplitWithoutTags::Next(size_t& pos) const {
-    size_t begin = pos;
+    size_t begin = pos; 
     while ((pos < Len) && !Delimiters.IsDelimiter(Str[pos]) && ('<' != Str[pos]))
-        ++pos;
-    TSizeTRegion result(begin, pos);
-
-    pos = SkipDelimiters(pos);
-
-    return result;
-}
-
+        ++pos; 
+    TSizeTRegion result(begin, pos); 
+
+    pos = SkipDelimiters(pos); 
+ 
+    return result; 
+} 
+ 
 TDelimitersSplitWithoutTags::TIterator TDelimitersSplitWithoutTags::Iterator() const {
-    return TIterator(*this);
-}
-
-/****************** TCharSplit ******************/
-
+    return TIterator(*this); 
+} 
+ 
+/****************** TCharSplit ******************/ 
+ 
 TCharSplit::TCharSplit(const char* str, size_t length)
     : TSplitBase(str, length)
-{
-}
-
+{ 
+} 
+ 
 TCharSplit::TCharSplit(const TString& s)
     : TSplitBase(s)
-{
-}
-
+{ 
+} 
+ 
 TCharSplit::TIterator TCharSplit::Iterator() const {
-    return TIterator(*this);
-}
-
+    return TIterator(*this); 
+} 
+ 
 TSizeTRegion TCharSplit::Next(size_t& pos) const {
-    TSizeTRegion result(pos, pos + 1);
-    ++pos;
-    return result;
-}
-
+    TSizeTRegion result(pos, pos + 1); 
+    ++pos; 
+    return result; 
+} 
+ 
 size_t TCharSplit::Begin() const {
-    return 0;
-}
-
-/****************** TCharSplitWithoutTags ******************/
-
-TCharSplitWithoutTags::TCharSplitWithoutTags(const char* str, size_t length)
-    : TSplitBase(str, length)
-{
-}
-
+    return 0; 
+} 
+ 
+/****************** TCharSplitWithoutTags ******************/ 
+ 
+TCharSplitWithoutTags::TCharSplitWithoutTags(const char* str, size_t length) 
+    : TSplitBase(str, length) 
+{ 
+} 
+ 
 TCharSplitWithoutTags::TCharSplitWithoutTags(const TString& s)
-    : TSplitBase(s)
-{
-}
-
+    : TSplitBase(s) 
+{ 
+} 
+ 
 size_t TCharSplitWithoutTags::SkipTag(size_t pos) const {
     Y_ASSERT('<' == Str[pos]);
-    while ((pos < Len) && ('>' != Str[pos]))
-        ++pos;
-    return pos + 1;
-}
-
+    while ((pos < Len) && ('>' != Str[pos])) 
+        ++pos; 
+    return pos + 1; 
+} 
+ 
 size_t TCharSplitWithoutTags::SkipDelimiters(size_t pos) const {
     while (true) {
         if (pos < Len) {
-            if ('<' != Str[pos])
-                break;
-            else
-                pos = SkipTag(pos);
+            if ('<' != Str[pos]) 
+                break; 
+            else 
+                pos = SkipTag(pos); 
         } else
-            break;
-    }
-    return pos;
-}
-
+            break; 
+    } 
+    return pos; 
+} 
+ 
 size_t TCharSplitWithoutTags::Begin() const {
-    size_t pos = 0;
-    pos = SkipDelimiters(pos);
-    return pos;
-}
-
+    size_t pos = 0; 
+    pos = SkipDelimiters(pos); 
+    return pos; 
+} 
+ 
 TSizeTRegion TCharSplitWithoutTags::Next(size_t& pos) const {
-    size_t begin = pos++;
-    TSizeTRegion result(begin, pos);
-
-    pos = SkipDelimiters(pos);
-
-    return result;
-}
-
+    size_t begin = pos++; 
+    TSizeTRegion result(begin, pos); 
+ 
+    pos = SkipDelimiters(pos); 
+ 
+    return result; 
+} 
+ 
 TCharSplitWithoutTags::TIterator TCharSplitWithoutTags::Iterator() const {
-    return TIterator(*this);
-}
-
+    return TIterator(*this); 
+} 
+ 
 TSubstringSplitDelimiter::TSubstringSplitDelimiter(const TString& s)
-    : Matcher(s)
+    : Matcher(s) 
     , Len(s.size())
-{
-}
-
-/****************** TSubstringSplit ******************/
-
+{ 
+} 
+ 
+/****************** TSubstringSplit ******************/ 
+ 
 TSubstringSplit::TSubstringSplit(const char* str, size_t length, const TSubstringSplitDelimiter& delimiter)
     : TSplitBase(str, length)
     , Delimiter(delimiter)
@@ -289,30 +289,30 @@ TSubstringSplit::TSubstringSplit(const char* str, size_t length, const TSubstrin
 }
 
 TSubstringSplit::TSubstringSplit(const TString& str, const TSubstringSplitDelimiter& delimiter)
-    : TSplitBase(str)
-    , Delimiter(delimiter)
-{
-}
-
-TSubstringSplit::TIterator TSubstringSplit::Iterator() const {
-    return TIterator(*this);
-}
-
-TSizeTRegion TSubstringSplit::Next(size_t& pos) const {
-    const char* begin = Str + pos;
-    const char* end = Str + Len;
-    const char* delim;
-    if (Delimiter.Matcher.SubStr(begin, end, delim)) {
-        TSizeTRegion result(pos, delim - begin + pos);
-        pos += delim - begin + Delimiter.Len;
-        return result;
-    } else {
-        TSizeTRegion result(pos, end - begin + pos);
-        pos += end - begin;
-        return result;
-    }
-}
-
-size_t TSubstringSplit::Begin() const {
-    return 0;
-}
+    : TSplitBase(str) 
+    , Delimiter(delimiter) 
+{ 
+} 
+ 
+TSubstringSplit::TIterator TSubstringSplit::Iterator() const { 
+    return TIterator(*this); 
+} 
+ 
+TSizeTRegion TSubstringSplit::Next(size_t& pos) const { 
+    const char* begin = Str + pos; 
+    const char* end = Str + Len; 
+    const char* delim; 
+    if (Delimiter.Matcher.SubStr(begin, end, delim)) { 
+        TSizeTRegion result(pos, delim - begin + pos); 
+        pos += delim - begin + Delimiter.Len; 
+        return result; 
+    } else { 
+        TSizeTRegion result(pos, end - begin + pos); 
+        pos += end - begin; 
+        return result; 
+    } 
+} 
+ 
+size_t TSubstringSplit::Begin() const { 
+    return 0; 
+} 
diff --git a/library/cpp/deprecated/split/split_iterator.h b/library/cpp/deprecated/split/split_iterator.h
index 0eacc29228..f6f73dae11 100644
--- a/library/cpp/deprecated/split/split_iterator.h
+++ b/library/cpp/deprecated/split/split_iterator.h
@@ -1,5 +1,5 @@
 #pragma once
-
+ 
 #include <library/cpp/deprecated/kmp/kmp.h>
 #include <util/string/cast.h>
 #include <util/string/util.h>
@@ -11,7 +11,7 @@
 #include <util/generic/string.h>
 #include <util/generic/vector.h>
 #include <util/generic/yexception.h>
-
+ 
 #include <cstdio>
 
 template <typename T>
@@ -57,225 +57,225 @@ inline TUi32Region FromString(const TString& s) {
 }
 
 class TSplitDelimiters {
-private:
-    bool Delims[256];
-
-public:
+private: 
+    bool Delims[256]; 
+ 
+public: 
     explicit TSplitDelimiters(const char* s);
 
     Y_FORCE_INLINE bool IsDelimiter(ui8 ch) const {
-        return Delims[ch];
-    }
-};
-
+        return Delims[ch]; 
+    } 
+}; 
+ 
 template <class Split>
-class TSplitIterator;
-
+class TSplitIterator; 
+ 
 class TSplitBase {
-protected:
-    const char* Str;
-    size_t Len;
-
-public:
-    TSplitBase(const char* str, size_t length);
+protected: 
+    const char* Str; 
+    size_t Len; 
+ 
+public: 
+    TSplitBase(const char* str, size_t length); 
     TSplitBase(const TString& s);
-
+ 
     Y_FORCE_INLINE const char* GetString() const {
-        return Str;
-    }
-
+        return Str; 
+    } 
+ 
     Y_FORCE_INLINE size_t GetLength() const {
-        return Len;
-    }
+        return Len; 
+    } 
 
 private:
     // we don't own Str, make sure that no one calls us with temporary object
     TSplitBase(TString&&) = delete;
-};
-
-#ifdef _MSC_VER
+}; 
+ 
+#ifdef _MSC_VER 
 #pragma warning(push)
 #pragma warning(disable : 4512)
-#endif
-
+#endif 
+ 
 class TDelimitersSplit: public TSplitBase {
-private:
-    const TSplitDelimiters& Delimiters;
-
-public:
+private: 
+    const TSplitDelimiters& Delimiters; 
+ 
+public: 
     using TIterator = TSplitIterator<TDelimitersSplit>;
-    friend class TSplitIterator<TDelimitersSplit>;
-
-    TDelimitersSplit(const char* str, size_t length, const TSplitDelimiters& delimiters);
+    friend class TSplitIterator<TDelimitersSplit>; 
+ 
+    TDelimitersSplit(const char* str, size_t length, const TSplitDelimiters& delimiters); 
     TDelimitersSplit(const TString& s, const TSplitDelimiters& delimiters);
-    TIterator Iterator() const;
-    TSizeTRegion Next(size_t& pos) const;
-    size_t Begin() const;
+    TIterator Iterator() const; 
+    TSizeTRegion Next(size_t& pos) const; 
+    size_t Begin() const; 
 
 private:
     // we don't own Delimiters, make sure that no one calls us with temporary object
     TDelimitersSplit(const char*, size_t, TSplitDelimiters&&) = delete;
     TDelimitersSplit(const TString&, TSplitDelimiters&&) = delete;
     TDelimitersSplit(TString&&, const TSplitDelimiters&) = delete;
-};
-
+}; 
+ 
 class TDelimitersStrictSplit: public TSplitBase {
-private:
-    const TSplitDelimiters& Delimiters;
-
-public:
+private: 
+    const TSplitDelimiters& Delimiters; 
+ 
+public: 
     using TIterator = TSplitIterator<TDelimitersStrictSplit>;
-    friend class TSplitIterator<TDelimitersStrictSplit>;
-
-    TDelimitersStrictSplit(const char* str, size_t length, const TSplitDelimiters& delimiters);
+    friend class TSplitIterator<TDelimitersStrictSplit>; 
+ 
+    TDelimitersStrictSplit(const char* str, size_t length, const TSplitDelimiters& delimiters); 
     TDelimitersStrictSplit(const TString& s, const TSplitDelimiters& delimiters);
-    TIterator Iterator() const;
-    TSizeTRegion Next(size_t& pos) const;
-    size_t Begin() const;
+    TIterator Iterator() const; 
+    TSizeTRegion Next(size_t& pos) const; 
+    size_t Begin() const; 
 
 private:
     // we don't own Delimiters, make sure that no one calls us with temporary object
     TDelimitersStrictSplit(const char*, size_t, TSplitDelimiters&&) = delete;
     TDelimitersStrictSplit(const TString&, TSplitDelimiters&&) = delete;
     TDelimitersStrictSplit(TString&&, const TSplitDelimiters&) = delete;
-};
-
+}; 
+ 
 class TScreenedDelimitersSplit: public TSplitBase {
-private:
-    const TSplitDelimiters& Delimiters;
-    const TSplitDelimiters& Screens;
-
-public:
+private: 
+    const TSplitDelimiters& Delimiters; 
+    const TSplitDelimiters& Screens; 
+ 
+public: 
     using TIterator = TSplitIterator<TScreenedDelimitersSplit>;
-    friend class TSplitIterator<TScreenedDelimitersSplit>;
-
+    friend class TSplitIterator<TScreenedDelimitersSplit>; 
+ 
     TScreenedDelimitersSplit(const char*, size_t, const TSplitDelimiters& delimiters, const TSplitDelimiters& screens);
     TScreenedDelimitersSplit(const TString& s, const TSplitDelimiters& delimiters, const TSplitDelimiters& screens);
-    TIterator Iterator() const;
-    TSizeTRegion Next(size_t& pos) const;
-    size_t Begin() const;
+    TIterator Iterator() const; 
+    TSizeTRegion Next(size_t& pos) const; 
+    size_t Begin() const; 
 
 private:
     // we don't own Delimiters and Screens, make sure that no one calls us with temporary object
     TScreenedDelimitersSplit(TString&&, const TSplitDelimiters&, const TSplitDelimiters&) = delete;
     TScreenedDelimitersSplit(const TString&, TSplitDelimiters&&, const TSplitDelimiters&) = delete;
     TScreenedDelimitersSplit(const TString&, const TSplitDelimiters&, TSplitDelimiters&&) = delete;
-};
-
+}; 
+ 
 class TDelimitersSplitWithoutTags: public TSplitBase {
-private:
-    const TSplitDelimiters& Delimiters;
-    size_t SkipTag(size_t pos) const;
-    size_t SkipDelimiters(size_t pos) const;
-
-public:
+private: 
+    const TSplitDelimiters& Delimiters; 
+    size_t SkipTag(size_t pos) const; 
+    size_t SkipDelimiters(size_t pos) const; 
+ 
+public: 
     using TIterator = TSplitIterator<TDelimitersSplitWithoutTags>;
-    friend class TSplitIterator<TDelimitersSplitWithoutTags>;
-
-    TDelimitersSplitWithoutTags(const char* str, size_t length, const TSplitDelimiters& delimiters);
+    friend class TSplitIterator<TDelimitersSplitWithoutTags>; 
+ 
+    TDelimitersSplitWithoutTags(const char* str, size_t length, const TSplitDelimiters& delimiters); 
     TDelimitersSplitWithoutTags(const TString& s, const TSplitDelimiters& delimiters);
-    TIterator Iterator() const;
-    TSizeTRegion Next(size_t& pos) const;
-    size_t Begin() const;
+    TIterator Iterator() const; 
+    TSizeTRegion Next(size_t& pos) const; 
+    size_t Begin() const; 
 
 private:
     // we don't own Delimiters, make sure that no one calls us with temporary object
     TDelimitersSplitWithoutTags(const char*, size_t, TSplitDelimiters&&) = delete;
     TDelimitersSplitWithoutTags(const TString&, TSplitDelimiters&&) = delete;
     TDelimitersSplitWithoutTags(TString&&, const TSplitDelimiters&) = delete;
-};
-
+}; 
+ 
 class TCharSplit: public TSplitBase {
-public:
+public: 
     using TIterator = TSplitIterator<TCharSplit>;
-    friend class TSplitIterator<TCharSplit>;
-
-    TCharSplit(const char* str, size_t length);
+    friend class TSplitIterator<TCharSplit>; 
+ 
+    TCharSplit(const char* str, size_t length); 
     TCharSplit(const TString& s);
-    TIterator Iterator() const;
-    TSizeTRegion Next(size_t& pos) const;
-    size_t Begin() const;
+    TIterator Iterator() const; 
+    TSizeTRegion Next(size_t& pos) const; 
+    size_t Begin() const; 
 
 private:
     // we don't own Str, make sure that no one calls us with temporary object
     TCharSplit(TString&&) = delete;
-};
-
-#ifdef _MSC_VER
+}; 
+ 
+#ifdef _MSC_VER 
 #pragma warning(pop)
-#endif
-
+#endif 
+ 
 class TCharSplitWithoutTags: public TSplitBase {
-private:
-    size_t SkipTag(size_t pos) const;
-    size_t SkipDelimiters(size_t pos) const;
-
-public:
+private: 
+    size_t SkipTag(size_t pos) const; 
+    size_t SkipDelimiters(size_t pos) const; 
+ 
+public: 
     using TIterator = TSplitIterator<TCharSplitWithoutTags>;
-    friend class TSplitIterator<TCharSplitWithoutTags>;
-
-    TCharSplitWithoutTags(const char* str, size_t length);
+    friend class TSplitIterator<TCharSplitWithoutTags>; 
+ 
+    TCharSplitWithoutTags(const char* str, size_t length); 
     TCharSplitWithoutTags(const TString& s);
-    TIterator Iterator() const;
-    TSizeTRegion Next(size_t& pos) const;
-    size_t Begin() const;
+    TIterator Iterator() const; 
+    TSizeTRegion Next(size_t& pos) const; 
+    size_t Begin() const; 
 
 private:
     // we don't own Str, make sure that no one calls us with temporary object
     TCharSplitWithoutTags(TString&&) = delete;
-};
-
+}; 
+ 
 class TSubstringSplitDelimiter {
-public:
-    TKMPMatcher Matcher;
-    size_t Len;
-
+public: 
+    TKMPMatcher Matcher; 
+    size_t Len; 
+ 
     TSubstringSplitDelimiter(const TString& s);
-};
-
+}; 
+ 
 class TSubstringSplit: public TSplitBase {
-private:
-    const TSubstringSplitDelimiter& Delimiter;
-
-public:
+private: 
+    const TSubstringSplitDelimiter& Delimiter; 
+ 
+public: 
     using TIterator = TSplitIterator<TSubstringSplit>;
-    friend class TSplitIterator<TSubstringSplit>;
-
+    friend class TSplitIterator<TSubstringSplit>; 
+ 
     TSubstringSplit(const char* str, size_t length, const TSubstringSplitDelimiter& delimiter);
     TSubstringSplit(const TString& str, const TSubstringSplitDelimiter& delimiter);
-    TIterator Iterator() const;
-    TSizeTRegion Next(size_t& pos) const;
-    size_t Begin() const;
+    TIterator Iterator() const; 
+    TSizeTRegion Next(size_t& pos) const; 
+    size_t Begin() const; 
 
 private:
     // we don't own Delimiters, make sure that no one calls us with temporary object
     TSubstringSplit(TString&&, const TSubstringSplitDelimiter&) = delete;
     TSubstringSplit(const TString&, TSubstringSplitDelimiter&&) = delete;
-};
-
+}; 
+ 
 template <class TSplit>
 class TSplitIterator {
-protected:
-    const TSplit& Split;
-    size_t Pos;
+protected: 
+    const TSplit& Split; 
+    size_t Pos; 
     TString* CurrentStroka;
-
-public:
-    TSplitIterator(const TSplit& split)
-        : Split(split)
-        , Pos(Split.Begin())
+ 
+public: 
+    TSplitIterator(const TSplit& split) 
+        : Split(split) 
+        , Pos(Split.Begin()) 
         , CurrentStroka(nullptr)
-    {
-    }
-
-    virtual ~TSplitIterator() {
-        delete CurrentStroka;
-    }
-
-    inline TSizeTRegion Next() {
+    { 
+    } 
+ 
+    virtual ~TSplitIterator() { 
+        delete CurrentStroka; 
+    } 
+
+    inline TSizeTRegion Next() { 
         Y_ENSURE(!Eof(), TStringBuf("eof reached"));
-        return Split.Next(Pos);
-    }
+        return Split.Next(Pos); 
+    } 
 
     TStringBuf NextTok() {
         if (Eof())
@@ -285,33 +285,33 @@ public:
     }
 
     const TString& NextString() {
-        if (!CurrentStroka)
+        if (!CurrentStroka) 
             CurrentStroka = new TString();
-        TSizeTRegion region = Next();
-        CurrentStroka->assign(Split.Str, region.Begin, region.Length() - 1);
-        return *CurrentStroka;
-    }
-
-    inline bool Eof() const {
-        return Pos >= Split.Len;
-    }
-
+        TSizeTRegion region = Next(); 
+        CurrentStroka->assign(Split.Str, region.Begin, region.Length() - 1); 
+        return *CurrentStroka; 
+    } 
+ 
+    inline bool Eof() const { 
+        return Pos >= Split.Len; 
+    } 
+ 
     TString GetTail() const {
         return TString(Split.Str + Pos);
-    }
-
-    void Skip(size_t count) {
-        for (size_t i = 0; i < count; ++i)
-            Next();
-    }
-};
-
+    } 
+ 
+    void Skip(size_t count) { 
+        for (size_t i = 0; i < count; ++i) 
+            Next(); 
+    } 
+}; 
+ 
 using TSplitTokens = TVector<TString>;
-
+ 
 template <typename TSplit>
 void Split(const TSplit& split, TSplitTokens* words) {
-    words->clear();
-    TSplitIterator<TSplit> it(split);
-    while (!it.Eof())
+    words->clear(); 
+    TSplitIterator<TSplit> it(split); 
+    while (!it.Eof()) 
         words->push_back(it.NextString());
-}
+} 
diff --git a/library/cpp/deprecated/split/split_iterator_ut.cpp b/library/cpp/deprecated/split/split_iterator_ut.cpp
index be5069c4be..42951b6ab4 100644
--- a/library/cpp/deprecated/split/split_iterator_ut.cpp
+++ b/library/cpp/deprecated/split/split_iterator_ut.cpp
@@ -1,93 +1,93 @@
 #include "split_iterator.h"
-
+ 
 #include <library/cpp/testing/unittest/registar.h>
-
+ 
 class TSplitIteratorTest: public TTestBase {
-    UNIT_TEST_SUITE(TSplitIteratorTest);
+    UNIT_TEST_SUITE(TSplitIteratorTest); 
     UNIT_TEST(TestDelimiters);
     UNIT_TEST(TestDelimitersSplit);
     UNIT_TEST(TestDelimitersStrictSplit);
     UNIT_TEST(TestTail);
     UNIT_TEST(TestScreenedDelimitersSplit);
     UNIT_TEST(TestSubstringDelimiter);
-    UNIT_TEST_SUITE_END();
-
-public:
-    void TestDelimiters();
-    void TestDelimitersSplit();
-    void TestDelimitersStrictSplit();
-    void TestTail();
-    void TestScreenedDelimitersSplit();
-    void TestSubstringDelimiter();
-};
-
+    UNIT_TEST_SUITE_END(); 
+ 
+public: 
+    void TestDelimiters(); 
+    void TestDelimitersSplit(); 
+    void TestDelimitersStrictSplit(); 
+    void TestTail(); 
+    void TestScreenedDelimitersSplit(); 
+    void TestSubstringDelimiter(); 
+}; 
+ 
 void TSplitIteratorTest::TestDelimiters() {
-    TSplitDelimiters delims("@");
-    for (int i = 0; i < 256; ++i)
+    TSplitDelimiters delims("@"); 
+    for (int i = 0; i < 256; ++i) 
         if ('@' != i) {
-            UNIT_ASSERT(!delims.IsDelimiter((ui8)i));
+            UNIT_ASSERT(!delims.IsDelimiter((ui8)i)); 
         } else {
-            UNIT_ASSERT(delims.IsDelimiter((ui8)i));
-        }
-}
-
+            UNIT_ASSERT(delims.IsDelimiter((ui8)i)); 
+        } 
+} 
+ 
 void TSplitIteratorTest::TestDelimitersSplit() {
-    {
+    { 
         TString s = "1a3b45cd";
         TSplitDelimiters delims("abcd");
         TDelimitersSplit split(s, delims);
-        TSplitTokens tokens;
-        Split(split, &tokens);
+        TSplitTokens tokens; 
+        Split(split, &tokens); 
         TSplitTokens pattern = {"1", "3", "45"};
-        UNIT_ASSERT(tokens == pattern);
-    }
-    {
+        UNIT_ASSERT(tokens == pattern); 
+    } 
+    { 
         TString s = "aaaaaa";
         TSplitDelimiters delims("abcd");
         TDelimitersSplit split(s, delims);
-        TSplitTokens tokens;
-        Split(split, &tokens);
+        TSplitTokens tokens; 
+        Split(split, &tokens); 
         TSplitTokens pattern = {};
-        UNIT_ASSERT(tokens == pattern);
-    }
-}
-
+        UNIT_ASSERT(tokens == pattern); 
+    } 
+} 
+ 
 void TSplitIteratorTest::TestDelimitersStrictSplit() {
-    {
+    { 
         TString s = "grp@2";
         TSplitDelimiters delims("@");
         TDelimitersStrictSplit split(s, delims);
-        TSplitTokens tokens;
-        Split(split, &tokens);
+        TSplitTokens tokens; 
+        Split(split, &tokens); 
         TSplitTokens pattern = {"grp", "2"};
-        UNIT_ASSERT(tokens == pattern);
-    }
-
-    {
+        UNIT_ASSERT(tokens == pattern); 
+    } 
+ 
+    { 
         TString s = "@grp@2@@";
         TSplitDelimiters delims("@");
         TDelimitersStrictSplit split(s, delims);
-        TSplitTokens tokens;
-        Split(split, &tokens);
+        TSplitTokens tokens; 
+        Split(split, &tokens); 
         TSplitTokens pattern = {"", "grp", "2", ""};
-        UNIT_ASSERT(tokens == pattern);
-    }
-}
-
+        UNIT_ASSERT(tokens == pattern); 
+    } 
+} 
+ 
 void TSplitIteratorTest::TestTail() {
     TString s = "grp@2@4";
     TSplitDelimiters delims("@");
     TDelimitersSplit split(s, delims);
-    TDelimitersSplit::TIterator it = split.Iterator();
-    UNIT_ASSERT_EQUAL(it.GetTail(), "grp@2@4");
-    it.Next();
-    UNIT_ASSERT_EQUAL(it.GetTail(), "2@4");
-    it.Next();
-    UNIT_ASSERT_EQUAL(it.GetTail(), "4");
-    it.Next();
-    UNIT_ASSERT_EQUAL(it.GetTail(), "");
-}
-
+    TDelimitersSplit::TIterator it = split.Iterator(); 
+    UNIT_ASSERT_EQUAL(it.GetTail(), "grp@2@4"); 
+    it.Next(); 
+    UNIT_ASSERT_EQUAL(it.GetTail(), "2@4"); 
+    it.Next(); 
+    UNIT_ASSERT_EQUAL(it.GetTail(), "4"); 
+    it.Next(); 
+    UNIT_ASSERT_EQUAL(it.GetTail(), ""); 
+} 
+ 
 void TSplitIteratorTest::TestScreenedDelimitersSplit() {
     {
         const TString s = "77.88.58.91 - - [28/Aug/2008:00:08:07 +0400] \"GET /export/mordashka.tgz HTTP/1.1\" 304 - \"-\" \"libwww-perl/5.805\" \"news.yandex.ru,80\" \"-\" \"-\" 1219867687 \"0\" 3283 2";
@@ -135,18 +135,18 @@ void TSplitIteratorTest::TestScreenedDelimitersSplit() {
         UNIT_ASSERT_EQUAL(it.NextString(), "3283");
         UNIT_ASSERT_EQUAL(it.NextString(), "2");
     }
-}
-
+} 
+ 
 void TSplitIteratorTest::TestSubstringDelimiter() {
     const TString s = "a@@bb@@cc@c.d@@r";
-    static const TSubstringSplitDelimiter delimiter("@@");
-    const TSubstringSplit splitter(s, delimiter);
-    TSubstringSplit::TIterator it = splitter.Iterator();
+    static const TSubstringSplitDelimiter delimiter("@@"); 
+    const TSubstringSplit splitter(s, delimiter); 
+    TSubstringSplit::TIterator it = splitter.Iterator(); 
     UNIT_ASSERT_EQUAL(it.NextString(), "a");
     UNIT_ASSERT_EQUAL(it.NextString(), "bb");
     UNIT_ASSERT_EQUAL(it.NextString(), "cc@c.d");
     UNIT_ASSERT_EQUAL(it.NextString(), "r");
-    UNIT_ASSERT(it.Eof());
-}
-
-UNIT_TEST_SUITE_REGISTRATION(TSplitIteratorTest);
+    UNIT_ASSERT(it.Eof()); 
+} 
+ 
+UNIT_TEST_SUITE_REGISTRATION(TSplitIteratorTest);