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

1 files changed, 160 insertions, 160 deletions

diff --git a/library/cpp/yson/json/json_writer.cpp b/library/cpp/yson/json/json_writer.cpp
index 87481256ec..f65144bd67 100644
--- a/library/cpp/yson/json/json_writer.cpp
+++ b/library/cpp/yson/json/json_writer.cpp
@@ -3,20 +3,20 @@
 #include <library/cpp/json/json_writer.h>
 
 namespace NYT {
-    ////////////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////////// 
 
-    static bool IsSpecialJsonKey(const TStringBuf& key) {
-        return key.size() > 0 && key[0] == '$';
-    }
+    static bool IsSpecialJsonKey(const TStringBuf& key) { 
+        return key.size() > 0 && key[0] == '$'; 
+    } 
 
-    ////////////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////////// 
 
-    TJsonWriter::TJsonWriter(
-        IOutputStream* output,
+    TJsonWriter::TJsonWriter( 
+        IOutputStream* output, 
         ::NYson::EYsonType type,
-        EJsonFormat format,
-        EJsonAttributesMode attributesMode,
-        ESerializedBoolFormat booleanFormat)
+        EJsonFormat format, 
+        EJsonAttributesMode attributesMode, 
+        ESerializedBoolFormat booleanFormat) 
         : TJsonWriter(
             output,
             NJson::TJsonWriterConfig{}.SetFormatOutput(format == JF_PRETTY),
@@ -32,189 +32,189 @@ namespace NYT {
         ::NYson::EYsonType type,
         EJsonAttributesMode attributesMode,
         ESerializedBoolFormat booleanFormat)
-        : Output(output)
-        , Type(type)
-        , AttributesMode(attributesMode)
-        , BooleanFormat(booleanFormat)
-        , Depth(0)
-    {
+        : Output(output) 
+        , Type(type) 
+        , AttributesMode(attributesMode) 
+        , BooleanFormat(booleanFormat) 
+        , Depth(0) 
+    { 
         if (Type == ::NYson::EYsonType::MapFragment) {
             ythrow ::NYson::TYsonException() << ("Map fragments are not supported by Json");
-        }
+        } 
 
-        UnderlyingJsonWriter.Reset(new NJson::TJsonWriter(
-            output,
+        UnderlyingJsonWriter.Reset(new NJson::TJsonWriter( 
+            output, 
             config));
-        JsonWriter = UnderlyingJsonWriter.Get();
-        HasAttributes = false;
-        InAttributesBalance = 0;
-    }
-
-    void TJsonWriter::EnterNode() {
-        if (AttributesMode == JAM_NEVER) {
-            HasAttributes = false;
-        } else if (AttributesMode == JAM_ON_DEMAND) {
-            // Do nothing
-        } else if (AttributesMode == JAM_ALWAYS) {
-            if (!HasAttributes) {
-                JsonWriter->OpenMap();
-                JsonWriter->Write("$attributes");
-                JsonWriter->OpenMap();
-                JsonWriter->CloseMap();
-            }
-            HasAttributes = true;
-        }
-        HasUnfoldedStructureStack.push_back(HasAttributes);
-
-        if (HasAttributes) {
-            JsonWriter->Write("$value");
-            HasAttributes = false;
-        }
-
-        Depth += 1;
-    }
-
-    void TJsonWriter::LeaveNode() {
-        Y_ASSERT(!HasUnfoldedStructureStack.empty());
-        if (HasUnfoldedStructureStack.back()) {
-            // Close map of the {$attributes, $value}
-            JsonWriter->CloseMap();
-        }
-        HasUnfoldedStructureStack.pop_back();
-
-        Depth -= 1;
-
+        JsonWriter = UnderlyingJsonWriter.Get(); 
+        HasAttributes = false; 
+        InAttributesBalance = 0; 
+    }
+
+    void TJsonWriter::EnterNode() { 
+        if (AttributesMode == JAM_NEVER) { 
+            HasAttributes = false; 
+        } else if (AttributesMode == JAM_ON_DEMAND) { 
+            // Do nothing 
+        } else if (AttributesMode == JAM_ALWAYS) { 
+            if (!HasAttributes) { 
+                JsonWriter->OpenMap(); 
+                JsonWriter->Write("$attributes"); 
+                JsonWriter->OpenMap(); 
+                JsonWriter->CloseMap(); 
+            } 
+            HasAttributes = true; 
+        } 
+        HasUnfoldedStructureStack.push_back(HasAttributes); 
+
+        if (HasAttributes) { 
+            JsonWriter->Write("$value"); 
+            HasAttributes = false; 
+        }
+
+        Depth += 1; 
+    }
+
+    void TJsonWriter::LeaveNode() { 
+        Y_ASSERT(!HasUnfoldedStructureStack.empty()); 
+        if (HasUnfoldedStructureStack.back()) { 
+            // Close map of the {$attributes, $value} 
+            JsonWriter->CloseMap(); 
+        } 
+        HasUnfoldedStructureStack.pop_back(); 
+
+        Depth -= 1; 
+ 
         if (Depth == 0 && Type == ::NYson::EYsonType::ListFragment && InAttributesBalance == 0) {
-            JsonWriter->Flush();
-            Output->Write("\n");
-        }
+            JsonWriter->Flush(); 
+            Output->Write("\n"); 
+        } 
     }
 
-    bool TJsonWriter::IsWriteAllowed() {
-        if (AttributesMode == JAM_NEVER) {
-            return InAttributesBalance == 0;
-        }
-        return true;
+    bool TJsonWriter::IsWriteAllowed() { 
+        if (AttributesMode == JAM_NEVER) { 
+            return InAttributesBalance == 0; 
+        } 
+        return true; 
     }
 
     void TJsonWriter::OnStringScalar(TStringBuf value) {
-        if (IsWriteAllowed()) {
-            EnterNode();
-            WriteStringScalar(value);
-            LeaveNode();
-        }
-    }
-
-    void TJsonWriter::OnInt64Scalar(i64 value) {
-        if (IsWriteAllowed()) {
-            EnterNode();
-            JsonWriter->Write(value);
-            LeaveNode();
-        }
-    }
-
-    void TJsonWriter::OnUint64Scalar(ui64 value) {
-        if (IsWriteAllowed()) {
+        if (IsWriteAllowed()) { 
+            EnterNode(); 
+            WriteStringScalar(value); 
+            LeaveNode(); 
+        } 
+    }
+
+    void TJsonWriter::OnInt64Scalar(i64 value) { 
+        if (IsWriteAllowed()) { 
+            EnterNode(); 
+            JsonWriter->Write(value); 
+            LeaveNode(); 
+        } 
+    }
+
+    void TJsonWriter::OnUint64Scalar(ui64 value) { 
+        if (IsWriteAllowed()) { 
+            EnterNode(); 
+            JsonWriter->Write(value); 
+            LeaveNode(); 
+        } 
+    }
+
+    void TJsonWriter::OnDoubleScalar(double value) { 
+        if (IsWriteAllowed()) { 
+            EnterNode(); 
+            JsonWriter->Write(value); 
+            LeaveNode(); 
+        } 
+    }
+
+    void TJsonWriter::OnBooleanScalar(bool value) { 
+        if (IsWriteAllowed()) { 
+            if (BooleanFormat == SBF_STRING) { 
+                OnStringScalar(value ? "true" : "false"); 
+            } else { 
+                EnterNode(); 
+                JsonWriter->Write(value); 
+                LeaveNode(); 
+            } 
+        } 
+    }
+
+    void TJsonWriter::OnEntity() { 
+        if (IsWriteAllowed()) { 
             EnterNode();
-            JsonWriter->Write(value);
+            JsonWriter->WriteNull(); 
             LeaveNode();
         }
     }
 
-    void TJsonWriter::OnDoubleScalar(double value) {
-        if (IsWriteAllowed()) {
-            EnterNode();
-            JsonWriter->Write(value);
-            LeaveNode();
-        }
-    }
-
-    void TJsonWriter::OnBooleanScalar(bool value) {
-        if (IsWriteAllowed()) {
-            if (BooleanFormat == SBF_STRING) {
-                OnStringScalar(value ? "true" : "false");
-            } else {
-                EnterNode();
-                JsonWriter->Write(value);
-                LeaveNode();
-            }
-        }
+    void TJsonWriter::OnBeginList() { 
+        if (IsWriteAllowed()) { 
+            EnterNode(); 
+            JsonWriter->OpenArray(); 
+        } 
     }
 
-    void TJsonWriter::OnEntity() {
-        if (IsWriteAllowed()) {
-            EnterNode();
-            JsonWriter->WriteNull();
-            LeaveNode();
-        }
+    void TJsonWriter::OnListItem() { 
     }
 
-    void TJsonWriter::OnBeginList() {
-        if (IsWriteAllowed()) {
-            EnterNode();
-            JsonWriter->OpenArray();
-        }
-    }
+    void TJsonWriter::OnEndList() { 
+        if (IsWriteAllowed()) { 
+            JsonWriter->CloseArray(); 
+            LeaveNode(); 
+        } 
+    } 
 
-    void TJsonWriter::OnListItem() {
-    }
-
-    void TJsonWriter::OnEndList() {
-        if (IsWriteAllowed()) {
-            JsonWriter->CloseArray();
-            LeaveNode();
-        }
-    }
-
-    void TJsonWriter::OnBeginMap() {
-        if (IsWriteAllowed()) {
-            EnterNode();
-            JsonWriter->OpenMap();
-        }
+    void TJsonWriter::OnBeginMap() { 
+        if (IsWriteAllowed()) { 
+            EnterNode(); 
+            JsonWriter->OpenMap(); 
+        } 
     }
 
     void TJsonWriter::OnKeyedItem(TStringBuf name) {
-        if (IsWriteAllowed()) {
-            if (IsSpecialJsonKey(name)) {
-                WriteStringScalar(TString("$") + name);
-            } else {
-                WriteStringScalar(name);
-            }
-        }
-    }
-
-    void TJsonWriter::OnEndMap() {
-        if (IsWriteAllowed()) {
-            JsonWriter->CloseMap();
-            LeaveNode();
-        }
+        if (IsWriteAllowed()) { 
+            if (IsSpecialJsonKey(name)) { 
+                WriteStringScalar(TString("$") + name); 
+            } else { 
+                WriteStringScalar(name); 
+            } 
+        } 
     }
 
-    void TJsonWriter::OnBeginAttributes() {
-        InAttributesBalance += 1;
-        if (AttributesMode != JAM_NEVER) {
-            JsonWriter->OpenMap();
-            JsonWriter->Write("$attributes");
-            JsonWriter->OpenMap();
+    void TJsonWriter::OnEndMap() { 
+        if (IsWriteAllowed()) { 
+            JsonWriter->CloseMap(); 
+            LeaveNode(); 
         }
     }
 
-    void TJsonWriter::OnEndAttributes() {
-        InAttributesBalance -= 1;
-        if (AttributesMode != JAM_NEVER) {
-            HasAttributes = true;
-            JsonWriter->CloseMap();
-        }
+    void TJsonWriter::OnBeginAttributes() { 
+        InAttributesBalance += 1; 
+        if (AttributesMode != JAM_NEVER) { 
+            JsonWriter->OpenMap(); 
+            JsonWriter->Write("$attributes"); 
+            JsonWriter->OpenMap(); 
+        } 
     }
 
-    void TJsonWriter::WriteStringScalar(const TStringBuf& value) {
-        JsonWriter->Write(value);
+    void TJsonWriter::OnEndAttributes() { 
+        InAttributesBalance -= 1; 
+        if (AttributesMode != JAM_NEVER) { 
+            HasAttributes = true; 
+            JsonWriter->CloseMap(); 
+        } 
     }
 
-    void TJsonWriter::Flush() {
-        JsonWriter->Flush();
+    void TJsonWriter::WriteStringScalar(const TStringBuf& value) { 
+        JsonWriter->Write(value); 
     }
 
-    ////////////////////////////////////////////////////////////////////////////////
+    void TJsonWriter::Flush() { 
+        JsonWriter->Flush(); 
+    } 
 
+    //////////////////////////////////////////////////////////////////////////////// 
+ 
 }