it's basically a type that let you return either a "value" or an "error" and the caller of the function has to check which did the function return. it's a modern way of handling errors in C++ that was introduced in C++23
because "if constexpr(...)" is a c++17 feature which i'm using it to allow usage of nl::unexpected() to return a nl::expected<nl::monostate, E> to nl::expected<T, E> in this copy constructor
cpp
template<class U>
expected(const expected<U, E>& other) : _has_value(other.has_value()) // a copy constructor
{
if (_has_value)
{
if constexpr (std::is_same<U, monostate>::value) // it checks if U == monostate
{
// makes an empty instance of "T"
}
else if constexpr (std::is_same<U, T>::value) // it checks if U == T
{
// otherwise copies "other._value" into _value
}
else
{
static_assert(
not std::is_same<U, T>::value, "no available conversion between the provided value types");
}
}
else
{
new (std::addressof(_error)) E(other.error());
}
}
template<class E>
expected<monostate, E> unexpected(const E& e) // then this can covert <monostate, E> to <T, E> fine because of this copy constructor
{
return expected<monostate, E>(e);
}
// example usage
nl::expected<int, std::string> meow = nl::unexpected("error");
but i could take a different approach and make 2 copy constructor one that explicitly takes
cpp
expected(const expected<monostate, E>& other)
and another
cpp
expected(const expected& other)
I was also using "std::is_same_v" which is a c++17 feature instead "std::is_same<>::value" but i made a commit and changed it. it now compiles with c++14 but with c++17 extensions
ljson::node n = {
{"name", "Alice"},
{"age", 30},
{"active", true},
{"tags", ljson::node({"dev", "cat_lover"})},
{"profile", ljson::node({{"city", "Paris"}, {"zip", 75000}})}
};
// n is now a JSON object with nested objects and arrays!
Type-Safe Value Accessors and Type Queries
cpp
if (n.at("age").is_integer())
std::cout << "Age: " << n.at("age").as_integer() << "\n";
if (n.at("tags").is_array()) {
for (auto& tag : *n.at("tags").as_array())
std::cout << tag.as_string() << " ";
}
Type-Safe Mutation and Assignment
cpp
n.at("name") = "Bob"; // changes value to "Bob"
n.at("age") = 31; // changes value to 31
n.at("active") = false; // changes value to false
n.at("tags").push_back("gamer"); // add "gamer" to tags array
Exception-Free Parsing (Error Handling Without throw)
cpp
auto result = ljson::parser::try_parse(R"({"x":1})");
if (result) {
std::cout << "Parsed!\n";
} else {
std::cerr << "Parse error: " << result.error().message() << "\n";
}
Pretty Printing and File Output with Custom Indentation
cpp
n.dump_to_stdout({'\t', 2}); // Pretty print using tabs, 2 per indent
n.write_to_file("output.json"); // Write to file
std::string s = n.dump_to_string(); // Get pretty JSON string
Operator Overloading for JSON Merge and Addition
Concatenate arrays and objects in a natural way:
cpp
ljson::node a = {1, 2, 3};
ljson::node b = {4, 5};
ljson::node c = a + b; // [1,2,3,4,5]
ljson::node obj1 = {{"x", 1}};
ljson::node obj2 = {{"y", 2}};
ljson::node obj3 = obj1 + obj2; // {"x":1,"y":2}
thank you! if someone wants a more modern API that's kinda similar to tomlplusplus and a little nicer to use with modern error handling then my library might come in handy. my API is inspired a lot by tomlplusplus . i was trying to make a build system that uses TOML as a config file and I needed a json library so i decided to make my own as a learning experience which was great.
I'm not familiar with simdjson, but i know a little about nlohmann and I think the exception free path using ljson::expected is a nicer/safer approach. also there is convenient operator overloads in my library to add objects/array together, but nlohmann also has that i think
cpp
// accessing values in ljson
ljson::node node = ljson::parser::parse(raw_json);
std::string val = node.at("key").as_string();
// accessing values in nlohmann
nlohmann::json::json json;
raw_json >> json;
std::string val = json["key"].get<std::string>();
I searched for a River socket or riverctl command that would allow me to get the active workspace number, but i couldn't find a way for that currently in River. so i can't implement it for River not currently at least. unless maybe someone knows a way to get that info who could refer me to the documentation
thanks! kinda, but i'm using hyprland and the foot terminal. You can control the inactive opacity on hyprland, and control foot's alpha channel, which can make it transparent
