Feature Request: constexpr glz::read_json and more

[orhosko]

I don't know whether is there a specific blocker to implement something like this. However, with C++26's #embed, I would like to be able to do something like this.

  struct Config {
      int foo{};
  };

  template <>
  struct glz::meta<Config> {
      using T = Config;
      static constexpr auto value = object("foo", &T::foo);
  };

    static constexpr char config_json[] = {
        #embed "config.json"
    };

    static constexpr Config conf;
    static constexpr auto error = glz::read_json(conf, config_json);

    static_assert(error.ec != glz::error_code::none);
    static_assert(conf->foo == 10);

[stephenberry]

I'm excited about #embed, but still waiting for the major compilers to all get robust support. I think GCC has the best support and Clang's is in progress (MSVC doesn't have it yet).

As for glz::read_json being constexpr, this will be more achievable with C++26 improvements (I'd want this to work with reflection). I'm thinking we're one to two years away from this being implemented cleanly. Definitely a long term goal and we're not too far away, but I think this would make the most sense once C++26 is decently supported.

[orhosko]

I'm excited about #embed, but still waiting for the major compilers to all get robust support. I think GCC has the best support and Clang's is in progress (MSVC doesn't have it yet).

It would be less ergonomic but still that can be used with string literals. And since it is backported to C++20 many linux only user can use it. Since it is not really about this issue, it doesn't matter i guess.

As for glz::read_json being constexpr, this will be more achievable with C++26 improvements (I'd want this to work with reflection).

I tried to compile a basic example with C++23, following compile errors and adding constexpr to required places. After refactoring some gotos, reinterpreted_casts, and memcpy/memchr; I get it working with gcc 15 (without #embed gcc 13 is also working). C++26 constexpr additions mostly about cmath and some algorithms, which I didn't came across in the refactoring.

I'm thinking we're one to two years away from this being implemented cleanly. Definitely a long term goal and we're not too far away, but I think this would make the most sense once C++26 is decently supported.

If my small test representative for the rest of the repo, which probably is not. With not trivial but manageable changes it seems to be possible for GCC 13(I believe it is the oldest supported gcc compiler at this time). What I am trying to say is this feature may be possible with GCC 13 and C++23. If that is the case I would like to help too.

[stephenberry]

Thanks for looking into this in such detail. I agree that a lot of this could be tackled now, but I'd like to be able to populate std::string in a constexpr constructed struct, and right now I think we'll find friction. Being able to handle strings in config is just really important. If you could explore what compilers can populate a struct of std::strings in a constexpr/consteval context, this would be helpful.

[orhosko]

AFAIU, there is currently no way to transfer compile time heap allocated data to runtime both in C++23 and C++26. However after some more tinkering this following is possible.

The trick is passing a known size object like array back and using string views pointing to constexpr json. This is the only way I found to don't allocate any memory in the heap. IMO, this is a understandable limitation and will not be solved in the languages side in a near future. Only problem I see is having 2 versions for memcpy/memchr with if consteval. It would hurt maintainability a little.

static constexpr char json[] = {
#embed "config.json"
   , '\0'
};

consteval auto validate_json() {
    std::vector<Config> configs{};
    return glz::read_json(configs, std::string_view{json});
}

static_assert(!validate_json(), glz::format_error(validate_json(), json)); // C++26 but added to earlier versions too

consteval std::size_t config_json_size() {
    std::vector<Config> configs{};
    glz::read_json(configs, std::string_view{json});
    return configs.size();
}

consteval auto get_config() {
    static constexpr auto buffer = std::string_view{json};
    static constexpr auto N = config_json_size();

    std::array<Config, N> configs {};
    glz::read_json(configs, buffer);
    return configs;
}

It will output the following if parsing fails:

../config.h: error: static assertion failed: 3:60: parse_number_failure
..., "port": "1234", ...
                  ^
   58 |     static_assert(!validate_json(), glz::format_error(validate_json(), json));
      |                   ^~~~~~~~~~~~~~~~