3

I'm having troubles with the JSON classes of the CPP REST SDK. I can't figure out when to use json::value, json::object and json::array. Especially the latter two seem very alike. Also the usage of json::array is rather unintuitive to me. Finally I want to write the JSON to a file or at least to stdcout, so I can check it is correct.

It was way easier for me to use json-spirit, but since I want to make REST requests later on I thought I'd save me the string/wstring madness and use the json classes of the CPP REST SDK.

What I want to achieve is a JSON file like this:

{
  "foo-list" : [
      {
        "bar" : "value1",
        "bob" : "value2"
      }
  ]
}

This is the code I tried:

json::value arr;
int i{0};
for(auto& thing : things)
{
  json::value obj;
  obj[L"bar"] = json::value::string(thing.first);
  obj[L"bob"] = json::value::string(thing.second);
  arr[i++] = obj;
}
json::value result;
result[L"foo-list"] = arr;

Do I really need this extra counter variable i? Seems rather inelegant. Would using json::array/json::object make things nicer? And how do I write my JSON to a file?

DenverCoder21
  • 879
  • 3
  • 16
  • 34

2 Answers2

9

This could help you:

json::value output;
output[L"foo-list"][L"bar"] = json::value::string(utility::conversions::to_utf16string("value1"));
output[L"foo-list"][L"bob"] = json::value::string(utility::conversions::to_utf16string("value2"));

output[L"foo-list"][L"bobList"][0] = json::value::string(utility::conversions::to_utf16string("bobValue1"));
output[L"foo-list"][L"bobList"][1] = json::value::string(utility::conversions::to_utf16string("bobValue1"));
output[L"foo-list"][L"bobList"][2] = json::value::string(utility::conversions::to_utf16string("bobValue1"));

If you want to create list, like bobList, you really need to use some iterator variable. Otherwise you will get only bunch of separate variables.

For output to console use 

cout << output.serialize().c_str();

And finally, this will lead to

{
   "foo-list":{
      "bar":"value1",
      "bob":"value2",
      "bobList":[
         "bobValue1",
         "bobValue1",
         "bobValue1"
      ]
   }
}
Zdeno Pavlik
  • 728
  • 6
  • 15
  • 1
    Great answer, helped a lot. just for your info, instead of `cout` you can use `wcout` and then you don't need the `c_str()` method to print to the console. – Rabbi Shuki Gur May 07 '19 at 09:13
  • 1
    Instead of ```L"something"```, it'd be much better to use ```U("something")``` so that it can be built both on Linux and Windows without any issues. This code won't compile under Linux like this. – Hossein Feb 21 '21 at 12:42
0

-- To answer your first question, in arrays, JSON values are stored at ordered indices. Thus, arrays can be traversed efficiently compared to objects as objects are more like hashmaps where the input key goes through hashing mechanism every time and a match within a hashtable is found to reach the value of that key. Thus, arrays are efficient especially when we are trying to traverse through a large JSON.

-- To answer your second question. As you mentioned you need to create something like this.

{
  "foo-list" : [
      {
        "bar" : "value1",
        "bob" : "value2"
      }
  ]
}

-- If we were to have json::object with these two json values {"bar":"value1"} and {"bob":"value2"} as the value of the key foo-list,(if we were to have curly braces instead of the square above) it can be implemented as

result[U("foo-list")][U("bar")] = "value1"; 
result[U("foo-list")][U("bob")] = "value2";

-- But here json::object with these two JSON values {"bar":"value1"} and {"bob":"value2"} is at index 0 of a json::array; and this array is the value of the key foo-list. Thus you need the index variable to implement something like

result[U("foo-list")][0][U("bar")] = "value1"; 
result[U("foo-list")][0][U("bob")] = "value2";

-- To answer your third question, as correctly pointed out by @Zdeno you can use serialize to convert json::value to string and dump it to the file

Omi
  • 31
  • 2