property_tree | Boost.org property_tree module | SDK library

You can't. Boost Property Tree, unsurprisingly, is not an XML library. It's a property tree library.

To write XML, consider using an XML library: What XML parser should I use in C++?

Then again, there is potentially a hack using undocumented interface: removing encoding attribute from xml using boost

That way you effectively bypass the document writing code and you can substitute it with your own hack.

You need to "escape" the dot. Dots are special, so your key is interpreted as [Sensor][Offsets][x], not [Sensor.Offsets][x].

You can force it:

Please, do not use Property Tree as a JSON library.

Boost 1.75.0 added a JSON library though!

As the other commenter said, it's not very clear what exactly you require, so let me just sketch a few similar use-cases:

The newline is not explicitly mentioned in the JSON RFC-7159 but it is defined as part of the POSIX standard for a line.

Incase you're interested in where the newline comes from you can take a look at the write_json_internal source code, we can see that there is an stream << std::endl; near the end of the method. Note that ...::write_json references write_json_internal.

Don't use Property Tree as if it's a JSON library. It has well known limitations: https://www.boost.org/doc/libs/1_75_0/doc/html/property_tree/parsers.html#property_tree.parsers.json_parser

Note especially the limitationssurrounding arrays.

Next up, you didn't write an array to begin with, instead writing a string. But since it's binary data, it may be a valid JSON string, and this could be a source of error.

Also, you probably don't need to copy the whole JSON again to put it in a buffer. Instead, boost::asio::buffer(resultString) will work (as long as you make sure that the lifetime of resultString is enough, like with buffer_).

Just testing a little does suggest that characters are being escaped correctly by write_json:

Live On Compiler Explorer

Every iteration of your for loop adds to the parentKey value so it will have all the children's names in it by the end of the loop. Use a separate variable to hold the key name for each node:

Depends on the actual usage context, but if you are familiar with the singleton pattern, this might be a way to go here in doubt if you are not able to forward the configuration information by design in a quite non-intrusive way (the latter should almost always be the preferred way but I know there are sometimes exceptional situations in reality). The context of the singleton needn't to be totally global in doubt since you can use a global singleton to ensure more "context-sensitive" branching if required.

But as mentioned: Try to solve this by design if the context of this configuration isn't that global in doubt. Provide a possibly quite central handler class (as sharedPtr for instance) that offers the configuration data on request. Then, solely the used objects' constructors require that one as a parameter.

No you cannot change this behavior, as the string value type is pretty muched baked into boost::property_tree. While you could technically use different template type parameters than the default ones, you loose much of the conversion logic that went into that library.

As a somewhat wanky alternative, consider the following.

The Standard library has no platform independent way to detect if a locale is UTF-8. There's only a name method which returns a platform dependent name. Even if it is a POSIX name there's no guarantee that the encoding is part of the locale's name.

Boost.Locale offers an additional facet called boost::locale::info holding detailed information about the current locale. https://www.boost.org/doc/libs/1_70_0/libs/locale/doc/html/locale_information.html

You can obtain the info like this: