Add "maybe" operations to JSON. (#1520)

BillyONeal · web-flow · commit 829b20e144a9 · 2024-10-23T14:57:27.000-07:00
Extracted from #1514
diff --git a/include/vcpkg/base/json.h b/include/vcpkg/base/json.h
@@ -108,15 +108,23 @@ namespace vcpkg::Json
         int64_t integer(LineInfo li) const noexcept;
         double number(LineInfo li) const noexcept;
         StringView string(LineInfo li) const noexcept;
+        std::string* maybe_string() noexcept;
+        const std::string* maybe_string() const noexcept;
 
         const Array& array(LineInfo li) const& noexcept;
         Array& array(LineInfo li) & noexcept;
         Array&& array(LineInfo li) && noexcept;
 
+        Array* maybe_array() noexcept;
+        const Array* maybe_array() const noexcept;
+
         const Object& object(LineInfo li) const& noexcept;
         Object& object(LineInfo li) & noexcept;
         Object&& object(LineInfo li) && noexcept;
 
+        Object* maybe_object() noexcept;
+        const Object* maybe_object() const noexcept;
+
         static Value null(std::nullptr_t) noexcept;
         static Value boolean(bool) noexcept;
         static Value integer(int64_t i) noexcept;
diff --git a/src/vcpkg/base/json.cpp b/src/vcpkg/base/json.cpp
@@ -157,6 +157,26 @@ namespace vcpkg::Json
         return underlying_->string;
     }
 
+    std::string* Value::maybe_string() noexcept
+    {
+        if (underlying_ && underlying_->tag == VK::String)
+        {
+            return &underlying_->string;
+        }
+
+        return nullptr;
+    }
+
+    const std::string* Value::maybe_string() const noexcept
+    {
+        if (underlying_ && underlying_->tag == VK::String)
+        {
+            return &underlying_->string;
+        }
+
+        return nullptr;
+    }
+
     const Array& Value::array(LineInfo li) const& noexcept
     {
         vcpkg::Checks::msg_check_exit(li, is_array(), msgJsonValueNotArray);
@@ -169,6 +189,26 @@ namespace vcpkg::Json
     }
     Array&& Value::array(LineInfo li) && noexcept { return std::move(this->array(li)); }
 
+    Array* Value::maybe_array() noexcept
+    {
+        if (underlying_ && underlying_->tag == VK::Array)
+        {
+            return &underlying_->array;
+        }
+
+        return nullptr;
+    }
+
+    const Array* Value::maybe_array() const noexcept
+    {
+        if (underlying_ && underlying_->tag == VK::Array)
+        {
+            return &underlying_->array;
+        }
+
+        return nullptr;
+    }
+
     const Object& Value::object(LineInfo li) const& noexcept
     {
         vcpkg::Checks::msg_check_exit(li, is_object(), msgJsonValueNotObject);
@@ -181,6 +221,26 @@ namespace vcpkg::Json
     }
     Object&& Value::object(LineInfo li) && noexcept { return std::move(this->object(li)); }
 
+    Object* Value::maybe_object() noexcept
+    {
+        if (underlying_ && underlying_->tag == VK::Object)
+        {
+            return &underlying_->object;
+        }
+
+        return nullptr;
+    }
+
+    const Object* Value::maybe_object() const noexcept
+    {
+        if (underlying_ && underlying_->tag == VK::Object)
+        {
+            return &underlying_->object;
+        }
+
+        return nullptr;
+    }
+
     Value::Value() noexcept = default;
     Value::Value(Value&&) noexcept = default;
     Value& Value::operator=(Value&&) noexcept = default;
@@ -1120,9 +1180,9 @@ namespace vcpkg::Json
     {
         return parse(text, origin).then([&](ParsedJson&& mabeValueIsh) -> ExpectedL<Json::Object> {
             auto& asValue = mabeValueIsh.value;
-            if (asValue.is_object())
+            if (auto as_object = asValue.maybe_object())
             {
-                return std::move(asValue).object(VCPKG_LINE_INFO);
+                return std::move(*as_object);
             }
 
             return msg::format(msgJsonErrorMustBeAnObject, msg::path = origin);
diff --git a/src/vcpkg/binarycaching.cpp b/src/vcpkg/binarycaching.cpp
@@ -812,10 +812,12 @@ namespace
                 auto maybe_json = Json::parse_object(*p, m_url);
                 if (auto json = maybe_json.get())
                 {
-                    auto archive_location = json->get(JsonIdArchiveCapitalLocation);
-                    if (archive_location && archive_location->is_string())
+                    if (auto archive_location = json->get(JsonIdArchiveCapitalLocation))
                     {
-                        return archive_location->string(VCPKG_LINE_INFO).to_string();
+                        if (auto archive_location_string = archive_location->maybe_string())
+                        {
+                            return *archive_location_string;
+                        }
                     }
                 }
             }
diff --git a/src/vcpkg/bundlesettings.cpp b/src/vcpkg/bundlesettings.cpp
@@ -32,18 +32,17 @@ namespace
 
     bool parse_optional_json_string(const Json::Object& doc, StringLiteral field_name, Optional<std::string>& output)
     {
-        auto value = doc.get(field_name);
-        if (!value)
+        if (auto value = doc.get(field_name))
         {
-            return true;
-        }
+            if (auto value_string = value->maybe_string())
+            {
+                output = *value_string;
+                return true;
+            }
 
-        if (!value->is_string())
-        {
             return false;
         }
 
-        output = value->string(VCPKG_LINE_INFO).to_string();
         return true;
     }
 }
diff --git a/src/vcpkg/commands.set-installed.cpp b/src/vcpkg/commands.set-installed.cpp
@@ -50,24 +50,27 @@ namespace vcpkg
     Optional<Json::Object> create_dependency_graph_snapshot(const VcpkgCmdArguments& args,
                                                             const ActionPlan& action_plan)
     {
-        if (args.github_ref.has_value() && args.github_sha.has_value() && args.github_job.has_value() &&
-            args.github_workflow.has_value() && args.github_run_id.has_value())
+        const auto github_ref = args.github_ref.get();
+        const auto github_sha = args.github_sha.get();
+        const auto github_job = args.github_job.get();
+        const auto github_workflow = args.github_workflow.get();
+        const auto github_run_id = args.github_run_id.get();
+        if (github_ref && github_sha && github_job && github_workflow && github_run_id)
         {
             Json::Object detector;
             detector.insert(JsonIdName, Json::Value::string("vcpkg"));
             detector.insert(JsonIdUrl, Json::Value::string("https://github.com/microsoft/vcpkg"));
             detector.insert(JsonIdVersion, Json::Value::string("1.0.0"));
 
             Json::Object job;
-            job.insert(JsonIdId, Json::Value::string(*args.github_run_id.get()));
-            job.insert(JsonIdCorrelator,
-                       Json::Value::string(*args.github_workflow.get() + "-" + *args.github_job.get()));
+            job.insert(JsonIdId, Json::Value::string(*github_run_id));
+            job.insert(JsonIdCorrelator, Json::Value::string(fmt::format("{}-{}", *github_workflow, *github_run_id)));
 
             Json::Object snapshot;
             snapshot.insert(JsonIdJob, job);
             snapshot.insert(JsonIdVersion, Json::Value::integer(0));
-            snapshot.insert(JsonIdSha, Json::Value::string(*args.github_sha.get()));
-            snapshot.insert(JsonIdRef, Json::Value::string(*args.github_ref.get()));
+            snapshot.insert(JsonIdSha, Json::Value::string(*github_sha));
+            snapshot.insert(JsonIdRef, Json::Value::string(*github_ref));
             snapshot.insert(JsonIdScanned, Json::Value::string(CTime::now_string()));
             snapshot.insert(JsonIdDetector, detector);
 
@@ -77,44 +80,45 @@ namespace vcpkg
             std::unordered_map<std::string, std::string> map;
             for (auto&& action : action_plan.install_actions)
             {
-                if (!action.source_control_file_and_location.has_value())
+                const auto scfl = action.source_control_file_and_location.get();
+                if (!scfl)
                 {
                     return nullopt;
                 }
-                const auto& scf = *action.source_control_file_and_location.get();
-                auto version = scf.to_version().to_string();
-                auto s = action.spec.to_string();
-                auto pkg_url = Strings::concat("pkg:github/vcpkg/", s, "@", version);
-                map.insert({s, pkg_url});
+                auto spec = action.spec.to_string();
+                map.insert(
+                    {spec, fmt::format("pkg:github/vcpkg/{}@{}", spec, scfl->source_control_file->to_version())});
             }
 
             Json::Object resolved;
             for (auto&& action : action_plan.install_actions)
             {
                 Json::Object resolved_item;
-                if (map.find(action.spec.to_string()) != map.end())
+                auto spec = action.spec.to_string();
+                const auto found = map.find(spec);
+                if (found != map.end())
                 {
-                    auto pkg_url = map.at(action.spec.to_string());
+                    const auto& pkg_url = found->second;
                     resolved_item.insert(JsonIdPackageUnderscoreUrl, pkg_url);
                     resolved_item.insert(JsonIdRelationship, Json::Value::string(JsonIdDirect));
                     Json::Array deps_list;
                     for (auto&& dep : action.package_dependencies)
                     {
-                        if (map.find(dep.to_string()) != map.end())
+                        const auto found_dep = map.find(dep.to_string());
+                        if (found_dep != map.end())
                         {
-                            auto dep_pkg_url = map.at(dep.to_string());
-                            deps_list.push_back(dep_pkg_url);
+                            deps_list.push_back(found_dep->second);
                         }
                     }
                     resolved_item.insert(JsonIdDependencies, deps_list);
                     resolved.insert(pkg_url, resolved_item);
                 }
             }
+
             manifest.insert(JsonIdResolved, resolved);
             Json::Object manifests;
             manifests.insert(JsonIdVcpkgDotJson, manifest);
             snapshot.insert(JsonIdManifests, manifests);
-
             Debug::print(Json::stringify(snapshot));
             return snapshot;
         }
diff --git a/src/vcpkg/configuration.cpp b/src/vcpkg/configuration.cpp
@@ -441,20 +441,20 @@ namespace
                 continue;
             }
 
-            if (!el.second.is_object())
+            auto maybe_demand_obj = el.second.maybe_object();
+            if (!maybe_demand_obj)
             {
                 r.add_generic_error(type_name(), msg::format(msgJsonFieldNotObject, msg::json_field = key));
                 continue;
             }
 
-            const auto& demand_obj = el.second.object(VCPKG_LINE_INFO);
-            if (demand_obj.contains(JsonIdDemands))
+            if (maybe_demand_obj->contains(JsonIdDemands))
             {
                 r.add_generic_error(type_name(),
                                     msg::format(msgConfigurationNestedDemands, msg::json_field = el.first));
             }
 
-            auto maybe_demand = r.visit(demand_obj, CeMetadataDeserializer::instance);
+            auto maybe_demand = r.visit(*maybe_demand_obj, CeMetadataDeserializer::instance);
             if (maybe_demand.has_value())
             {
                 ret.insert_or_replace(key, maybe_demand.value_or_exit(VCPKG_LINE_INFO));
@@ -602,13 +602,14 @@ namespace
         auto serialize_demands = [](const Json::Object& obj, Json::Object& put_into) {
             if (auto demands = obj.get(JsonIdDemands))
             {
-                if (!demands->is_object())
+                auto demands_obj = demands->maybe_object();
+                if (!demands_obj)
                 {
                     return;
                 }
 
                 Json::Object serialized_demands;
-                for (const auto& el : demands->object(VCPKG_LINE_INFO))
+                for (const auto& el : *demands_obj)
                 {
                     auto key = el.first;
                     if (Strings::starts_with(key, "$"))
@@ -617,10 +618,10 @@ namespace
                         continue;
                     }
 
-                    if (el.second.is_object())
+                    if (auto demand_obj = el.second.maybe_object())
                     {
                         auto& inserted = serialized_demands.insert_or_replace(key, Json::Object{});
-                        serialize_ce_metadata(el.second.object(VCPKG_LINE_INFO), inserted);
+                        serialize_ce_metadata(*demand_obj, inserted);
                     }
                 }
                 put_into.insert_or_replace(JsonIdDemands, serialized_demands);
@@ -667,12 +668,13 @@ namespace
 
             if (el.first == JsonIdDemands)
             {
-                if (!el.second.is_object())
+                auto maybe_demands_object = el.second.maybe_object();
+                if (!maybe_demands_object)
                 {
                     continue;
                 }
 
-                for (const auto& demand : el.second.object(VCPKG_LINE_INFO))
+                for (const auto& demand : *maybe_demands_object)
                 {
                     if (Strings::starts_with(demand.first, "$"))
                     {
@@ -840,13 +842,13 @@ namespace vcpkg
         }
 
         auto conf_value = std::move(conf).value(VCPKG_LINE_INFO).value;
-        if (!conf_value.is_object())
+        if (auto conf_value_object = conf_value.maybe_object())
         {
-            messageSink.println(msgFailedToParseNoTopLevelObj, msg::path = origin);
-            return nullopt;
+            return parse_configuration(std::move(*conf_value_object), origin, messageSink);
         }
 
-        return parse_configuration(std::move(conf_value).object(VCPKG_LINE_INFO), origin, messageSink);
+        messageSink.println(msgFailedToParseNoTopLevelObj, msg::path = origin);
+        return nullopt;
     }
 
     Optional<Configuration> parse_configuration(const Json::Object& obj, StringView origin, MessageSink& messageSink)
diff --git a/src/vcpkg/configure-environment.cpp b/src/vcpkg/configure-environment.cpp
@@ -42,30 +42,32 @@ namespace
             return;
         }
 
-        auto acquired_artifacts = pparsed->get(JsonIdAcquiredArtifacts);
-        if (acquired_artifacts)
+        if (auto acquired_artifacts = pparsed->get(JsonIdAcquiredArtifacts))
         {
-            if (acquired_artifacts->is_string())
+            if (auto maybe_acquired_string = acquired_artifacts->maybe_string())
             {
-                get_global_metrics_collector().track_string(StringMetric::AcquiredArtifacts,
-                                                            acquired_artifacts->string(VCPKG_LINE_INFO));
+                get_global_metrics_collector().track_string(StringMetric::AcquiredArtifacts, *maybe_acquired_string);
+            }
+            else
+            {
+                Debug::println("Acquired artifacts was not a string.");
             }
-            Debug::println("Acquired artifacts was not a string.");
         }
         else
         {
             Debug::println("No artifacts acquired.");
         }
 
-        auto activated_artifacts = pparsed->get(JsonIdActivatedArtifacts);
-        if (activated_artifacts)
+        if (auto activated_artifacts = pparsed->get(JsonIdActivatedArtifacts))
         {
-            if (activated_artifacts->is_string())
+            if (auto maybe_activated_string = activated_artifacts->maybe_string())
+            {
+                get_global_metrics_collector().track_string(StringMetric::ActivatedArtifacts, *maybe_activated_string);
+            }
+            else
             {
-                get_global_metrics_collector().track_string(StringMetric::ActivatedArtifacts,
-                                                            activated_artifacts->string(VCPKG_LINE_INFO));
+                Debug::println("Activated artifacts was not a string.");
             }
-            Debug::println("Activated artifacts was not a string.");
         }
         else
         {
diff --git a/src/vcpkg/sourceparagraph.cpp b/src/vcpkg/sourceparagraph.cpp
@@ -1194,9 +1194,9 @@ namespace vcpkg
 
             if (auto configuration = obj.get(JsonIdVcpkgConfiguration))
             {
-                if (configuration->is_object())
+                if (auto configuration_object = configuration->maybe_object())
                 {
-                    spgh.vcpkg_configuration.emplace(configuration->object(VCPKG_LINE_INFO));
+                    spgh.vcpkg_configuration.emplace(*configuration_object);
                 }
                 else
                 {
diff --git a/src/vcpkg/spdx.cpp b/src/vcpkg/spdx.cpp
diff --git a/src/vcpkg/vcpkgpaths.cpp b/src/vcpkg/vcpkgpaths.cpp

Original file line number	Diff line number	Diff line change
`@@ -812,10 +812,12 @@ namespace`
`812`	`812`	`auto maybe_json = Json::parse_object(*p, m_url);`
`813`	`813`	`if (auto json = maybe_json.get())`
`814`	`814`	`{`
`815`		`- auto archive_location = json->get(JsonIdArchiveCapitalLocation);`
`816`		`- if (archive_location && archive_location->is_string())`
	`815`	`+ if (auto archive_location = json->get(JsonIdArchiveCapitalLocation))`
`817`	`816`	`{`
`818`		`- return archive_location->string(VCPKG_LINE_INFO).to_string();`
	`817`	`+ if (auto archive_location_string = archive_location->maybe_string())`
	`818`	`+ {`
	`819`	`+ return *archive_location_string;`
	`820`	`+ }`
`819`	`821`	`}`
`820`	`822`	`}`
`821`	`823`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,18 +32,17 @@ namespace`
`32`	`32`
`33`	`33`	`bool parse_optional_json_string(const Json::Object& doc, StringLiteral field_name, Optional<std::string>& output)`
`34`	`34`	`{`
`35`		`- auto value = doc.get(field_name);`
`36`		`- if (!value)`
	`35`	`+ if (auto value = doc.get(field_name))`
`37`	`36`	`{`
`38`		`- return true;`
`39`		`- }`
	`37`	`+ if (auto value_string = value->maybe_string())`
	`38`	`+ {`
	`39`	`+ output = *value_string;`
	`40`	`+ return true;`
	`41`	`+ }`
`40`	`42`
`41`		`- if (!value->is_string())`
`42`		`- {`
`43`	`43`	`return false;`
`44`	`44`	`}`
`45`	`45`
`46`		`- output = value->string(VCPKG_LINE_INFO).to_string();`
`47`	`46`	`return true;`
`48`	`47`	`}`
`49`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -441,20 +441,20 @@ namespace`
`441`	`441`	`continue;`
`442`	`442`	`}`
`443`	`443`
`444`		`- if (!el.second.is_object())`
	`444`	`+ auto maybe_demand_obj = el.second.maybe_object();`
	`445`	`+ if (!maybe_demand_obj)`
`445`	`446`	`{`
`446`	`447`	`r.add_generic_error(type_name(), msg::format(msgJsonFieldNotObject, msg::json_field = key));`
`447`	`448`	`continue;`
`448`	`449`	`}`
`449`	`450`
`450`		`- const auto& demand_obj = el.second.object(VCPKG_LINE_INFO);`
`451`		`- if (demand_obj.contains(JsonIdDemands))`
	`451`	`+ if (maybe_demand_obj->contains(JsonIdDemands))`
`452`	`452`	`{`
`453`	`453`	`r.add_generic_error(type_name(),`
`454`	`454`	`msg::format(msgConfigurationNestedDemands, msg::json_field = el.first));`
`455`	`455`	`}`
`456`	`456`
`457`		`- auto maybe_demand = r.visit(demand_obj, CeMetadataDeserializer::instance);`
	`457`	`+ auto maybe_demand = r.visit(*maybe_demand_obj, CeMetadataDeserializer::instance);`
`458`	`458`	`if (maybe_demand.has_value())`
`459`	`459`	`{`
`460`	`460`	`ret.insert_or_replace(key, maybe_demand.value_or_exit(VCPKG_LINE_INFO));`
`@@ -602,13 +602,14 @@ namespace`
`602`	`602`	`auto serialize_demands = [](const Json::Object& obj, Json::Object& put_into) {`
`603`	`603`	`if (auto demands = obj.get(JsonIdDemands))`
`604`	`604`	`{`
`605`		`- if (!demands->is_object())`
	`605`	`+ auto demands_obj = demands->maybe_object();`
	`606`	`+ if (!demands_obj)`
`606`	`607`	`{`
`607`	`608`	`return;`
`608`	`609`	`}`
`609`	`610`
`610`	`611`	`Json::Object serialized_demands;`
`611`		`- for (const auto& el : demands->object(VCPKG_LINE_INFO))`
	`612`	`+ for (const auto& el : *demands_obj)`
`612`	`613`	`{`
`613`	`614`	`auto key = el.first;`
`614`	`615`	`if (Strings::starts_with(key, "$"))`
`@@ -617,10 +618,10 @@ namespace`
`617`	`618`	`continue;`
`618`	`619`	`}`
`619`	`620`
`620`		`- if (el.second.is_object())`
	`621`	`+ if (auto demand_obj = el.second.maybe_object())`
`621`	`622`	`{`
`622`	`623`	`auto& inserted = serialized_demands.insert_or_replace(key, Json::Object{});`
`623`		`- serialize_ce_metadata(el.second.object(VCPKG_LINE_INFO), inserted);`
	`624`	`+ serialize_ce_metadata(*demand_obj, inserted);`
`624`	`625`	`}`
`625`	`626`	`}`
`626`	`627`	`put_into.insert_or_replace(JsonIdDemands, serialized_demands);`
`@@ -667,12 +668,13 @@ namespace`
`667`	`668`
`668`	`669`	`if (el.first == JsonIdDemands)`
`669`	`670`	`{`
`670`		`- if (!el.second.is_object())`
	`671`	`+ auto maybe_demands_object = el.second.maybe_object();`
	`672`	`+ if (!maybe_demands_object)`
`671`	`673`	`{`
`672`	`674`	`continue;`
`673`	`675`	`}`
`674`	`676`
`675`		`- for (const auto& demand : el.second.object(VCPKG_LINE_INFO))`
	`677`	`+ for (const auto& demand : *maybe_demands_object)`
`676`	`678`	`{`
`677`	`679`	`if (Strings::starts_with(demand.first, "$"))`
`678`	`680`	`{`
`@@ -840,13 +842,13 @@ namespace vcpkg`
`840`	`842`	`}`
`841`	`843`
`842`	`844`	`auto conf_value = std::move(conf).value(VCPKG_LINE_INFO).value;`
`843`		`- if (!conf_value.is_object())`
	`845`	`+ if (auto conf_value_object = conf_value.maybe_object())`
`844`	`846`	`{`
`845`		`- messageSink.println(msgFailedToParseNoTopLevelObj, msg::path = origin);`
`846`		`- return nullopt;`
	`847`	`+ return parse_configuration(std::move(*conf_value_object), origin, messageSink);`
`847`	`848`	`}`
`848`	`849`
`849`		`- return parse_configuration(std::move(conf_value).object(VCPKG_LINE_INFO), origin, messageSink);`
	`850`	`+ messageSink.println(msgFailedToParseNoTopLevelObj, msg::path = origin);`
	`851`	`+ return nullopt;`
`850`	`852`	`}`
`851`	`853`
`852`	`854`	`Optional<Configuration> parse_configuration(const Json::Object& obj, StringView origin, MessageSink& messageSink)`
Original file line number	Diff line number	Diff line change
`@@ -42,30 +42,32 @@ namespace`
`42`	`42`	`return;`
`43`	`43`	`}`
`44`	`44`
`45`		`- auto acquired_artifacts = pparsed->get(JsonIdAcquiredArtifacts);`
`46`		`- if (acquired_artifacts)`
	`45`	`+ if (auto acquired_artifacts = pparsed->get(JsonIdAcquiredArtifacts))`
`47`	`46`	`{`
`48`		`- if (acquired_artifacts->is_string())`
	`47`	`+ if (auto maybe_acquired_string = acquired_artifacts->maybe_string())`
`49`	`48`	`{`
`50`		`- get_global_metrics_collector().track_string(StringMetric::AcquiredArtifacts,`
`51`		`- acquired_artifacts->string(VCPKG_LINE_INFO));`
	`49`	`+ get_global_metrics_collector().track_string(StringMetric::AcquiredArtifacts, *maybe_acquired_string);`
	`50`	`+ }`
	`51`	`+ else`
	`52`	`+ {`
	`53`	`+ Debug::println("Acquired artifacts was not a string.");`
`52`	`54`	`}`
`53`		`- Debug::println("Acquired artifacts was not a string.");`
`54`	`55`	`}`
`55`	`56`	`else`
`56`	`57`	`{`
`57`	`58`	`Debug::println("No artifacts acquired.");`
`58`	`59`	`}`
`59`	`60`
`60`		`- auto activated_artifacts = pparsed->get(JsonIdActivatedArtifacts);`
`61`		`- if (activated_artifacts)`
	`61`	`+ if (auto activated_artifacts = pparsed->get(JsonIdActivatedArtifacts))`
`62`	`62`	`{`
`63`		`- if (activated_artifacts->is_string())`
	`63`	`+ if (auto maybe_activated_string = activated_artifacts->maybe_string())`
	`64`	`+ {`
	`65`	`+ get_global_metrics_collector().track_string(StringMetric::ActivatedArtifacts, *maybe_activated_string);`
	`66`	`+ }`
	`67`	`+ else`
`64`	`68`	`{`
`65`		`- get_global_metrics_collector().track_string(StringMetric::ActivatedArtifacts,`
`66`		`- activated_artifacts->string(VCPKG_LINE_INFO));`
	`69`	`+ Debug::println("Activated artifacts was not a string.");`
`67`	`70`	`}`
`68`		`- Debug::println("Activated artifacts was not a string.");`
`69`	`71`	`}`
`70`	`72`	`else`
`71`	`73`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1194,9 +1194,9 @@ namespace vcpkg`
`1194`	`1194`
`1195`	`1195`	`if (auto configuration = obj.get(JsonIdVcpkgConfiguration))`
`1196`	`1196`	`{`
`1197`		`- if (configuration->is_object())`
	`1197`	`+ if (auto configuration_object = configuration->maybe_object())`
`1198`	`1198`	`{`
`1199`		`- spgh.vcpkg_configuration.emplace(configuration->object(VCPKG_LINE_INFO));`
	`1199`	`+ spgh.vcpkg_configuration.emplace(*configuration_object);`
`1200`	`1200`	`}`
`1201`	`1201`	`else`
`1202`	`1202`	`{`