(API) remove freestanding API

this change seems necessary to allow for internally managing the
lifetime of strings.

* enable string management in logic_rule:
  currently all strings are stored in logic_data until the
  logic_rule object is destructed. This may lead to string
  accumulation over time, if a rule generates many strings.
  e.g., through string concatenation.

* remove ast-core. It is no longer needed as the user-side no
  longer accesses the any_expr directly.

* move essential types for logic_data into ast-full.hpp

Author: ppete

cpp/bench/src/benchmark-complex1.cpp

@@ -91,6 +91,7 @@ int main(int argc, const char **argv) try {
   // Create jsonlogic benchmark
   auto jv_xy = boost::json::parse(expr);
   boost::json::object data_obj;
+  jsonlogic::logic_rule rule = jsonlogic::create_logic(jv_xy);
 
   size_t matches = 0;
   auto jl_lambda = [&] {
@@ -99,8 +100,8 @@ int main(int argc, const char **argv) try {
       data_obj["x"] = xs[i];
       data_obj["y"] = ys[i];
       data_obj["z"] = zs[i];
-      auto data = boost::json::value_from(data_obj);
-      auto v_xy = jsonlogic::apply(jv_xy, data);
+      auto varaccess = jsonlogic::json_accessor(boost::json::value_from(data_obj));
+      auto v_xy = rule.apply(varaccess);
 
       bool val = jsonlogic::truthy(v_xy);
 
@@ -116,9 +117,9 @@ int main(int argc, const char **argv) try {
 
   auto jl2_lambda = [&] {
     matches = 0;
-    auto [rule, ignore1, igmore2] = jsonlogic::create_logic(jv_xy);
+    jsonlogic::logic_rule rule = jsonlogic::create_logic(jv_xy);
     for (size_t i = 0; i < N; ++i) {
-      auto v_xy = jsonlogic::apply(rule, {xs[i], ys[i], zs[i]});
+      auto v_xy = rule.apply({xs[i], ys[i], zs[i]});
       bool val = jsonlogic::truthy(v_xy);
 
       if (val) {

cpp/bench/src/benchmark-equality.cpp

@@ -162,11 +162,13 @@ int main(int argc, const char **argv) try {
   size_t matches = 0;
   auto jl_lambda = [&] {
     matches = 0;
+    auto rule = jsonlogic::create_logic(jv_xy);
+
     for (size_t i = 0; i < N; ++i) {
       data_obj["x"] = xs[i];
       data_obj["y"] = ys[i];
-      auto data = boost::json::value_from(data_obj);
-      auto v_xy = jsonlogic::apply(jv_xy, data);
+      auto accessor = jsonlogic::json_accessor(boost::json::value_from(data_obj));
+      auto v_xy = rule.apply(accessor);
 
       bool val = jsonlogic::truthy(v_xy);
 
@@ -182,9 +184,9 @@ int main(int argc, const char **argv) try {
 
   auto jl2_lambda = [&] {
     matches = 0;
-    auto [rule, ignore1, igmore2] = jsonlogic::create_logic(jv_xy);
+    auto rule = jsonlogic::create_logic(jv_xy);
     for (size_t i = 0; i < N; ++i) {
-      auto v_xy = jsonlogic::apply(rule, {xs[i], ys[i]});
+      auto v_xy = rule.apply({xs[i], ys[i]});
       bool val = jsonlogic::truthy(v_xy);
 
       if (val) {

cpp/bench/src/benchmark-membership.cpp

@@ -85,16 +85,15 @@ int main(int argc, const char **argv) try {
   std::cout << "initialized data_obj\n";
   //   data_obj["haystack"] = haystack;
   size_t matches = 0;
-  jsonlogic::any_expr rule;
-  std::tie(rule, std::ignore, std::ignore) = jsonlogic::create_logic(jv_in);
+  jsonlogic::logic_rule rule = jsonlogic::create_logic(jv_in);
 
   auto jl_lambda = [&] {
     matches = 0;
     for (size_t i = 0; i < N; ++i) {
       data_obj["x"] = xs[i];
       auto varaccess =
-          jsonlogic::data_accessor(boost::json::value_from(data_obj));
-      auto v_in = jsonlogic::apply(rule, varaccess);
+          jsonlogic::json_accessor(boost::json::value_from(data_obj));
+      auto v_in = rule.apply(varaccess);
 
       bool val = jsonlogic::truthy(v_in);
 

cpp/bench/src/benchmark-simple-and.cpp

@@ -81,15 +81,16 @@ int main(int argc, const char **argv) try {
 
   auto jv_expr = boost::json::parse(expr);
   boost::json::object data_obj;
+  jsonlogic::logic_rule rule = jsonlogic::create_logic(jv_expr);
 
   size_t matches = 0;
   auto jl1_lambda = [&] {
     matches = 0;
     for (size_t i = 0; i < N; ++i) {
       data_obj["x"] = xs[i];
       data_obj["y"] = ys[i];
-      auto data = boost::json::value_from(data_obj);
-      auto result = jsonlogic::apply(jv_expr, data);
+      auto varaccess = jsonlogic::json_accessor(boost::json::value_from(data_obj));
+      auto result = rule.apply(varaccess);
 
       bool val = jsonlogic::truthy(result);
 
@@ -105,9 +106,9 @@ int main(int argc, const char **argv) try {
 
   auto jl2_lambda = [&] {
     matches = 0;
-    auto [rule, ignore1, ignore2] = jsonlogic::create_logic(jv_expr);
+    jsonlogic::logic_rule rule = jsonlogic::create_logic(jv_expr);
     for (size_t i = 0; i < N; ++i) {
-      auto result = jsonlogic::apply(rule, {xs[i], ys[i]});
+      auto result = rule.apply({xs[i], ys[i]});
       bool val = jsonlogic::truthy(result);
 
       if (val) {

cpp/include/jsonlogic/details/ast-core.hpp

@@ -1,17 +1,38 @@
 #pragma once
 
-#include <boost/json.hpp>
+#include <memory>
 #include <map>
+#include <set>
 #include <vector>
+#include <iosfwd>
 
-#include "ast-core.hpp"
 #include "cxx-compat.hpp"
 
 #if !defined(WITH_JSONLOGIC_EXTENSIONS)
 #define WITH_JSONLOGIC_EXTENSIONS 1
 #endif /* !defined(WITH_JSONLOGIC_EXTENSIONS) */
 
 namespace jsonlogic {
+
+struct visitor;
+
+// the root class
+struct expr {
+  expr() = default;
+  virtual ~expr() = default;
+
+  virtual void accept(visitor &) const = 0;
+
+private:
+  expr(expr &&) = delete;
+  expr(const expr &) = delete;
+  expr &operator=(expr &&) = delete;
+  expr &operator=(const expr &) = delete;
+};
+
+using any_expr = std::unique_ptr<expr>;
+
+
 struct oper : expr, private std::vector<any_expr> {
   using container_type = std::vector<any_expr>;
 
@@ -557,4 +578,59 @@ auto generic_visit(ast_functor fn, ast_node *n, arguments... args)
   n->accept(disp);
   return std::move(disp).result();
 }
+
+
+//
+// logic internal data
+
+/// type for string storage
+/// \note if the compiler uses small string optimization, we cannot
+///       use an std::vector because resizing invalidates the
+///       string_views.
+///       alternatives include forward_list or deque
+using string_table_base = std::set<std::string>;
+
+/// string table ensures lifetime of string exceeds lifetime of string_views
+struct string_table : private string_table_base
+{
+  using string_table_base::size;
+
+  std::string_view safe_string(std::string v)
+  {
+    auto res = this->emplace(std::move(v));
+    return *res.first;
+  }
+
+  template <class iterator>
+  std::string_view safe_string(iterator aa, iterator zz)
+  {
+    return safe_string(std::string(aa, zz));
+  }
+};
+
+
+using logic_data_base = std::tuple<any_expr, std::vector<std::string_view>, string_table, bool>;
+struct logic_data : logic_data_base
+{
+  using base = logic_data_base;
+  using base::base;
+
+  /// returns the logic expression
+  any_expr const &syntax_tree() const { return std::get<0>(*this); }
+
+  /// returns static variable names (i.e., variable names that are not computed)
+  std::vector<std::string_view> const &variable_names() const { return std::get<1>(*this); }
+
+  /// returns the string table
+  string_table&       strings()       { return std::get<2>(*this); }
+  string_table const& strings() const { return std::get<2>(*this); }
+
+  /// returns if the expression contains computed names.
+  bool has_computed_variable_names() const { return std::get<3>(*this); }
+};
+
+
+
+
+
 }  // namespace jsonlogic