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

1 files changed, 95 insertions, 95 deletions

diff --git a/library/cpp/digest/md5/md5.cpp b/library/cpp/digest/md5/md5.cpp
index b10e63e425..24a5b69eef 100644
--- a/library/cpp/digest/md5/md5.cpp
+++ b/library/cpp/digest/md5/md5.cpp
@@ -1,17 +1,17 @@
 #include "md5.h"
 
-#include <library/cpp/string_utils/base64/base64.h> 
+#include <library/cpp/string_utils/base64/base64.h>
 
 #include <util/stream/input.h>
 #include <util/stream/file.h>
 #include <util/string/hex.h>
 
-#include <contrib/libs/nayuki_md5/md5.h> 
+#include <contrib/libs/nayuki_md5/md5.h>
 
 namespace {
 
-    constexpr size_t MD5_BLOCK_LENGTH = 64; 
-    constexpr size_t MD5_PADDING_SHIFT = 56; 
+    constexpr size_t MD5_BLOCK_LENGTH = 64;
+    constexpr size_t MD5_PADDING_SHIFT = 56;
     constexpr size_t MD5_HEX_DIGEST_LENGTH = 32;
 
     struct TMd5Stream: public IOutputStream {
@@ -26,14 +26,14 @@ namespace {
 
         MD5* M_;
     };
- 
-    inline TArrayRef<const ui8> MakeUnsignedArrayRef(const void* data, const size_t size) { 
-        return MakeArrayRef(static_cast<const ui8*>(data), size); 
-    } 
- 
-    inline TArrayRef<const ui8> MakeUnsignedArrayRef(const TArrayRef<const char>& data) { 
-        return MakeUnsignedArrayRef(data.data(), data.size()); 
-    } 
+
+    inline TArrayRef<const ui8> MakeUnsignedArrayRef(const void* data, const size_t size) {
+        return MakeArrayRef(static_cast<const ui8*>(data), size);
+    }
+
+    inline TArrayRef<const ui8> MakeUnsignedArrayRef(const TArrayRef<const char>& data) {
+        return MakeUnsignedArrayRef(data.data(), data.size());
+    }
 }
 
 char* MD5::File(const char* filename, char* buf) {
@@ -57,23 +57,23 @@ TString MD5::File(const TString& filename) {
     return buf;
 }
 
-char* MD5::Data(const TArrayRef<const ui8>& data, char* buf) { 
-    return MD5().Update(data).End(buf); 
-} 
- 
+char* MD5::Data(const TArrayRef<const ui8>& data, char* buf) {
+    return MD5().Update(data).End(buf);
+}
+
 char* MD5::Data(const void* data, size_t len, char* buf) {
-    return Data(MakeUnsignedArrayRef(data, len), buf); 
+    return Data(MakeUnsignedArrayRef(data, len), buf);
 }
 
-TString MD5::Data(const TArrayRef<const ui8>& data) { 
+TString MD5::Data(const TArrayRef<const ui8>& data) {
     TString buf;
     buf.ReserveAndResize(MD5_HEX_DIGEST_LENGTH);
-    Data(data, buf.begin()); 
+    Data(data, buf.begin());
     return buf;
 }
 
 TString MD5::Data(TStringBuf data) {
-    return Data(MakeUnsignedArrayRef(data)); 
+    return Data(MakeUnsignedArrayRef(data));
 }
 
 char* MD5::Stream(IInputStream* in, char* buf) {
@@ -88,7 +88,7 @@ MD5& MD5::Update(IInputStream* in) {
     return *this;
 }
 
-static const ui8 PADDING[MD5_BLOCK_LENGTH] = { 
+static const ui8 PADDING[MD5_BLOCK_LENGTH] = {
     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
@@ -96,8 +96,8 @@ static const ui8 PADDING[MD5_BLOCK_LENGTH] = {
 /* MD5 initialization. Begins an MD5 operation, writing a new context. */
 
 void MD5::Init() {
-    BufferSize = 0; 
-    StreamSize = 0; 
+    BufferSize = 0;
+    StreamSize = 0;
     /* Load magic initialization constants.  */
     State[0] = 0x67452301;
     State[1] = 0xefcdab89;
@@ -111,30 +111,30 @@ void MD5::Init() {
  * context.
  */
 
-void MD5::UpdatePart(TArrayRef<const ui8> data) { 
-    /* Count input bytes */ 
-    StreamSize += data.size(); 
-    if (BufferSize > 0) { 
-        /* Filling remaining buffer */ 
-        const ui8 freeBufferSize = MD5_BLOCK_LENGTH - BufferSize; 
-        const ui8 partLen = data.size() >= freeBufferSize ? freeBufferSize : data.size(); 
-        memcpy(&Buffer[BufferSize], data.data(), partLen); 
-        BufferSize += partLen; 
-        data = data.Slice(partLen); 
-        if (BufferSize == MD5_BLOCK_LENGTH) { 
-            /* Buffer is full and ready for hashing */ 
-            md5_compress(State, Buffer); 
-            BufferSize = 0; 
-        } 
-    } 
-    /* Processing input by chanks */ 
-    while (data.size() >= MD5_BLOCK_LENGTH) { 
-        md5_compress(State, data.data()); 
-        data = data.Slice(MD5_BLOCK_LENGTH); 
-    } 
-    /* Save remaining input in buffer */ 
-    memcpy(Buffer, data.data(), data.size()); 
-    BufferSize += data.size(); 
+void MD5::UpdatePart(TArrayRef<const ui8> data) {
+    /* Count input bytes */
+    StreamSize += data.size();
+    if (BufferSize > 0) {
+        /* Filling remaining buffer */
+        const ui8 freeBufferSize = MD5_BLOCK_LENGTH - BufferSize;
+        const ui8 partLen = data.size() >= freeBufferSize ? freeBufferSize : data.size();
+        memcpy(&Buffer[BufferSize], data.data(), partLen);
+        BufferSize += partLen;
+        data = data.Slice(partLen);
+        if (BufferSize == MD5_BLOCK_LENGTH) {
+            /* Buffer is full and ready for hashing */
+            md5_compress(State, Buffer);
+            BufferSize = 0;
+        }
+    }
+    /* Processing input by chanks */
+    while (data.size() >= MD5_BLOCK_LENGTH) {
+        md5_compress(State, data.data());
+        data = data.Slice(MD5_BLOCK_LENGTH);
+    }
+    /* Save remaining input in buffer */
+    memcpy(Buffer, data.data(), data.size());
+    BufferSize += data.size();
 }
 
 /*
@@ -142,19 +142,19 @@ void MD5::UpdatePart(TArrayRef<const ui8> data) {
  */
 
 void MD5::Pad() {
-    size_t streamSize = StreamSize; 
- 
-    const size_t paddingSize = (MD5_PADDING_SHIFT > BufferSize) ? (MD5_PADDING_SHIFT - BufferSize) : (MD5_PADDING_SHIFT + MD5_BLOCK_LENGTH - BufferSize); 
-    Update(PADDING, paddingSize); 
- 
-    // Size of stream in bits 
-    // If size greater than 2^64 - 1 only lower 64 bits used 
-    streamSize <<= 3; 
-    for (int i = 0; i < 8; ++i, streamSize >>= 8) { 
-        // Storing in reverse order 
-        Buffer[MD5_PADDING_SHIFT + i] = static_cast<ui8>(streamSize & 0xFFU); 
-    } 
-    md5_compress(State, Buffer); 
+    size_t streamSize = StreamSize;
+
+    const size_t paddingSize = (MD5_PADDING_SHIFT > BufferSize) ? (MD5_PADDING_SHIFT - BufferSize) : (MD5_PADDING_SHIFT + MD5_BLOCK_LENGTH - BufferSize);
+    Update(PADDING, paddingSize);
+
+    // Size of stream in bits
+    // If size greater than 2^64 - 1 only lower 64 bits used
+    streamSize <<= 3;
+    for (int i = 0; i < 8; ++i, streamSize >>= 8) {
+        // Storing in reverse order
+        Buffer[MD5_PADDING_SHIFT + i] = static_cast<ui8>(streamSize & 0xFFU);
+    }
+    md5_compress(State, Buffer);
 }
 
 /*
@@ -162,35 +162,35 @@ void MD5::Pad() {
  * the message digest and zeroizing the context.
  */
 
-ui8* MD5::Final(ui8 digest[16]) { 
+ui8* MD5::Final(ui8 digest[16]) {
     /* Do padding. */
     Pad();
     /* Store state in digest */
-    memcpy(digest, State, 16); 
+    memcpy(digest, State, 16);
     /* Zeroize sensitive information. */
-    Init(); 
+    Init();
 
     return digest;
 }
 
 char* MD5::End(char* buf) {
     static const char hex[] = "0123456789abcdef";
-    ui8 digest[16]; 
+    ui8 digest[16];
     if (!buf)
         buf = (char*)malloc(33);
     if (!buf)
         return nullptr;
     Final(digest);
-    for (ui8 i = 0; i < MD5_HEX_DIGEST_LENGTH / 2; i++) { 
-        buf[i * 2] = hex[digest[i] >> 4]; 
-        buf[i * 2 + 1] = hex[digest[i] & 0x0f]; 
+    for (ui8 i = 0; i < MD5_HEX_DIGEST_LENGTH / 2; i++) {
+        buf[i * 2] = hex[digest[i] >> 4];
+        buf[i * 2 + 1] = hex[digest[i] & 0x0f];
     }
-    buf[32] = '\0'; 
+    buf[32] = '\0';
     return buf;
 }
 
 char* MD5::End_b64(char* buf) {
-    ui8 digest[16]; 
+    ui8 digest[16];
     if (!buf)
         buf = (char*)malloc(25);
     if (!buf)
@@ -202,7 +202,7 @@ char* MD5::End_b64(char* buf) {
 }
 
 ui64 MD5::EndHalfMix() {
-    ui8 digest[16]; 
+    ui8 digest[16];
     Final(digest);
     ui64 res = 0;
     for (int i = 3; i >= 0; i--) {
@@ -212,47 +212,47 @@ ui64 MD5::EndHalfMix() {
     return res;
 }
 
-TString MD5::Calc(TStringBuf data) { 
-    return Calc(MakeUnsignedArrayRef(data)); 
-} 
+TString MD5::Calc(TStringBuf data) {
+    return Calc(MakeUnsignedArrayRef(data));
+}
 
-TString MD5::Calc(const TArrayRef<const ui8>& data) { 
-    return Data(data); 
-} 
+TString MD5::Calc(const TArrayRef<const ui8>& data) {
+    return Data(data);
+}
 
-TString MD5::CalcRaw(TStringBuf data) { 
-    return CalcRaw(MakeUnsignedArrayRef(data)); 
+TString MD5::CalcRaw(TStringBuf data) {
+    return CalcRaw(MakeUnsignedArrayRef(data));
 }
 
-TString MD5::CalcRaw(const TArrayRef<const ui8>& data) { 
+TString MD5::CalcRaw(const TArrayRef<const ui8>& data) {
     TString result;
-    result.ReserveAndResize(16); 
-    MD5().Update(data).Final(reinterpret_cast<ui8*>(result.begin())); 
+    result.ReserveAndResize(16);
+    MD5().Update(data).Final(reinterpret_cast<ui8*>(result.begin()));
     return result;
 }
 
 ui64 MD5::CalcHalfMix(const char* data, size_t len) {
-    return CalcHalfMix(MakeUnsignedArrayRef(data, len)); 
+    return CalcHalfMix(MakeUnsignedArrayRef(data, len));
+}
+
+ui64 MD5::CalcHalfMix(TStringBuf data) {
+    return CalcHalfMix(MakeUnsignedArrayRef(data));
+}
+
+ui64 MD5::CalcHalfMix(const TArrayRef<const ui8>& data) {
+    return MD5().Update(data).EndHalfMix();
 }
 
-ui64 MD5::CalcHalfMix(TStringBuf data) { 
-    return CalcHalfMix(MakeUnsignedArrayRef(data)); 
+bool MD5::IsMD5(TStringBuf data) {
+    return IsMD5(MakeUnsignedArrayRef(data));
 }
 
-ui64 MD5::CalcHalfMix(const TArrayRef<const ui8>& data) { 
-    return MD5().Update(data).EndHalfMix(); 
-} 
- 
-bool MD5::IsMD5(TStringBuf data) { 
-    return IsMD5(MakeUnsignedArrayRef(data)); 
-} 
- 
-bool MD5::IsMD5(const TArrayRef<const ui8>& data) { 
+bool MD5::IsMD5(const TArrayRef<const ui8>& data) {
     if (data.size() != 32) {
         return false;
     }
-    for (const ui8 *p = data.data(), *e = data.data() + data.size(); p != e; ++p) { 
-        if (Char2DigitTable[*p] == '\xff') { 
+    for (const ui8 *p = data.data(), *e = data.data() + data.size(); p != e; ++p) {
+        if (Char2DigitTable[*p] == '\xff') {
             return false;
         }
     }