How to get string value from a number?

[Jack012a]

#include <iostream>
#include <nlohmann/json.hpp>
#include <string>

using json = nlohmann::json;

int main()
{
    std::string str = R"({"number":3.1410})"; // this is an input and I cannot change.
    std::cout << "input: " << str << std::endl;
    json j = json::parse(str);
    std::cout << "output: " << j.dump(4) << std::endl;

    auto pi = j["number"].get<double>();
    auto pi_str = std::to_string(pi);
    std::cout << "converted pi: " << pi_str << std::endl;
}

Output:

input: {"number":3.1410}
output: {
    "number": 3.141
}
converted pi: 3.141000

Question> Is there a way that I can get the original number's string value(i.e. "3.1410")?
I need to get this exact string representation for the number in order to compute the checksum.

If the current version doesn't support this, is there a hack I can do?
Or, is there a method that I can wrap all numbers with quotes before feeding into nlohmann::json parser?

Thank you

[falbrechtskirchinger]

I suggest you take a look at https://json.nlohmann.me/api/json_sax/number_float/.

Using the SAX-style parser gives you access to the original string. You can then store or process it as you see fit.

[Jack012a]

Question> Is it true that I have to manually parse the returned values after I switch to using the SAX interface?

For example,

class sax_event_consumer : public json::json_sax_t
{
  public:
    std::vector<std::string> events;

(start: object) (key: Image) (start: object) (key: Width) (value: 800) (key: Height) (value: 600) (key: Title) (value: View from 15th Floor) (key: Thumbnail) (start: object) (key: Url) (value: http://www.example.com/image/481989943) (key: Height) (value: 125) (key: Width) (value: 100) (end: object) (key: Animated) (value: false) (key: IDs) (start: array) (value: 116) (value: 943) (value: 234) (value: 38793) (end: array) (key: Distance) (value: 12.723374634) (end: object) (end: object) 

Basically, I have to build a parser to parse the sax_event_consumer::events and extract the key:value pair one by one?

If that is the case, then this is not what I really wanted to do.
I still prefer to just calling get<std::string>, get<double> to interface with the json library.
Thank you

[falbrechtskirchinger]

If you're willing to rely on internal, undocumented classes that could change without notice, I'd recommend taking a look at json_sax_dom_parser in detail/input/json_sax.hpp. You should then be able to do something like this:

using nlohmann::json;

class my_sax_parser {
public:
  my_sax_parser(json &root) : parser(root) {}

  // re-implement all SAX function and forward to parser member
  bool null() { return parser.null(); }
  bool boolean(bool val) { return parser.boolean(val); }

  bool number_float(json::float_t val, json::string_t &str) {
    // do whatever you need with str here
    return parser.number_float(val, str);
  }

  // implement the remaining functions as above

private:
  nlohmann::detail::json_sax_dom_parser<json> parser;
};

int main() {
  json j;
  my_sax_parser parser{j};
  std::string input = ...;
  json::sax_parse(input, &parser);
  // use j as usual
}

Note that I've never used the SAX interface before myself but this should work.

[falbrechtskirchinger]

sax_parse() does not return false on parse error. I've updated the code in my previous reply.

[Jack012a]

Hello falbrechtskirchinger,

Thank you very much for your quick response.
Your proposal looks very promising and I have a few follow-up questions:

Question 1> Can I cast away the const w/o causing issues when I force the library to treat a float as a std::string?

bool number_float(json::number_float_t val, const json::string_t &str) {
  //return parser.number_float(val, str);
  return parser.string(const_cast<json::string_t&>(str));
}

Similarly, why the signature of string takes json::string_t& instead of const json::string_t&?

bool string(json::string_t& val)

Question 2> Why the returned value from handle_value is ignored in the library implementation?
version 3.10.5

5996 BasicJsonType* handle_value(Value&& v)
..
6014 *object_element = BasicJsonType(std::forward(v)); // v is "3.1410"
6015 return object_element;

5912 bool string(string_t& val)
5913 {
5914 handle_value(val); // returned value is NOT used!
5915 return true;
5916 }

Question 3> I will reuse the same json j and parser to parse multiple inputs. Do I need to clean up anything, or I can just keep calling the json::sax_parse with different input and the value of json j will be updated from scratch?

  for(const auto& elem : pool)
  {
    json::sax_parse(elem, &parser);
    // use j as usual
  }

Thank you

[falbrechtskirchinger]

Hello falbrechtskirchinger,

Thank you very much for your quick response. Your proposal looks very promising and I have a few follow-up questions:

Question 1> Can I cast away the const w/o causing issues when I force the library to treat a float as a std::string?

bool number_float(json::number_float_t val, const json::string_t &str) {
  //return parser.number_float(val, str);
  return parser.string(const_cast<json::string_t&>(str));
}

Without checking more of the source code than I have time to do right now, I'd recommend you do the following:

bool number_float(json::number_float_t val, const json::string_t &str) {
  json::string_t str_copy{str};
  return parser.string(str_copy);
}

That would always be safe.

Similarly, why the signature of string takes json::string_t& instead of const json::string_t&?

bool string(json::string_t& val)

I'm not sure. I suspect the intent might have been to std::move() the string but I don't see that actually happen. Possibly a bug/minuscule performance issue.

Question 2> Why the returned value from handle_value is ignored in the library implementation? version 3.10.5

5996 BasicJsonType* handle_value(Value&& v) .. 6014 *object_element = BasicJsonType(std::forward(v)); // v is "3.1410" 6015 return object_element;

5912 bool string(string_t& val) 5913 { 5914 handle_value(val); // returned value is NOT used! 5915 return true; 5916 }

handle_value() just returns the pointer to the value added to the root JSON value (the one passed to the constructor). The return value is only useful in a few places, like start_object(), where it is handled.

Question 3> I will reuse the same json j and parser to parse multiple inputs. Do I need to clean up anything, or I can just keep calling the json::sax_parse with different input and the value of json j will be updated from scratch?

  for(const auto& elem : pool)
  {
    json::sax_parse(elem, &parser);
    // use j as usual
  }

It seems that root is reassigned. No need to clean anything up.

    BasicJsonType* handle_value(Value&& v)
    {
        if (ref_stack.empty())
        {
            root = BasicJsonType(std::forward<Value>(v));
            return &root;
        }

[gregmarr]

Similarly, why the signature of string takes json::string_t& instead of const json::string_t&?

Explained in the function documentation:

/*!
@brief a string value was read
@param[in] val  string value
@return whether parsing should proceed
@note It is safe to move the passed string value.
*/
virtual bool string(string_t& val) = 0;