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

1 files changed, 41 insertions, 41 deletions

diff --git a/library/cpp/protobuf/util/cast.h b/library/cpp/protobuf/util/cast.h
index 40076feac8..83749dfcee 100644
--- a/library/cpp/protobuf/util/cast.h
+++ b/library/cpp/protobuf/util/cast.h
@@ -1,17 +1,17 @@
-#pragma once 
+#pragma once
 
 #include "traits.h"
- 
+
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/message.h>
- 
+
 #include <util/generic/cast.h>
- 
-namespace NProtoBuf { 
+
+namespace NProtoBuf {
     // C++ compatible conversions of FieldDescriptor::CppType's
- 
+
     using ECppType = FieldDescriptor::CppType;
- 
+
     namespace NCast {
         template <ECppType src, ECppType dst>
         struct TIsCompatibleCppType {
@@ -19,67 +19,67 @@ namespace NProtoBuf {
                 Result = src == dst ||
                          (TIsNumericCppType<src>::Result && TIsNumericCppType<dst>::Result)
             };
-        }; 
- 
+        };
+
         template <ECppType src, ECppType dst>
         struct TIsEnumToNumericCppType {
             enum {
                 Result = (src == FieldDescriptor::CPPTYPE_ENUM && TIsNumericCppType<dst>::Result)
             };
-        }; 
- 
+        };
+
         template <ECppType src, ECppType dst, bool compatible> // compatible == true
         struct TCompatCastBase {
             static const bool IsCompatible = true;
- 
+
             typedef typename TCppTypeTraits<src>::T TSrc;
             typedef typename TCppTypeTraits<dst>::T TDst;
- 
+
             static inline TDst Cast(TSrc value) {
                 return value;
             }
         };
- 
+
         template <ECppType src, ECppType dst> // compatible == false
         struct TCompatCastBase<src, dst, false> {
             static const bool IsCompatible = false;
- 
+
             typedef typename TCppTypeTraits<src>::T TSrc;
             typedef typename TCppTypeTraits<dst>::T TDst;
- 
+
             static inline TDst Cast(TSrc) {
                 ythrow TBadCastException() << "Incompatible FieldDescriptor::CppType conversion: #"
                                            << (size_t)src << " to #" << (size_t)dst;
             }
         };
- 
+
         template <ECppType src, ECppType dst, bool isEnumToNum> // enum -> numeric
         struct TCompatCastImpl {
             static const bool IsCompatible = true;
- 
+
             typedef typename TCppTypeTraits<dst>::T TDst;
- 
+
             static inline TDst Cast(const EnumValueDescriptor* value) {
                 Y_ASSERT(value != nullptr);
                 return value->number();
             }
         };
- 
+
         template <ECppType src, ECppType dst>
         struct TCompatCastImpl<src, dst, false>: public TCompatCastBase<src, dst, TIsCompatibleCppType<src, dst>::Result> {
             using TCompatCastBase<src, dst, TIsCompatibleCppType<src, dst>::Result>::IsCompatible;
         };
- 
+
         template <ECppType src, ECppType dst>
         struct TCompatCast: public TCompatCastImpl<src, dst, TIsEnumToNumericCppType<src, dst>::Result> {
             typedef TCompatCastImpl<src, dst, TIsEnumToNumericCppType<src, dst>::Result> TBase;
- 
+
             typedef typename TCppTypeTraits<src>::T TSrc;
             typedef typename TCppTypeTraits<dst>::T TDst;
- 
+
             using TBase::Cast;
             using TBase::IsCompatible;
- 
+
             inline bool Try(TSrc value, TDst& res) {
                 if (IsCompatible) {
                     res = Cast(value);
@@ -88,69 +88,69 @@ namespace NProtoBuf {
                 return false;
             }
         };
- 
+
     }
 
-    template <ECppType src, ECppType dst> 
+    template <ECppType src, ECppType dst>
     inline typename TCppTypeTraits<dst>::T CompatCast(typename TCppTypeTraits<src>::T value) {
         return NCast::TCompatCast<src, dst>::Cast(value);
     }
- 
-    template <ECppType src, ECppType dst> 
+
+    template <ECppType src, ECppType dst>
     inline bool TryCompatCast(typename TCppTypeTraits<src>::T value, typename TCppTypeTraits<dst>::T& res) {
         return NCast::TCompatCast<src, dst>::Try(value, res);
     }
- 
+
     // Message static/dynamic checked casts
- 
+
     template <typename TpMessage>
     inline const TpMessage* TryCast(const Message* msg) {
         if (!msg || TpMessage::descriptor() != msg->GetDescriptor())
             return NULL;
         return CheckedCast<const TpMessage*>(msg);
     }
- 
+
     template <typename TpMessage>
     inline const TpMessage* TryCast(const Message* msg, const TpMessage*& ret) {
         ret = TryCast<TpMessage>(msg);
         return ret;
     }
- 
+
     template <typename TpMessage>
     inline TpMessage* TryCast(Message* msg) {
         if (!msg || TpMessage::descriptor() != msg->GetDescriptor())
             return nullptr;
         return CheckedCast<TpMessage*>(msg);
     }
- 
+
     template <typename TpMessage>
     inline TpMessage* TryCast(Message* msg, TpMessage*& ret) {
         ret = TryCast<TpMessage>(msg);
         return ret;
     }
- 
+
     // specialize for Message itself
- 
+
     template <>
     inline const Message* TryCast<Message>(const Message* msg) {
         return msg;
     }
- 
+
     template <>
     inline Message* TryCast<Message>(Message* msg) {
         return msg;
     }
- 
+
     // Binary serialization compatible conversion
     inline bool TryBinaryCast(const Message* from, Message* to, TString* buffer = nullptr) {
         TString tmpbuf;
         if (!buffer)
             buffer = &tmpbuf;
- 
+
         if (!from->SerializeToString(buffer))
             return false;
- 
+
         return to->ParseFromString(*buffer);
     }
- 
-} 
+
+}