Avoid deprecated jsoncons features

3 files changed, 127 insertions, 95 deletions

diff --git a/src/squelch/condition.cc b/src/squelch/condition.cc
index 8768774d..2872cae5 100644
--- a/src/squelch/condition.cc
+++ b/src/squelch/condition.cc
@@ -3,6 +3,7 @@
 
 #include <boost/algorithm/string/predicate.hpp>
 
+#include "jsoncons_helpers.hpp"
 #include "tome/squelch/cursor.hpp"
 #include "tome/squelch/tree_printer.hpp"
 #include "../ability_type.hpp"
@@ -109,17 +110,18 @@ std::shared_ptr<Condition> Condition::parse_condition(jsoncons::json const &cond
 		return nullptr;
 	}
 
-	const char *type_s = condition_json.get("type").as<const char *>();
-	if (!type_s)
+	auto maybe_type_s = get_optional<std::string>(condition_json, "type");
+	if (!maybe_type_s)
 	{
 		msg_print("Missing/invalid 'type' in condition");
 		return nullptr;
 	}
+	auto type_s = *maybe_type_s;
 
 	match_type match;
 	if (!match_mapping().parse(type_s, &match))
 	{
-		msg_format("Invalid 'type' in condition: %s", type_s);
+		msg_format("Invalid 'type' in condition: %s", type_s.c_str());
 		return nullptr;
 	}
 
@@ -138,7 +140,7 @@ jsoncons::json Condition::optional_to_json(std::shared_ptr<Condition> condition)
 {
 	return condition
 		? condition->to_json()
-		: jsoncons::json::null_type();
+		: jsoncons::null_type();
 }
 
 bool TvalCondition::is_match(object_type *o_ptr) const
@@ -148,16 +150,15 @@ bool TvalCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> TvalCondition::from_json(jsoncons::json const &j)
 {
-	auto tval_j = j.get("tval");
-	if (!tval_j.is_uinteger())
+	if (auto maybe_tval = get_optional<uint8_t>(j, "tval"))
+	{
+		return std::make_shared<TvalCondition>(*maybe_tval);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'tval' property");
 		return nullptr;
 	}
-
-	int tval = tval_j.as_uint();
-
-	return std::make_shared<TvalCondition>(tval);
 }
 
 void TvalCondition::to_json(jsoncons::json &j) const
@@ -186,15 +187,15 @@ bool NameCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> NameCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("name").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "name"))
+	{
+		return std::make_shared<NameCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'name' property");
 		return nullptr;
 	}
-
-	return std::make_shared<NameCondition>(s);
 }
 
 void NameCondition::write_tree(TreePrinter *p, Cursor *cursor, uint8_t ecol, uint8_t bcol) const
@@ -221,15 +222,15 @@ bool ContainCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> ContainCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("contain").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "contain"))
+	{
+		return std::make_shared<ContainCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'contain' property");
 		return nullptr;
 	}
-
-	return std::make_shared<ContainCondition>(s);
 }
 
 void ContainCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -256,23 +257,21 @@ bool SvalCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> SvalCondition::from_json(jsoncons::json const &j)
 {
-	auto min_j = j.get("min");
-	if (!min_j.is_uinteger())
+	auto min_j = get_optional<uint8_t>(j, "min");
+	if (!min_j)
 	{
 		msg_print("Missing/invalid 'min' property");
 		return nullptr;
 	}
 
-	auto max_j = j.get("max");
-	if (!max_j.is_uinteger())
+	auto max_j = get_optional<uint8_t>(j, "max");
+	if (!max_j)
 	{
 		msg_print("Missing/invalid 'max' property");
 		return nullptr;
 	}
 
-	return std::make_shared<SvalCondition>(
-		min_j.as_uint(),
-		max_j.as_uint());
+	return std::make_shared<SvalCondition>(*min_j, *max_j);
 }
 
 void SvalCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -373,7 +372,7 @@ std::shared_ptr<Condition> GroupingCondition::next_child(Condition *current)
 
 std::vector< std::shared_ptr<Condition> > GroupingCondition::parse_conditions(jsoncons::json const &j)
 {
-	auto conditions_j = j.get("conditions");
+	auto conditions_j = j.get_with_default<jsoncons::json>("conditions", jsoncons::null_type());
 
 	if (conditions_j.is_null())
 	{
@@ -489,22 +488,23 @@ bool StatusCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> StatusCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("status").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "status"))
 	{
-		msg_print("Missing/invalid 'status' property");
-		return nullptr;
-	}
+		std::string s = *maybe_s;
+		status_type status;
+		if (!status_mapping().parse(s, &status))
+		{
+			msg_format("Invalid 'status' property: %s", s.c_str());
+			return nullptr;
+		}
 
-	status_type status;
-	if (!status_mapping().parse(s, &status))
+		return std::make_shared<StatusCondition>(status);
+	}
+	else
 	{
-		msg_format("Invalid 'status' property: %s", s);
+		msg_print("Missing/invalid 'status' property");
 		return nullptr;
 	}
-
-	return std::make_shared<StatusCondition>(status);
 }
 
 void StatusCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -530,15 +530,15 @@ bool RaceCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> RaceCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("race").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "race"))
+	{
+		return std::make_shared<RaceCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'race' property");
 		return nullptr;
 	}
-
-	return std::make_shared<RaceCondition>(s);
 }
 
 void RaceCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -564,15 +564,15 @@ bool SubraceCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> SubraceCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("subrace").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "subrace"))
+	{
+		return std::make_shared<SubraceCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'subrace' property");
 		return nullptr;
 	}
-
-	return std::make_shared<SubraceCondition>(s);
 }
 
 void SubraceCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -598,15 +598,15 @@ bool ClassCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> ClassCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("class").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "class"))
+	{
+		return std::make_shared<ClassCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'class' property");
 		return nullptr;
 	}
-
-	return std::make_shared<ClassCondition>(s);
 }
 
 void ClassCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -634,15 +634,15 @@ bool InscriptionCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> InscriptionCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("inscription").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "inscription"))
+	{
+		return std::make_shared<InscriptionCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'inscription' property");
 		return nullptr;
 	}
-
-	return std::make_shared<InscriptionCondition>(s);
 }
 
 void InscriptionCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -670,21 +670,21 @@ bool DiscountCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> DiscountCondition::from_json(jsoncons::json const &j)
 {
-	auto min_j = j.get("min");
-	if (!min_j.is_integer())
+	auto maybe_min = get_optional<int>(j, "min");
+	if (!maybe_min)
 	{
 		msg_print("Missing/invalid 'min' property");
 		return nullptr;
 	}
-	int min = min_j.as_int();
+	auto min = *maybe_min;
 
-	auto max_j = j.get("max");
-	if (!max_j.is_integer())
+	auto maybe_max = get_optional<int>(j, "max");
+	if (!maybe_max)
 	{
 		msg_print("Missing/invalid 'max' property");
 		return nullptr;
 	}
-	int max = max_j.as_int();
+	auto max = *maybe_max;
 
 	return std::make_shared<DiscountCondition>(min, max);
 }
@@ -714,21 +714,21 @@ bool LevelCondition::is_match(object_type *) const
 
 std::shared_ptr<Condition> LevelCondition::from_json(jsoncons::json const &j)
 {
-	auto min_j = j.get("min");
-	if (!min_j.is_integer())
+	auto maybe_min = get_optional<int>(j, "min");
+	if (!maybe_min)
 	{
 		msg_print("Missing/invalid 'min' property");
 		return nullptr;
 	}
-	int min = min_j.as_int();
+	auto min = *maybe_min;
 
-	auto max_j = j.get("max");
-	if (!max_j.is_integer())
+	auto maybe_max = get_optional<int>(j, "max");
+	if (!maybe_max)
 	{
 		msg_print("Missing/invalid 'max' property");
 		return nullptr;
 	}
-	int max = max_j.as_int();
+	int max = *maybe_max;
 
 	return std::make_shared<LevelCondition>(min, max);
 }
@@ -760,33 +760,34 @@ bool SkillCondition::is_match(object_type *) const
 
 std::shared_ptr<Condition> SkillCondition::from_json(jsoncons::json const &j)
 {
-	auto min_j = j.get("min");
-	if (!min_j.is_integer())
+	auto maybe_min = get_optional<int>(j, "min");
+	if (!maybe_min)
 	{
 		msg_print("Missing/invalid 'min' property");
 		return nullptr;
 	}
-	int min = min_j.as_int();
+	auto min = *maybe_min;
 
-	auto max_j = j.get("max");
-	if (!max_j.is_integer())
+	auto maybe_max = get_optional<int>(j, "max");
+	if (!maybe_max)
 	{
 		msg_print("Missing/invalid 'max' property");
 		return nullptr;
 	}
-	int max = max_j.as_int();
+	auto max = *maybe_max;
 
-	auto s = j.get("name").as<const char *>();
-	if (!s)
+	auto maybe_s = get_optional<std::string>(j, "name");
+	if (!maybe_s)
 	{
 		msg_print("Missing/invalid 'name' property");
 		return nullptr;
 	}
+	auto s = *maybe_s;
 
 	auto si = find_skill_i(s);
 	if (si < 0)
 	{
-		msg_print("Invalid 'name' property");
+		msg_format("Invalid 'name' property: %s", s.c_str());
 		return nullptr;
 	}
 
@@ -822,7 +823,7 @@ bool SymbolCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> SymbolCondition::from_json(jsoncons::json const &j)
 {
-	auto s = j.get("symbol").as<std::string>();
+	auto s = get_optional<std::string>(j, "symbol").value_or("");
 
 	if (s.empty())
 	{
@@ -862,18 +863,18 @@ bool AbilityCondition::is_match(object_type *) const
 
 std::shared_ptr<Condition> AbilityCondition::from_json(jsoncons::json const &j)
 {
-	const char *a = j.get("ability").as<const char *>();
-
-	if (!a)
+	auto maybe_a = get_optional<std::string>(j, "ability");
+	if (!maybe_a)
 	{
 		msg_print("Missing/invalid 'ability' property");
 		return nullptr;
 	}
+	auto a = *maybe_a;
 
 	auto ai = find_ability(a);
 	if (ai < 0)
 	{
-		msg_print("Invalid 'ability' property");
+		msg_format("Invalid 'ability' property: %s", a.c_str());
 		return nullptr;
 	}
 
@@ -926,7 +927,7 @@ void SingleSubconditionCondition::to_json(jsoncons::json &j) const
 
 std::shared_ptr<Condition> SingleSubconditionCondition::parse_single_subcondition(jsoncons::json const &in_json)
 {
-	auto condition_j = in_json.get("condition");
+	auto condition_j = in_json.get_with_default<jsoncons::json>("condition", jsoncons::null_type());
 
 	if (condition_j.is_null())
 	{
diff --git a/src/squelch/jsoncons_helpers.hpp b/src/squelch/jsoncons_helpers.hpp
new file mode 100644
index 00000000..1ce6b094
--- /dev/null
+++ b/src/squelch/jsoncons_helpers.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <boost/optional.hpp>
+#include <jsoncons/json.hpp>
+#include <string>
+
+namespace squelch {
+
+template <class T>
+boost::optional<T> get_optional(jsoncons::json const &json, std::string const &key)
+{
+	if (!json.has_key(key))
+	{
+		return boost::none;
+	}
+
+	auto value = json.at(key);
+
+	if (!value.is<T>())
+	{
+		return boost::none;
+	}
+
+	return value.as<T>();
+}
+
+} // namespace squelch
diff --git a/src/squelch/rule.cc b/src/squelch/rule.cc
index c528bf8d..e79fc1f2 100644
--- a/src/squelch/rule.cc
+++ b/src/squelch/rule.cc
@@ -1,6 +1,7 @@
 #include "tome/squelch/rule_fwd.hpp"
 #include "tome/squelch/rule.hpp"
 
+#include "jsoncons_helpers.hpp"
 #include "tome/squelch/cursor.hpp"
 #include "tome/squelch/condition.hpp"
 #include "tome/squelch/tree_printer.hpp"
@@ -140,41 +141,44 @@ std::shared_ptr<Rule> Rule::parse_rule(jsoncons::json const &rule_json)
 	}
 
 	// Retrieve the attributes
-	char const *rule_name_s = rule_json.get("name").as<char const *>();
-	char const *rule_action_s = rule_json.get("action").as<char const *>();
-	char const *rule_module_s = rule_json.get("module").as<char const *>();
-	if ((!rule_name_s) || (!rule_action_s) || (!rule_module_s))
+	auto maybe_rule_name_s = get_optional<std::string>(rule_json, "name");
+	auto maybe_rule_action_s = get_optional<std::string>(rule_json, "action");
+	auto maybe_rule_module_s = get_optional<std::string>(rule_json, "module");
+	if ((!maybe_rule_name_s) || (!maybe_rule_action_s) || (!maybe_rule_module_s))
 	{
 		msg_print("Rule missing required field(s)");
 		return nullptr;
 	}
+	auto rule_name_s = *maybe_rule_name_s;
+	auto rule_action_s = *maybe_rule_action_s;
+	auto rule_module_s = *maybe_rule_module_s;
 
 	// Convert attributes
 	action_type action;
 	if (!action_mapping().parse(rule_action_s, &action))
 	{
-		msg_format("Invalid rule action '%s'", rule_action_s);
+		msg_format("Invalid rule action '%s'", rule_action_s.c_str());
 		return nullptr;
 	}
 
-	int module_idx = find_module(rule_module_s);
+	int module_idx = find_module(rule_module_s.c_str());
 	if (module_idx < 0)
 	{
 		msg_format("Skipping rule for unrecognized module '%s'",
-			   rule_module_s);
+			   rule_module_s.c_str());
 		return nullptr;
 	}
 
 	// Parse condition
 	std::shared_ptr<Condition> condition =
-		Condition::parse_condition(rule_json.get("condition"));
+		Condition::parse_condition(rule_json.get_with_default<jsoncons::json>("condition", jsoncons::null_type()));
 
 	// Parse rule
 	switch (action)
 	{
 	case action_type::AUTO_INSCRIBE:
 	{
-		auto rule_inscription_j = rule_json.get("inscription");
+		auto rule_inscription_j = rule_json.get_with_default<jsoncons::json>("inscription", jsoncons::null_type());
 
 		if (rule_inscription_j.is_null())
 		{