How can I detect that an input stream contains an incomplete json

[jpgaribotti]

I've seen some questions with similar cases, and tried to go through the documentation, but couldn't quite find a clean solution.

My issue is I have a stream, which could contain several json objects. I am waiting for data to come in, and each time a chunk is received I try to parse it. When I find a json object, I remove it from the stream and move on to the next. There are two failure cases I care about:

1: if there's something that's not valid json, I should discard the stream. I expect this to not happen but I can't trust the stream to not be corrupted at some point.

2: if a chunk only contains part of a json, I need to wait for the next chunk (or several) to be able to complete parsing. In this case, I can ignore the error and try again later.

I've seen it suggested to use accept() to check, but that would treat both the above cases the same. There could be a situation where some broken json is sent, and the program just keeps waiting for more and more chunks to arrive even though the parse will never succeed.

The parse exception distinguishes between these two cases, reporting "unexpected end of input" for case 2, which is what I need. My current approach is to catch the exception and search the what() string for the error:

std::stringstream ss{ std::string{buffer.begin(), buffer.end()} };
nlohmann::json json;
auto consumed = std::size_t{};
try {
  while (ss >> json) {
    consumed = ss.tellg();
    doSomehting( json );
  }
} catch (const nlohmann::json::parse_error& e) {
  if ( !std::strstr(e.what(), "unexpected end of input") ) {
    throw;
  }
}
buffer.erase(buffer.begin(), buffer.begin() + consumed);

This works, but I'm not a fan of "stringly typed" values. I'd rather have an actual sub-error value to check, seeing as all the logic to distinguish the error cases is already in place. Is there a way to get this other than parsing the error string?

[nlohmann]

You could check the id member of the parse_error exception to be 110 which is the code for general parse errors including the "unexpected end of input". Then you could also check the byte member which indicates the error position. This should point to the last byte of the input in case of an "unexpected end of input" error.

[jpgaribotti]

Odd, I recall trying to use the byte character and it showing up close to the start, but I must be misremembering. The following change to the condition behaves like I wanted:

if (e.id != 101 || e.byte != buffer.size() - consumed + 1) throw;

Thanks.