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

1 files changed, 244 insertions, 244 deletions

diff --git a/library/cpp/protobuf/util/simple_reflection.h b/library/cpp/protobuf/util/simple_reflection.h
index 61e877a787..172de02f78 100644
--- a/library/cpp/protobuf/util/simple_reflection.h
+++ b/library/cpp/protobuf/util/simple_reflection.h
@@ -13,137 +13,137 @@
 #include <util/system/defaults.h>
 
 namespace NProtoBuf {
-    class TConstField {
-    public:
-        TConstField(const Message& msg, const FieldDescriptor* fd)
-            : Msg(msg)
-            , Fd(fd)
-        {
-            Y_ASSERT(Fd && Fd->containing_type() == Msg.GetDescriptor());
-        }
-
-        static TMaybe<TConstField> ByPath(const Message& msg, const TStringBuf& path);
-        static TMaybe<TConstField> ByPath(const Message& msg, const TVector<const FieldDescriptor*>& fieldsPath);
-        static TMaybe<TConstField> ByPath(const Message& msg, const TFieldPath& fieldsPath);
-
-        const Message& Parent() const {
-            return Msg;
-        }
-
-        const FieldDescriptor* Field() const {
-            return Fd;
-        }
-
-        bool HasValue() const {
-            return IsRepeated() ? Refl().FieldSize(Msg, Fd) > 0
-                                : Refl().HasField(Msg, Fd);
-        }
-
-        // deprecated, use HasValue() instead
-        bool Has() const {
-            return HasValue();
-        }
-
-        size_t Size() const {
-            return IsRepeated() ? Refl().FieldSize(Msg, Fd)
-                                : (Refl().HasField(Msg, Fd) ? 1 : 0);
-        }
-
-        template <typename T>
-        inline typename TSelectCppType<T>::T Get(size_t index = 0) const;
-
-        template <typename TMsg>
-        inline const TMsg* GetAs(size_t index = 0) const {
-            // casting version of Get
-            return IsMessageInstance<TMsg>() ? CheckedCast<const TMsg*>(Get<const Message*>(index)) : nullptr;
-        }
-
-        template <typename T>
-        bool IsInstance() const {
-            return CppType() == TSelectCppType<T>::Result;
-        }
-
-        template <typename TMsg>
-        bool IsMessageInstance() const {
-            return IsMessage() && Fd->message_type() == TMsg::descriptor();
-        }
-
-        template <typename TMsg>
-        bool IsInstance(std::enable_if_t<std::is_base_of<Message, TMsg>::value && !std::is_same<Message, TMsg>::value, void>* = NULL) const { // template will be selected when specifying Message children types
-            return IsMessage() && Fd->message_type() == TMsg::descriptor();
-        }
-
-        bool IsString() const {
-            return CppType() == FieldDescriptor::CPPTYPE_STRING;
-        }
-
-        bool IsMessage() const {
-            return CppType() == FieldDescriptor::CPPTYPE_MESSAGE;
-        }
-
-        bool HasSameType(const TConstField& other) const {
-            if (CppType() != other.CppType())
-                return false;
-            if (IsMessage() && Field()->message_type() != other.Field()->message_type())
-                return false;
-            if (CppType() == FieldDescriptor::CPPTYPE_ENUM && Field()->enum_type() != other.Field()->enum_type())
-                return false;
-            return true;
-        }
-
-    protected:
-        bool IsRepeated() const {
-            return Fd->is_repeated();
-        }
-
-        FieldDescriptor::CppType CppType() const {
-            return Fd->cpp_type();
-        }
-
-        const Reflection& Refl() const {
-            return *Msg.GetReflection();
-        }
+    class TConstField { 
+    public: 
+        TConstField(const Message& msg, const FieldDescriptor* fd) 
+            : Msg(msg) 
+            , Fd(fd) 
+        { 
+            Y_ASSERT(Fd && Fd->containing_type() == Msg.GetDescriptor()); 
+        } 
+
+        static TMaybe<TConstField> ByPath(const Message& msg, const TStringBuf& path); 
+        static TMaybe<TConstField> ByPath(const Message& msg, const TVector<const FieldDescriptor*>& fieldsPath); 
+        static TMaybe<TConstField> ByPath(const Message& msg, const TFieldPath& fieldsPath); 
+
+        const Message& Parent() const { 
+            return Msg; 
+        } 
+
+        const FieldDescriptor* Field() const { 
+            return Fd; 
+        } 
+
+        bool HasValue() const { 
+            return IsRepeated() ? Refl().FieldSize(Msg, Fd) > 0 
+                                : Refl().HasField(Msg, Fd); 
+        } 
+
+        // deprecated, use HasValue() instead 
+        bool Has() const { 
+            return HasValue(); 
+        } 
+
+        size_t Size() const { 
+            return IsRepeated() ? Refl().FieldSize(Msg, Fd) 
+                                : (Refl().HasField(Msg, Fd) ? 1 : 0); 
+        } 
+
+        template <typename T> 
+        inline typename TSelectCppType<T>::T Get(size_t index = 0) const; 
+
+        template <typename TMsg> 
+        inline const TMsg* GetAs(size_t index = 0) const { 
+            // casting version of Get 
+            return IsMessageInstance<TMsg>() ? CheckedCast<const TMsg*>(Get<const Message*>(index)) : nullptr; 
+        } 
+
+        template <typename T> 
+        bool IsInstance() const { 
+            return CppType() == TSelectCppType<T>::Result; 
+        } 
+
+        template <typename TMsg> 
+        bool IsMessageInstance() const { 
+            return IsMessage() && Fd->message_type() == TMsg::descriptor(); 
+        } 
+
+        template <typename TMsg> 
+        bool IsInstance(std::enable_if_t<std::is_base_of<Message, TMsg>::value && !std::is_same<Message, TMsg>::value, void>* = NULL) const { // template will be selected when specifying Message children types 
+            return IsMessage() && Fd->message_type() == TMsg::descriptor(); 
+        } 
+
+        bool IsString() const { 
+            return CppType() == FieldDescriptor::CPPTYPE_STRING; 
+        } 
+
+        bool IsMessage() const { 
+            return CppType() == FieldDescriptor::CPPTYPE_MESSAGE; 
+        } 
+
+        bool HasSameType(const TConstField& other) const { 
+            if (CppType() != other.CppType()) 
+                return false; 
+            if (IsMessage() && Field()->message_type() != other.Field()->message_type()) 
+                return false; 
+            if (CppType() == FieldDescriptor::CPPTYPE_ENUM && Field()->enum_type() != other.Field()->enum_type()) 
+                return false; 
+            return true; 
+        } 
+
+    protected: 
+        bool IsRepeated() const { 
+            return Fd->is_repeated(); 
+        } 
+
+        FieldDescriptor::CppType CppType() const { 
+            return Fd->cpp_type(); 
+        } 
+
+        const Reflection& Refl() const { 
+            return *Msg.GetReflection(); 
+        } 
 
         [[noreturn]] void RaiseUnknown() const {
-            ythrow yexception() << "Unknown field cpp-type: " << (size_t)CppType();
-        }
+            ythrow yexception() << "Unknown field cpp-type: " << (size_t)CppType(); 
+        } 
 
-        bool IsSameField(const TConstField& other) const {
-            return &Parent() == &other.Parent() && Field() == other.Field();
-        }
+        bool IsSameField(const TConstField& other) const { 
+            return &Parent() == &other.Parent() && Field() == other.Field(); 
+        } 
 
-    protected:
-        const Message& Msg;
-        const FieldDescriptor* Fd;
-    };
+    protected: 
+        const Message& Msg; 
+        const FieldDescriptor* Fd; 
+    }; 
 
-    class TMutableField: public TConstField {
-    public:
-        TMutableField(Message& msg, const FieldDescriptor* fd)
-            : TConstField(msg, fd)
-        {
-        }
+    class TMutableField: public TConstField { 
+    public: 
+        TMutableField(Message& msg, const FieldDescriptor* fd) 
+            : TConstField(msg, fd) 
+        { 
+        } 
 
-        static TMaybe<TMutableField> ByPath(Message& msg, const TStringBuf& path, bool createPath = false);
-        static TMaybe<TMutableField> ByPath(Message& msg, const TVector<const FieldDescriptor*>& fieldsPath, bool createPath = false);
-        static TMaybe<TMutableField> ByPath(Message& msg, const TFieldPath& fieldsPath, bool createPath = false);
+        static TMaybe<TMutableField> ByPath(Message& msg, const TStringBuf& path, bool createPath = false); 
+        static TMaybe<TMutableField> ByPath(Message& msg, const TVector<const FieldDescriptor*>& fieldsPath, bool createPath = false); 
+        static TMaybe<TMutableField> ByPath(Message& msg, const TFieldPath& fieldsPath, bool createPath = false); 
 
-        Message* MutableParent() {
-            return Mut();
-        }
+        Message* MutableParent() { 
+            return Mut(); 
+        } 
 
-        template <typename T>
-        inline void Set(T value, size_t index = 0);
+        template <typename T> 
+        inline void Set(T value, size_t index = 0); 
 
-        template <typename T>
-        inline void Add(T value);
+        template <typename T> 
+        inline void Add(T value); 
 
-        inline void MergeFrom(const TConstField& src);
+        inline void MergeFrom(const TConstField& src); 
 
-        inline void Clear() {
-            Refl().ClearField(Mut(), Fd);
-        }
-        /*
+        inline void Clear() { 
+            Refl().ClearField(Mut(), Fd); 
+        } 
+        /* 
     void Swap(TMutableField& f) {
         Y_ASSERT(Field() == f.Field());
 
@@ -151,139 +151,139 @@ namespace NProtoBuf {
         // is ported into arcadia protobuf library from up-stream.
     }
 */
-        inline void RemoveLast() {
-            Y_ASSERT(HasValue());
-            if (IsRepeated())
-                Refl().RemoveLast(Mut(), Fd);
-            else
-                Clear();
-        }
-
-        inline void SwapElements(size_t index1, size_t index2) {
-            Y_ASSERT(IsRepeated());
-            Y_ASSERT(index1 < Size());
-            Y_ASSERT(index2 < Size());
-            if (index1 == index2)
-                return;
-            Refl().SwapElements(Mut(), Fd, index1, index2);
-        }
-
-        inline void Remove(size_t index) {
-            if (index >= Size())
-                return;
-
-            // Move to the end
-            for (size_t i = index, size = Size(); i < size - 1; ++i)
-                SwapElements(i, i + 1);
-            RemoveLast();
-        }
-
-        Message* MutableMessage(size_t index = 0) {
-            Y_ASSERT(IsMessage());
-            if (IsRepeated()) {
-                Y_ASSERT(index < Size());
-                return Refl().MutableRepeatedMessage(Mut(), Fd, index);
-            } else {
-                Y_ASSERT(index == 0);
-                return Refl().MutableMessage(Mut(), Fd);
-            }
-        }
-
-        template <typename TMsg>
-        inline TMsg* AddMessage() {
-            return CheckedCast<TMsg*>(AddMessage());
-        }
-
-        inline Message* AddMessage() {
-            Y_ASSERT(IsMessage() && IsRepeated());
-            return Refl().AddMessage(Mut(), Fd);
-        }
-
-    private:
-        Message* Mut() {
-            return const_cast<Message*>(&Msg);
-        }
-
-        template <typename T>
-        inline void MergeValue(T srcValue);
-    };
-
-    // template implementations
-
-    template <typename T>
-    inline typename TSelectCppType<T>::T TConstField::Get(size_t index) const {
-        Y_ASSERT(index < Size() || !Fd->is_repeated() && index == 0); // Get for single fields is always allowed because of default values
-#define TMP_MACRO_FOR_CPPTYPE(CPPTYPE) \
-    case CPPTYPE:                      \
-        return CompatCast<CPPTYPE, TSelectCppType<T>::Result>(TSimpleFieldTraits<CPPTYPE>::Get(Msg, Fd, index));
-        switch (CppType()) {
-            APPLY_TMP_MACRO_FOR_ALL_CPPTYPES()
-            default:
-                RaiseUnknown();
-        }
-#undef TMP_MACRO_FOR_CPPTYPE
+        inline void RemoveLast() { 
+            Y_ASSERT(HasValue()); 
+            if (IsRepeated()) 
+                Refl().RemoveLast(Mut(), Fd); 
+            else 
+                Clear(); 
+        } 
+
+        inline void SwapElements(size_t index1, size_t index2) { 
+            Y_ASSERT(IsRepeated()); 
+            Y_ASSERT(index1 < Size()); 
+            Y_ASSERT(index2 < Size()); 
+            if (index1 == index2) 
+                return; 
+            Refl().SwapElements(Mut(), Fd, index1, index2); 
+        } 
+
+        inline void Remove(size_t index) { 
+            if (index >= Size()) 
+                return; 
+
+            // Move to the end 
+            for (size_t i = index, size = Size(); i < size - 1; ++i) 
+                SwapElements(i, i + 1); 
+            RemoveLast(); 
+        } 
+
+        Message* MutableMessage(size_t index = 0) { 
+            Y_ASSERT(IsMessage()); 
+            if (IsRepeated()) { 
+                Y_ASSERT(index < Size()); 
+                return Refl().MutableRepeatedMessage(Mut(), Fd, index); 
+            } else { 
+                Y_ASSERT(index == 0); 
+                return Refl().MutableMessage(Mut(), Fd); 
+            } 
+        }
+
+        template <typename TMsg> 
+        inline TMsg* AddMessage() { 
+            return CheckedCast<TMsg*>(AddMessage()); 
+        } 
+
+        inline Message* AddMessage() { 
+            Y_ASSERT(IsMessage() && IsRepeated()); 
+            return Refl().AddMessage(Mut(), Fd); 
+        } 
+
+    private: 
+        Message* Mut() { 
+            return const_cast<Message*>(&Msg); 
+        } 
+
+        template <typename T> 
+        inline void MergeValue(T srcValue); 
+    }; 
+
+    // template implementations 
+
+    template <typename T> 
+    inline typename TSelectCppType<T>::T TConstField::Get(size_t index) const { 
+        Y_ASSERT(index < Size() || !Fd->is_repeated() && index == 0); // Get for single fields is always allowed because of default values 
+#define TMP_MACRO_FOR_CPPTYPE(CPPTYPE) \ 
+    case CPPTYPE:                      \ 
+        return CompatCast<CPPTYPE, TSelectCppType<T>::Result>(TSimpleFieldTraits<CPPTYPE>::Get(Msg, Fd, index)); 
+        switch (CppType()) { 
+            APPLY_TMP_MACRO_FOR_ALL_CPPTYPES() 
+            default: 
+                RaiseUnknown(); 
+        } 
+#undef TMP_MACRO_FOR_CPPTYPE 
     }
 
-    template <typename T>
-    inline void TMutableField::Set(T value, size_t index) {
-        Y_ASSERT(!IsRepeated() && index == 0 || index < Size());
-#define TMP_MACRO_FOR_CPPTYPE(CPPTYPE)                                                                              \
-    case CPPTYPE:                                                                                                   \
-        TSimpleFieldTraits<CPPTYPE>::Set(*Mut(), Fd, CompatCast<TSelectCppType<T>::Result, CPPTYPE>(value), index); \
-        break;
-        switch (CppType()) {
-            APPLY_TMP_MACRO_FOR_ALL_CPPTYPES()
-            default:
-                RaiseUnknown();
-        }
-#undef TMP_MACRO_FOR_CPPTYPE
+    template <typename T> 
+    inline void TMutableField::Set(T value, size_t index) { 
+        Y_ASSERT(!IsRepeated() && index == 0 || index < Size()); 
+#define TMP_MACRO_FOR_CPPTYPE(CPPTYPE)                                                                              \ 
+    case CPPTYPE:                                                                                                   \ 
+        TSimpleFieldTraits<CPPTYPE>::Set(*Mut(), Fd, CompatCast<TSelectCppType<T>::Result, CPPTYPE>(value), index); \ 
+        break; 
+        switch (CppType()) { 
+            APPLY_TMP_MACRO_FOR_ALL_CPPTYPES() 
+            default: 
+                RaiseUnknown(); 
+        } 
+#undef TMP_MACRO_FOR_CPPTYPE 
     }
 
-    template <typename T>
-    inline void TMutableField::Add(T value) {
-#define TMP_MACRO_FOR_CPPTYPE(CPPTYPE)                                                                       \
-    case CPPTYPE:                                                                                            \
-        TSimpleFieldTraits<CPPTYPE>::Add(*Mut(), Fd, CompatCast<TSelectCppType<T>::Result, CPPTYPE>(value)); \
-        break;
-        switch (CppType()) {
-            APPLY_TMP_MACRO_FOR_ALL_CPPTYPES()
-            default:
-                RaiseUnknown();
-        }
-#undef TMP_MACRO_FOR_CPPTYPE
+    template <typename T> 
+    inline void TMutableField::Add(T value) { 
+#define TMP_MACRO_FOR_CPPTYPE(CPPTYPE)                                                                       \ 
+    case CPPTYPE:                                                                                            \ 
+        TSimpleFieldTraits<CPPTYPE>::Add(*Mut(), Fd, CompatCast<TSelectCppType<T>::Result, CPPTYPE>(value)); \ 
+        break; 
+        switch (CppType()) { 
+            APPLY_TMP_MACRO_FOR_ALL_CPPTYPES() 
+            default: 
+                RaiseUnknown(); 
+        } 
+#undef TMP_MACRO_FOR_CPPTYPE 
     }
 
-    template <typename T>
-    inline void TMutableField::MergeValue(T srcValue) {
+    template <typename T> 
+    inline void TMutableField::MergeValue(T srcValue) { 
         Add(srcValue);
     }
 
-    template <>
-    inline void TMutableField::MergeValue<const Message*>(const Message* srcValue) {
-        if (IsRepeated()) {
-            Add(srcValue);
-        } else {
-            MutableMessage()->MergeFrom(*srcValue);
+    template <> 
+    inline void TMutableField::MergeValue<const Message*>(const Message* srcValue) { 
+        if (IsRepeated()) { 
+            Add(srcValue); 
+        } else { 
+            MutableMessage()->MergeFrom(*srcValue); 
         }
     }
-
-    inline void TMutableField::MergeFrom(const TConstField& src) {
-        Y_ASSERT(HasSameType(src));
-        if (IsSameField(src))
-            return;
-#define TMP_MACRO_FOR_CPPTYPE(CPPTYPE)                                                        \
-    case CPPTYPE: {                                                                           \
-        for (size_t itemIdx = 0; itemIdx < src.Size(); ++itemIdx) {                           \
-            MergeValue(TSimpleFieldTraits<CPPTYPE>::Get(src.Parent(), src.Field(), itemIdx)); \
-        }                                                                                     \
-        break;                                                                                \
-    }
-        switch (CppType()) {
-            APPLY_TMP_MACRO_FOR_ALL_CPPTYPES()
-            default:
-                RaiseUnknown();
-        }
-#undef TMP_MACRO_FOR_CPPTYPE
-    }
-
+ 
+    inline void TMutableField::MergeFrom(const TConstField& src) { 
+        Y_ASSERT(HasSameType(src)); 
+        if (IsSameField(src)) 
+            return; 
+#define TMP_MACRO_FOR_CPPTYPE(CPPTYPE)                                                        \ 
+    case CPPTYPE: {                                                                           \ 
+        for (size_t itemIdx = 0; itemIdx < src.Size(); ++itemIdx) {                           \ 
+            MergeValue(TSimpleFieldTraits<CPPTYPE>::Get(src.Parent(), src.Field(), itemIdx)); \ 
+        }                                                                                     \ 
+        break;                                                                                \ 
+    } 
+        switch (CppType()) { 
+            APPLY_TMP_MACRO_FOR_ALL_CPPTYPES() 
+            default: 
+                RaiseUnknown(); 
+        } 
+#undef TMP_MACRO_FOR_CPPTYPE 
+    } 
+ 
 }