This has been a "known" issue for some time, but as mentioned in #672, the JSONArray.iterator method is exposing the raw values from the backing array instead of JSON-compliant values.
We should do 1 of 2 things:
- Implement a private/internal
JSONArrayIterator class that would ensure any fetched values are properly "wrapped" and thus suitable output to JSON processors.
- Update all of our
put* operations to ensure that all values are properly "wrapped" in both JSONObject and JSONArray. This would also allow us to simplify our toString methods and remove the wrapping from there as all values should be proper JSON.
Option 1 keeps the wrapping "lazy" and thus would only guarantee JSON compliance on values that are fetched. Fetching a non-wrapped value multiple times would cause wrapping to happen each time.
Option 2 makes the wrapping more proactive; guaranteeing that our JSON compliance happens up-front even if the value is not fetched later. Fetching an initially non-wrapped value multiple times would cause NO wrapping to happen at fetch as it would have been pre-wrapped by the put operation.
Both options only affect code-built JSONObjects/Arrays. Parsed objects would be unaffected as the parser is only placing JSON-compliant values in the backing collections.
Thoughts on whether we should implement either option, something else, or neither?
This has been a "known" issue for some time, but as mentioned in #672, the
JSONArray.iteratormethod is exposing the raw values from the backing array instead of JSON-compliant values.We should do 1 of 2 things:
JSONArrayIteratorclass that would ensure any fetched values are properly "wrapped" and thus suitable output to JSON processors.put*operations to ensure that all values are properly "wrapped" in bothJSONObjectandJSONArray. This would also allow us to simplify ourtoStringmethods and remove the wrapping from there as all values should be proper JSON.Option 1 keeps the wrapping "lazy" and thus would only guarantee JSON compliance on values that are fetched. Fetching a non-wrapped value multiple times would cause wrapping to happen each time.
Option 2 makes the wrapping more proactive; guaranteeing that our JSON compliance happens up-front even if the value is not fetched later. Fetching an initially non-wrapped value multiple times would cause NO wrapping to happen at fetch as it would have been pre-wrapped by the
putoperation.Both options only affect code-built JSONObjects/Arrays. Parsed objects would be unaffected as the parser is only placing JSON-compliant values in the backing collections.
Thoughts on whether we should implement either option, something else, or neither?