This is a kind of follow-up question to #2223 .

It is doesn't make sense to do value.get_string().value() repeatedly in a single loop. However considering the following use case

• A simdjson object is created from an string input
• Now I have multiple json paths that is willing to extract from the JSON object, these json paths can be duplicated, (e.g. ["$.key1", "$.key1"]) or they have overlapping with each other, e.g. ["$.key1.key2", "$.key1.key0", "$.key3", "$key3.key4"]
  It will be inevitably to go through the simdjson object repeatedly. And due to the underlying buffer held by the parser, every time a json path item is processed, the underlying buffer will be advanced, and it would be chances to overflow without even notice.

So what's the sugested way to do this?

What I can think of, there will be two approaches

• Option 1: redo the parsing to generate the doc again before processing every json path, the simdjson object will be refresh new and the underlying buffer pointer will be rewound to the beginning.
• Option 2: provide buffer-overflow-safe interface, e.g. field.unescaped_key(char *buffer), value.get_string(char * buffer), allow the caller to provide the buffer to use for the returned string_view, so the interfaces will be independent to the underlying string buffer.

B.T.W. the interface simdjson_inline simdjson_warn_unused error_code field::unescaped_key(string_type& receiver, bool allow_replacement) added in PR #2224 is risky and error-prone.

When the caller is running with the code snippet,

std::string key;
field.unescaped_key(key);

It looks like the unescaped_key is stored directly into the std::string, BUT actually the underlying string buffer will be forwarded even an std::string is provided.

it is identical to the following code.

std::string_view key_view = field.unescaped_key();
std::string key(key_view);