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

6 files changed, 687 insertions, 687 deletions

diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp
index 6b5bf41441..c3c989bedb 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp
@@ -1,107 +1,107 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
- 
-#include <aws/core/utils/event/EventHeader.h> 
-#include <aws/core/utils/HashingUtils.h> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            static const int HASH_BOOL_TRUE = HashingUtils::HashString("BOOL_TRUE"); 
-            static const int HASH_BOOL_FALSE = HashingUtils::HashString("BOOL_FALSE"); 
-            static const int HASH_BYTE = HashingUtils::HashString("BYTE"); 
-            static const int HASH_INT16 = HashingUtils::HashString("INT16"); 
-            static const int HASH_INT32 = HashingUtils::HashString("INT32"); 
-            static const int HASH_INT64 = HashingUtils::HashString("INT64"); 
-            static const int HASH_BYTE_BUF = HashingUtils::HashString("BYTE_BUFFER"); 
-            static const int HASH_STRING = HashingUtils::HashString("STRING"); 
-            static const int HASH_TIMESTAMP = HashingUtils::HashString("TIMESTAMP"); 
-            static const int HASH_UUID = HashingUtils::HashString("UUID"); 
- 
-            EventHeaderValue::EventHeaderType EventHeaderValue::GetEventHeaderTypeForName(const Aws::String& name) 
-            { 
-                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str()); 
-                if (hashCode == HASH_BOOL_TRUE) 
-                { 
-                    return EventHeaderType::BOOL_TRUE; 
-                } 
-                else if (hashCode == HASH_BOOL_FALSE) 
-                { 
-                    return EventHeaderType::BOOL_FALSE; 
-                } 
-                else if (hashCode == HASH_BYTE) 
-                { 
-                    return EventHeaderType::BYTE; 
-                } 
-                else if (hashCode == HASH_INT16) 
-                { 
-                    return EventHeaderType::INT16; 
-                } 
-                else if (hashCode == HASH_INT32) 
-                { 
-                    return EventHeaderType::INT32; 
-                } 
-                else if (hashCode == HASH_INT64) 
-                { 
-                    return EventHeaderType::INT64; 
-                } 
-                else if (hashCode == HASH_BYTE_BUF) 
-                { 
-                    return EventHeaderType::BYTE_BUF; 
-                } 
-                else if (hashCode == HASH_STRING) 
-                { 
-                    return EventHeaderType::STRING; 
-                } 
-                else if (hashCode == HASH_TIMESTAMP) 
-                { 
-                    return EventHeaderType::TIMESTAMP; 
-                } 
-                else if (hashCode == HASH_UUID) 
-                { 
-                    return EventHeaderType::UUID; 
-                } 
-                else 
-                { 
-                    return EventHeaderType::UNKNOWN; 
-                } 
-            } 
- 
-            Aws::String EventHeaderValue::GetNameForEventHeaderType(EventHeaderType value) 
-            { 
-                switch (value) 
-                { 
-                case EventHeaderType::BOOL_TRUE: 
-                    return "BOOL_TRUE"; 
-                case EventHeaderType::BOOL_FALSE: 
-                    return "BOOL_FALSE"; 
-                case EventHeaderType::BYTE: 
-                    return "BYTE"; 
-                case EventHeaderType::INT16: 
-                    return "INT16"; 
-                case EventHeaderType::INT32: 
-                    return "INT32"; 
-                case EventHeaderType::INT64: 
-                    return "INT64"; 
-                case EventHeaderType::BYTE_BUF: 
-                    return "BYTE_BUF"; 
-                case EventHeaderType::STRING: 
-                    return "STRING"; 
-                case EventHeaderType::TIMESTAMP: 
-                    return "TIMESTAMP"; 
-                case EventHeaderType::UUID: 
-                    return "UUID"; 
-                default: 
-                    return "UNKNOWN"; 
-                } 
-            } 
- 
-        } 
-    } 
-} 
- 
+ */
+
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/HashingUtils.h>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const int HASH_BOOL_TRUE = HashingUtils::HashString("BOOL_TRUE");
+            static const int HASH_BOOL_FALSE = HashingUtils::HashString("BOOL_FALSE");
+            static const int HASH_BYTE = HashingUtils::HashString("BYTE");
+            static const int HASH_INT16 = HashingUtils::HashString("INT16");
+            static const int HASH_INT32 = HashingUtils::HashString("INT32");
+            static const int HASH_INT64 = HashingUtils::HashString("INT64");
+            static const int HASH_BYTE_BUF = HashingUtils::HashString("BYTE_BUFFER");
+            static const int HASH_STRING = HashingUtils::HashString("STRING");
+            static const int HASH_TIMESTAMP = HashingUtils::HashString("TIMESTAMP");
+            static const int HASH_UUID = HashingUtils::HashString("UUID");
+
+            EventHeaderValue::EventHeaderType EventHeaderValue::GetEventHeaderTypeForName(const Aws::String& name)
+            {
+                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
+                if (hashCode == HASH_BOOL_TRUE)
+                {
+                    return EventHeaderType::BOOL_TRUE;
+                }
+                else if (hashCode == HASH_BOOL_FALSE)
+                {
+                    return EventHeaderType::BOOL_FALSE;
+                }
+                else if (hashCode == HASH_BYTE)
+                {
+                    return EventHeaderType::BYTE;
+                }
+                else if (hashCode == HASH_INT16)
+                {
+                    return EventHeaderType::INT16;
+                }
+                else if (hashCode == HASH_INT32)
+                {
+                    return EventHeaderType::INT32;
+                }
+                else if (hashCode == HASH_INT64)
+                {
+                    return EventHeaderType::INT64;
+                }
+                else if (hashCode == HASH_BYTE_BUF)
+                {
+                    return EventHeaderType::BYTE_BUF;
+                }
+                else if (hashCode == HASH_STRING)
+                {
+                    return EventHeaderType::STRING;
+                }
+                else if (hashCode == HASH_TIMESTAMP)
+                {
+                    return EventHeaderType::TIMESTAMP;
+                }
+                else if (hashCode == HASH_UUID)
+                {
+                    return EventHeaderType::UUID;
+                }
+                else
+                {
+                    return EventHeaderType::UNKNOWN;
+                }
+            }
+
+            Aws::String EventHeaderValue::GetNameForEventHeaderType(EventHeaderType value)
+            {
+                switch (value)
+                {
+                case EventHeaderType::BOOL_TRUE:
+                    return "BOOL_TRUE";
+                case EventHeaderType::BOOL_FALSE:
+                    return "BOOL_FALSE";
+                case EventHeaderType::BYTE:
+                    return "BYTE";
+                case EventHeaderType::INT16:
+                    return "INT16";
+                case EventHeaderType::INT32:
+                    return "INT32";
+                case EventHeaderType::INT64:
+                    return "INT64";
+                case EventHeaderType::BYTE_BUF:
+                    return "BYTE_BUF";
+                case EventHeaderType::STRING:
+                    return "STRING";
+                case EventHeaderType::TIMESTAMP:
+                    return "TIMESTAMP";
+                case EventHeaderType::UUID:
+                    return "UUID";
+                default:
+                    return "UNKNOWN";
+                }
+            }
+
+        }
+    }
+}
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp
index 811d116223..de8b904775 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp
@@ -1,70 +1,70 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
- 
-#include <aws/core/utils/event/EventMessage.h> 
-#include <aws/core/utils/HashingUtils.h> 
-#include <algorithm> 
-#include <iterator> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            const char EVENT_TYPE_HEADER[] = ":event-type"; 
-            const char CONTENT_TYPE_HEADER[] = ":content-type"; 
-            const char MESSAGE_TYPE_HEADER[] = ":message-type"; 
-            const char ERROR_CODE_HEADER[] = ":error-code"; 
-            const char ERROR_MESSAGE_HEADER[] = ":error-message"; 
+ */
+
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <algorithm>
+#include <iterator>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            const char EVENT_TYPE_HEADER[] = ":event-type";
+            const char CONTENT_TYPE_HEADER[] = ":content-type";
+            const char MESSAGE_TYPE_HEADER[] = ":message-type";
+            const char ERROR_CODE_HEADER[] = ":error-code";
+            const char ERROR_MESSAGE_HEADER[] = ":error-message";
             const char EXCEPTION_TYPE_HEADER[] = ":exception-type";
- 
-            static const int EVENT_HASH = HashingUtils::HashString("event"); 
-            static const int ERROR_HASH = HashingUtils::HashString("error"); 
+
+            static const int EVENT_HASH = HashingUtils::HashString("event");
+            static const int ERROR_HASH = HashingUtils::HashString("error");
             static const int EXCEPTION_HASH = HashingUtils::HashString("exception");
- 
+
             static const int CONTENT_TYPE_APPLICATION_OCTET_STREAM_HASH = HashingUtils::HashString("application/octet-stream");
             static const int CONTENT_TYPE_APPLICATION_JSON_HASH = HashingUtils::HashString("application/json");
             static const int CONTENT_TYPE_TEXT_PLAIN_HASH = HashingUtils::HashString("text/plain");
 
-            Message::MessageType Message::GetMessageTypeForName(const Aws::String& name) 
-            { 
-                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str()); 
-                if (hashCode == EVENT_HASH) 
-                { 
-                    return MessageType::EVENT; 
-                } 
-                else if (hashCode == ERROR_HASH) 
-                { 
-                    return MessageType::REQUEST_LEVEL_ERROR; 
-                } 
+            Message::MessageType Message::GetMessageTypeForName(const Aws::String& name)
+            {
+                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
+                if (hashCode == EVENT_HASH)
+                {
+                    return MessageType::EVENT;
+                }
+                else if (hashCode == ERROR_HASH)
+                {
+                    return MessageType::REQUEST_LEVEL_ERROR;
+                }
                 else if (hashCode == EXCEPTION_HASH)
                 {
                     return MessageType::REQUEST_LEVEL_EXCEPTION;
                 }
-                else 
-                { 
-                    return MessageType::UNKNOWN; 
-                } 
-            } 
- 
-            Aws::String Message::GetNameForMessageType(MessageType value) 
-            { 
-                switch (value) 
-                { 
-                case MessageType::EVENT: 
-                    return "event"; 
-                case MessageType::REQUEST_LEVEL_ERROR: 
-                    return "error"; 
+                else
+                {
+                    return MessageType::UNKNOWN;
+                }
+            }
+
+            Aws::String Message::GetNameForMessageType(MessageType value)
+            {
+                switch (value)
+                {
+                case MessageType::EVENT:
+                    return "event";
+                case MessageType::REQUEST_LEVEL_ERROR:
+                    return "error";
                 case MessageType::REQUEST_LEVEL_EXCEPTION:
                     return "exception";
-                default: 
-                    return "unknown"; 
-                } 
-            } 
- 
+                default:
+                    return "unknown";
+                }
+            }
+
             Message::ContentType Message::GetContentTypeForName(const Aws::String& name)
             {
                 int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
@@ -101,32 +101,32 @@ namespace Aws
                 }
             }
 
-            void Message::Reset() 
-            { 
-                m_totalLength = 0; 
-                m_headersLength = 0; 
-                m_payloadLength = 0; 
- 
-                m_eventHeaders.clear(); 
-                m_eventPayload.clear(); 
-            } 
- 
+            void Message::Reset()
+            {
+                m_totalLength = 0;
+                m_headersLength = 0;
+                m_payloadLength = 0;
+
+                m_eventHeaders.clear();
+                m_eventPayload.clear();
+            }
+
             void Message::WriteEventPayload(const unsigned char* data, size_t length)
             {
                 std::copy(data, data + length, std::back_inserter(m_eventPayload));
             }
 
-            void Message::WriteEventPayload(const Aws::Vector<unsigned char>& bits) 
-            { 
-                std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload)); 
-            } 
- 
+            void Message::WriteEventPayload(const Aws::Vector<unsigned char>& bits)
+            {
+                std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload));
+            }
+
             void Message::WriteEventPayload(const Aws::String& bits)
             {
                 std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload));
             }
 
-        } // namespace Event 
-    } // namespace Utils 
-} // namespace Aws 
- 
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp
index eb740d9ac0..6a1766bb9f 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp
@@ -1,147 +1,147 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
-#include <aws/core/utils/event/EventStreamBuf.h> 
-#include <cassert> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
+ */
+#include <aws/core/utils/event/EventStreamBuf.h>
+#include <cassert>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
             const size_t DEFAULT_BUF_SIZE = 1024;
 
-            EventStreamBuf::EventStreamBuf(EventStreamDecoder& decoder, size_t bufferLength) : 
-                m_byteBuffer(bufferLength), 
-                m_bufferLength(bufferLength), 
-                m_decoder(decoder) 
-            { 
-                assert(decoder); 
-                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()); 
-                char* end = begin + bufferLength - 1; 
- 
-                setp(begin, end); 
-                setg(begin, begin, begin); 
-            } 
- 
-            EventStreamBuf::~EventStreamBuf() 
-            { 
-                if (m_decoder) 
-                { 
-                    writeToDecoder(); 
-                } 
-            } 
- 
-            void EventStreamBuf::writeToDecoder() 
-            { 
-                if (pptr() > pbase()) 
-                { 
-                    size_t length = static_cast<size_t>(pptr() - pbase()); 
-                    m_decoder.Pump(m_byteBuffer, length); 
- 
-                    if (!m_decoder) 
-                    { 
-                        m_err.write(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), length); 
-                    } 
-                    else 
-                    { 
-                        pbump(-static_cast<int>(length)); 
-                    } 
-                } 
-            } 
- 
-            std::streampos EventStreamBuf::seekoff(std::streamoff off, std::ios_base::seekdir dir, std::ios_base::openmode which) 
-            { 
-                if (dir == std::ios_base::beg) 
-                { 
-                    return seekpos(off, which); 
-                } 
-                else if (dir == std::ios_base::end) 
-                { 
-                    return seekpos(m_bufferLength - 1 - off, which); 
-                } 
-                else if (dir == std::ios_base::cur) 
-                { 
-                    if (which == std::ios_base::in) 
-                    { 
-                        return seekpos((gptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which); 
-                    } 
-                    if (which == std::ios_base::out) 
-                    { 
-                        return seekpos((pptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which); 
-                    } 
-                } 
- 
-                return std::streamoff(-1); 
-            } 
- 
-            std::streampos EventStreamBuf::seekpos(std::streampos pos, std::ios_base::openmode which) 
-            { 
-                assert(static_cast<size_t>(pos) <= m_bufferLength); 
-                if (static_cast<size_t>(pos) > m_bufferLength) 
-                { 
-                    return std::streampos(std::streamoff(-1)); 
-                } 
- 
-                if (which == std::ios_base::in) 
-                { 
-                    m_err.seekg(pos); 
-                    return m_err.tellg(); 
-                } 
- 
-                if (which == std::ios_base::out) 
-                { 
-                    return pos; 
-                } 
- 
-                return std::streampos(std::streamoff(-1)); 
-            } 
- 
-            int EventStreamBuf::underflow() 
-            { 
-                if (!m_err || m_err.eof() || m_decoder) 
-                { 
-                    return std::char_traits<char>::eof(); 
-                } 
- 
-                m_err.flush(); 
-                m_err.read(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), m_byteBuffer.GetLength()); 
- 
-                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()); 
-                setg(begin, begin, begin + m_err.gcount()); 
-                return std::char_traits<char>::to_int_type(*gptr()); 
-            } 
- 
-            int EventStreamBuf::overflow(int ch) 
-            { 
-                auto eof = std::char_traits<char>::eof(); 
- 
-                if (m_decoder) 
-                { 
-                    if (ch != eof) 
-                    { 
-                        *pptr() = (char)ch; 
-                        pbump(1); 
-                    } 
- 
-                    writeToDecoder(); 
-                    return ch; 
-                } 
- 
-                return eof; 
-            } 
- 
-            int EventStreamBuf::sync() 
-            { 
-                if (m_decoder) 
-                { 
-                    writeToDecoder(); 
-                } 
- 
-                return 0; 
-            } 
-        } 
-    } 
-} 
+            EventStreamBuf::EventStreamBuf(EventStreamDecoder& decoder, size_t bufferLength) :
+                m_byteBuffer(bufferLength),
+                m_bufferLength(bufferLength),
+                m_decoder(decoder)
+            {
+                assert(decoder);
+                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData());
+                char* end = begin + bufferLength - 1;
+
+                setp(begin, end);
+                setg(begin, begin, begin);
+            }
+
+            EventStreamBuf::~EventStreamBuf()
+            {
+                if (m_decoder)
+                {
+                    writeToDecoder();
+                }
+            }
+
+            void EventStreamBuf::writeToDecoder()
+            {
+                if (pptr() > pbase())
+                {
+                    size_t length = static_cast<size_t>(pptr() - pbase());
+                    m_decoder.Pump(m_byteBuffer, length);
+
+                    if (!m_decoder)
+                    {
+                        m_err.write(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), length);
+                    }
+                    else
+                    {
+                        pbump(-static_cast<int>(length));
+                    }
+                }
+            }
+
+            std::streampos EventStreamBuf::seekoff(std::streamoff off, std::ios_base::seekdir dir, std::ios_base::openmode which)
+            {
+                if (dir == std::ios_base::beg)
+                {
+                    return seekpos(off, which);
+                }
+                else if (dir == std::ios_base::end)
+                {
+                    return seekpos(m_bufferLength - 1 - off, which);
+                }
+                else if (dir == std::ios_base::cur)
+                {
+                    if (which == std::ios_base::in)
+                    {
+                        return seekpos((gptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which);
+                    }
+                    if (which == std::ios_base::out)
+                    {
+                        return seekpos((pptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which);
+                    }
+                }
+
+                return std::streamoff(-1);
+            }
+
+            std::streampos EventStreamBuf::seekpos(std::streampos pos, std::ios_base::openmode which)
+            {
+                assert(static_cast<size_t>(pos) <= m_bufferLength);
+                if (static_cast<size_t>(pos) > m_bufferLength)
+                {
+                    return std::streampos(std::streamoff(-1));
+                }
+
+                if (which == std::ios_base::in)
+                {
+                    m_err.seekg(pos);
+                    return m_err.tellg();
+                }
+
+                if (which == std::ios_base::out)
+                {
+                    return pos;
+                }
+
+                return std::streampos(std::streamoff(-1));
+            }
+
+            int EventStreamBuf::underflow()
+            {
+                if (!m_err || m_err.eof() || m_decoder)
+                {
+                    return std::char_traits<char>::eof();
+                }
+
+                m_err.flush();
+                m_err.read(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), m_byteBuffer.GetLength());
+
+                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData());
+                setg(begin, begin, begin + m_err.gcount());
+                return std::char_traits<char>::to_int_type(*gptr());
+            }
+
+            int EventStreamBuf::overflow(int ch)
+            {
+                auto eof = std::char_traits<char>::eof();
+
+                if (m_decoder)
+                {
+                    if (ch != eof)
+                    {
+                        *pptr() = (char)ch;
+                        pbump(1);
+                    }
+
+                    writeToDecoder();
+                    return ch;
+                }
+
+                return eof;
+            }
+
+            int EventStreamBuf::sync()
+            {
+                if (m_decoder)
+                {
+                    writeToDecoder();
+                }
+
+                return 0;
+            }
+        }
+    }
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp
index eeabf140b3..f70a6c88f6 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp
@@ -1,170 +1,170 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
- 
-#include <aws/common/common.h> 
-#include <aws/core/utils/event/EventHeader.h> 
-#include <aws/core/utils/event/EventMessage.h> 
-#include <aws/core/utils/event/EventStreamDecoder.h> 
-#include <aws/core/utils/logging/LogMacros.h> 
-#include <aws/core/utils/UnreferencedParam.h> 
+ */
+
+#include <aws/common/common.h>
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/event/EventStreamDecoder.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/utils/UnreferencedParam.h>
 #include <aws/core/utils/memory/AWSMemory.h>
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            static const char EVENT_STREAM_DECODER_CLASS_TAG[] = "Aws::Utils::Event::EventStreamDecoder"; 
- 
-            EventStreamDecoder::EventStreamDecoder(EventStreamHandler* handler) : m_eventStreamHandler(handler) 
-            { 
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const char EVENT_STREAM_DECODER_CLASS_TAG[] = "Aws::Utils::Event::EventStreamDecoder";
+
+            EventStreamDecoder::EventStreamDecoder(EventStreamHandler* handler) : m_eventStreamHandler(handler)
+            {
                 aws_event_stream_streaming_decoder_init(&m_decoder,
                     get_aws_allocator(),
-                    onPayloadSegment, 
-                    onPreludeReceived, 
-                    onHeaderReceived, 
-                    onError, 
-                    (void*)handler); 
-            } 
- 
-            EventStreamDecoder::~EventStreamDecoder() 
-            { 
-                aws_event_stream_streaming_decoder_clean_up(&m_decoder); 
-            } 
- 
-            void EventStreamDecoder::Pump(const ByteBuffer& data) 
-            { 
-                Pump(data, data.GetLength()); 
-            } 
- 
-            void EventStreamDecoder::Pump(const ByteBuffer& data, size_t length) 
-            { 
-                aws_byte_buf dataBuf = aws_byte_buf_from_array(static_cast<uint8_t*>(data.GetUnderlyingData()), length); 
-                aws_event_stream_streaming_decoder_pump(&m_decoder, &dataBuf); 
-            } 
- 
-            void EventStreamDecoder::Reset() 
-            { 
-                m_eventStreamHandler->Reset(); 
-            } 
- 
-            void EventStreamDecoder::ResetEventStreamHandler(EventStreamHandler* handler) 
-            { 
+                    onPayloadSegment,
+                    onPreludeReceived,
+                    onHeaderReceived,
+                    onError,
+                    (void*)handler);
+            }
+
+            EventStreamDecoder::~EventStreamDecoder()
+            {
+                aws_event_stream_streaming_decoder_clean_up(&m_decoder);
+            }
+
+            void EventStreamDecoder::Pump(const ByteBuffer& data)
+            {
+                Pump(data, data.GetLength());
+            }
+
+            void EventStreamDecoder::Pump(const ByteBuffer& data, size_t length)
+            {
+                aws_byte_buf dataBuf = aws_byte_buf_from_array(static_cast<uint8_t*>(data.GetUnderlyingData()), length);
+                aws_event_stream_streaming_decoder_pump(&m_decoder, &dataBuf);
+            }
+
+            void EventStreamDecoder::Reset()
+            {
+                m_eventStreamHandler->Reset();
+            }
+
+            void EventStreamDecoder::ResetEventStreamHandler(EventStreamHandler* handler)
+            {
                 aws_event_stream_streaming_decoder_init(&m_decoder, get_aws_allocator(),
-                    onPayloadSegment, 
-                    onPreludeReceived, 
-                    onHeaderReceived, 
-                    onError, 
-                    reinterpret_cast<void *>(handler)); 
-            } 
- 
-            void EventStreamDecoder::onPayloadSegment( 
-                aws_event_stream_streaming_decoder* decoder, 
-                aws_byte_buf* payload, 
-                int8_t isFinalSegment, 
-                void* context) 
-            { 
-                AWS_UNREFERENCED_PARAM(decoder); 
-                auto handler = static_cast<EventStreamHandler*>(context); 
-                assert(handler); 
-                if (!handler) 
-                { 
-                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before." 
-                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", " 
-                        "ErrorMessage: " << handler->GetEventPayloadAsString()); 
-                    return; 
-                } 
-                handler->WriteMessageEventPayload(static_cast<unsigned char*>(payload->buffer), payload->len); 
- 
-                // Complete payload received 
-                if (isFinalSegment == 1) 
-                { 
-                    assert(handler->IsMessageCompleted()); 
-                    handler->OnEvent(); 
-                    handler->Reset(); 
-                } 
-            } 
- 
-            void EventStreamDecoder::onPreludeReceived( 
-                aws_event_stream_streaming_decoder* decoder, 
-                aws_event_stream_message_prelude* prelude, 
-                void* context) 
-            { 
-                AWS_UNREFERENCED_PARAM(decoder); 
-                auto handler = static_cast<EventStreamHandler*>(context); 
-                handler->Reset(); 
-                 
-                //Encounter internal error in prelude received. 
-                //This error will be handled by OnError callback function later. 
-                if (prelude->total_len < prelude->headers_len + 16) 
-                { 
-                    return; 
-                } 
-                handler->SetMessageMetadata(prelude->total_len, prelude->headers_len, 
-                    prelude->total_len - prelude->headers_len - 4/*total byte-length*/ - 4/*headers byte-length*/ - 4/*prelude crc*/ - 4/*message crc*/); 
-                AWS_LOGSTREAM_TRACE(EVENT_STREAM_DECODER_CLASS_TAG, "Message received, the expected length of the message is: " << prelude->total_len << 
-                                                                    " bytes, and the expected length of the header is: " << prelude->headers_len << " bytes"); 
- 
-                //Handle empty message  
-                //if (handler->m_message.GetHeadersLength() == 0 && handler->m_message.GetPayloadLength() == 0) 
-                if (handler->IsMessageCompleted()) 
-                { 
-                    handler->OnEvent(); 
-                    handler->Reset(); 
-                } 
-            } 
- 
-            void EventStreamDecoder::onHeaderReceived( 
-                aws_event_stream_streaming_decoder* decoder, 
-                aws_event_stream_message_prelude* prelude, 
-                aws_event_stream_header_value_pair* header, 
-                void* context) 
-            { 
-                AWS_UNREFERENCED_PARAM(decoder); 
-                AWS_UNREFERENCED_PARAM(prelude); 
-                auto handler = static_cast<EventStreamHandler*>(context); 
-                assert(handler); 
-                if (!handler) 
-                { 
-                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before." 
-                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", " 
-                        "ErrorMessage: " << handler->GetEventPayloadAsString()); 
-                    return; 
-                } 
- 
-                // The length of a header = 1 byte (to represent the length of header name) + length of header name + 1 byte (to represent header type) 
-                //                          + 2 bytes (to represent length of header value) + length of header value 
-                handler->InsertMessageEventHeader(Aws::String(header->header_name, header->header_name_len), 
-                    1 + header->header_name_len + 1 + 2 + header->header_value_len, EventHeaderValue(header)); 
- 
-                // Handle messages only have headers, but without payload. 
-                //if (handler->m_message.GetHeadersLength() == handler->m_headersBytesReceived() && handler->m_message.GetPayloadLength() == 0) 
-                if (handler->IsMessageCompleted()) 
-                { 
-                    handler->OnEvent(); 
-                    handler->Reset(); 
-                } 
-            } 
- 
-            void EventStreamDecoder::onError( 
-                aws_event_stream_streaming_decoder* decoder, 
-                aws_event_stream_message_prelude* prelude, 
-                int error_code, 
-                const char* message, 
-                void* context) 
-            { 
-                AWS_UNREFERENCED_PARAM(decoder); 
-                AWS_UNREFERENCED_PARAM(prelude); 
-                auto handler = static_cast<EventStreamHandler*>(context); 
-                handler->SetFailure(); 
-                handler->SetInternalError(error_code); 
-                handler->WriteMessageEventPayload(reinterpret_cast<const unsigned char*>(message), strlen(message)); 
-                handler->OnEvent(); 
-            } 
-        } // namespace Event 
-    } // namespace Utils 
-} // namespace Aws 
- 
+                    onPayloadSegment,
+                    onPreludeReceived,
+                    onHeaderReceived,
+                    onError,
+                    reinterpret_cast<void *>(handler));
+            }
+
+            void EventStreamDecoder::onPayloadSegment(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_byte_buf* payload,
+                int8_t isFinalSegment,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                assert(handler);
+                if (!handler)
+                {
+                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before."
+                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", "
+                        "ErrorMessage: " << handler->GetEventPayloadAsString());
+                    return;
+                }
+                handler->WriteMessageEventPayload(static_cast<unsigned char*>(payload->buffer), payload->len);
+
+                // Complete payload received
+                if (isFinalSegment == 1)
+                {
+                    assert(handler->IsMessageCompleted());
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onPreludeReceived(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                handler->Reset();
+                
+                //Encounter internal error in prelude received.
+                //This error will be handled by OnError callback function later.
+                if (prelude->total_len < prelude->headers_len + 16)
+                {
+                    return;
+                }
+                handler->SetMessageMetadata(prelude->total_len, prelude->headers_len,
+                    prelude->total_len - prelude->headers_len - 4/*total byte-length*/ - 4/*headers byte-length*/ - 4/*prelude crc*/ - 4/*message crc*/);
+                AWS_LOGSTREAM_TRACE(EVENT_STREAM_DECODER_CLASS_TAG, "Message received, the expected length of the message is: " << prelude->total_len <<
+                                                                    " bytes, and the expected length of the header is: " << prelude->headers_len << " bytes");
+
+                //Handle empty message 
+                //if (handler->m_message.GetHeadersLength() == 0 && handler->m_message.GetPayloadLength() == 0)
+                if (handler->IsMessageCompleted())
+                {
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onHeaderReceived(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                aws_event_stream_header_value_pair* header,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                AWS_UNREFERENCED_PARAM(prelude);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                assert(handler);
+                if (!handler)
+                {
+                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before."
+                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", "
+                        "ErrorMessage: " << handler->GetEventPayloadAsString());
+                    return;
+                }
+
+                // The length of a header = 1 byte (to represent the length of header name) + length of header name + 1 byte (to represent header type)
+                //                          + 2 bytes (to represent length of header value) + length of header value
+                handler->InsertMessageEventHeader(Aws::String(header->header_name, header->header_name_len),
+                    1 + header->header_name_len + 1 + 2 + header->header_value_len, EventHeaderValue(header));
+
+                // Handle messages only have headers, but without payload.
+                //if (handler->m_message.GetHeadersLength() == handler->m_headersBytesReceived() && handler->m_message.GetPayloadLength() == 0)
+                if (handler->IsMessageCompleted())
+                {
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onError(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                int error_code,
+                const char* message,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                AWS_UNREFERENCED_PARAM(prelude);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                handler->SetFailure();
+                handler->SetInternalError(error_code);
+                handler->WriteMessageEventPayload(reinterpret_cast<const unsigned char*>(message), strlen(message));
+                handler->OnEvent();
+            }
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp
index c7491a3e26..ef7104e839 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp
@@ -1,162 +1,162 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
- 
-#include <aws/core/utils/event/EventHeader.h> 
-#include <aws/core/utils/event/EventMessage.h> 
-#include <aws/core/utils/event/EventStreamEncoder.h> 
-#include <aws/core/utils/logging/LogMacros.h> 
-#include <aws/core/auth/AWSAuthSigner.h> 
-#include <aws/common/byte_order.h> 
+ */
+
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/event/EventStreamEncoder.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/auth/AWSAuthSigner.h>
+#include <aws/common/byte_order.h>
 #include <aws/core/utils/memory/AWSMemory.h>
- 
-#include <cassert> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            static const char TAG[] = "EventStreamEncoder"; 
- 
-            static void EncodeHeaders(const Aws::Utils::Event::Message& msg, aws_array_list* headers) 
-            { 
+
+#include <cassert>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const char TAG[] = "EventStreamEncoder";
+
+            static void EncodeHeaders(const Aws::Utils::Event::Message& msg, aws_array_list* headers)
+            {
                 aws_array_list_init_dynamic(headers, get_aws_allocator(), msg.GetEventHeaders().size(), sizeof(aws_event_stream_header_value_pair));
-                for (auto&& header : msg.GetEventHeaders()) 
-                { 
-                    const uint8_t headerKeyLen = static_cast<uint8_t>(header.first.length()); 
-                    switch(header.second.GetType()) 
-                    { 
-                        case EventHeaderValue::EventHeaderType::BOOL_TRUE: 
-                        case EventHeaderValue::EventHeaderType::BOOL_FALSE: 
-                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsBoolean()); 
-                            break; 
-                        case EventHeaderValue::EventHeaderType::BYTE: 
-                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsByte()); 
-                            break; 
-                        case EventHeaderValue::EventHeaderType::INT16: 
+                for (auto&& header : msg.GetEventHeaders())
+                {
+                    const uint8_t headerKeyLen = static_cast<uint8_t>(header.first.length());
+                    switch(header.second.GetType())
+                    {
+                        case EventHeaderValue::EventHeaderType::BOOL_TRUE:
+                        case EventHeaderValue::EventHeaderType::BOOL_FALSE:
+                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsBoolean());
+                            break;
+                        case EventHeaderValue::EventHeaderType::BYTE:
+                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsByte());
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT16:
                             aws_event_stream_add_int16_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt16());
-                            break; 
-                        case EventHeaderValue::EventHeaderType::INT32: 
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT32:
                             aws_event_stream_add_int32_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt32());
-                            break; 
-                        case EventHeaderValue::EventHeaderType::INT64: 
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT64:
                             aws_event_stream_add_int64_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt64());
-                            break; 
-                        case EventHeaderValue::EventHeaderType::BYTE_BUF: 
-                            { 
-                                const auto& bytes = header.second.GetEventHeaderValueAsBytebuf(); 
+                            break;
+                        case EventHeaderValue::EventHeaderType::BYTE_BUF:
+                            {
+                                const auto& bytes = header.second.GetEventHeaderValueAsBytebuf();
                                 aws_event_stream_add_bytebuf_header(headers, header.first.c_str(), headerKeyLen, bytes.GetUnderlyingData(), static_cast<uint16_t>(bytes.GetLength()), 1 /*copy*/);
-                            } 
-                            break; 
-                        case EventHeaderValue::EventHeaderType::STRING: 
-                            { 
-                                const auto& bytes = header.second.GetUnderlyingBuffer(); 
-                                aws_event_stream_add_string_header(headers, header.first.c_str(), headerKeyLen, reinterpret_cast<char*>(bytes.GetUnderlyingData()), static_cast<uint16_t>(bytes.GetLength()), 0 /*copy*/); 
-                            } 
-                            break; 
-                        case EventHeaderValue::EventHeaderType::TIMESTAMP: 
+                            }
+                            break;
+                        case EventHeaderValue::EventHeaderType::STRING:
+                            {
+                                const auto& bytes = header.second.GetUnderlyingBuffer();
+                                aws_event_stream_add_string_header(headers, header.first.c_str(), headerKeyLen, reinterpret_cast<char*>(bytes.GetUnderlyingData()), static_cast<uint16_t>(bytes.GetLength()), 0 /*copy*/);
+                            }
+                            break;
+                        case EventHeaderValue::EventHeaderType::TIMESTAMP:
                             aws_event_stream_add_timestamp_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsTimestamp());
-                            break; 
-                        case EventHeaderValue::EventHeaderType::UUID: 
-                            { 
-                                ByteBuffer uuidBytes = header.second.GetEventHeaderValueAsUuid(); 
-                                aws_event_stream_add_uuid_header(headers, header.first.c_str(), headerKeyLen, uuidBytes.GetUnderlyingData()); 
-                            } 
-                            break; 
-                        default: 
-                            AWS_LOG_ERROR(TAG, "Encountered unknown type of header."); 
-                            break; 
-                    } 
-                } 
-            } 
- 
-            EventStreamEncoder::EventStreamEncoder(Client::AWSAuthSigner* signer) : m_signer(signer) 
-            { 
-            } 
- 
- 
-            Aws::Vector<unsigned char> EventStreamEncoder::EncodeAndSign(const Aws::Utils::Event::Message& msg) 
-            { 
-                aws_event_stream_message encoded = Encode(msg); 
-                aws_event_stream_message signedMessage = Sign(&encoded); 
- 
-                const auto signedMessageLength = signedMessage.message_buffer ? aws_event_stream_message_total_length(&signedMessage) : 0; 
- 
-                Aws::Vector<unsigned char> outputBits(signedMessage.message_buffer, signedMessage.message_buffer + signedMessageLength); 
-                aws_event_stream_message_clean_up(&encoded); 
-                aws_event_stream_message_clean_up(&signedMessage); 
-                return outputBits; 
-            } 
- 
-            aws_event_stream_message EventStreamEncoder::Encode(const Aws::Utils::Event::Message& msg) 
-            { 
-                aws_array_list headers; 
-                EncodeHeaders(msg, &headers); 
- 
-                aws_byte_buf payload; 
-                payload.len = msg.GetEventPayload().size(); 
-                // this const_cast is OK because aws_byte_buf will only be "read from" by the following functions. 
-                payload.buffer = const_cast<uint8_t*>(msg.GetEventPayload().data()); 
-                payload.capacity = 0; 
-                payload.allocator = nullptr; 
- 
-                aws_event_stream_message encoded; 
+                            break;
+                        case EventHeaderValue::EventHeaderType::UUID:
+                            {
+                                ByteBuffer uuidBytes = header.second.GetEventHeaderValueAsUuid();
+                                aws_event_stream_add_uuid_header(headers, header.first.c_str(), headerKeyLen, uuidBytes.GetUnderlyingData());
+                            }
+                            break;
+                        default:
+                            AWS_LOG_ERROR(TAG, "Encountered unknown type of header.");
+                            break;
+                    }
+                }
+            }
+
+            EventStreamEncoder::EventStreamEncoder(Client::AWSAuthSigner* signer) : m_signer(signer)
+            {
+            }
+
+
+            Aws::Vector<unsigned char> EventStreamEncoder::EncodeAndSign(const Aws::Utils::Event::Message& msg)
+            {
+                aws_event_stream_message encoded = Encode(msg);
+                aws_event_stream_message signedMessage = Sign(&encoded);
+
+                const auto signedMessageLength = signedMessage.message_buffer ? aws_event_stream_message_total_length(&signedMessage) : 0;
+
+                Aws::Vector<unsigned char> outputBits(signedMessage.message_buffer, signedMessage.message_buffer + signedMessageLength);
+                aws_event_stream_message_clean_up(&encoded);
+                aws_event_stream_message_clean_up(&signedMessage);
+                return outputBits;
+            }
+
+            aws_event_stream_message EventStreamEncoder::Encode(const Aws::Utils::Event::Message& msg)
+            {
+                aws_array_list headers;
+                EncodeHeaders(msg, &headers);
+
+                aws_byte_buf payload;
+                payload.len = msg.GetEventPayload().size();
+                // this const_cast is OK because aws_byte_buf will only be "read from" by the following functions.
+                payload.buffer = const_cast<uint8_t*>(msg.GetEventPayload().data());
+                payload.capacity = 0;
+                payload.allocator = nullptr;
+
+                aws_event_stream_message encoded;
                 if(aws_event_stream_message_init(&encoded, get_aws_allocator(), &headers, &payload) == AWS_OP_ERR)
-                { 
+                {
                     AWS_LOGSTREAM_ERROR(TAG, "Error creating event-stream message from payload.");
                     aws_event_stream_headers_list_cleanup(&headers);
-                    // GCC 4.9.4 issues a warning with -Wextra if we simply do 
-                    // return {}; 
-                    aws_event_stream_message empty{nullptr, nullptr, 0}; 
-                    return empty; 
-                } 
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
                 aws_event_stream_headers_list_cleanup(&headers);
-                return encoded; 
-            } 
- 
-            aws_event_stream_message EventStreamEncoder::Sign(aws_event_stream_message* msg) 
-            { 
-                const auto msglen = msg->message_buffer ? aws_event_stream_message_total_length(msg) : 0; 
-                Event::Message signedMessage; 
-                signedMessage.WriteEventPayload(msg->message_buffer, msglen); 
- 
-                assert(m_signer); 
-                if (!m_signer->SignEventMessage(signedMessage, m_signatureSeed)) 
-                { 
-                    AWS_LOGSTREAM_ERROR(TAG, "Failed to sign event message frame."); 
-                    // GCC 4.9.4 issues a warning with -Wextra if we simply do 
-                    // return {}; 
-                    aws_event_stream_message empty{nullptr, nullptr, 0}; 
-                    return empty; 
-                } 
- 
-                aws_array_list headers; 
-                EncodeHeaders(signedMessage, &headers); 
- 
-                aws_byte_buf payload; 
-                payload.len = signedMessage.GetEventPayload().size(); 
-                payload.buffer = signedMessage.GetEventPayload().data(); 
-                payload.capacity = 0; 
-                payload.allocator = nullptr; 
- 
-                aws_event_stream_message signedmsg; 
+                return encoded;
+            }
+
+            aws_event_stream_message EventStreamEncoder::Sign(aws_event_stream_message* msg)
+            {
+                const auto msglen = msg->message_buffer ? aws_event_stream_message_total_length(msg) : 0;
+                Event::Message signedMessage;
+                signedMessage.WriteEventPayload(msg->message_buffer, msglen);
+
+                assert(m_signer);
+                if (!m_signer->SignEventMessage(signedMessage, m_signatureSeed))
+                {
+                    AWS_LOGSTREAM_ERROR(TAG, "Failed to sign event message frame.");
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
+
+                aws_array_list headers;
+                EncodeHeaders(signedMessage, &headers);
+
+                aws_byte_buf payload;
+                payload.len = signedMessage.GetEventPayload().size();
+                payload.buffer = signedMessage.GetEventPayload().data();
+                payload.capacity = 0;
+                payload.allocator = nullptr;
+
+                aws_event_stream_message signedmsg;
                 if(aws_event_stream_message_init(&signedmsg, get_aws_allocator(), &headers, &payload))
-                { 
+                {
                     AWS_LOGSTREAM_ERROR(TAG, "Error creating event-stream message from payload.");
                     aws_event_stream_headers_list_cleanup(&headers);
-                    // GCC 4.9.4 issues a warning with -Wextra if we simply do 
-                    // return {}; 
-                    aws_event_stream_message empty{nullptr, nullptr, 0}; 
-                    return empty; 
-                } 
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
                 aws_event_stream_headers_list_cleanup(&headers);
-                return signedmsg; 
-            } 
- 
-        } // namespace Event 
-    } // namespace Utils 
-} // namespace Aws 
- 
+                return signedmsg;
+            }
+
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp
index df999b07b8..836d0b47c5 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp
@@ -1,66 +1,66 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
-#include <aws/core/client/AWSError.h> 
-#include <aws/core/utils/HashingUtils.h> 
-#include <aws/core/utils/event/EventStreamErrors.h> 
- 
- using namespace Aws::Client; 
-// using namespace Aws::S3; 
-// using namespace Aws::Utils; 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            namespace EventStreamErrorsMapper 
-            { 
-                /* 
-                static const int EVENT_STREAM_NO_ERROR_HASH = HashingUtils::HashString("EventStreamNoError"); 
-                static const int EVENT_STREAM_BUFFER_LENGTH_MISMATCH_HASH = HashingUtils::HashString("EventStreamBufferLengthMismatch"); 
-                static const int EVENT_STREAM_INSUFFICIENT_BUFFER_LEN_HASH = HashingUtils::HashString("EventStreamInsufficientBufferLen"); 
-                static const int EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED_HASH = HashingUtils::HashString("EventStreamMessageFieldSizeExceeded"); 
-                static const int EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamPreludeChecksumFailure"); 
-                static const int EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamMessageChecksumFailure"); 
-                static const int EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN_HASH = HashingUtils::HashString("EventStreamMessageInvalidHeadersLen"); 
-                static const int EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE_HASH = HashingUtils::HashString("EventStreamMessageUnknownHeaderType"); 
-                static const int EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE_HASH = HashingUtils::HashString("EventStreamMessageParserIllegalState"); 
-                */ 
-                const char* GetNameForError(EventStreamErrors error) 
-                { 
-                    switch (error) 
-                    { 
-                    case EventStreamErrors::EVENT_STREAM_NO_ERROR: 
-                        return "EventStreamNoError"; 
-                    case EventStreamErrors::EVENT_STREAM_BUFFER_LENGTH_MISMATCH: 
-                        return "EventStreamBufferLengthMismatch"; 
-                    case EventStreamErrors::EVENT_STREAM_INSUFFICIENT_BUFFER_LEN: 
-                        return "EventStreamInsufficientBufferLen"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED: 
-                        return "EventStreamMessageFieldSizeExceeded"; 
-                    case EventStreamErrors::EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE: 
-                        return "EventStreamPreludeChecksumFailure"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE: 
-                        return "EventStreamMessageChecksumFailure"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN: 
-                        return "EventStreamMessageInvalidHeadersLen"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE: 
-                        return "EventStreamMessageUnknownHeaderType"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE: 
-                        return "EventStreamMessageParserIllegalState"; 
-                    default: 
-                        return "EventStreamUnknownError"; 
-                    } 
-                } 
- 
-                AWSError<CoreErrors> GetAwsErrorForEventStreamError(EventStreamErrors error) 
-                { 
-                    return AWSError<CoreErrors>(CoreErrors::UNKNOWN, GetNameForError(error), "", false); 
-                } 
-            } // namespace EventStreamErrorsMapper 
-        } // namespace Event 
-    } // namespace Utils 
-} // namespace Aws 
+ */
+#include <aws/core/client/AWSError.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/event/EventStreamErrors.h>
+
+ using namespace Aws::Client;
+// using namespace Aws::S3;
+// using namespace Aws::Utils;
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            namespace EventStreamErrorsMapper
+            {
+                /*
+                static const int EVENT_STREAM_NO_ERROR_HASH = HashingUtils::HashString("EventStreamNoError");
+                static const int EVENT_STREAM_BUFFER_LENGTH_MISMATCH_HASH = HashingUtils::HashString("EventStreamBufferLengthMismatch");
+                static const int EVENT_STREAM_INSUFFICIENT_BUFFER_LEN_HASH = HashingUtils::HashString("EventStreamInsufficientBufferLen");
+                static const int EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED_HASH = HashingUtils::HashString("EventStreamMessageFieldSizeExceeded");
+                static const int EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamPreludeChecksumFailure");
+                static const int EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamMessageChecksumFailure");
+                static const int EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN_HASH = HashingUtils::HashString("EventStreamMessageInvalidHeadersLen");
+                static const int EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE_HASH = HashingUtils::HashString("EventStreamMessageUnknownHeaderType");
+                static const int EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE_HASH = HashingUtils::HashString("EventStreamMessageParserIllegalState");
+                */
+                const char* GetNameForError(EventStreamErrors error)
+                {
+                    switch (error)
+                    {
+                    case EventStreamErrors::EVENT_STREAM_NO_ERROR:
+                        return "EventStreamNoError";
+                    case EventStreamErrors::EVENT_STREAM_BUFFER_LENGTH_MISMATCH:
+                        return "EventStreamBufferLengthMismatch";
+                    case EventStreamErrors::EVENT_STREAM_INSUFFICIENT_BUFFER_LEN:
+                        return "EventStreamInsufficientBufferLen";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED:
+                        return "EventStreamMessageFieldSizeExceeded";
+                    case EventStreamErrors::EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE:
+                        return "EventStreamPreludeChecksumFailure";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE:
+                        return "EventStreamMessageChecksumFailure";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN:
+                        return "EventStreamMessageInvalidHeadersLen";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE:
+                        return "EventStreamMessageUnknownHeaderType";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE:
+                        return "EventStreamMessageParserIllegalState";
+                    default:
+                        return "EventStreamUnknownError";
+                    }
+                }
+
+                AWSError<CoreErrors> GetAwsErrorForEventStreamError(EventStreamErrors error)
+                {
+                    return AWSError<CoreErrors>(CoreErrors::UNKNOWN, GetNameForError(error), "", false);
+                }
+            } // namespace EventStreamErrorsMapper
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws