deep copy options for glz::obj type

[GJanos]

Dear @stephenberry !

I made a post about this earlier, but this deserves its separate discussion.

I completed a small demo code that explains one of my problems. When I run this, instead of incrementing numbers getting printed, I only get 10 10 times.

#include <vector>
#include <glaze/glaze.hpp>
#include <fmt/core.h>

int main() {
    int cnt = 0;
    glz::obj o{"count", cnt};
    std::vector<decltype(o)> vec;
    for (cnt = 0; cnt < 10; ++cnt) {
        vec.emplace_back(glz::obj{"cnt", cnt});
    }
    for( const auto& i: vec ) {
        fmt::print("count value:{}\n", glz::tuplet::get<1>(i.value));
    }
}

Log output: 10 pieces of 10. No incrementing numbers, because of the glz::obj taking the cnt value as a const int&.

This problem could be handles with casting the cnt value as type, so it does not taken by reference. But I think that is not the most elegant way to solve this issue.

size_t cnt = 0;
glz::obj o{"count", size_t{cnt}};
std::vector<std::decay_t<decltype(o)>> vec;
for (; cnt < 10; ++cnt) {
   vec.emplace_back(glz::obj{"count", size_t{cnt}});
}
for (size_t i = 0; i < vec.size(); ++i) {
   expect(i == glz::tuplet::get<1>(vec[i].value));
}

Glz::obj taking references indeed improve performance, but sometimes occasional deep-copies are needed. Especially when a glz::obj would want to be logged, so it would get copied and the copy would be put to a backend threads spnc queue for later work. But because of a shallow-copy getting made, the values of the object inside of the queue would get corrupted.

For this reason it would be an awesome feature to be able to customize the glz::obj and maybe even your own types (but currently glz::obj is the priority) whether you want them shallow or deep-copied.

Glaze already supports something like:

glz::write<glz::opts{.prettify = true}>(obj, buffer);
So, applying this to glz::obj would be something like:
glz::obj<glz::opts{.deep_copy = true}> object {...}

This would make the systax a lot nicer.

Basically I would need a way to deep copy glz::obj on the stack. Not with moving the data or references.

Thank you for your time!

[stephenberry]

@GJanos
If we just want the entire object to use copies (behave like std::tuple), then I think it might be best to simply create another type, such as glz::obj_copy. So, you would just write: glz::obj_copy object{...};
It's less typing than requiring template options and I think does the job. Would this work for you?

[GJanos]

Yes, thank you for listening to my request. That will be a good solution.

[stephenberry]

@GJanos
glz::obj_copy and glz::arr_copy have been merged with #357. Let me know if you need additional support in this regard.