ChaiScript / ChaiScript
1
#ifndef CHAISCRIPT_SIMPLEJSON_WRAP_HPP
2
#define CHAISCRIPT_SIMPLEJSON_WRAP_HPP
3

4
#include "json.hpp"
5

6
namespace chaiscript
7
{
8
  class json_wrap
9
  {
10
    public:
11

12 1
      static Module& library(Module& m)
13
      {
14

15 1
        m.add(chaiscript::fun([](const std::string &t_str) { return from_json(t_str); }), "from_json");
16 1
        m.add(chaiscript::fun(&json_wrap::to_json), "to_json");
17

18 1
        return m;
19

20
      }
21

22
    private:
23

24 1
      static Boxed_Value from_json(const json::JSON &t_json)
25
      {
26 1
        switch( t_json.JSONType() ) {
27 1
          case json::JSON::Class::Null:
28 1
            return Boxed_Value();
29 1
          case json::JSON::Class::Object:
30
            {
31 1
              std::map<std::string, Boxed_Value> m;
32

33 1
              for (const auto &p : t_json.object_range())
34
              {
35 1
                m.insert(std::make_pair(p.first, from_json(p.second)));
36
              }
37

38 1
              return Boxed_Value(m);
39
            }
40 1
          case json::JSON::Class::Array:
41
            {
42 1
              std::vector<Boxed_Value> vec;
43

44 1
              for (const auto &p : t_json.array_range()) 
45
              {
46 1
                vec.emplace_back(from_json(p));
47
              }
48

49 1
              return Boxed_Value(vec);
50
            }
51 1
          case json::JSON::Class::String:
52 1
            return Boxed_Value(t_json.to_string());
53 1
          case json::JSON::Class::Floating:
54 1
            return Boxed_Value(t_json.to_float());
55 1
          case json::JSON::Class::Integral:
56 1
            return Boxed_Value(t_json.to_int());
57 1
          case json::JSON::Class::Boolean:
58 1
            return Boxed_Value(t_json.to_bool());
59
        }
60

61 0
        throw std::runtime_error("Unknown JSON type");
62
      }
63

64 1
      static Boxed_Value from_json(const std::string &t_json)
65
      {
66
        try {
67 1
          return from_json( json::JSON::Load(t_json) );
68 1
        } catch (const std::out_of_range& ) {
69 1
          throw std::runtime_error("Unparsed JSON input");
70
        }
71
      }
72

73 1
      static std::string to_json(const Boxed_Value &t_bv)
74
      {
75 1
        return to_json_object(t_bv).dump();
76
      }
77

78
      static json::JSON to_json_object(const Boxed_Value &t_bv)
79
      {
80
        try {
81
          const std::map<std::string, Boxed_Value> m = chaiscript::boxed_cast<const std::map<std::string, Boxed_Value> &>(t_bv);
82

83
          json::JSON obj(json::JSON::Class::Object);
84
          for (const auto &o : m)
85
          {
86
            obj[o.first] = to_json_object(o.second);
87
          }
88
          return obj;
89 1
        } catch (const chaiscript::exception::bad_boxed_cast &) {
90
          // not a map
91
        }
92

93
        try {
94 1
          const std::vector<Boxed_Value> v = chaiscript::boxed_cast<const std::vector<Boxed_Value> &>(t_bv);
95

96 1
          json::JSON obj(json::JSON::Class::Array);
97 1
          for (size_t i = 0; i < v.size(); ++i)
98
          {
99 1
            obj[i] = to_json_object(v[i]);
100
          }
101 1
          return obj;
102 1
        } catch (const chaiscript::exception::bad_boxed_cast &) {
103
          // not a vector
104
        }
105

106

107
        try {
108 1
          Boxed_Number bn(t_bv);
109 1
          if (Boxed_Number::is_floating_point(t_bv))
110
          {
111 1
            return json::JSON(bn.get_as<double>());
112
          } else {
113 1
            return json::JSON(bn.get_as<std::int64_t>());
114
          }
115 1
        } catch (const chaiscript::detail::exception::bad_any_cast &) {
116
          // not a number
117
        }
118

119
        try {
120 1
          return json::JSON(boxed_cast<bool>(t_bv));
121 1
        } catch (const chaiscript::exception::bad_boxed_cast &) {
122
          // not a bool
123
        }
124

125
        try {
126 1
          return json::JSON(boxed_cast<std::string>(t_bv));
127 1
        } catch (const chaiscript::exception::bad_boxed_cast &) {
128
          // not a string
129
        }
130

131

132
        try {
133 1
          const chaiscript::dispatch::Dynamic_Object &o = boxed_cast<const dispatch::Dynamic_Object &>(t_bv);
134

135 1
          json::JSON obj(json::JSON::Class::Object);
136 1
          for (const auto &attr : o.get_attrs())
137
          {
138 0
            obj[attr.first] = to_json_object(attr.second);
139
          }
140 1
          return obj;
141 1
        } catch (const chaiscript::exception::bad_boxed_cast &) {
142
          // not a dynamic object
143
        }
144

145 1
        if (t_bv.is_null()) return json::JSON(); // a null value
146

147 1
        throw std::runtime_error("Unknown object type to convert to JSON");
148
      }
149

150

151
  };
152

153

154
}
155

156
#endif

Read our documentation on viewing source code .

Loading