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

1 files changed, 162 insertions, 162 deletions

diff --git a/library/cpp/deprecated/split/split_iterator.h b/library/cpp/deprecated/split/split_iterator.h
index f6f73dae11..0eacc29228 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());
-} 
+}