void set_user_action_text(const object &object_, int action_index_, std::variant<const std::string, const rv_text> text_menu_, std::variant<const std::string, const rv_text> text_window_background_, std::variant<const std::string, const rv_text> text_window_foreground_) {
auto_array<game_value> params_right({
action_index_
});
if (text_menu_.index() == 0) {
params_right.push_back(std::get<0>(text_menu_));
}
else {
params_right.push_back(std::get<1>(text_menu_));
}
if (text_window_background_.index() == 0) {
params_right.push_back(std::get<0>(text_window_background_));
}
else {
params_right.push_back(std::get<1>(text_window_background_));
}
if (text_window_foreground_.index() == 0) {
params_right.push_back(std::get<0>(text_window_foreground_));
}
else {
params_right.push_back(std::get<1>(text_window_foreground_));
}
host::functions.invoke_raw_binary(__sqf::binary__setuseractiontext__object__array__ret__nothing, object_, std::move(params_right));
}
void test_ctor_basic() {
{
constexpr std::variant<InitList, InitListArg> v(
std::in_place_type<InitList>, {1, 2, 3});
static_assert(v.index() == 0, "");
static_assert(std::get<0>(v).size == 3, "");
}
{
constexpr std::variant<InitList, InitListArg> v(
std::in_place_type<InitListArg>, {1, 2, 3, 4}, 42);
static_assert(v.index() == 1, "");
static_assert(std::get<1>(v).size == 4, "");
static_assert(std::get<1>(v).value == 42, "");
}
}
game_value remote_exec(const game_value ¶ms_, sqf_string_const_ref function_, std::variant<int, object, sqf_string_const_ref_wrapper, side, group, std::reference_wrapper<const std::vector<game_value>>> targets_, std::optional<std::variant<sqf_string_const_ref_wrapper, bool, object, group>> jip_) {
game_value targets;
game_value jip;
switch (targets_.index()) {
case 0: targets = static_cast<float>(std::get<int>(targets_)); break;
case 1: targets = std::get<object>(targets_); break;
case 2: targets = std::get<2>(targets_).get(); break;
case 3: targets = std::get<side>(targets_); break;
case 4: targets = std::get<group>(targets_); break;
case 5: targets = std::move(auto_array<game_value>({ std::get<5>(targets_).get().begin(), std::get<5>(targets_).get().end() })); break;
}
if (jip_.has_value()) {
switch ((*jip_).index()) {
case 0: jip = std::get<0>(*jip_).get(); break;
case 1: jip = std::get<bool>(*jip_); break;
case 2: jip = std::get<object>(*jip_); break;
case 3: jip = std::get<group>(*jip_); break;
}
}
game_value params_right = game_value({
function_,
targets,
jip
});
return host::functions.invoke_raw_binary(__sqf::binary__remoteexec__any__array__ret__any, params_, params_right);
}
constexpr bool test_constexpr_copy_ctor_extension_imp(
std::variant<long, void*, const int> const& v)
{
auto v2 = v;
return v2.index() == v.index() &&
v2.index() == Idx &&
std::get<Idx>(v2) == std::get<Idx>(v);
}
game_value remote_exec_call(sqf_string_const_ref function_name_, std::variant<int, object, side, group, sqf_string_const_ref_wrapper> target_, sqf_string_const_ref jip_id_) {
auto_array<game_value> params({ function_name_ });
switch (target_.index()) {
case 0: params.push_back(std::get<0>(target_)); break;
case 1: params.push_back(std::get<1>(target_)); break;
case 2: params.push_back(std::get<2>(target_)); break;
case 3: params.push_back(std::get<3>(target_)); break;
case 4: params.push_back(std::get<4>(target_).get()); break;
}
params.push_back(jip_id_);
return host::functions.invoke_raw_unary(__sqf::unary__remoteexeccall__array__ret__any, std::move(params));
}
void test_ctor_basic() {
{
constexpr std::variant<int> v(std::in_place_index<0>, 42);
static_assert(v.index() == 0, "");
static_assert(std::get<0>(v) == 42, "");
}
{
constexpr std::variant<int, long, long> v(std::in_place_index<1>, 42);
static_assert(v.index() == 1, "");
static_assert(std::get<1>(v) == 42, "");
}
{
constexpr std::variant<int, const int, long> v(std::in_place_index<1>, 42);
static_assert(v.index() == 1, "");
static_assert(std::get<1>(v) == 42, "");
}
{
using V = std::variant<const int, volatile int, int>;
int x = 42;
V v(std::in_place_index<0>, x);
assert(v.index() == 0);
assert(std::get<0>(v) == x);
}
{
using V = std::variant<const int, volatile int, int>;
int x = 42;
V v(std::in_place_index<1>, x);
assert(v.index() == 1);
assert(std::get<1>(v) == x);
}
{
using V = std::variant<const int, volatile int, int>;
int x = 42;
V v(std::in_place_index<2>, x);
assert(v.index() == 2);
assert(std::get<2>(v) == x);
}
}
void test_copy_ctor_basic() {
{
std::variant<int> v(std::in_place_index<0>, 42);
std::variant<int> v2 = v;
assert(v2.index() == 0);
assert(std::get<0>(v2) == 42);
}
{
std::variant<int, long> v(std::in_place_index<1>, 42);
std::variant<int, long> v2 = v;
assert(v2.index() == 1);
assert(std::get<1>(v2) == 42);
}
{
std::variant<NonT> v(std::in_place_index<0>, 42);
assert(v.index() == 0);
std::variant<NonT> v2(v);
assert(v2.index() == 0);
assert(std::get<0>(v2).value == 42);
}
{
std::variant<int, NonT> v(std::in_place_index<1>, 42);
assert(v.index() == 1);
std::variant<int, NonT> v2(v);
assert(v2.index() == 1);
assert(std::get<1>(v2).value == 42);
}
// The following tests are for not-yet-standardized behavior (P0602):
{
constexpr std::variant<int> v(std::in_place_index<0>, 42);
static_assert(v.index() == 0, "");
constexpr std::variant<int> v2 = v;
static_assert(v2.index() == 0, "");
static_assert(std::get<0>(v2) == 42, "");
}
{
constexpr std::variant<int, long> v(std::in_place_index<1>, 42);
static_assert(v.index() == 1, "");
constexpr std::variant<int, long> v2 = v;
static_assert(v2.index() == 1, "");
static_assert(std::get<1>(v2) == 42, "");
}
{
constexpr std::variant<TCopy> v(std::in_place_index<0>, 42);
static_assert(v.index() == 0, "");
constexpr std::variant<TCopy> v2(v);
static_assert(v2.index() == 0, "");
static_assert(std::get<0>(v2).value == 42, "");
}
{
constexpr std::variant<int, TCopy> v(std::in_place_index<1>, 42);
static_assert(v.index() == 1, "");
constexpr std::variant<int, TCopy> v2(v);
static_assert(v2.index() == 1, "");
static_assert(std::get<1>(v2).value == 42, "");
}
{
constexpr std::variant<TCopyNTMove> v(std::in_place_index<0>, 42);
static_assert(v.index() == 0, "");
constexpr std::variant<TCopyNTMove> v2(v);
static_assert(v2.index() == 0, "");
static_assert(std::get<0>(v2).value == 42, "");
}
{
constexpr std::variant<int, TCopyNTMove> v(std::in_place_index<1>, 42);
static_assert(v.index() == 1, "");
constexpr std::variant<int, TCopyNTMove> v2(v);
static_assert(v2.index() == 1, "");
static_assert(std::get<1>(v2).value == 42, "");
}
}