digitalmars.D.learn - building a simple json tree

anonymous (25/25) Jan 15 2015 what's the right syntax for building a JSON tree ? I try to do

Rikki Cattermole (26/51) Jan 15 2015 import std.stdio, std.json;

anonymous (15/73) Jan 15 2015 Thx, but actually I initially liked to get an array of object

Rikki Cattermole (6/81) Jan 15 2015 It makes sense to do it. But like I said std.json is rubbish.

Colin (4/100) Jan 15 2015 Also, look at the new std.json candidate:

"anonymous" <sdfhfsdgh dfdg.fi> writes:

what's the right syntax for building a JSON tree ? I try to do 
like in an AA but the program throw because the Key doesn't exist:

---
import std.stdio, std.json;

void main(string[] args)
{
     struct Foo{
         string a,  b;
         void writeToJson(ref JSONValue target) {
             target["a"] = JSONValue(a);
             target["b"] = JSONValue(b);
         }
     }

     JSONValue root = parseJSON("{}");
     root["items"] = JSONValue([""]);

     Foo*[] foos;
     foos ~= new Foo("a1","b1");
     foos ~= new Foo("a2","b2");

     foreach(foo; foos) {
         root["items"].array.length += 1;
         root["items"].array[$-1] = parseJSON("{}");
         foo.writeToJson(root["items"].array[$-1]);
     }
}
---

Jan 15 2015

Rikki Cattermole <alphaglosined gmail.com> writes:

On 16/01/2015 12:16 a.m., anonymous wrote:
 what's the right syntax for building a JSON tree ? I try to do like in
 an AA but the program throw because the Key doesn't exist:

 ---
 import std.stdio, std.json;

 void main(string[] args)
 {
      struct Foo{
          string a,  b;
          void writeToJson(ref JSONValue target) {
              target["a"] = JSONValue(a);
              target["b"] = JSONValue(b);
          }
      }

      JSONValue root = parseJSON("{}");
      root["items"] = JSONValue([""]);

      Foo*[] foos;
      foos ~= new Foo("a1","b1");
      foos ~= new Foo("a2","b2");

      foreach(foo; foos) {
          root["items"].array.length += 1;
          root["items"].array[$-1] = parseJSON("{}");
          foo.writeToJson(root["items"].array[$-1]);
      }
 }
 ---

import std.stdio, std.json;

void main(string[] args)
{
     struct Foo{
         string a,  b;
         void writeToJson(ref JSONValue target) {
             target["a"] = JSONValue(a);
             target["b"] = JSONValue(b);
         }
     }

     JSONValue root = ["items": cast(string[])[]];

     Foo[] foos;
     foos ~= Foo("a1","b1");
     foos ~= Foo("a2","b2");

     foreach(foo; foos) {
         root["items"].array ~= JSONValue(foo.a);
		root["items"].array ~= JSONValue(foo.b);
     }
	
	writeln(root.toString());
}

I would recommend keeping away from std.json. Its an old piece of code, 
that needs to be replaced.
Vibe.d has a much nicer implementation that is really decent. I would 
recommend that, if you are up to using the build manager dub.

Jan 15 2015

"anonymous" <sdfhfsdgh dfdg.fi> writes:

On Thursday, 15 January 2015 at 12:10:09 UTC, Rikki Cattermole 
wrote:
 On 16/01/2015 12:16 a.m., anonymous wrote:
 what's the right syntax for building a JSON tree ? I try to do 
 like in
 an AA but the program throw because the Key doesn't exist:

 ---
 import std.stdio, std.json;

 void main(string[] args)
 {
     struct Foo{
         string a,  b;
         void writeToJson(ref JSONValue target) {
             target["a"] = JSONValue(a);
             target["b"] = JSONValue(b);
         }
     }

     JSONValue root = parseJSON("{}");
     root["items"] = JSONValue([""]);

     Foo*[] foos;
     foos ~= new Foo("a1","b1");
     foos ~= new Foo("a2","b2");

     foreach(foo; foos) {
         root["items"].array.length += 1;
         root["items"].array[$-1] = parseJSON("{}");
         foo.writeToJson(root["items"].array[$-1]);
     }
 }
 ---

 import std.stdio, std.json;

 void main(string[] args)
 {
     struct Foo{
         string a,  b;
         void writeToJson(ref JSONValue target) {
             target["a"] = JSONValue(a);
             target["b"] = JSONValue(b);
         }
     }

     JSONValue root = ["items": cast(string[])[]];

     Foo[] foos;
     foos ~= Foo("a1","b1");
     foos ~= Foo("a2","b2");

     foreach(foo; foos) {
         root["items"].array ~= JSONValue(foo.a);
 		root["items"].array ~= JSONValue(foo.b);
     }
 	
 	writeln(root.toString());
 }

 I would recommend keeping away from std.json. Its an old piece 
 of code, that needs to be replaced.
 Vibe.d has a much nicer implementation that is really decent. I 
 would recommend that, if you are up to using the build manager 
 dub.

Thx, but actually I initially liked to get an array of object 
with each identifier:

currently it produces:

{"items":["a1","b1","a2","b2"]}

while it'd be more desirable to have

{"items":[{"a":"a1","b":"b1"}, {"a":"a2","b":"b2"}]}

because the reader will test the presence of each the key "a" and 
"b" in each element of "items".

Would it be a complete non-sense to assign an element with 
opIndexAssign(), just like I wrote initially ? I know this is 
wrong but the syntax seemed natural and logic.
Reading from std.json is straightforward but writing looks a bit 
messy.

Jan 15 2015

Rikki Cattermole <alphaglosined gmail.com> writes:

On 16/01/2015 1:37 a.m., anonymous wrote:
 On Thursday, 15 January 2015 at 12:10:09 UTC, Rikki Cattermole wrote:
 On 16/01/2015 12:16 a.m., anonymous wrote:
 what's the right syntax for building a JSON tree ? I try to do like in
 an AA but the program throw because the Key doesn't exist:

 ---
 import std.stdio, std.json;

 void main(string[] args)
 {
     struct Foo{
         string a,  b;
         void writeToJson(ref JSONValue target) {
             target["a"] = JSONValue(a);
             target["b"] = JSONValue(b);
         }
     }

     JSONValue root = parseJSON("{}");
     root["items"] = JSONValue([""]);

     Foo*[] foos;
     foos ~= new Foo("a1","b1");
     foos ~= new Foo("a2","b2");

     foreach(foo; foos) {
         root["items"].array.length += 1;
         root["items"].array[$-1] = parseJSON("{}");
         foo.writeToJson(root["items"].array[$-1]);
     }
 }
 ---

 import std.stdio, std.json;

 void main(string[] args)
 {
     struct Foo{
         string a,  b;
         void writeToJson(ref JSONValue target) {
             target["a"] = JSONValue(a);
             target["b"] = JSONValue(b);
         }
     }

     JSONValue root = ["items": cast(string[])[]];

     Foo[] foos;
     foos ~= Foo("a1","b1");
     foos ~= Foo("a2","b2");

     foreach(foo; foos) {
         root["items"].array ~= JSONValue(foo.a);
         root["items"].array ~= JSONValue(foo.b);
     }

     writeln(root.toString());
 }

 I would recommend keeping away from std.json. Its an old piece of
 code, that needs to be replaced.
 Vibe.d has a much nicer implementation that is really decent. I would
 recommend that, if you are up to using the build manager dub.

 Thx, but actually I initially liked to get an array of object with each
 identifier:

 currently it produces:

 {"items":["a1","b1","a2","b2"]}

 while it'd be more desirable to have

 {"items":[{"a":"a1","b":"b1"}, {"a":"a2","b":"b2"}]}

 because the reader will test the presence of each the key "a" and "b" in
 each element of "items".

 Would it be a complete non-sense to assign an element with
 opIndexAssign(), just like I wrote initially ? I know this is wrong but
 the syntax seemed natural and logic.
 Reading from std.json is straightforward but writing looks a bit messy.

It makes sense to do it. But like I said std.json is rubbish.
Just so you can see why I'm saying vibe.d's json implementation is 
better[0].

[0] 
https://github.com/rejectedsoftware/vibe.d/blob/master/source/vibe/data/json.d#L1670

Jan 15 2015

"Colin" <grogan.colin gmail.com> writes:

On Thursday, 15 January 2015 at 12:50:59 UTC, Rikki Cattermole 
wrote:
 On 16/01/2015 1:37 a.m., anonymous wrote:
 On Thursday, 15 January 2015 at 12:10:09 UTC, Rikki Cattermole 
 wrote:
 On 16/01/2015 12:16 a.m., anonymous wrote:
 what's the right syntax for building a JSON tree ? I try to 
 do like in
 an AA but the program throw because the Key doesn't exist:

 ---
 import std.stdio, std.json;

 void main(string[] args)
 {
    struct Foo{
        string a,  b;
        void writeToJson(ref JSONValue target) {
            target["a"] = JSONValue(a);
            target["b"] = JSONValue(b);
        }
    }

    JSONValue root = parseJSON("{}");
    root["items"] = JSONValue([""]);

    Foo*[] foos;
    foos ~= new Foo("a1","b1");
    foos ~= new Foo("a2","b2");

    foreach(foo; foos) {
        root["items"].array.length += 1;
        root["items"].array[$-1] = parseJSON("{}");
        foo.writeToJson(root["items"].array[$-1]);
    }
 }
 ---

 import std.stdio, std.json;

 void main(string[] args)
 {
    struct Foo{
        string a,  b;
        void writeToJson(ref JSONValue target) {
            target["a"] = JSONValue(a);
            target["b"] = JSONValue(b);
        }
    }

    JSONValue root = ["items": cast(string[])[]];

    Foo[] foos;
    foos ~= Foo("a1","b1");
    foos ~= Foo("a2","b2");

    foreach(foo; foos) {
        root["items"].array ~= JSONValue(foo.a);
        root["items"].array ~= JSONValue(foo.b);
    }

    writeln(root.toString());
 }

 I would recommend keeping away from std.json. Its an old 
 piece of
 code, that needs to be replaced.
 Vibe.d has a much nicer implementation that is really decent. 
 I would
 recommend that, if you are up to using the build manager dub.

 Thx, but actually I initially liked to get an array of object 
 with each
 identifier:

 currently it produces:

 {"items":["a1","b1","a2","b2"]}

 while it'd be more desirable to have

 {"items":[{"a":"a1","b":"b1"}, {"a":"a2","b":"b2"}]}

 because the reader will test the presence of each the key "a" 
 and "b" in
 each element of "items".

 Would it be a complete non-sense to assign an element with
 opIndexAssign(), just like I wrote initially ? I know this is 
 wrong but
 the syntax seemed natural and logic.
 Reading from std.json is straightforward but writing looks a 
 bit messy.

 It makes sense to do it. But like I said std.json is rubbish.
 Just so you can see why I'm saying vibe.d's json implementation 
 is better[0].

 [0] 
 https://github.com/rejectedsoftware/vibe.d/blob/master/source/vibe/data/json.d#L1670

Also, look at the new std.json candidate:
http://code.dlang.org/packages/std_data_json

Jan 15 2015

D Programming

C/C++ Programming

Other

digitalmars.D.learn - building a simple json tree