summaryrefslogtreecommitdiff
path: root/src/squelch
diff options
context:
space:
mode:
Diffstat (limited to 'src/squelch')
-rw-r--r--src/squelch/automatizer.cc25
-rw-r--r--src/squelch/condition.cc323
-rw-r--r--src/squelch/rule.cc63
3 files changed, 212 insertions, 199 deletions
diff --git a/src/squelch/automatizer.cc b/src/squelch/automatizer.cc
index c3c52b1b..2f177ef9 100644
--- a/src/squelch/automatizer.cc
+++ b/src/squelch/automatizer.cc
@@ -12,20 +12,21 @@ namespace squelch {
/**
* Parse rules from JSON array
*/
-static std::vector< std::shared_ptr < Rule > > parse_rules(json_t *rules_j)
+static std::vector< std::shared_ptr < Rule > > parse_rules(jsoncons::json const &rules_json)
{
std::vector< std::shared_ptr < Rule > > rules;
- if (!json_is_array(rules_j))
+ if (!rules_json.is_array())
{
msg_format("Error 'rules' is not an array");
return rules;
}
- for (size_t i = 0; i < json_array_size(rules_j); i++)
+ auto rules_array = rules_json.array_value();
+
+ for (auto const &rule_value : rules_array)
{
- json_t *rule_j = json_array_get(rules_j, i);
- auto rule = Rule::parse_rule(rule_j);
+ auto rule = Rule::parse_rule(rule_value);
if (rule)
{
rules.push_back(rule);
@@ -63,25 +64,25 @@ bool Automatizer::apply_rules(object_type *o_ptr, int item_idx) const
return false;
}
-std::shared_ptr<json_t> Automatizer::to_json() const
+jsoncons::json Automatizer::to_json() const
{
- auto rules_json = std::shared_ptr<json_t>(json_array(), &json_decref);
+ auto document = jsoncons::json::array();
for (auto rule : m_rules)
{
- json_array_append_new(rules_json.get(), rule->to_json());
+ document.push_back(rule->to_json());
}
- return rules_json;
+ return document;
}
-void Automatizer::load_json(json_t *json)
+void Automatizer::load_json(jsoncons::json const &document)
{
// Go through all the found rules
- auto rules = parse_rules(json);
+ auto rules = parse_rules(document);
// Load rule
- for (auto rule : rules)
+ for (auto rule: rules)
{
append_rule(rule);
}
diff --git a/src/squelch/condition.cc b/src/squelch/condition.cc
index 9e93016e..e7429cab 100644
--- a/src/squelch/condition.cc
+++ b/src/squelch/condition.cc
@@ -57,12 +57,15 @@ EnumStringMap<identification_state> &identification_state_mapping()
return *m;
}
-json_t *Condition::to_json() const
+jsoncons::json Condition::to_json() const
{
- json_t *j = json_object();
- json_object_set_new(j, "type",
- json_string(match_mapping().stringify(match)));
+ // Start with an object with only 'type' property
+ jsoncons::json j;
+ j["type"] = match_mapping().stringify(match);
+
+ // Add sub-class properties
to_json(j);
+ // Return the completed JSON
return j;
}
@@ -85,11 +88,11 @@ void Condition::display(TreePrinter *tree_printer, Cursor *cursor) const
tree_printer->dedent();
}
-std::shared_ptr<Condition> Condition::parse_condition(json_t *condition_json)
+std::shared_ptr<Condition> Condition::parse_condition(jsoncons::json const &condition_json)
{
// Parsers for concrete types of conditions.
static std::map< match_type,
- std::function< std::shared_ptr< Condition > ( json_t * ) > > parsers {
+ std::function<std::shared_ptr<Condition>(jsoncons::json const &)>> parsers {
{ match_type::AND, &AndCondition::from_json },
{ match_type::OR, &OrCondition::from_json },
{ match_type::NOT, &NotCondition::from_json },
@@ -111,15 +114,13 @@ std::shared_ptr<Condition> Condition::parse_condition(json_t *condition_json)
{ match_type::SKILL, &SkillCondition::from_json },
{ match_type::ABILITY, &AbilityCondition::from_json } };
- if ((condition_json == nullptr) || json_is_null(condition_json))
+ if (condition_json.is_null())
{
return nullptr;
}
- cptr type_s = nullptr;
- if (json_unpack(condition_json,
- "{s:s}",
- "type", &type_s) < 0)
+ cptr type_s = condition_json.get("type").as<cptr>();
+ if (!type_s)
{
msg_print("Missing/invalid 'type' in condition");
return nullptr;
@@ -143,11 +144,11 @@ std::shared_ptr<Condition> Condition::parse_condition(json_t *condition_json)
return nullptr;
}
-json_t *Condition::optional_to_json(std::shared_ptr<Condition> condition)
+jsoncons::json Condition::optional_to_json(std::shared_ptr<Condition> condition)
{
return condition
? condition->to_json()
- : json_null();
+ : jsoncons::json::null_type();
}
bool TvalCondition::is_match(object_type *o_ptr) const
@@ -155,22 +156,23 @@ bool TvalCondition::is_match(object_type *o_ptr) const
return (o_ptr->tval == m_tval);
}
-std::shared_ptr<Condition> TvalCondition::from_json(json_t *j)
+std::shared_ptr<Condition> TvalCondition::from_json(jsoncons::json const &j)
{
- int tval;
-
- if (json_unpack(j, "{s:i}", "tval", &tval) < 0)
+ auto tval_j = j.get("tval");
+ if (!tval_j.is_uinteger())
{
msg_print("Missing/invalid 'tval' property");
return nullptr;
}
+ int tval = tval_j.as_uint();
+
return std::make_shared<TvalCondition>(tval);
}
-void TvalCondition::to_json(json_t *j) const
+void TvalCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "tval", json_integer(m_tval));
+ j["tval"] = m_tval;
}
void TvalCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -192,14 +194,16 @@ bool NameCondition::is_match(object_type *o_ptr) const
return boost::algorithm::iequals(m_name, buf1);
}
-std::shared_ptr<Condition> NameCondition::from_json(json_t *j)
+std::shared_ptr<Condition> NameCondition::from_json(jsoncons::json const &j)
{
- cptr s = nullptr;
- if (json_unpack(j, "{s:s}", "name", &s) < 0)
+ cptr s = j.get("name").as<cptr>();
+
+ if (!s)
{
msg_print("Missing/invalid 'name' property");
return nullptr;
}
+
return std::make_shared<NameCondition>(s);
}
@@ -213,9 +217,9 @@ void NameCondition::write_tree(TreePrinter *p, Cursor *cursor, uint8_t ecol, uin
p->write(TERM_WHITE, "\n");
}
-void NameCondition::to_json(json_t *j) const
+void NameCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "name", json_string(m_name.c_str()));
+ j["name"] = m_name;
}
bool ContainCondition::is_match(object_type *o_ptr) const
@@ -225,14 +229,16 @@ bool ContainCondition::is_match(object_type *o_ptr) const
return boost::algorithm::icontains(buf1, m_contain);
}
-std::shared_ptr<Condition> ContainCondition::from_json(json_t *j)
+std::shared_ptr<Condition> ContainCondition::from_json(jsoncons::json const &j)
{
- cptr s = nullptr;
- if (json_unpack(j, "{s:s}", "contain", &s) < 0)
+ cptr s = j.get("contain").as<cptr>();
+
+ if (!s)
{
msg_print("Missing/invalid 'contain' property");
return nullptr;
}
+
return std::make_shared<ContainCondition>(s);
}
@@ -246,9 +252,9 @@ void ContainCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_
p->write(TERM_WHITE, "\n");
}
-void ContainCondition::to_json(json_t *j) const
+void ContainCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "contain", json_string(m_contain.c_str()));
+ j["contain"] = m_contain;
}
bool SvalCondition::is_match(object_type *o_ptr) const
@@ -258,19 +264,25 @@ bool SvalCondition::is_match(object_type *o_ptr) const
(o_ptr->sval <= m_max));
}
-std::shared_ptr<Condition> SvalCondition::from_json(json_t *j)
+std::shared_ptr<Condition> SvalCondition::from_json(jsoncons::json const &j)
{
- int min, max;
+ auto min_j = j.get("min");
+ if (!min_j.is_uinteger())
+ {
+ msg_print("Missing/invalid 'min' property");
+ return nullptr;
+ }
- if (json_unpack(j, "{s:i,s:i}",
- "min", &min,
- "max", &max) < 0)
+ auto max_j = j.get("max");
+ if (!max_j.is_uinteger())
{
- msg_print("Missing/invalid 'min'/'max' properties");
+ msg_print("Missing/invalid 'max' property");
return nullptr;
}
- return std::make_shared<SvalCondition>(min, max);
+ return std::make_shared<SvalCondition>(
+ min_j.as_uint(),
+ max_j.as_uint());
}
void SvalCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -284,10 +296,10 @@ void SvalCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t b
p->write(TERM_WHITE, "\n");
}
-void SvalCondition::to_json(json_t *j) const
+void SvalCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "min", json_integer(m_min));
- json_object_set_new(j, "max", json_integer(m_max));
+ j["min"] = m_min;
+ j["max"] = m_max;
}
void GroupingCondition::add_child(ConditionFactory const &factory)
@@ -369,16 +381,15 @@ std::shared_ptr<Condition> GroupingCondition::next_child(Condition *current)
return nullptr;
}
-std::vector< std::shared_ptr<Condition> > GroupingCondition::parse_conditions(json_t *j)
+std::vector< std::shared_ptr<Condition> > GroupingCondition::parse_conditions(jsoncons::json const &j)
{
- json_t *conditions_j = json_object_get(j, "conditions");
+ auto conditions_j = j.get("conditions");
- if ((conditions_j == nullptr) ||
- (json_is_null(conditions_j)))
+ if (conditions_j.is_null())
{
return std::vector< std::shared_ptr<Condition> >();
}
- else if (!json_is_array(conditions_j))
+ else if (!conditions_j.is_array())
{
msg_print("'conditions' property has invalid type");
return std::vector< std::shared_ptr<Condition> >();
@@ -386,11 +397,8 @@ std::vector< std::shared_ptr<Condition> > GroupingCondition::parse_conditions(js
else
{
std::vector< std::shared_ptr<Condition> > subconditions;
- for (size_t i = 0; i < json_array_size(conditions_j); i++)
+ for (auto const &subcondition_j: conditions_j.array_value())
{
- json_t *subcondition_j =
- json_array_get(conditions_j, i);
-
std::shared_ptr<Condition> subcondition =
parse_condition(subcondition_j);
@@ -403,14 +411,16 @@ std::vector< std::shared_ptr<Condition> > GroupingCondition::parse_conditions(js
}
}
-void GroupingCondition::to_json(json_t *j) const
+void GroupingCondition::to_json(jsoncons::json &j) const
{
- json_t *ja = json_array();
+ // Put all the sub-conditions into an array
+ jsoncons::json::array ja;
for (auto condition_p : m_conditions)
{
- json_array_append_new(ja, optional_to_json(condition_p));
+ ja.push_back(optional_to_json(condition_p));
}
- json_object_set_new(j, "conditions", ja);
+ // Add to JSON object
+ j["conditions"] = ja;
}
bool AndCondition::is_match(object_type *o_ptr) const
@@ -425,7 +435,7 @@ bool AndCondition::is_match(object_type *o_ptr) const
return true;
}
-std::shared_ptr<Condition> AndCondition::from_json(json_t *j)
+std::shared_ptr<Condition> AndCondition::from_json(jsoncons::json const &j)
{
auto condition = std::make_shared<AndCondition>();
for (auto subcondition : parse_conditions(j))
@@ -458,7 +468,7 @@ bool OrCondition::is_match(object_type *o_ptr) const
return false;
}
-std::shared_ptr<Condition> OrCondition::from_json(json_t *j)
+std::shared_ptr<Condition> OrCondition::from_json(jsoncons::json const &j)
{
std::shared_ptr<OrCondition> condition =
std::make_shared<OrCondition>();
@@ -487,10 +497,11 @@ bool StatusCondition::is_match(object_type *o_ptr) const
return m_status == object_status(o_ptr);
}
-std::shared_ptr<Condition> StatusCondition::from_json(json_t *j)
+std::shared_ptr<Condition> StatusCondition::from_json(jsoncons::json const &j)
{
- cptr s;
- if (json_unpack(j, "{s:s}", "status", &s) < 0)
+ cptr s = j.get("status").as<cptr>();
+
+ if (!s)
{
msg_print("Missing/invalid 'status' property");
return nullptr;
@@ -517,9 +528,9 @@ void StatusCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t
p->write(TERM_WHITE, "\n");
}
-void StatusCondition::to_json(json_t *j) const
+void StatusCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "status", json_string(status_mapping().stringify(m_status)));
+ j["status"] = status_mapping().stringify(m_status);
}
bool RaceCondition::is_match(object_type *o_ptr) const
@@ -527,11 +538,11 @@ bool RaceCondition::is_match(object_type *o_ptr) const
return boost::algorithm::iequals(m_race, rp_ptr->title);
}
-std::shared_ptr<Condition> RaceCondition::from_json(json_t *j)
+std::shared_ptr<Condition> RaceCondition::from_json(jsoncons::json const &j)
{
- cptr s;
+ cptr s = j.get("race").as<cptr>();
- if (json_unpack(j, "{s:s}", "race", &s) < 0)
+ if (!s)
{
msg_print("Missing/invalid 'race' property");
return nullptr;
@@ -551,9 +562,9 @@ void RaceCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t b
p->write(TERM_WHITE, "\n");
}
-void RaceCondition::to_json(json_t *j) const
+void RaceCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "race", json_string(m_race.c_str()));
+ j["race"] = m_race;
}
bool SubraceCondition::is_match(object_type *o_ptr) const
@@ -561,11 +572,11 @@ bool SubraceCondition::is_match(object_type *o_ptr) const
return boost::algorithm::iequals(m_subrace, rmp_ptr->title);
}
-std::shared_ptr<Condition> SubraceCondition::from_json(json_t *j)
+std::shared_ptr<Condition> SubraceCondition::from_json(jsoncons::json const &j)
{
- cptr s;
+ cptr s = j.get("subrace").as<cptr>();
- if (json_unpack(j, "{s:s}", "subrace", &s) < 0)
+ if (!s)
{
msg_print("Missing/invalid 'subrace' property");
return nullptr;
@@ -585,9 +596,9 @@ void SubraceCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_
p->write(TERM_WHITE, "\n");
}
-void SubraceCondition::to_json(json_t *j) const
+void SubraceCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "subrace", json_string(m_subrace.c_str()));
+ j["subrace"] = m_subrace;
}
bool ClassCondition::is_match(object_type *o_ptr) const
@@ -595,11 +606,11 @@ bool ClassCondition::is_match(object_type *o_ptr) const
return boost::algorithm::iequals(m_class, spp_ptr->title);
}
-std::shared_ptr<Condition> ClassCondition::from_json(json_t *j)
+std::shared_ptr<Condition> ClassCondition::from_json(jsoncons::json const &j)
{
- cptr s;
+ cptr s = j.get("class").as<cptr>();
- if (json_unpack(j, "{s:s}", "class", &s) < 0)
+ if (!s)
{
msg_print("Missing/invalid 'class' property");
return nullptr;
@@ -619,9 +630,9 @@ void ClassCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t
p->write(TERM_WHITE, "\n");
}
-void ClassCondition::to_json(json_t *j) const
+void ClassCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "class", json_string(m_class.c_str()));
+ j["class"] = m_class;
}
bool InscriptionCondition::is_match(object_type *o_ptr) const
@@ -631,14 +642,16 @@ bool InscriptionCondition::is_match(object_type *o_ptr) const
m_inscription);
}
-std::shared_ptr<Condition> InscriptionCondition::from_json(json_t *j)
+std::shared_ptr<Condition> InscriptionCondition::from_json(jsoncons::json const &j)
{
- cptr s = nullptr;
- if (json_unpack(j, "{s:s}", "inscription", &s) < 0)
+ cptr s = j.get("inscription").as<cptr>();
+
+ if (!s)
{
msg_print("Missing/invalid 'inscription' property");
return nullptr;
}
+
return std::make_shared<InscriptionCondition>(s);
}
@@ -653,9 +666,9 @@ void InscriptionCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, ui
p->write(TERM_WHITE, "\n");
}
-void InscriptionCondition::to_json(json_t *j) const
+void InscriptionCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "inscription", json_string(m_inscription.c_str()));
+ j["inscription"] = m_inscription;
}
bool DiscountCondition::is_match(object_type *o_ptr) const
@@ -665,17 +678,23 @@ bool DiscountCondition::is_match(object_type *o_ptr) const
(o_ptr->discount <= m_max));
}
-std::shared_ptr<Condition> DiscountCondition::from_json(json_t *j)
+std::shared_ptr<Condition> DiscountCondition::from_json(jsoncons::json const &j)
{
- int min, max;
+ auto min_j = j.get("min");
+ if (!min_j.is_integer())
+ {
+ msg_print("Missing/invalid 'min' property");
+ return nullptr;
+ }
+ int min = min_j.as_int();
- if (json_unpack(j, "{s:i,s:i}",
- "min", &min,
- "max", &max) < 0)
+ auto max_j = j.get("max");
+ if (!max_j.is_integer())
{
- msg_print("Missing/invalid 'min'/'max' properties");
+ msg_print("Missing/invalid 'max' property");
return nullptr;
}
+ int max = max_j.as_int();
return std::make_shared<DiscountCondition>(min, max);
}
@@ -691,10 +710,10 @@ void DiscountCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8
p->write(TERM_WHITE, "\n");
}
-void DiscountCondition::to_json(json_t *j) const
+void DiscountCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "min", json_integer(m_min));
- json_object_set_new(j, "max", json_integer(m_max));
+ j["min"] = m_min;
+ j["max"] = m_max;
}
bool LevelCondition::is_match(object_type *) const
@@ -703,16 +722,23 @@ bool LevelCondition::is_match(object_type *) const
(p_ptr->lev <= m_max));
}
-std::shared_ptr<Condition> LevelCondition::from_json(json_t *j)
+std::shared_ptr<Condition> LevelCondition::from_json(jsoncons::json const &j)
{
- int min, max;
- if (json_unpack(j, "{s:i,s:i}",
- "min", &min,
- "max", &max) < 0)
+ auto min_j = j.get("min");
+ if (!min_j.is_integer())
{
- msg_print("Missing/invalid 'min'/'max' properties");
+ msg_print("Missing/invalid 'min' property");
return nullptr;
}
+ int min = min_j.as_int();
+
+ auto max_j = j.get("max");
+ if (!max_j.is_integer())
+ {
+ msg_print("Missing/invalid 'max' property");
+ return nullptr;
+ }
+ int max = max_j.as_int();
return std::make_shared<LevelCondition>(min, max);
}
@@ -729,10 +755,10 @@ void LevelCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t
p->write(TERM_WHITE, "\n");
}
-void LevelCondition::to_json(json_t *j) const
+void LevelCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "min", json_integer(m_min));
- json_object_set_new(j, "max", json_integer(m_max));
+ j["min"] = m_min;
+ j["max"] = m_max;
}
bool SkillCondition::is_match(object_type *) const
@@ -742,16 +768,28 @@ bool SkillCondition::is_match(object_type *) const
(sk <= m_max));
}
-std::shared_ptr<Condition> SkillCondition::from_json(json_t *j)
+std::shared_ptr<Condition> SkillCondition::from_json(jsoncons::json const &j)
{
- cptr s;
- int min, max;
- if (json_unpack(j, "{s:i,s:i,s:s}",
- "min", &min,
- "max", &max,
- "name", &s) < 0)
+ auto min_j = j.get("min");
+ if (!min_j.is_integer())
+ {
+ msg_print("Missing/invalid 'min' property");
+ return nullptr;
+ }
+ int min = min_j.as_int();
+
+ auto max_j = j.get("max");
+ if (!max_j.is_integer())
{
- msg_print("Missing/invalid 'min'/'max'/'name' properties");
+ msg_print("Missing/invalid 'max' property");
+ return nullptr;
+ }
+ int max = max_j.as_int();
+
+ auto s = j.get("name").as<cptr>();
+ if (!s)
+ {
+ msg_print("Missing/invalid 'name' property");
return nullptr;
}
@@ -776,14 +814,11 @@ void SkillCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t
p->write(TERM_WHITE, "\n");
}
-void SkillCondition::to_json(json_t *j) const
+void SkillCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "name",
- json_string(s_descriptors[m_skill_idx].name));
- json_object_set_new(j, "min",
- json_integer(m_min));
- json_object_set_new(j, "max",
- json_integer(m_max));
+ j["name"] = s_descriptors[m_skill_idx].name;
+ j["min"] = m_min;
+ j["max"] = m_max;
}
bool StateCondition::is_match(object_type *o_ptr) const
@@ -800,10 +835,11 @@ bool StateCondition::is_match(object_type *o_ptr) const
return false;
}
-std::shared_ptr<Condition> StateCondition::from_json(json_t *j)
+std::shared_ptr<Condition> StateCondition::from_json(jsoncons::json const &j)
{
- cptr s;
- if (json_unpack(j, "{s:s}", "state", &s) < 0)
+ cptr s = j.get("state").as<cptr>();
+
+ if (!s)
{
msg_print("Missing/invalid 'state' property");
return nullptr;
@@ -830,11 +866,9 @@ void StateCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t
p->write(TERM_WHITE, "\n");
}
-void StateCondition::to_json(json_t *j) const
+void StateCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "state",
- json_string(identification_state_mapping().
- stringify(m_state)));
+ j["state"] = identification_state_mapping().stringify(m_state);
}
bool SymbolCondition::is_match(object_type *o_ptr) const
@@ -843,21 +877,16 @@ bool SymbolCondition::is_match(object_type *o_ptr) const
return k_ptr->d_char == m_symbol;
}
-std::shared_ptr<Condition> SymbolCondition::from_json(json_t *j)
+std::shared_ptr<Condition> SymbolCondition::from_json(jsoncons::json const &j)
{
- cptr s_ = nullptr;
- if (json_unpack(j, "{s:s}", "symbol", &s_) < 0)
- {
- msg_print("Missing/invalid 'symbol' property");
- return nullptr;
- }
+ auto s = j.get("symbol").as<std::string>();
- std::string s(s_);
if (s.empty())
{
- msg_print("Invalid 'symbol' property: Too short");
+ msg_print("Missing/invalid 'symbol' property");
return nullptr;
}
+
if (s.size() > 1)
{
msg_print("Invalid 'symbol' property: Too long");
@@ -878,10 +907,9 @@ void SymbolCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t
p->write(TERM_WHITE, "\n");
}
-void SymbolCondition::to_json(json_t *j) const
+void SymbolCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "symbol",
- json_string(format("%c", m_symbol)));
+ j["symbol"] = format("%c", m_symbol);
}
bool AbilityCondition::is_match(object_type *) const
@@ -889,10 +917,11 @@ bool AbilityCondition::is_match(object_type *) const
return p_ptr->has_ability(m_ability_idx);
}
-std::shared_ptr<Condition> AbilityCondition::from_json(json_t *j)
+std::shared_ptr<Condition> AbilityCondition::from_json(jsoncons::json const &j)
{
- cptr a;
- if (json_unpack(j, "{s:s}", "ability", &a) < 0)
+ cptr a = j.get("ability").as<cptr>();
+
+ if (!a)
{
msg_print("Missing/invalid 'ability' property");
return nullptr;
@@ -918,10 +947,9 @@ void AbilityCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_
p->write(TERM_WHITE, "\n");
}
-void AbilityCondition::to_json(json_t *j) const
+void AbilityCondition::to_json(jsoncons::json &j) const
{
- cptr ability_s = ab_info[m_ability_idx].name;
- json_object_set_new(j, "ability", json_string(ability_s));
+ j["ability"] = ab_info[m_ability_idx].name;
}
void SingleSubconditionCondition::add_child(std::function< std::shared_ptr<Condition> () > const &factory)
@@ -946,23 +974,20 @@ std::shared_ptr<Condition> SingleSubconditionCondition::first_child()
return m_subcondition;
}
-void SingleSubconditionCondition::to_json(json_t *j) const
+void SingleSubconditionCondition::to_json(jsoncons::json &j) const
{
- json_object_set_new(j, "condition",
- optional_to_json(m_subcondition));
+ j["condition"] = optional_to_json(m_subcondition);
}
-std::shared_ptr<Condition> SingleSubconditionCondition::parse_single_subcondition(json_t *in_json)
+std::shared_ptr<Condition> SingleSubconditionCondition::parse_single_subcondition(jsoncons::json const &in_json)
{
- json_t *condition_j =
- json_object_get(in_json, "condition");
+ auto condition_j = in_json.get("condition");
- if ((condition_j == nullptr) ||
- (json_is_null(condition_j)))
+ if (condition_j.is_null())
{
return nullptr;
}
- else if (!json_is_object(condition_j))
+ else if (!condition_j.is_object())
{
msg_format("Invalid 'condition' property");
return nullptr;
@@ -983,7 +1008,7 @@ bool NotCondition::is_match(object_type *o_ptr) const
return !m_subcondition->is_match(o_ptr);
}
-std::shared_ptr<Condition> NotCondition::from_json(json_t *j)
+std::shared_ptr<Condition> NotCondition::from_json(jsoncons::json const &j)
{
return std::make_shared<NotCondition>(parse_single_subcondition(j));
}
@@ -1016,7 +1041,7 @@ bool InventoryCondition::is_match(object_type *) const
return false;
}
-std::shared_ptr<Condition> InventoryCondition::from_json(json_t *j)
+std::shared_ptr<Condition> InventoryCondition::from_json(jsoncons::json const &j)
{
return std::make_shared<InventoryCondition>(
parse_single_subcondition(j));
@@ -1052,7 +1077,7 @@ bool EquipmentCondition::is_match(object_type *) const
return false;
}
-std::shared_ptr<Condition> EquipmentCondition::from_json(json_t *j)
+std::shared_ptr<Condition> EquipmentCondition::from_json(jsoncons::json const &j)
{
return std::make_shared<EquipmentCondition>(
parse_single_subcondition(j));
diff --git a/src/squelch/rule.cc b/src/squelch/rule.cc
index 223cf6d3..50a771ae 100644
--- a/src/squelch/rule.cc
+++ b/src/squelch/rule.cc
@@ -41,22 +41,16 @@ std::shared_ptr<Condition> Rule::get_condition() const
return m_condition;
}
-json_t *Rule::to_json() const
+jsoncons::json Rule::to_json() const
{
- json_t *rule_json = json_object();
- json_object_set_new(rule_json,
- "name",
- json_string(m_name.c_str()));
- json_object_set_new(rule_json,
- "action",
- json_string(action_mapping().stringify(m_action)));
- json_object_set_new(rule_json,
- "module",
- json_string(modules[m_module_idx].meta.name));
- json_object_set_new(rule_json,
- "condition",
- Condition::optional_to_json(m_condition));
- return rule_json;
+ jsoncons::json j;
+
+ j["name"] = jsoncons::json::string_type(m_name);
+ j["action"] = action_mapping().stringify(m_action);
+ j["module"] = modules[m_module_idx].meta.name;
+ j["condition"] = Condition::optional_to_json(m_condition);
+
+ return j;
}
void Rule::add_new_condition(Cursor *cursor,
@@ -138,23 +132,19 @@ bool Rule::apply_rule(object_type *o_ptr, int item_idx) const
return false;
}
-std::shared_ptr<Rule> Rule::parse_rule(json_t *rule_json)
+std::shared_ptr<Rule> Rule::parse_rule(jsoncons::json const &rule_json)
{
- if (!json_is_object(rule_json))
+ if (!rule_json.is_object())
{
msg_print("Rule is not an object");
return nullptr;
}
// Retrieve the attributes
- char *rule_name_s = nullptr;
- char *rule_action_s = nullptr;
- char *rule_module_s = nullptr;
- if (json_unpack(rule_json,
- "{s:s,s:s,s:s}",
- "name", &rule_name_s,
- "action", &rule_action_s,
- "module", &rule_module_s) < 0)
+ 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))
{
msg_print("Rule missing required field(s)");
return nullptr;
@@ -178,28 +168,29 @@ std::shared_ptr<Rule> Rule::parse_rule(json_t *rule_json)
// Parse condition
std::shared_ptr<Condition> condition =
- Condition::parse_condition(json_object_get(rule_json, "condition"));
+ Condition::parse_condition(rule_json.get("condition"));
// Parse rule
switch (action)
{
case action_type::AUTO_INSCRIBE:
{
- json_t *rule_inscription_j = json_object_get(rule_json, "inscription");
+ auto rule_inscription_j = rule_json.get("inscription");
- if (rule_inscription_j == nullptr)
+ if (rule_inscription_j.is_null())
{
msg_print("Inscription rule missing 'inscription' attribute");
return nullptr;
}
- if (!json_is_string(rule_inscription_j))
+
+ if (!rule_inscription_j.is_string())
{
msg_print("Inscription rule 'inscription' attribute wrong type");
return nullptr;
}
- std::string inscription =
- json_string_value(rule_inscription_j);
+ std::string inscription = rule_inscription_j.as<std::string>();
+
return std::make_shared<InscribeRule>(
rule_name_s, module_idx, condition, inscription);
}
@@ -290,14 +281,10 @@ bool PickUpRule::do_apply_rule(object_type *o_ptr, int item_idx) const
return true;
}
-json_t *InscribeRule::to_json() const
+jsoncons::json InscribeRule::to_json() const
{
- json_t *j = Rule::to_json();
-
- json_object_set_new(j,
- "inscription",
- json_string(m_inscription.c_str()));
-
+ jsoncons::json j;
+ j["inscription"] = m_inscription;
return j;
}