Repository navigation
Wishlist #65
Description
A common use case in web development is the need for flatten and unflatten functions, that is the ability to flatten a json object into a map of javascript assignment strings and vice versa.
{
"member1" : true,
"member2" : "Hello World",
"member3" : [1, {"member4" : 4, "member5" : 6.5}, 3]
}
into
prefix "whatever"
key = whatever.member1
value = true
key = whatever.member2
value = "Hello World"
key = whatever.member3[0]
value = 1
key = whatever.member1[1].member4
value = 4
key = whatever.member1[1].member5
value = 6.5
key = whatever.member3[2]
value = 3
function sighatures would be something like
map<string, json_primitive_that_insn't_object_or_array> flatten(json_object_or_array, symbol_name);
json_object_or_array unflatten(map<string, json_primitive_that_insn't_object_or_array>, symbol_name);
The type of the map would be string to a json primitive that isn't an object or an array.
The use case is that the keys in the map could be used as form field names. PHP and jQuery both are already doing this natively. Wouldn't it be nice if C++ had equal or better footing for web development.
Activity
nlohmann commentedon May 3, 2015
Hi @jrandall, thanks for the input. I have an idea what you mean, and I have an idea how to realize it. Could you give me some references for PHP and jQuery so I can check?
nlohmann commentedon Jun 4, 2015
Without more information, I close this issue for now.
jrandall commentedon Jun 5, 2015
@nlohmann it looks like you replied to me instead of @jwaterloo by mistake. @jwaterloo, perhaps you can provide the references for PHP and jQuery that Niels is looks for?
nlohmann commentedon Jun 5, 2015
Oops, my bad...
nlohmann commentedon Jun 16, 2015
Hi @jwaterloo, thanks for the input. I have an idea what you mean, and I have an idea how to realize it. Could you give me some references for PHP and jQuery so I can check?
jwaterloo commentedon Jun 17, 2015
On 6/16/2015 4:43 PM, Niels wrote:
http://api.jquery.com/jQuery.param/
jQuery.param()
|// >=1.4:|
|$.param({ a: { b: 1, c: 2 }, d: [ 3, 4, { e: 5 } ] });|
|// "a[b]=1&a[c]=2&d[]=3&d[]=4&d[2][e]=5"|
In our case
map<string, ?>
key -> value
a[b] -> 1
a[c] -> 2
d[] -> 3
d[] -> 4
d[2][e] -> 5
or
a.b -> 1
a.c -> 2
d[] -> 3
d[] -> 4
d[2].e -> 5
see also http://api.jquery.com/jQuery.ajax/ which is used throughout
jQuery AJAX calls since 1.4
"Sending Data to the Server
By default, Ajax requests are sent using the GET HTTP method. If the
POST method is required, the method can be specified by setting a value
for the type option. This option affects how the contents of the data
option are sent to the server. POST data will always be transmitted to
the server using UTF-8 charset, per the W3C XMLHTTPRequest standard.
The data option can contain either a query string of the form
key1=value1&key2=value2, or an object of the form {key1: 'value1', key2:
'value2'}. If the latter form is used, the data is converted into a
query string using jQuery.param() before it is sent. This processing can
be circumvented by setting processData to false. The processing might be
undesirable if you wish to send an XML object to the server; in this
case, change the contentType option from
application/x-www-form-urlencoded to a more appropriate MIME type."
In case of PHP, it automatic. Whenever you request anything from the
$GET and other collections
a[b] -> 1
a[c] -> 2
d[] -> 3
d[] -> 4
d[2][e] -> 5
is automatically converted to the PHP map/hash equivalent of JSON's { a:
{ b: 1, c: 2 }, d: [ 3, 4, { e: 5 } ] }
So web developers rarely ever has to do any serialization, knowingly, as
long as the data type complexity is a tree and not an object graph which
JSON can't handle anyway.
Any C++ library should definitely have the general use case for when
they are needed but also the most common convenient functions/objects
for use by the 90%++ of the time. Of course this needs to be reflexive,
ie. going in the opposite direction.
...
More jQuery usage
http://api.jquery.com/serialize/
web developers typically name there input fields "d[2][e]" so when the
form is submitted it is already in the proper format for PHP. So jquery
isn't even needed. However when jquery is needed they'll param() for
code and serialize() when dealing with the form element in the UI. Both
returns the encoded format.
nlohmann commentedon Jun 17, 2015
Thanks. I'll have a look and maybe come back if I have some questions. Until then, I would appreciate more concrete examples.
nlohmann commentedon Jun 27, 2015
Hi @jwaterloo, could you be so kind and give me more concrete examples?
jwaterloo commentedon Jun 30, 2015
On 6/17/2015 5:55 PM, Niels wrote:
I am not over set on the names
// flatten
std::map<string, string>&& flatten(const json& object_or_array, const
std::string& name);
std::map<wstring, wstring>&& flatten(const json& object_or_array);
std::map<string, boost|std::any>&& flatten(const json& object_or_array,
const std::string& name);
std::map<wstring, boost|std::any>&& flatten(const json& object_or_array);
std::map<string, boost|std::variant>&& flatten(const json&
object_or_array, const std::string& name);
std::map<wstring, boost|std::variant>&& flatten(const json&
object_or_array);
// boost|std::any means boost::any or std::any depending on which
version of standard you are targeting
// boost|std::variant means boost::variant or std::variant depending on
which version of standard you are targeting
// boost::any, std::any, boost::variant or std::variant could be
replaced with json object that is not an array or embedded object or in
other words a primitive string, number, null, true, false, empty object
or empty array
// json object actual means your json object container class or any C++
class that could be converted to actual json object via copying or more
efficient streaming/reflection
// there should be a symmetric operation
// deflatten (again a better name might be better)
json&& deflatten(const std::map<string, string>& values, const
std::string& name);
json&& deflatten(const std::map<wstring, wstring>& values);
json&& deflatten(const std::map<string, boost|std::any>& values, const
std::string& name);
json&& deflatten(const std::map<wstring, boost|std::any>& values);
json&& deflatten(const std::map<string, boost|std::variant>& values,
const std::string& name);
json&& deflatten(const std::map<wstring, boost|std::variant>& values);
// symmetry guarantees
json object = ...;
json object2 = deflatten(flatten(object, "somename"), "somename");
assert(object == object2);
std::map<wstring, wstring> values = ...;
std::map<wstring, wstring> values2 = flatten(deflatten(values,
"somename"), "somename");
assert(values == values2);
// what does parameters look like
json somename = {"a" : "1", "b" : {"d" : "5", "f" : [6, true, null, 7,
false]}, "co ff ee" : [3, true, 4, false]};
result of flatten(somename, "somename");
key: somename.a, value: 1
key: somename.b.d, value: 5
key: somename.b.f[0], value: 6
key: somename.b.f[1], value: true
key: somename.b.f[2], value: null
key: somename.b.f[3], value: 7
key: somename.b.f[4], value: false
key: somename.["co ff ee"][0], value: 3
key: somename.["co ff ee"][1], value: true
key: somename.["co ff ee"][2], value: 4
key: somename.["co ff ee"][3], value: false
...
std::map<wstring, any|variant|primitive_json> values;
values.push_back("somename2.b.f[0]", "6");// ignored
values.push_back("somename.a", "1");
values.push_back("somename.b.d", "5");
values.push_back("somename.b.f[0]", "6");
values.push_back("somename.b.f[1]", true);
values.push_back("somename.b.f[2]", null);
values.push_back("somename.b.f[3]", "7");
values.push_back("somename.b.f[4]", "false");
values.push_back("somename3.b.f[0]", "6");// ignored
values.push_back("somename.["co ff ee"][0]", "3");
values.push_back("somename.["co ff ee"][1]", "true");
values.push_back("somename.["co ff ee"][2]", "4");
values.push_back("somename.["co ff ee"][3]", "false");
values.push_back("somename4.b.f[0]", "6");// ignored
json object = deflatten(values, "somename");
...
// real world usage
// HTTP GET
write server servlet code to generate following HTML
// HTTP POST
// NOTE: usecase, no complicated manual serialization or
deserialization; deflatten reassembles the JSON tree
json object_or_array = deflatten(request_map, "products");
vector products = object_or_array;
for(auto product : products)
{
// insert product in database
}
// Next request: SECURITY
flatten(const json& object_or_array, const std::string& name,
std::function<bool(wstring, any|variant|primitive_json)> filter);
deflatten(const std::map<string, boost|std::any>& values, const
std::string& name, std::function<bool(wstring,
any|variant|primitive_json)> filter);
// std::function<bool(wstring, any|variant|primitive_json)> filter takes
the key and primitive value and return a boolean stating whether the
value gets applied to the map or object in question. function may throw
in case of fail fast security exceptions or if a member function may
aggregate the false attempts for informative debugging
nlohmann commentedon Dec 14, 2015
I think this change is too complicated and does not really cover JSON core functionality.
Fix publish doc trigger (nlohmann#65)
Add additional scores to statements and fix minor bugs (#35)