Default value of std::optional

[AnsiV01]

Hi

Having sample data to connect to the database, which have default values, I wanted to be able to override, some of them. For example:

struct in c++:

struct DatabaseAccessData
{
	std::optional<std::string> login{ "admin" };
	std::optional<std::string> password{ "admin" };

	std::optional<std::string> ip{ "127.0.0.1" };
	std::optional<std::string> database{ "test" };
	std::optional<unsigned short> port{ 3306 };
};

Json file:

{
	"ip": "192.168.4.1",
	"database": "beta",
	"port": 33061
}

And now I read the data from the JSON file:

DatabaseAccessData database{};
rfl::Result<DatabaseAccessData> res = rfl::json::load<DatabaseAccessData>("database.json");

if (res.error())
{
	std::cout << "Parsing Error: " << res.error()->what() << std::endl;
	return false;
}

database = *res; //<--  it's all his fault

std::cout
	<< "Login: " << (database.login ? *database.login : std::string{ "[Empty]" }) << "\n"
	<< "Password: " << (database.password ? *database.password : std::string{ "[Empty]" }) << "\n"
	<< "IP: " << (database.ip ? *database.ip : std::string{ "[Empty]" }) << "\n"
	<< "Database: " << (database.database ? *database.database : std::string{ "[Empty]" }) << "\n"
	<< "Port: " << *database.port << "\n";

and after displaying it, I find that I have lost the login and password values:

Login: [Empty]
Password: [Empty]
IP: 192.168.4.1
Database: beta
Port: 33061

Is there any other way to achieve my goal?

I also thought about using rfl::to_view, but the problem would be when there are other structures that contain other structures in the structure.

I think it would be nice to be able to do something like this

DatabaseAccessData database{};
std::optional<rfl::Error> err = rfl::json::load<DatabaseAccessData>("database.json", database);

if (err)
{
	std::cout << "Parsing Error: " << err->what() << std::endl;
	return false;
}

where as an argument of the load function we can add our instance of the structure.

Have a nice day

[liuzicheng1987]

@AnsiV01 , yes, I thought about this, because this how these things work in Pydantic and you are not the first one to raise this issue.

Unfortunately, it is not easy to do in C++ and I haven't thought of an elegant solution yet.

I think what you can always do is to create getters, like this:

struct DatabaseAccessData
{
	std::optional<std::string> login{ "admin" };
	std::optional<std::string> password{ "admin" };

	std::optional<std::string> ip{ "127.0.0.1" };
	std::optional<std::string> database{ "test" };
	std::optional<unsigned short> port{ 3306 };

       const auto& get_login() const { return login.value_or("admin"); }
       
       const auto& get_password() const { return password.value_or("admin"); }
};

But I do recognize that this isn't as beautiful as what you have mind.

[pwqbot]

I also need this feature as it’s really useful when reading YAML/JSON config files. Perhaps an rfl::Optional<T> could work—it’s an optional field that comes with a default value and can be seamlessly to/from T, like int x = rfl::Optional<int>{5}. This way, we can use it directly without needing to call .value to access its value, since it always has one.

[liuzicheng1987]

@AnsiV01 @pwqbot I have been thinking about this and here is what we could do:

struct DatabaseAccessData
{
	rfl::Default<std::string> login = "admin";
	rfl::Default<std::string> password = "admin";

	rfl::Default<std::string> ip = "127.0.0.1";
	rfl::Default<std::string> database = "test";
	rfl::Default<unsigned short> port = 3306;
};

Now, when you read in a JSON or YAML and the field is missing, it will just take the default value.

You can access fields like this:

my_struct.login(); // returns reference to std::string

What are your thoughts?

[AnsiV01]

@liuzicheng1987 For me it looks like a good compromise

[liuzicheng1987]

@AnsiV01 Another possibility that was suggested in #167 would be to treat this as a preprocessor:

struct DatabaseAccessData
{
	std::string login = "admin";
	std::string password = "admin";

	std::string ip = "127.0.0.1";
	std::string database = "test";
	unsigned short port = 3306;
};

rfl::read<DatabaseAccessData, rfl::DefaultIfMissing>(...);

If you then read in a JSON string like this:

{"database": "mydb"}

It would use mydb as the database and the default values for everything else. If you do not pass an explicit default value, it would use the default value of the type (T()). It is a less flexible solution, but also less invasive and more convenient.

[AnsiV01]

@liuzicheng1987 This looks even better. Of course, every solution has its pros and cons, but if at this point C++ doesn't allow us to do something else, it's acceptable

[AnsiV01]

@liuzicheng1987 I came up with the idea of a helper function that could to some extent solve such a problem with the default value of std::optional:

{
	"ip": "192.168.4.1",
	"database": "beta",
	"port": 33061
}

namespace ecpp
{
	template <auto Start, auto End, class F>
	constexpr void constexpr_for(F&& f)
	{
		if constexpr (Start < End)
		{
			f(std::integral_constant<decltype(Start), Start>());
			constexpr_for<Start + 1, End>(f);
		}
	}
}


template<typename>   constexpr bool is_optional_impl = false;
template<typename T> constexpr bool is_optional_impl<std::optional<T>> = true;

template<typename T>
constexpr bool is_optional = is_optional_impl<std::remove_cvref_t<T>>;

struct DatabaseAccessData
{
	std::optional<std::string> login{ "admin" };
	std::optional<std::string> password{ "admin" };

	std::optional<std::string> ip{ "127.0.0.1" };
	std::optional<std::string> database{ "test" };
	std::optional<unsigned short> port{ 3306 };
};

template<class T>
void SomeMagicFunc(const T& from, T& to)
{
	const auto view_from = rfl::to_view(from);
	const auto view_to = rfl::to_view(to);

	ecpp::constexpr_for<0, view_from.size()>([&](auto i) {
		auto& field_from = *view_from.get<i>();
		auto& field_to = *view_to.get<i>();

		using field_type = std::remove_reference_t<decltype(field_from)>;
		if constexpr (is_optional<field_type>)
		{
			if (field_from.has_value())
				field_to = field_from;
		}
		else
		{
			field_to = field_from;
		}
	});
}

int main() {
	DatabaseAccessData database{};
	rfl::Result<DatabaseAccessData> res = rfl::json::load<DatabaseAccessData>("database.json");

	if (res.error())
	{
		std::cout << "Parsing Error: " << res.error()->what() << std::endl;
		return false;
	}

	//database = *res;
	SomeMagicFunc(*res, database);

	std::cout
		<< "Login: " << (database.login ? *database.login : std::string{ "[Empty]" }) << "\n"
		<< "Password: " << (database.password ? *database.password : std::string{ "[Empty]" }) << "\n"
		<< "IP: " << (database.ip ? *database.ip : std::string{ "[Empty]" }) << "\n"
		<< "Database: " << (database.database ? *database.database : std::string{ "[Empty]" }) << "\n"
		<< "Port: " << *database.port << "\n";

	return 0;
}

Thanks to which, using the example from above, the result is what I expected. Of course, other data types would have to be taken into account, but I was mainly concerned with the outline of the function. What do you think?

[liuzicheng1987]

Yeah, this is pretty much what the preprocessor would do. Only it wouldn't create two objects, it would simply create the object with the default values and then fill the fields using the input data.

I think I can implement it over the next couple of days...I've been a bit busy lately, because I have moved into a new apartment, but now the worst is behind me.

[liuzicheng1987]

All right, here is the first draft and a simple test that shows how this works:

https://github.com/getml/reflect-cpp/blob/f/default_values/tests/json/test_default_if_missing.cpp

Let me know what your thoughts are.

[pwqbot]

All right, here is the first draft and a simple test that shows how this works:

f/default_values/tests/json/test_default_if_missing.cpp

Let me know what your thoughts are.

It looks great, thank you!

[AnsiV01]

I agree. It works superbly. Thanks boss 🗿

[pwqbot]

@liuzicheng1987
Sorry, I just noticed that in this solution, if a field without a default value is not provided, it won't trigger an error. Is it possible to make it throw an error in such cases?
The ideal case may be:

struct A {
   int a;        // error if not provided
   int b = 5;    // default if not provided
   std::optional<int> c;  // std::nullopt if not provided
}