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

1 files changed, 315 insertions, 315 deletions

diff --git a/util/ysafeptr.h b/util/ysafeptr.h
index 79c74e82b7..af7dfd4bed 100644
--- a/util/ysafeptr.h
+++ b/util/ysafeptr.h
@@ -21,8 +21,8 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #if defined(_MSC_VER) && defined(_DEBUG)
-    #include <util/system/winint.h> 
-    #define CHECK_YPTR2 
+    #include <util/system/winint.h>
+    #define CHECK_YPTR2
 #endif
 
 struct IBinSaver;
@@ -31,159 +31,159 @@ class IObjectBase {
 private:
 #ifdef CHECK_YPTR2
     static Y_POD_THREAD(bool) DisableThreadCheck;
-    void CheckThreadId() { 
-        if (dwThreadId == 0) 
-            dwThreadId = GetCurrentThreadId(); 
-        else 
+    void CheckThreadId() {
+        if (dwThreadId == 0)
+            dwThreadId = GetCurrentThreadId();
+        else
             Y_ASSERT(dwThreadId == GetCurrentThreadId() || DisableThreadCheck);
-    } 
-    void AddRef() { 
-        CheckThreadId(); 
-        ++RefData; 
-    } 
-    void AddObj(int nRef) { 
-        CheckThreadId(); 
-        ObjData += nRef; 
-    } 
+    }
+    void AddRef() {
+        CheckThreadId();
+        ++RefData;
+    }
+    void AddObj(int nRef) {
+        CheckThreadId();
+        ObjData += nRef;
+    }
 #else
-    void CheckThreadId() { 
-    } 
-    void AddRef() { 
-        ++RefData; 
-    } 
-    void AddObj(int nRef) { 
-        ObjData += nRef; 
-    } 
+    void CheckThreadId() {
+    }
+    void AddRef() {
+        ++RefData;
+    }
+    void AddObj(int nRef) {
+        ObjData += nRef;
+    }
 #endif
-    void ReleaseRefComplete(); 
-    void ReleaseObjComplete(int nMask); 
-    void DecRef() { 
-        CheckThreadId(); 
-        --RefData; 
-    } 
-    void DecObj(int nRef) { 
-        CheckThreadId(); 
-        ObjData -= nRef; 
-    } 
-    void ReleaseRef() { 
-        CheckThreadId(); 
-        --RefData; 
-        if (RefData == 0) 
-            ReleaseRefComplete(); 
-    } 
-    void ReleaseObj(int nRef, int nMask) { 
-        CheckThreadId(); 
-        ObjData -= nRef; 
-        if ((ObjData & nMask) == 0) 
-            ReleaseObjComplete(nMask); 
-    } 
- 
+    void ReleaseRefComplete();
+    void ReleaseObjComplete(int nMask);
+    void DecRef() {
+        CheckThreadId();
+        --RefData;
+    }
+    void DecObj(int nRef) {
+        CheckThreadId();
+        ObjData -= nRef;
+    }
+    void ReleaseRef() {
+        CheckThreadId();
+        --RefData;
+        if (RefData == 0)
+            ReleaseRefComplete();
+    }
+    void ReleaseObj(int nRef, int nMask) {
+        CheckThreadId();
+        ObjData -= nRef;
+        if ((ObjData & nMask) == 0)
+            ReleaseObjComplete(nMask);
+    }
+
 protected:
 #ifdef CHECK_YPTR2
-    DWORD dwThreadId; 
+    DWORD dwThreadId;
 #endif
-    ui32 ObjData; 
-    ui32 RefData; 
-    // function should clear contents of object, easy to implement via consequent calls to 
-    // destructor and constructor, this function should not be called directly, use Clear() 
-    virtual void DestroyContents() = 0; 
+    ui32 ObjData;
+    ui32 RefData;
+    // function should clear contents of object, easy to implement via consequent calls to
+    // destructor and constructor, this function should not be called directly, use Clear()
+    virtual void DestroyContents() = 0;
     virtual ~IObjectBase() = default;
     inline void CopyValidFlag(const IObjectBase& a) {
-        ObjData &= 0x7fffffff; 
-        ObjData |= a.ObjData & 0x80000000; 
-    } 
- 
+        ObjData &= 0x7fffffff;
+        ObjData |= a.ObjData & 0x80000000;
+    }
+
 public:
     IObjectBase()
-        : ObjData(0) 
-        , RefData(0) 
-    { 
+        : ObjData(0)
+        , RefData(0)
+    {
 #ifdef CHECK_YPTR2
-        dwThreadId = 0; 
+        dwThreadId = 0;
 #endif
-    } 
-    // do not copy refcount when copy object 
+    }
+    // do not copy refcount when copy object
     IObjectBase(const IObjectBase& a)
-        : ObjData(0) 
-        , RefData(0) 
-    { 
+        : ObjData(0)
+        , RefData(0)
+    {
 #ifdef CHECK_YPTR2
-        dwThreadId = 0; 
+        dwThreadId = 0;
 #endif
-        CopyValidFlag(a); 
-    } 
+        CopyValidFlag(a);
+    }
     IObjectBase& operator=(const IObjectBase& a) {
-        CopyValidFlag(a); 
-        return *this; 
-    } 
+        CopyValidFlag(a);
+        return *this;
+    }
 #ifdef CHECK_YPTR2
-    static void SetThreadCheckMode(bool val) { 
-        DisableThreadCheck = !val; 
-    } 
-    void ResetThreadId() { 
+    static void SetThreadCheckMode(bool val) {
+        DisableThreadCheck = !val;
+    }
+    void ResetThreadId() {
         Y_ASSERT(RefData == 0 && ObjData == 0); // can reset thread check only for ref free objects
         dwThreadId = 0;
     }
 #else
-    static void SetThreadCheckMode(bool) { 
-    } 
-    void ResetThreadId() { 
-    } 
+    static void SetThreadCheckMode(bool) {
+    }
+    void ResetThreadId() {
+    }
 #endif
- 
+
     // class name of derived class
     virtual const char* GetClassName() const = 0;
 
-    ui32 IsRefInvalid() const { 
-        return (ObjData & 0x80000000); 
-    } 
-    ui32 IsRefValid() const { 
-        return !IsRefInvalid(); 
-    } 
-    // reset data in class to default values, saves RefCount from destruction 
-    void Clear() { 
-        AddRef(); 
-        DestroyContents(); 
-        DecRef(); 
-    } 
- 
-    virtual int operator&(IBinSaver&) { 
-        return 0; 
-    } 
- 
-    struct TRefO { 
+    ui32 IsRefInvalid() const {
+        return (ObjData & 0x80000000);
+    }
+    ui32 IsRefValid() const {
+        return !IsRefInvalid();
+    }
+    // reset data in class to default values, saves RefCount from destruction
+    void Clear() {
+        AddRef();
+        DestroyContents();
+        DecRef();
+    }
+
+    virtual int operator&(IBinSaver&) {
+        return 0;
+    }
+
+    struct TRefO {
         void AddRef(IObjectBase* pObj) {
-            pObj->AddObj(1); 
-        } 
+            pObj->AddObj(1);
+        }
         void DecRef(IObjectBase* pObj) {
-            pObj->DecObj(1); 
-        } 
+            pObj->DecObj(1);
+        }
         void Release(IObjectBase* pObj) {
-            pObj->ReleaseObj(1, 0x000fffff); 
-        } 
-    }; 
-    struct TRefM { 
+            pObj->ReleaseObj(1, 0x000fffff);
+        }
+    };
+    struct TRefM {
         void AddRef(IObjectBase* pObj) {
-            pObj->AddObj(0x100000); 
-        } 
+            pObj->AddObj(0x100000);
+        }
         void DecRef(IObjectBase* pObj) {
-            pObj->DecObj(0x100000); 
-        } 
+            pObj->DecObj(0x100000);
+        }
         void Release(IObjectBase* pObj) {
-            pObj->ReleaseObj(0x100000, 0x3ff00000); 
-        } 
-    }; 
-    struct TRef { 
+            pObj->ReleaseObj(0x100000, 0x3ff00000);
+        }
+    };
+    struct TRef {
         void AddRef(IObjectBase* pObj) {
-            pObj->AddRef(); 
-        } 
+            pObj->AddRef();
+        }
         void DecRef(IObjectBase* pObj) {
-            pObj->DecRef(); 
-        } 
+            pObj->DecRef();
+        }
         void Release(IObjectBase* pObj) {
-            pObj->ReleaseRef(); 
-        } 
-    }; 
+            pObj->ReleaseRef();
+        }
+    };
     friend struct IObjectBase::TRef;
     friend struct IObjectBase::TRefO;
     friend struct IObjectBase::TRefM;
@@ -191,239 +191,239 @@ public:
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // macro that helps to create neccessary members for proper operation of refcount system
 // if class needs special destructor, use CFundament
-#define OBJECT_METHODS(classname)                                 \ 
-public:                                                           \ 
+#define OBJECT_METHODS(classname)                                 \
+public:                                                           \
     virtual const char* GetClassName() const override {           \
-        return #classname;                                        \ 
-    }                                                             \ 
+        return #classname;                                        \
+    }                                                             \
     static IObjectBase* NewSaveLoadNullItem() {                   \
-        return new classname();                                   \ 
-    }                                                             \ 
-                                                                  \ 
-protected:                                                        \ 
+        return new classname();                                   \
+    }                                                             \
+                                                                  \
+protected:                                                        \
     virtual void DestroyContents() override {                     \
-        this->~classname();                                       \ 
-        int nHoldRefs = this->RefData, nHoldObjs = this->ObjData; \ 
-        new (this) classname();                                   \ 
-        this->RefData += nHoldRefs;                               \ 
-        this->ObjData += nHoldObjs;                               \ 
-    }                                                             \ 
-                                                                  \ 
-private: 
+        this->~classname();                                       \
+        int nHoldRefs = this->RefData, nHoldObjs = this->ObjData; \
+        new (this) classname();                                   \
+        this->RefData += nHoldRefs;                               \
+        this->ObjData += nHoldObjs;                               \
+    }                                                             \
+                                                                  \
+private:
 #define OBJECT_NOCOPY_METHODS(classname) OBJECT_METHODS(classname)
-#define BASIC_REGISTER_CLASS(classname)                                              \ 
+#define BASIC_REGISTER_CLASS(classname)                                              \
     Y_PRAGMA_DIAGNOSTIC_PUSH                                                         \
     Y_PRAGMA_NO_UNUSED_FUNCTION                                                      \
-    template <>                                                                      \ 
+    template <>                                                                      \
     IObjectBase* CastToObjectBaseImpl<classname>(classname * p, void*) {             \
-        return p;                                                                    \ 
-    }                                                                                \ 
-    template <>                                                                      \ 
+        return p;                                                                    \
+    }                                                                                \
+    template <>                                                                      \
     classname* CastToUserObjectImpl<classname>(IObjectBase * p, classname*, void*) { \
-        return dynamic_cast<classname*>(p);                                          \ 
-    }                                                                                \ 
+        return dynamic_cast<classname*>(p);                                          \
+    }                                                                                \
     Y_PRAGMA_DIAGNOSTIC_POP
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-template <class TUserObj> 
+template <class TUserObj>
 IObjectBase* CastToObjectBaseImpl(TUserObj* p, void*);
-template <class TUserObj> 
+template <class TUserObj>
 IObjectBase* CastToObjectBaseImpl(TUserObj* p, IObjectBase*) {
-    return p; 
-} 
-template <class TUserObj> 
+    return p;
+}
+template <class TUserObj>
 TUserObj* CastToUserObjectImpl(IObjectBase* p, TUserObj*, void*);
-template <class TUserObj> 
+template <class TUserObj>
 TUserObj* CastToUserObjectImpl(IObjectBase* _p, TUserObj*, IObjectBase*) {
-    return dynamic_cast<TUserObj*>(_p); 
+    return dynamic_cast<TUserObj*>(_p);
 }
-template <class TUserObj> 
+template <class TUserObj>
 inline IObjectBase* CastToObjectBase(TUserObj* p) {
-    return CastToObjectBaseImpl(p, p); 
-} 
-template <class TUserObj> 
+    return CastToObjectBaseImpl(p, p);
+}
+template <class TUserObj>
 inline const IObjectBase* CastToObjectBase(const TUserObj* p) {
-    return p; 
-} 
-template <class TUserObj> 
+    return p;
+}
+template <class TUserObj>
 inline TUserObj* CastToUserObject(IObjectBase* p, TUserObj* pu) {
-    return CastToUserObjectImpl(p, pu, pu); 
-} 
+    return CastToUserObjectImpl(p, pu, pu);
+}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // TObject - base object for reference counting, TUserObj - user object name
 // TRef - struct with AddRef/DecRef/Release methods for refcounting to use
-template <class TUserObj, class TRef> 
-class TPtrBase { 
+template <class TUserObj, class TRef>
+class TPtrBase {
 private:
-    TUserObj* ptr; 
- 
-    void AddRef(TUserObj* _ptr) { 
-        TRef p; 
-        if (_ptr) 
-            p.AddRef(CastToObjectBase(_ptr)); 
-    } 
-    void DecRef(TUserObj* _ptr) { 
-        TRef p; 
-        if (_ptr) 
-            p.DecRef(CastToObjectBase(_ptr)); 
-    } 
-    void Release(TUserObj* _ptr) { 
-        TRef p; 
-        if (_ptr) 
-            p.Release(CastToObjectBase(_ptr)); 
-    } 
- 
+    TUserObj* ptr;
+
+    void AddRef(TUserObj* _ptr) {
+        TRef p;
+        if (_ptr)
+            p.AddRef(CastToObjectBase(_ptr));
+    }
+    void DecRef(TUserObj* _ptr) {
+        TRef p;
+        if (_ptr)
+            p.DecRef(CastToObjectBase(_ptr));
+    }
+    void Release(TUserObj* _ptr) {
+        TRef p;
+        if (_ptr)
+            p.Release(CastToObjectBase(_ptr));
+    }
+
 protected:
-    void SetObject(TUserObj* _ptr) { 
-        TUserObj* pOld = ptr; 
-        ptr = _ptr; 
-        AddRef(ptr); 
-        Release(pOld); 
-    } 
- 
+    void SetObject(TUserObj* _ptr) {
+        TUserObj* pOld = ptr;
+        ptr = _ptr;
+        AddRef(ptr);
+        Release(pOld);
+    }
+
 public:
-    TPtrBase() 
+    TPtrBase()
         : ptr(nullptr)
-    { 
-    } 
-    TPtrBase(TUserObj* _ptr) 
-        : ptr(_ptr) 
-    { 
-        AddRef(ptr); 
-    } 
-    TPtrBase(const TPtrBase& a) 
-        : ptr(a.ptr) 
-    { 
-        AddRef(ptr); 
-    } 
-    ~TPtrBase() { 
-        Release(ptr); 
-    } 
- 
-    void Set(TUserObj* _ptr) { 
-        SetObject(_ptr); 
-    } 
-    TUserObj* Extract() { 
-        TUserObj* pRes = ptr; 
-        DecRef(ptr); 
+    {
+    }
+    TPtrBase(TUserObj* _ptr)
+        : ptr(_ptr)
+    {
+        AddRef(ptr);
+    }
+    TPtrBase(const TPtrBase& a)
+        : ptr(a.ptr)
+    {
+        AddRef(ptr);
+    }
+    ~TPtrBase() {
+        Release(ptr);
+    }
+
+    void Set(TUserObj* _ptr) {
+        SetObject(_ptr);
+    }
+    TUserObj* Extract() {
+        TUserObj* pRes = ptr;
+        DecRef(ptr);
         ptr = nullptr;
-        return pRes; 
-    } 
- 
-    const char* GetClassName() const { 
-        return ptr->GetClassName(); 
-    } 
+        return pRes;
+    }
 
-    // assignment operators 
-    TPtrBase& operator=(TUserObj* _ptr) { 
-        Set(_ptr); 
-        return *this; 
-    } 
-    TPtrBase& operator=(const TPtrBase& a) { 
-        Set(a.ptr); 
-        return *this; 
-    } 
-    // access 
-    TUserObj* operator->() const { 
-        return ptr; 
-    } 
-    operator TUserObj*() const { 
-        return ptr; 
-    } 
-    TUserObj* Get() const { 
-        return ptr; 
-    } 
+    const char* GetClassName() const {
+        return ptr->GetClassName();
+    }
+
+    // assignment operators
+    TPtrBase& operator=(TUserObj* _ptr) {
+        Set(_ptr);
+        return *this;
+    }
+    TPtrBase& operator=(const TPtrBase& a) {
+        Set(a.ptr);
+        return *this;
+    }
+    // access
+    TUserObj* operator->() const {
+        return ptr;
+    }
+    operator TUserObj*() const {
+        return ptr;
+    }
+    TUserObj* Get() const {
+        return ptr;
+    }
     IObjectBase* GetBarePtr() const {
-        return CastToObjectBase(ptr); 
-    } 
-    int operator&(IBinSaver& f); 
+        return CastToObjectBase(ptr);
+    }
+    int operator&(IBinSaver& f);
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-template <class T> 
-inline bool IsValid(T* p) { 
+template <class T>
+inline bool IsValid(T* p) {
     return p != nullptr && !CastToObjectBase(p)->IsRefInvalid();
-} 
-template <class T, class TRef> 
-inline bool IsValid(const TPtrBase<T, TRef>& p) { 
-    return p.Get() && !p.GetBarePtr()->IsRefInvalid(); 
-} 
+}
+template <class T, class TRef>
+inline bool IsValid(const TPtrBase<T, TRef>& p) {
+    return p.Get() && !p.GetBarePtr()->IsRefInvalid();
+}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-#define BASIC_PTR_DECLARE(TPtrName, TRef)        \ 
-    template <class T>                           \ 
-    class TPtrName: public TPtrBase<T, TRef> {   \ 
-        using CBase = TPtrBase<T, TRef>;         \ 
-                                                 \ 
-    public:                                      \ 
-        using CDestType = T;                     \ 
-        TPtrName() {                             \ 
-        }                                        \ 
-        TPtrName(T* _ptr)                        \ 
-            : CBase(_ptr)                        \ 
-        {                                        \ 
-        }                                        \ 
-        TPtrName(const TPtrName& a)              \ 
-            : CBase(a)                           \ 
-        {                                        \ 
-        }                                        \ 
-        TPtrName& operator=(T* _ptr) {           \ 
-            this->Set(_ptr);                     \ 
-            return *this;                        \ 
-        }                                        \ 
-        TPtrName& operator=(const TPtrName& a) { \ 
-            this->SetObject(a.Get());            \ 
-            return *this;                        \ 
-        }                                        \ 
-        int operator&(IBinSaver& f) {            \ 
-            return (*(CBase*)this) & (f);        \ 
-        }                                        \ 
-    }; 
- 
+#define BASIC_PTR_DECLARE(TPtrName, TRef)        \
+    template <class T>                           \
+    class TPtrName: public TPtrBase<T, TRef> {   \
+        using CBase = TPtrBase<T, TRef>;         \
+                                                 \
+    public:                                      \
+        using CDestType = T;                     \
+        TPtrName() {                             \
+        }                                        \
+        TPtrName(T* _ptr)                        \
+            : CBase(_ptr)                        \
+        {                                        \
+        }                                        \
+        TPtrName(const TPtrName& a)              \
+            : CBase(a)                           \
+        {                                        \
+        }                                        \
+        TPtrName& operator=(T* _ptr) {           \
+            this->Set(_ptr);                     \
+            return *this;                        \
+        }                                        \
+        TPtrName& operator=(const TPtrName& a) { \
+            this->SetObject(a.Get());            \
+            return *this;                        \
+        }                                        \
+        int operator&(IBinSaver& f) {            \
+            return (*(CBase*)this) & (f);        \
+        }                                        \
+    };
+
 BASIC_PTR_DECLARE(TPtr, IObjectBase::TRef)
 BASIC_PTR_DECLARE(TObj, IObjectBase::TRefO)
 BASIC_PTR_DECLARE(TMObj, IObjectBase::TRefM)
 // misuse guard
-template <class T> 
-inline bool IsValid(TObj<T>* p) { 
-    return p->YouHaveMadeMistake(); 
-} 
-template <class T> 
-inline bool IsValid(TPtr<T>* p) { 
-    return p->YouHaveMadeMistake(); 
-} 
-template <class T> 
-inline bool IsValid(TMObj<T>* p) { 
-    return p->YouHaveMadeMistake(); 
-} 
+template <class T>
+inline bool IsValid(TObj<T>* p) {
+    return p->YouHaveMadeMistake();
+}
+template <class T>
+inline bool IsValid(TPtr<T>* p) {
+    return p->YouHaveMadeMistake();
+}
+template <class T>
+inline bool IsValid(TMObj<T>* p) {
+    return p->YouHaveMadeMistake();
+}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // assumes base class is IObjectBase
-template <class T> 
-class TDynamicCast { 
-    T* ptr; 
- 
+template <class T>
+class TDynamicCast {
+    T* ptr;
+
 public:
-    template <class TT> 
-    TDynamicCast(TT* _ptr) { 
-        ptr = dynamic_cast<T*>(CastToObjectBase(_ptr)); 
-    } 
-    template <class TT> 
-    TDynamicCast(const TT* _ptr) { 
-        ptr = dynamic_cast<T*>(CastToObjectBase(const_cast<TT*>(_ptr))); 
-    } 
-    template <class T1, class T2> 
-    TDynamicCast(const TPtrBase<T1, T2>& _ptr) { 
-        ptr = dynamic_cast<T*>(_ptr.GetBarePtr()); 
-    } 
-    operator T*() const { 
-        return ptr; 
-    } 
-    T* operator->() const { 
-        return ptr; 
-    } 
-    T* Get() const { 
-        return ptr; 
-    } 
+    template <class TT>
+    TDynamicCast(TT* _ptr) {
+        ptr = dynamic_cast<T*>(CastToObjectBase(_ptr));
+    }
+    template <class TT>
+    TDynamicCast(const TT* _ptr) {
+        ptr = dynamic_cast<T*>(CastToObjectBase(const_cast<TT*>(_ptr)));
+    }
+    template <class T1, class T2>
+    TDynamicCast(const TPtrBase<T1, T2>& _ptr) {
+        ptr = dynamic_cast<T*>(_ptr.GetBarePtr());
+    }
+    operator T*() const {
+        return ptr;
+    }
+    T* operator->() const {
+        return ptr;
+    }
+    T* Get() const {
+        return ptr;
+    }
 };
 template <class T>
-inline bool IsValid(const TDynamicCast<T>& p) { 
-    return IsValid(p.Get()); 
-} 
+inline bool IsValid(const TDynamicCast<T>& p) {
+    return IsValid(p.Get());
+}