Style

487fef9b3ffa1bdce95aad5e6b083283bb1476a7

5 files changed, 155 insertions, 145 deletions

diff --git a/yt/yt/core/json/config.cpp b/yt/yt/core/json/config.cpp
index bffb0e8f4e7..9ad77263e6d 100644
--- a/yt/yt/core/json/config.cpp
+++ b/yt/yt/core/json/config.cpp
@@ -14,18 +14,27 @@ void TJsonFormatConfig::Register(TRegistrar registrar)
         .Default(false);
     registrar.Parameter("encode_utf8", &TThis::EncodeUtf8)
         .Default(true);
+
+    registrar.Parameter("memory_limit", &TThis::MemoryLimit)
+        .Default(256_MB);
+    registrar.Parameter("nesting_level_limit", &TThis::NestingLevelLimit)
+        .Default(0);
     registrar.Parameter("string_length_limit", &TThis::StringLengthLimit)
         .Default();
+
     registrar.Parameter("stringify", &TThis::Stringify)
         .Default(false);
     registrar.Parameter("annotate_with_types", &TThis::AnnotateWithTypes)
         .Default(false);
+
     registrar.Parameter("support_infinity", &TThis::SupportInfinity)
         .Default(false);
     registrar.Parameter("stringify_nan_and_infinity", &TThis::StringifyNanAndInfinity)
         .Default(false);
+
     registrar.Parameter("buffer_size", &TThis::BufferSize)
         .Default(16 * 1024);
+
     registrar.Parameter("skip_null_values", &TThis::SkipNullValues)
         .Default(false);
 
diff --git a/yt/yt/core/json/config.h b/yt/yt/core/json/config.h
index 71fa8c46e7b..e9f2c527924 100644
--- a/yt/yt/core/json/config.h
+++ b/yt/yt/core/json/config.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "public.h"
+
 #include <yt/yt/core/ytree/yson_struct.h>
 
 namespace NYT::NJson {
@@ -25,9 +27,9 @@ public:
     EJsonAttributesMode AttributesMode;
     bool Plain;
     bool EncodeUtf8;
-    i64 MemoryLimit = 256_MB;
-    int NestingLevelLimit = 0;
 
+    i64 MemoryLimit;
+    int NestingLevelLimit;
     std::optional<int> StringLengthLimit;
 
     bool Stringify;
diff --git a/yt/yt/core/json/json_callbacks.cpp b/yt/yt/core/json/json_callbacks.cpp
index be342c6e8a5..5097c63ead0 100644
--- a/yt/yt/core/json/json_callbacks.cpp
+++ b/yt/yt/core/json/json_callbacks.cpp
@@ -151,7 +151,8 @@ void TJsonCallbacksBuildingNodesImpl::OnItemFinished()
 void TJsonCallbacksBuildingNodesImpl::ConsumeNode(INodePtr node, int nestingLevel)
 {
     if (NestingLevelLimit_ > 0 && nestingLevel > NestingLevelLimit_) {
-        THROW_ERROR_EXCEPTION("JSON nesting level limit exceeded") << TErrorAttribute("nesting_level_limit", NestingLevelLimit_);
+        THROW_ERROR_EXCEPTION("JSON nesting level limit exceeded")
+            << TErrorAttribute("nesting_level_limit", NestingLevelLimit_);
     }
     switch (node->GetType()) {
         case ENodeType::Int64:
diff --git a/yt/yt/core/json/json_writer.cpp b/yt/yt/core/json/json_writer.cpp
index 3d5c2b46926..c24fc0940fe 100644
--- a/yt/yt/core/json/json_writer.cpp
+++ b/yt/yt/core/json/json_writer.cpp
@@ -1,5 +1,5 @@
 #include "json_writer.h"
-#include "config.h"
+
 #include "helpers.h"
 
 #include <yt/yt/core/misc/utf8_decoder.h>
@@ -7,7 +7,6 @@
 #include <contrib/libs/yajl/api/yajl_gen.h>
 
 #include <cmath>
-#include <iostream>
 
 namespace NYT::NJson {
 
@@ -54,8 +53,8 @@ private:
     TStringBuf GetBuffer() const;
 
 private:
-    yajl_gen Handle;
-    IOutputStream* Output;
+    yajl_gen Handle_;
+    IOutputStream* Output_;
     ui64 WrittenToOutputByteCount_ = 0;
 };
 
@@ -117,20 +116,20 @@ private:
     bool IsWriteAllowed();
 
 private:
-    IJsonWriter* const JsonWriter;
+    IJsonWriter* const JsonWriter_;
     std::unique_ptr<IJsonWriter> JsonWriterHolder_;
 
-    const EYsonType Type;
-    const TJsonFormatConfigPtr Config;
+    const EYsonType Type_;
+    const TJsonFormatConfigPtr Config_;
     ENanInfinityMode NanInfinityMode_;
 
-    TUtf8Transcoder Utf8Transcoder;
+    TUtf8Transcoder Utf8Transcoder_;
 
-    std::vector<bool> HasUnfoldedStructureStack;
-    int InAttributesBalance = 0;
-    bool HasAttributes = false;
-    int Depth = 0;
-    bool CheckLimit = true;
+    std::vector<bool> HasUnfoldedStructureStack_;
+    int InAttributesBalance_ = 0;
+    bool HasAttributes_ = false;
+    int Depth_ = 0;
+    bool CheckLimit_ = true;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -169,54 +168,54 @@ static void CheckYajlCode(int yajlCode)
 }
 
 TJsonWriter::TJsonWriter(IOutputStream* output, bool isPretty)
-    : Output(output)
+    : Output_(output)
 {
-    Handle = yajl_gen_alloc(nullptr);
-    yajl_gen_config(Handle, yajl_gen_beautify, isPretty ? 1 : 0);
-    yajl_gen_config(Handle, yajl_gen_skip_final_newline, 0);
+    Handle_ = yajl_gen_alloc(nullptr);
+    yajl_gen_config(Handle_, yajl_gen_beautify, isPretty ? 1 : 0);
+    yajl_gen_config(Handle_, yajl_gen_skip_final_newline, 0);
 
-    yajl_gen_config(Handle, yajl_gen_support_infinity, 1);
+    yajl_gen_config(Handle_, yajl_gen_support_infinity, 1);
 
-    yajl_gen_config(Handle, yajl_gen_disable_yandex_double_format, 1);
-    yajl_gen_config(Handle, yajl_gen_validate_utf8, 1);
+    yajl_gen_config(Handle_, yajl_gen_disable_yandex_double_format, 1);
+    yajl_gen_config(Handle_, yajl_gen_validate_utf8, 1);
 }
 
 TJsonWriter::~TJsonWriter()
 {
-    yajl_gen_free(Handle);
+    yajl_gen_free(Handle_);
 }
 
 void TJsonWriter::GenerateString(TStringBuf value)
 {
-    CheckYajlCode(yajl_gen_string(Handle, (const unsigned char*) value.data(), value.size()));
+    CheckYajlCode(yajl_gen_string(Handle_, (const unsigned char*) value.data(), value.size()));
 }
 
 TStringBuf TJsonWriter::GetBuffer() const
 {
     size_t len = 0;
     const unsigned char* buf = nullptr;
-    CheckYajlCode(yajl_gen_get_buf(Handle, &buf, &len));
+    CheckYajlCode(yajl_gen_get_buf(Handle_, &buf, &len));
     return TStringBuf(static_cast<const char*>(static_cast<const void*>(buf)), len);
 }
 
 void TJsonWriter::Flush()
 {
     auto buf = GetBuffer();
-    Output->Write(buf);
+    Output_->Write(buf);
     WrittenToOutputByteCount_ += buf.Size();
-    yajl_gen_clear(Handle);
+    yajl_gen_clear(Handle_);
 }
 
 void TJsonWriter::StartNextValue()
 {
     Flush();
-    yajl_gen_reset(Handle, nullptr);
-    Output->Write('\n');
+    yajl_gen_reset(Handle_, nullptr);
+    Output_->Write('\n');
 }
 
 void TJsonWriter::OnBeginMap()
 {
-    CheckYajlCode(yajl_gen_map_open(Handle));
+    CheckYajlCode(yajl_gen_map_open(Handle_));
 }
 
 void TJsonWriter::OnKeyedItem(TStringBuf name)
@@ -226,12 +225,12 @@ void TJsonWriter::OnKeyedItem(TStringBuf name)
 
 void TJsonWriter::OnEndMap()
 {
-    CheckYajlCode(yajl_gen_map_close(Handle));
+    CheckYajlCode(yajl_gen_map_close(Handle_));
 }
 
 void TJsonWriter::OnBeginList()
 {
-    CheckYajlCode(yajl_gen_array_open(Handle));
+    CheckYajlCode(yajl_gen_array_open(Handle_));
 }
 
 void TJsonWriter::OnListItem()
@@ -239,7 +238,7 @@ void TJsonWriter::OnListItem()
 
 void TJsonWriter::OnEndList()
 {
-    CheckYajlCode(yajl_gen_array_close(Handle));
+    CheckYajlCode(yajl_gen_array_close(Handle_));
 }
 
 void TJsonWriter::OnStringScalar(TStringBuf value)
@@ -249,27 +248,27 @@ void TJsonWriter::OnStringScalar(TStringBuf value)
 
 void TJsonWriter::OnEntity()
 {
-    CheckYajlCode(yajl_gen_null(Handle));
+    CheckYajlCode(yajl_gen_null(Handle_));
 }
 
 void TJsonWriter::OnDoubleScalar(double value)
 {
-    CheckYajlCode(yajl_gen_double(Handle, value));
+    CheckYajlCode(yajl_gen_double(Handle_, value));
 }
 
 void TJsonWriter::OnInt64Scalar(i64 value)
 {
-    CheckYajlCode(yajl_gen_integer(Handle, value));
+    CheckYajlCode(yajl_gen_integer(Handle_, value));
 }
 
 void TJsonWriter::OnUint64Scalar(ui64 value)
 {
-    CheckYajlCode(yajl_gen_uinteger(Handle, value));
+    CheckYajlCode(yajl_gen_uinteger(Handle_, value));
 }
 
 void TJsonWriter::OnBooleanScalar(bool value)
 {
-    CheckYajlCode(yajl_gen_bool(Handle, value ? 1 : 0));
+    CheckYajlCode(yajl_gen_bool(Handle_, value ? 1 : 0));
 }
 
 void TJsonWriter::OnBeginAttributes()
@@ -298,19 +297,19 @@ TJsonConsumer::TJsonConsumer(
     IJsonWriter* jsonWriter,
     EYsonType type,
     TJsonFormatConfigPtr config)
-    : JsonWriter(jsonWriter)
-    , Type(type)
-    , Config(std::move(config))
-    , Utf8Transcoder(Config->EncodeUtf8)
+    : JsonWriter_(jsonWriter)
+    , Type_(type)
+    , Config_(std::move(config))
+    , Utf8Transcoder_(Config_->EncodeUtf8)
 {
-    if (Type == EYsonType::MapFragment) {
+    if (Type_ == EYsonType::MapFragment) {
         THROW_ERROR_EXCEPTION("Map fragments are not supported by JSON");
     }
 
     NanInfinityMode_ = ENanInfinityMode::NotSupported;
-    if (Config->SupportInfinity) {
+    if (Config_->SupportInfinity) {
         NanInfinityMode_ = ENanInfinityMode::WriteInfinitiesUnquoted;
-    } else if (Config->StringifyNanAndInfinity) {
+    } else if (Config_->StringifyNanAndInfinity) {
         NanInfinityMode_ = ENanInfinityMode::WriteAllQuouted;
     }
 }
@@ -326,49 +325,49 @@ TJsonConsumer::TJsonConsumer(
 
 void TJsonConsumer::EnterNode()
 {
-    if (Config->AttributesMode == EJsonAttributesMode::Never) {
-        HasAttributes = false;
-    } else if (Config->AttributesMode == EJsonAttributesMode::OnDemand) {
+    if (Config_->AttributesMode == EJsonAttributesMode::Never) {
+        HasAttributes_ = false;
+    } else if (Config_->AttributesMode == EJsonAttributesMode::OnDemand) {
         // Do nothing
-    } else if (Config->AttributesMode == EJsonAttributesMode::Always) {
-        if (!HasAttributes) {
-            JsonWriter->OnBeginMap();
-            JsonWriter->OnKeyedItem(TStringBuf("$attributes"));
-            JsonWriter->OnBeginMap();
-            JsonWriter->OnEndMap();
-            HasAttributes = true;
+    } else if (Config_->AttributesMode == EJsonAttributesMode::Always) {
+        if (!HasAttributes_) {
+            JsonWriter_->OnBeginMap();
+            JsonWriter_->OnKeyedItem(TStringBuf("$attributes"));
+            JsonWriter_->OnBeginMap();
+            JsonWriter_->OnEndMap();
+            HasAttributes_ = true;
         }
     }
-    HasUnfoldedStructureStack.push_back(HasAttributes);
+    HasUnfoldedStructureStack_.push_back(HasAttributes_);
 
-    if (HasAttributes) {
-        JsonWriter->OnKeyedItem(TStringBuf("$value"));
-        HasAttributes = false;
+    if (HasAttributes_) {
+        JsonWriter_->OnKeyedItem(TStringBuf("$value"));
+        HasAttributes_ = false;
     }
 
-    Depth += 1;
+    Depth_ += 1;
 }
 
 void TJsonConsumer::LeaveNode()
 {
-    YT_VERIFY(!HasUnfoldedStructureStack.empty());
-    if (HasUnfoldedStructureStack.back()) {
+    YT_VERIFY(!HasUnfoldedStructureStack_.empty());
+    if (HasUnfoldedStructureStack_.back()) {
         // Close map of the {$attributes, $value}
-        JsonWriter->OnEndMap();
+        JsonWriter_->OnEndMap();
     }
-    HasUnfoldedStructureStack.pop_back();
+    HasUnfoldedStructureStack_.pop_back();
 
-    Depth -= 1;
+    Depth_ -= 1;
 
-    if (Depth == 0 && Type == EYsonType::ListFragment && InAttributesBalance == 0) {
-        JsonWriter->StartNextValue();
+    if (Depth_ == 0 && Type_ == EYsonType::ListFragment && InAttributesBalance_ == 0) {
+        JsonWriter_->StartNextValue();
     }
 }
 
 bool TJsonConsumer::IsWriteAllowed()
 {
-    if (Config->AttributesMode == EJsonAttributesMode::Never) {
-        return InAttributesBalance == 0;
+    if (Config_->AttributesMode == EJsonAttributesMode::Never) {
+        return InAttributesBalance_ == 0;
     }
     return true;
 }
@@ -377,9 +376,9 @@ void TJsonConsumer::OnStringScalar(TStringBuf value)
 {
     TStringBuf writeValue = value;
     bool incomplete = false;
-    if (Config->AttributesMode != EJsonAttributesMode::Never) {
-        if (CheckLimit && Config->StringLengthLimit && std::ssize(value) > *Config->StringLengthLimit) {
-            writeValue = value.substr(0, *Config->StringLengthLimit);
+    if (Config_->AttributesMode != EJsonAttributesMode::Never) {
+        if (CheckLimit_ && Config_->StringLengthLimit && std::ssize(value) > *Config_->StringLengthLimit) {
+            writeValue = value.substr(0, *Config_->StringLengthLimit);
             incomplete = true;
         }
     }
@@ -390,19 +389,19 @@ void TJsonConsumer::OnStringScalar(TStringBuf value)
 void TJsonConsumer::OnInt64Scalar(i64 value)
 {
     if (IsWriteAllowed()) {
-        if (Config->AnnotateWithTypes && Config->AttributesMode != EJsonAttributesMode::Never) {
-            if (!HasAttributes) {
-                JsonWriter->OnBeginMap();
-                HasAttributes = true;
+        if (Config_->AnnotateWithTypes && Config_->AttributesMode != EJsonAttributesMode::Never) {
+            if (!HasAttributes_) {
+                JsonWriter_->OnBeginMap();
+                HasAttributes_ = true;
             }
-            JsonWriter->OnKeyedItem(TStringBuf("$type"));
-            JsonWriter->OnStringScalar(TStringBuf("int64"));
+            JsonWriter_->OnKeyedItem(TStringBuf("$type"));
+            JsonWriter_->OnStringScalar(TStringBuf("int64"));
         }
         EnterNode();
-        if (Config->Stringify) {
+        if (Config_->Stringify) {
             WriteStringScalar(::ToString(value));
         } else {
-            JsonWriter->OnInt64Scalar(value);
+            JsonWriter_->OnInt64Scalar(value);
         }
         LeaveNode();
     }
@@ -411,19 +410,19 @@ void TJsonConsumer::OnInt64Scalar(i64 value)
 void TJsonConsumer::OnUint64Scalar(ui64 value)
 {
     if (IsWriteAllowed()) {
-        if (Config->AnnotateWithTypes && Config->AttributesMode != EJsonAttributesMode::Never) {
-            if (!HasAttributes) {
-                JsonWriter->OnBeginMap();
-                HasAttributes = true;
+        if (Config_->AnnotateWithTypes && Config_->AttributesMode != EJsonAttributesMode::Never) {
+            if (!HasAttributes_) {
+                JsonWriter_->OnBeginMap();
+                HasAttributes_ = true;
             }
-            JsonWriter->OnKeyedItem(TStringBuf("$type"));
-            JsonWriter->OnStringScalar(TStringBuf("uint64"));
+            JsonWriter_->OnKeyedItem(TStringBuf("$type"));
+            JsonWriter_->OnStringScalar(TStringBuf("uint64"));
         }
         EnterNode();
-        if (Config->Stringify) {
+        if (Config_->Stringify) {
             WriteStringScalar(::ToString(value));
         } else {
-            JsonWriter->OnUint64Scalar(value);
+            JsonWriter_->OnUint64Scalar(value);
         }
         LeaveNode();
 
@@ -433,16 +432,16 @@ void TJsonConsumer::OnUint64Scalar(ui64 value)
 void TJsonConsumer::OnDoubleScalar(double value)
 {
     if (IsWriteAllowed()) {
-        if (Config->AnnotateWithTypes && Config->AttributesMode != EJsonAttributesMode::Never) {
-            if (!HasAttributes) {
-                JsonWriter->OnBeginMap();
-                HasAttributes = true;
+        if (Config_->AnnotateWithTypes && Config_->AttributesMode != EJsonAttributesMode::Never) {
+            if (!HasAttributes_) {
+                JsonWriter_->OnBeginMap();
+                HasAttributes_ = true;
             }
-            JsonWriter->OnKeyedItem(TStringBuf("$type"));
-            JsonWriter->OnStringScalar(TStringBuf("double"));
+            JsonWriter_->OnKeyedItem(TStringBuf("$type"));
+            JsonWriter_->OnStringScalar(TStringBuf("double"));
         }
         EnterNode();
-        if (Config->Stringify) {
+        if (Config_->Stringify) {
             char buf[256];
             auto str = TStringBuf(buf, FloatToString(value, buf, sizeof(buf)));
             WriteStringScalar(str);
@@ -450,15 +449,15 @@ void TJsonConsumer::OnDoubleScalar(double value)
             switch (NanInfinityMode_) {
                 case ENanInfinityMode::WriteAllQuouted:
                     if (std::isnan(value)) {
-                        JsonWriter->OnStringScalar(TStringBuf("nan"));
+                        JsonWriter_->OnStringScalar(TStringBuf("nan"));
                     } else if (std::isinf(value)) {
                         if (value < 0) {
-                            JsonWriter->OnStringScalar(TStringBuf("-inf"));
+                            JsonWriter_->OnStringScalar(TStringBuf("-inf"));
                         } else {
-                            JsonWriter->OnStringScalar(TStringBuf("inf"));
+                            JsonWriter_->OnStringScalar(TStringBuf("inf"));
                         }
                     } else {
-                        JsonWriter->OnDoubleScalar(value);
+                        JsonWriter_->OnDoubleScalar(value);
                     }
                     break;
                 case ENanInfinityMode::WriteInfinitiesUnquoted:
@@ -467,7 +466,7 @@ void TJsonConsumer::OnDoubleScalar(double value)
                             "Unexpected NaN encountered during JSON writing; "
                             "consider \"stringify_nan_and_infinity\" config option");
                     }
-                    JsonWriter->OnDoubleScalar(value);
+                    JsonWriter_->OnDoubleScalar(value);
                     break;
                 case ENanInfinityMode::NotSupported:
                     if (std::isnan(value) || std::isinf(value)) {
@@ -475,7 +474,7 @@ void TJsonConsumer::OnDoubleScalar(double value)
                             "Unexpected NaN or infinity encountered during JSON writing; "
                             "consider using either \"support_infinity\" or \"stringify_nan_and_infinity\" config options");
                     }
-                    JsonWriter->OnDoubleScalar(value);
+                    JsonWriter_->OnDoubleScalar(value);
                     break;
             }
         }
@@ -486,19 +485,19 @@ void TJsonConsumer::OnDoubleScalar(double value)
 void TJsonConsumer::OnBooleanScalar(bool value)
 {
     if (IsWriteAllowed()) {
-        if (Config->AnnotateWithTypes && Config->AttributesMode != EJsonAttributesMode::Never) {
-            if (!HasAttributes) {
-                JsonWriter->OnBeginMap();
-                HasAttributes = true;
+        if (Config_->AnnotateWithTypes && Config_->AttributesMode != EJsonAttributesMode::Never) {
+            if (!HasAttributes_) {
+                JsonWriter_->OnBeginMap();
+                HasAttributes_ = true;
             }
-            JsonWriter->OnKeyedItem(TStringBuf("$type"));
-            JsonWriter->OnStringScalar(TStringBuf("boolean"));
+            JsonWriter_->OnKeyedItem(TStringBuf("$type"));
+            JsonWriter_->OnStringScalar(TStringBuf("boolean"));
         }
         EnterNode();
-        if (Config->Stringify) {
+        if (Config_->Stringify) {
             WriteStringScalar(FormatBool(value));
         } else {
-            JsonWriter->OnBooleanScalar(value);
+            JsonWriter_->OnBooleanScalar(value);
         }
         LeaveNode();
     }
@@ -508,7 +507,7 @@ void TJsonConsumer::OnEntity()
 {
     if (IsWriteAllowed()) {
         EnterNode();
-        JsonWriter->OnEntity();
+        JsonWriter_->OnEntity();
         LeaveNode();
     }
 }
@@ -517,21 +516,21 @@ void TJsonConsumer::OnBeginList()
 {
     if (IsWriteAllowed()) {
         EnterNode();
-        JsonWriter->OnBeginList();
+        JsonWriter_->OnBeginList();
     }
 }
 
 void TJsonConsumer::OnListItem()
 {
     if (IsWriteAllowed()) {
-        JsonWriter->OnListItem();
+        JsonWriter_->OnListItem();
     }
 }
 
 void TJsonConsumer::OnEndList()
 {
     if (IsWriteAllowed()) {
-        JsonWriter->OnEndList();
+        JsonWriter_->OnEndList();
         LeaveNode();
     }
 }
@@ -540,7 +539,7 @@ void TJsonConsumer::OnBeginMap()
 {
     if (IsWriteAllowed()) {
         EnterNode();
-        JsonWriter->OnBeginMap();
+        JsonWriter_->OnBeginMap();
     }
 }
 
@@ -548,9 +547,9 @@ void TJsonConsumer::OnKeyedItem(TStringBuf name)
 {
     if (IsWriteAllowed()) {
         if (IsSpecialJsonKey(name)) {
-            JsonWriter->OnKeyedItem(Utf8Transcoder.Encode(TString("$") + name));
+            JsonWriter_->OnKeyedItem(Utf8Transcoder_.Encode(TString("$") + name));
         } else {
-            JsonWriter->OnKeyedItem(Utf8Transcoder.Encode(name));
+            JsonWriter_->OnKeyedItem(Utf8Transcoder_.Encode(name));
         }
     }
 }
@@ -558,38 +557,38 @@ void TJsonConsumer::OnKeyedItem(TStringBuf name)
 void TJsonConsumer::OnEndMap()
 {
     if (IsWriteAllowed()) {
-        JsonWriter->OnEndMap();
+        JsonWriter_->OnEndMap();
         LeaveNode();
     }
 }
 
 void TJsonConsumer::OnBeginAttributes()
 {
-    InAttributesBalance += 1;
-    if (Config->AttributesMode != EJsonAttributesMode::Never) {
-        JsonWriter->OnBeginMap();
-        JsonWriter->OnKeyedItem(TStringBuf("$attributes"));
-        JsonWriter->OnBeginMap();
+    InAttributesBalance_ += 1;
+    if (Config_->AttributesMode != EJsonAttributesMode::Never) {
+        JsonWriter_->OnBeginMap();
+        JsonWriter_->OnKeyedItem(TStringBuf("$attributes"));
+        JsonWriter_->OnBeginMap();
     }
 }
 
 void TJsonConsumer::OnEndAttributes()
 {
-    InAttributesBalance -= 1;
-    if (Config->AttributesMode != EJsonAttributesMode::Never) {
-        JsonWriter->OnEndMap();
-        HasAttributes = true;
+    InAttributesBalance_ -= 1;
+    if (Config_->AttributesMode != EJsonAttributesMode::Never) {
+        JsonWriter_->OnEndMap();
+        HasAttributes_ = true;
     }
 }
 
 void TJsonConsumer::Flush()
 {
-    JsonWriter->Flush();
+    JsonWriter_->Flush();
 }
 
 void TJsonConsumer::WriteStringScalar(TStringBuf value)
 {
-    JsonWriter->OnStringScalar(Utf8Transcoder.Encode(value));
+    JsonWriter_->OnStringScalar(Utf8Transcoder_.Encode(value));
 }
 
 void TJsonConsumer::WriteStringScalarWithAttributes(
@@ -598,25 +597,25 @@ void TJsonConsumer::WriteStringScalarWithAttributes(
     bool incomplete)
 {
     if (IsWriteAllowed()) {
-        if (Config->AttributesMode != EJsonAttributesMode::Never) {
+        if (Config_->AttributesMode != EJsonAttributesMode::Never) {
             if (incomplete) {
-                if (!HasAttributes) {
-                    JsonWriter->OnBeginMap();
-                    HasAttributes = true;
+                if (!HasAttributes_) {
+                    JsonWriter_->OnBeginMap();
+                    HasAttributes_ = true;
                 }
 
-                JsonWriter->OnKeyedItem(TStringBuf("$incomplete"));
-                JsonWriter->OnBooleanScalar(true);
+                JsonWriter_->OnKeyedItem(TStringBuf("$incomplete"));
+                JsonWriter_->OnBooleanScalar(true);
             }
 
-            if (Config->AnnotateWithTypes) {
-                if (!HasAttributes) {
-                    JsonWriter->OnBeginMap();
-                    HasAttributes = true;
+            if (Config_->AnnotateWithTypes) {
+                if (!HasAttributes_) {
+                    JsonWriter_->OnBeginMap();
+                    HasAttributes_ = true;
                 }
 
-                JsonWriter->OnKeyedItem(TStringBuf("$type"));
-                JsonWriter->OnStringScalar(type);
+                JsonWriter_->OnKeyedItem(TStringBuf("$type"));
+                JsonWriter_->OnStringScalar(type);
             }
         }
 
@@ -628,14 +627,14 @@ void TJsonConsumer::WriteStringScalarWithAttributes(
 
 void TJsonConsumer::SetAnnotateWithTypesParameter(bool value)
 {
-    Config->AnnotateWithTypes = value;
+    Config_->AnnotateWithTypes = value;
 }
 
 void TJsonConsumer::OnStringScalarWeightLimited(TStringBuf value, std::optional<i64> weightLimit)
 {
     TStringBuf writeValue = value;
     bool incomplete = false;
-    if (CheckLimit && weightLimit && std::ssize(value) > *weightLimit) {
+    if (CheckLimit_ && weightLimit && std::ssize(value) > *weightLimit) {
         writeValue = value.substr(0, *weightLimit);
         incomplete = true;
     }
@@ -645,7 +644,7 @@ void TJsonConsumer::OnStringScalarWeightLimited(TStringBuf value, std::optional<
 
 void TJsonConsumer::OnNodeWeightLimited(TStringBuf yson, std::optional<i64> weightLimit)
 {
-    if (CheckLimit && weightLimit && std::ssize(yson) > *weightLimit) {
+    if (CheckLimit_ && weightLimit && std::ssize(yson) > *weightLimit) {
         WriteStringScalarWithAttributes({}, TStringBuf("any"), true);
         return;
     }
diff --git a/yt/yt/core/json/json_writer.h b/yt/yt/core/json/json_writer.h
index a8482c4ebfd..a4d3023b7ef 100644
--- a/yt/yt/core/json/json_writer.h
+++ b/yt/yt/core/json/json_writer.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "public.h"
 #include "config.h"
 
 #include <yt/yt/core/yson/public.h>