Intermediate changes

Author: robot-piglet

yt/yt/core/concurrency/unittests/profiled_fair_share_invoker_pool_ut.cpp

@@ -14,6 +14,8 @@
 
 #include <yt/yt/library/profiling/solomon/exporter.h>
 
+#include <library/cpp/json/yson/json2yson.h>
+
 #include <util/datetime/base.h>
 
 #include <algorithm>
@@ -666,15 +668,7 @@ class TProfiledFairShareInvokerPoolProfilingTest
 
     auto GetSensors(TString json)
     {
-        for (auto& c : json) {
-            if (c == ':') {
-                c = '=';
-            } else if (c == ',') {
-                c = ';';
-            }
-        }
-
-        auto yson = NYson::TYsonString(json);
+        auto yson = NYson::TYsonString(NJson2Yson::SerializeJsonValueAsYson(NJson::ReadJsonFastTree(json)));
 
         auto list = NYTree::ConvertToNode(yson)->AsMap()->FindChild("sensors");
 
@@ -730,7 +724,7 @@ class TProfiledFairShareInvokerPoolProfilingTest
 
         THashMap<TString, int> invokerNameToDequeued = invokerNameToEnqueued;
 
-        for (const auto& entry : GetSensors(json)) {
+        for (const auto& entry : GetSensors(std::move(json))) {
             auto mapEntry = entry->AsMap();
             auto labels = mapEntry->FindChild("labels")->AsMap();
 

yt/yt/core/concurrency/unittests/ya.make

@@ -48,6 +48,8 @@ INCLUDE(${ARCADIA_ROOT}/yt/opensource.inc)
 PEERDIR(
     yt/yt/core
     yt/yt/core/test_framework
+
+    library/cpp/json/yson
 )
 
 REQUIREMENTS(

yt/yt/core/ytree/polymorphic_yson_struct-inl.h

@@ -10,48 +10,44 @@ namespace NYT::NYTree {
 
 namespace NDetail {
 
-template <class TEnum>
-    requires TEnumTraits<TEnum>::IsEnum
-template <class TBase, class TDerived>
-TIntrusivePtr<TBase> TEnumTraitsExt<TEnum>::ConcreteFactory()
+template <class TEnum, TEnum Value, class TBase, class TDerived>
+TIntrusivePtr<TBase> TMappingLeaf<TEnum, Value, TBase, TDerived>::CreateInstance()
 {
     return New<TDerived>();
 }
 
-template <class TEnum>
-    requires TEnumTraits<TEnum>::IsEnum
-template <class TBase, class... TDerived>
-TInstanceFactory<TEnum, TBase>  TEnumTraitsExt<TEnum>::MakeFactory()
+template <class TEnum, TEnum BaseValue, CYsonStructDerived TBase, TEnum... Values, class... TDerived>
+    requires (CHierarchy<TBase, TDerived...>)
+TIntrusivePtr<TBase>
+TPolymorphicMapping<TEnum, TLeafTag<BaseValue, TBase>, TLeafTag<Values, TDerived>...>::
+CreateInstance(TEnum value)
 {
-    static constexpr auto keys = TTraits::GetDomainValues();
-    using TTuple = std::tuple<TBase, TDerived...>;
+    if (value == BaseValue) {
+        return TLeaf<BaseValue, TBase>::CreateInstance();
+    }
 
-    TInstanceFactory<TEnum, TBase> mapping;
+    TIntrusivePtr<TBase> ret;
 
-    [&] <size_t... Idx> (std::index_sequence<Idx...>) {
-        ([&] {
-            mapping[keys[Idx]] = &TEnumTraitsExt<TEnum>::ConcreteFactory<TBase, std::tuple_element_t<Idx, TTuple>>;
-        } (), ...);
-    } (std::make_index_sequence<sizeof...(TDerived) + 1>());
+    ([&ret, value] {
+        if (value == Values) {
+            ret = TLeaf<Values, TDerived>::CreateInstance();
+            return false;
+        }
+        return true;
+    } () && ...);
 
-    return mapping;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-template <class TEnum, class TB, class... TD>
-TIntrusivePtr<TB> TPolymorphicEnumMapping<TEnum, TB, TD...>::MakeInstance(TEnum e)
-{
-    static auto factory =
-        TEnumTraitsExt<TEnum>::template MakeFactory<TB, TD...>();
-
-    return factory[e]();
+    return ret;
 }
 
 } // namespace NDetail
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <CPolymorphicEnumMapping TMapping>
+TPolymorphicYsonStruct<TMapping>::TPolymorphicYsonStruct(TKey key)
+    : TPolymorphicYsonStruct(key, TMapping::CreateInstance(key))
+{ }
+
 template <CPolymorphicEnumMapping TMapping>
 TPolymorphicYsonStruct<TMapping>::TPolymorphicYsonStruct(TKey key, TIntrusivePtr<TBase> ptr) noexcept
     : Storage_(std::move(ptr))
@@ -77,6 +73,11 @@ void TPolymorphicYsonStruct<TMapping>::Load(
     // parse (unless we want to slice which we don't).
     IMapNodePtr map = TTraits::AsNode(source)->AsMap();
 
+    if (!map || map->GetChildCount() == 0) {
+        // Empty struct.
+        return;
+    }
+
     auto key = map->FindChildValue<TKey>("type");
     THROW_ERROR_EXCEPTION_UNLESS(
         key.has_value(),
@@ -86,7 +87,7 @@ void TPolymorphicYsonStruct<TMapping>::Load(
     if (!Storage_ || HeldType_ != type) {
         // NB: We will try to merge configs if types match.
         HeldType_ = type;
-        Storage_ = TMapping::MakeInstance(HeldType_);
+        Storage_ = TMapping::CreateInstance(HeldType_);
     }
 
     if (recursiveUnrecognizedStrategy) {
@@ -97,33 +98,62 @@ void TPolymorphicYsonStruct<TMapping>::Load(
     // therefore we must delete it prior to |Load| call.
     map->RemoveChild("type");
     Storage_->Load(map, postprocess, setDefaults, path);
+
+    // NB(arkady-e1ppa): We must not actually remove contents of the node as a postcondition
+    // since it mutates serialized data which might be used for config validation.
+    map->AddChild("type", ConvertToNode(HeldType_));
 }
 
 template <CPolymorphicEnumMapping TMapping>
 void TPolymorphicYsonStruct<TMapping>::Save(NYson::IYsonConsumer* consumer) const
 {
     consumer->OnBeginMap();
 
-    consumer->OnKeyedItem("type");
-    consumer->OnStringScalar(FormatEnum(HeldType_));
+    if (Storage_) {
+        consumer->OnKeyedItem("type");
+        consumer->OnStringScalar(FormatEnum(HeldType_));
+
+        Storage_->SaveAsMapFragment(consumer);
+    }
 
-    Storage_->SaveAsMapFragment(consumer);
     consumer->OnEndMap();
 }
 
 template <CPolymorphicEnumMapping TMapping>
-template <std::derived_from<typename TMapping::TBase> TConcrete>
+template <std::derived_from<typename TMapping::TBaseClass> TConcrete>
 TIntrusivePtr<TConcrete> TPolymorphicYsonStruct<TMapping>::TryGetConcrete() const
 {
     return DynamicPointerCast<TConcrete>(Storage_);
 }
 
+template <CPolymorphicEnumMapping TMapping>
+template <typename TMapping::TKey Value>
+TIntrusivePtr<typename TMapping::template TDerivedToEnum<Value>> TPolymorphicYsonStruct<TMapping>::TryGetConcrete() const
+{
+    if (Value != HeldType_) {
+        return {};
+    }
+    return TryGetConcrete<typename TMapping::template TDerivedToEnum<Value>>();
+}
+
 template <CPolymorphicEnumMapping TMapping>
 typename TPolymorphicYsonStruct<TMapping>::TKey TPolymorphicYsonStruct<TMapping>::GetCurrentType() const
 {
     return HeldType_;
 }
 
+template <CPolymorphicEnumMapping TMapping>
+typename TPolymorphicYsonStruct<TMapping>::TBase* TPolymorphicYsonStruct<TMapping>::operator->()
+{
+    return Storage_.Get();
+}
+
+template <CPolymorphicEnumMapping TMapping>
+const typename TPolymorphicYsonStruct<TMapping>::TBase* TPolymorphicYsonStruct<TMapping>::operator->() const
+{
+    return Storage_.Get();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <CPolymorphicEnumMapping TMapping>
@@ -141,6 +171,7 @@ void Deserialize(TPolymorphicYsonStruct<TMapping>& value, TSource source)
 ////////////////////////////////////////////////////////////////////////////////
 
 #undef DEFINE_POLYMORPHIC_YSON_STRUCT
+#undef DEFINE_POLYMORPHIC_YSON_STRUCT_FOR_ENUM
 
 #define POLYMORPHIC_YSON_STRUCT_IMPL__GET_ENUM_SEQ_ELEM(item) \
     PP_LEFT_PARENTHESIS PP_ELEMENT(item, 0) PP_RIGHT_PARENTHESIS
@@ -151,23 +182,37 @@ void Deserialize(TPolymorphicYsonStruct<TMapping>& value, TSource source)
 #define POLYMORPHIC_YSON_STRUCT_IMPL__ENUM_NAME(Struct) \
     E##Struct##Type
 
-#define POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_ENUM(Struct, seq) \
+#define POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_ENUM(seq) \
     DEFINE_ENUM(EType, POLYMORPHIC_YSON_STRUCT_IMPL__GET_ENUM_SEQ(seq))
 
+#define POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_ENUM_ALIAS(EnumName) \
+    using EType = EnumName;
+
 #define POLYMORPHIC_YSON_STRUCT_IMPL__GET_CLASS_ELEM(item) \
     PP_COMMA() PP_ELEMENT(item, 1)
 
+#define POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_LEAF_FROM_ETYPE(item) \
+    PP_COMMA() ::NYT::NYTree::NDetail::TLeafTag<EType:: PP_ELEMENT(item, 0), PP_ELEMENT(item, 1)>
+
 #define POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_CLASS(Struct, seq) \
-    using TMapping = TPolymorphicEnumMapping<EType PP_FOR_EACH(POLYMORPHIC_YSON_STRUCT_IMPL__GET_CLASS_ELEM, seq)>
+    using TMapping = ::NYT::NYTree::TPolymorphicEnumMapping<EType PP_FOR_EACH(POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_LEAF_FROM_ETYPE, seq)>
 
 #define DEFINE_POLYMORPHIC_YSON_STRUCT(name, seq) \
 namespace NPolymorphicYsonStructFor##name { \
  \
-    POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_ENUM(name, seq); \
+    POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_ENUM(seq); \
     POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_CLASS(name, seq); \
 } /*NPolymorphicYsonStructFor##name*/ \
 using POLYMORPHIC_YSON_STRUCT_IMPL__ENUM_NAME(name) = NPolymorphicYsonStructFor##name::EType; \
-using T##name = TPolymorphicYsonStruct<NPolymorphicYsonStructFor##name::TMapping>; \
+using T##name = ::NYT::NYTree::TPolymorphicYsonStruct<NPolymorphicYsonStructFor##name::TMapping>; \
+static_assert(true)
+
+#define DEFINE_POLYMORPHIC_YSON_STRUCT_FOR_ENUM(name, enum, seq) \
+namespace NPolymorphicYsonStructFor##name { \
+    POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_ENUM_ALIAS(enum); \
+    POLYMORPHIC_YSON_STRUCT_IMPL__MAKE_MAPPING_CLASS(name, seq); \
+} /*NPolymorphicYsonStructFor##name*/ \
+using T##name = ::NYT::NYTree::TPolymorphicYsonStruct<NPolymorphicYsonStructFor##name::TMapping>; \
 static_assert(true)
 
 ////////////////////////////////////////////////////////////////////////////////