On Wednesday, 4 July 2012 at 16:55:19 UTC, Ali Çehreli wrote:
> On 07/04/2012 08:25 AM, Alexsej wrote:
> > On Monday, 26 March 2012 at 07:14:50 UTC, Ali Çehreli wrote:
>
> >> // Assumes UTF-8 file
> >> auto content = to!string(read("json_file"));
>
> > Your example only works if the json file in UTF-8 (BOM), how
> to make
> > sure that it worked with the files in UTF-8 without BOM.
>
> I am pretty sure that I have tested it without BOM, which is not recommended nor needed for UTF-8 anyway.
>
> If anything, the file should not have any BOM because it is being converted to a string and is being passed to parseJSON(). I don't think parseJSON() expects a BOM either. Does it?
>
> Ali

Ali, I allowed myself to copy-modify.a.little-paste your example to dpaste.dzfl.pl

Hope you don't mind!
Here it is http://dpaste.dzfl.pl/a76157cf

On 07/04/2012 10:51 AM, nazriel wrote:

> Ali, I allowed myself to copy-modify.a.little-paste your example to
> dpaste.dzfl.pl
>
> Hope you don't mind!
> Here it is http://dpaste.dzfl.pl/a76157cf

No problem! Thanks for doing that. :)

Ali

On Thursday, 17 May 2012 at 18:55:57 UTC, Jarl André wrote:
> On Thursday, 17 May 2012 at 18:36:22 UTC, Jarl André wrote:
>> On Thursday, 17 May 2012 at 14:08:27 UTC, Vincent wrote:
>>> On Sunday, 25 March 2012 at 17:50:45 UTC, Andrea Fontana wrote:
>>>> Hope it's clear...
>>>
>>> Nope, it's something like chess and have nothing common with simplicity of the real JSON usage! This is example from C#:
>>>
>>> var p = JsonConvert.DeserializeObject<Person>("{some real JSON, not crapy EOS}");
>>> var str = JsonConvert.SerializeObject(p);
>>>
>>> That's it! And this is how it SHOULD be implemented. Cannot catch why this stupid realization came to standard library... :((
>>
>> I'm pretty new to D, but I am an expert Java developer, self claimed. I am fluent in many other languages as well. In all languages there is a basis documentation.
>>
>> Read the documentation for parseJSON and you'll see that it should be possible to send in a straight JSON string. I think the complex example is a bit stupid. It scares developers away from the lang.
>>
>> Feel free to correct me of course.
>
> The final proof of exisiting simplicity :)
>
> JSONValue[string] value = parseJSON("{ \"test\": \"1\"
> }").object;
> writeln(value["test"].str);
>
> This outputs "1"


+1

Ali Çehreli:

>     // Assumes UTF-8 file
>     auto content = to!string(read("json_file"));

Is this better/worse?

auto content = "json_file".readText;

Bye,
bearophile

On 2012-05-17 14:08:26 +0000, Vincent said:

> On Sunday, 25 March 2012 at 17:50:45 UTC, Andrea Fontana wrote:
>> Hope it's clear...
> 
> Nope, it's something like chess and have nothing common with simplicity of the real JSON usage! This is example from C#:
> 
> var p = JsonConvert.DeserializeObject<Person>("{some real JSON, not crapy EOS}");
> var str = JsonConvert.SerializeObject(p);
> 
> That's it! And this is how it SHOULD be implemented. Cannot catch why this stupid realization came to standard library... :((

This is planned in the upgrade to std.json which is currently being developed.   However, you'll note that you cannot parse generic JSON that way ( since you need a defined type "Person").   The current parseJSON is really a different feature from what exists in your example, and was implemented before opDispatch was introduced.   C# has a similar feature to deserialize JSON into ExpandoObjects, but that's also different from your example.

On 11/13/2013 01:47 AM, bearophile wrote:
> Ali Çehreli:
>
>>     // Assumes UTF-8 file
>>     auto content = to!string(read("json_file"));
>
> Is this better/worse?
>
> auto content = "json_file".readText;
>
> Bye,
> bearophile

That is much better.

Ali

On Wednesday, 4 July 2012 at 16:55:19 UTC, Ali Çehreli wrote:
> On 07/04/2012 08:25 AM, Alexsej wrote:
> > On Monday, 26 March 2012 at 07:14:50 UTC, Ali Çehreli wrote:
>
> >> // Assumes UTF-8 file
> >> auto content = to!string(read("json_file"));
>
> > Your example only works if the json file in UTF-8 (BOM), how
> to make
> > sure that it worked with the files in UTF-8 without BOM.
>
> I am pretty sure that I have tested it without BOM, which is not recommended nor needed for UTF-8 anyway.
>
> If anything, the file should not have any BOM because it is being converted to a string and is being passed to parseJSON(). I don't think parseJSON() expects a BOM either. Does it?
>
> Ali

Last time I checked, parseJSON will fail if a BOM exists. Now that I think of it, maybe that state of affairs should be filed as a bug or feature enhancement.

--rt

On Monday, 26 March 2012 at 07:14:50 UTC, Ali Çehreli wrote:
> On 03/25/2012 08:26 AM, AaronP wrote:
>> Could I get a "hello, world" example of parsing json? The docs look
>> simple enough, but I could still use an example.
>
> For what it's worth, I've just sent the following program to a friend before seeing this thread.
>
> 1) Save this sample text to a file named "json_file"
>
> {
>   "employees": [
>      { "firstName":"John" , "lastName":"Doe" },
>      { "firstName":"Anna" , "lastName":"Smith" },
>      { "firstName":"Peter" , "lastName":"Jones" }
>   ]
> }
>
> 2) The following program makes struct Employee objects from that file:
>
> import std.stdio;
> import std.json;
> import std.conv;
> import std.file;
>
> struct Employee
> {
>     string firstName;
>     string lastName;
> }
>
> void main()
> {
>     // Assumes UTF-8 file
>     auto content = to!string(read("json_file"));
>
>     JSONValue[string] document = parseJSON(content).object;
>     JSONValue[] employees = document["employees"].array;
>
>     foreach (employeeJson; employees) {
>         JSONValue[string] employee = employeeJson.object;
>
>         string firstName = employee["firstName"].str;
>         string lastName = employee["lastName"].str;
>
>         auto e = Employee(firstName, lastName);
>         writeln("Constructed: ", e);
>     }
> }
>
> The output of the program:
>
> Constructed: Employee("John", "Doe")
> Constructed: Employee("Anna", "Smith")
> Constructed: Employee("Peter", "Jones")
>
> Ali

So I was thinking of adding an example to the std.json documents,
and was going to ask to rip-off Ali's example here.  However, I
thought I would be nice to have an example going the other way
(ie. taking some data structure and converting to JSON format).
I came up with the following using Ali's Employee struct:

/**
  * Generate a JSON string from an array of employees using
std.json,
  * even though the code to generate the same by hand would be
shorter
  * and easier to follow :o)
  */
string employeesToJSON( Employee[] employees )
{
     JSONValue emp_array;
     emp_array.type = JSON_TYPE.ARRAY;
     emp_array.array = [];

     foreach( e; employees ) {
	JSONValue emp_object;
	emp_object.type = JSON_TYPE.OBJECT;
	emp_object.object = null;
	
	JSONValue first_name;
	first_name.str = e.firstName;
	first_name.type = JSON_TYPE.STRING;
	
	JSONValue last_name;
	last_name.str = e.lastName;
	last_name.type = JSON_TYPE.STRING;
	
	emp_object.object["firstName"] = first_name;
	emp_object.object["lastName"] = last_name;
	
	emp_array.array ~= emp_object;
     }

     JSONValue root;
     root.type = JSON_TYPE.OBJECT;
     root.object[""] = emp_array;

     return toJSON( &root );
}

Then if I call it using the following code:

	Employee[] employees =  [ { "Walter", "Bright" },
				  { "Andrei", "Alexandrescu"},
				  { "Celine", "Dion" } ];
	
	writeln( employeesToJSON( employees ) );

It prints out:

{"":[{"lastName":"Bright","firstName":"Walter"},{"lastName":"Alexandrescu","firstName":"Andrei"},{"lastName":"Dion","firstName":"Celine"}]}

Which isn't exactly what I want as I have the extra "" at the
start.

So I have two questions:

1. Is there a nicer way to generate my JSONValue tree.

2. How do I insert my JSONValue.array of employees into my root
JSONValue.
I tried:
   root.object[""] = emp_array; // generates { "": [ ... }
   root.object[null] = emp_array; // generates { "": [ ... }
   root.object = emp_array; //Syntax error
     //Error: cannot implicitly convert expression
     //(emp_array) of type JSONValue to JSONValue[string]
I want my returned string as { [ ... ] }

Cheers,

Craig

For tasks that imply conversion between D types and JSON text (alike to serialization), vibe.d module is really much superior because it provides functions like http://vibed.org/api/vibe.data.json/serializeToJson which "just work" on many user types.

On Wednesday, 20 November 2013 at 13:20:48 UTC, Dicebot wrote:
> For tasks that imply conversion between D types and JSON text (alike to serialization), vibe.d module is really much superior because it provides functions like http://vibed.org/api/vibe.data.json/serializeToJson which "just work" on many user types.

I absolutely agree.  However, I wanted to come up with an example
for std.json, and this mess was the best I could do.  I was
curious if someone could come up with a nicer mess than mine.

Also for small jobs it might be preferable to use std.json - if
you don't want the vibe.d dependency.