simplify parser

[vinniefalco]

we dont need all the extra overloads of finish(), we can just make write work like finish and the user can deal with the error if they want to continue processing the extra data.

[viccpp]

Don't think it is a simplification. User will need to keep an addition state - the last write result.

[viccpp]

Off topic:
Why write()? parse() would be more logical for me. Parser is for reading. write() is appropriate for serializer (output)

[vinniefalco]

User will need to keep an addition state - the last write result

Users have to observe that anyway, since they need to check the error code. 99% of users don't care about processing additional data which lies past the JSON, so this is certainly a simplification. We still get the same features but with fewer functions. Having the proliferation of functions was confusing.

To be clear consider this input string: "[ 1, 2, 3 ] #abc"

There is a JSON followed by something that isn't a JSON. The parser can handle this, it will simply return 12 indicating that 12 characters were consumed, and the error will be set to error::extra_data. Almost all users will want to consider this an error, since the input string is not valid JSON. The users which want to process the remaining string (the "#abc") as something other than JSON, can easily do so by checking for the error and then handling the remaining part of the buffer themselves.

[viccpp]

What about truncated input? Like:

"{ a: ...." // ok
" ... [ 1, 2" // ok
---EOF--- // ??? what we supposed to do here?

[vinniefalco]

I don't understand the question here.

"{ a: ..." is not valid JSON, the key needs to be a string (i.e. in double quotes).

If you can write out exactly what is in each buffer, that would be helpful. For example consider this json:

json::value jv = { 1, 2, 3 };

This produces an array which serializes to the string "[1,2,3]".

We can parse this in two buffers thusly:

json::parser p;
p.write( "[1," );
assert( ! p.is_complete() );
p.write( "2,3]" );
assert( p.is_complete() );

A number however, needs a call to finish:

json::parser p;
p.write( "1" );
assert( ! p.is_complete) );
p.write( "0" );
assert( ! p.is_complete) );
p.finish();
assert( p.is_complete() );
assert( number_cast<int>(p.release()) == 10 );

If the end of the buffer is indicated (from a call to finish) and the resulting JSON is incomplete, then an error is returned:

error_code ec;
json::parser p;
p.write( "[" );
p.finish( ec );
assert( ec ); // incomplete JSON

[viccpp]

... means some omitted part of valid JSON. OK, full example:

{ "a" : 1,

"b" : "abc"

--EOF--

How to correctly process this without finish() that you want to kill?

[vinniefalco]

How to correctly process this without finish() that you want to kill?

I only removed one overload of finish, the one which takes the buffer as a parameter. We still have finish with no parameters, which is necessary in your example above.

[viccpp]

Ah... Ok, undestand now.

we dont need finish()

sounded too radical for me :-)

[vinniefalco]

sounded too radical for me :-)

Heh, I should have been more clear. Note, that there were previously eight member functions (2 each of write_some, write, finish, and finish, one for errors and one for exceptions).

[vinniefalco]

This is done