mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

refactor: replace tr_variant::is_*() with tr_variant::holds_alternative() (#5930)

This commit is contained in:
Charles Kerr 2023-08-21 16:16:54 -05:00 committed by GitHub
parent 5190db57d9
commit 59c638c63d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 182 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libtransmission/peer-msgs.cc
View File

@ -1030,7 +1030,7 @@ void parseLtepHandshake(tr_peerMsgsImpl* msgs, MessageReader& payload)
auto const handshake_sv = payload.to_string_view();
auto var = tr_variant_serde::benc().inplace().parse(handshake_sv);
if (!var || !tr_variantIsDict(&*var))
if (!var || !var->holds_alternative<tr_variant::Map>())
{
logtrace(msgs, "GET extended-handshake, couldn't get dictionary");
return;

4
libtransmission/resume.cc
View File

@ -528,13 +528,13 @@ auto loadProgress(tr_variant* dict, tr_torrent* tor)
tr_variant* const b = tr_variantListChild(l, fi);
auto time_checked = time_t{};
if (tr_variantIsInt(b))
if (b != nullptr && b->holds_alternative<int64_t>())
{
auto t = int64_t{};
tr_variantGetInt(b, &t);
time_checked = time_t(t);
}
else if (tr_variantIsList(b))
else if (b != nullptr && b->holds_alternative<tr_variant::Vector>())
{
auto offset = int64_t{};
tr_variantGetInt(tr_variantListChild(b, 0), &offset);

15
libtransmission/session.cc
View File

@ -485,7 +485,8 @@ bool tr_sessionLoadSettings(tr_variant* settings_in, char const* config_dir, cha
{
using namespace settings_helpers;
TR_ASSERT(tr_variantIsDict(settings_in));
TR_ASSERT(settings_in != nullptr);
TR_ASSERT(settings_in->holds_alternative<tr_variant::Map>());
// first, start with the libtransmission default settings
auto settings = tr_variant{};
@ -525,7 +526,8 @@ void tr_sessionSaveSettings(tr_session* session, char const* config_dir, tr_vari
{
using namespace bandwidth_group_helpers;
TR_ASSERT(tr_variantIsDict(client_settings));
TR_ASSERT(client_settings != nullptr);
TR_ASSERT(client_settings->holds_alternative<tr_variant::Map>());
tr_variant settings;
auto const filename = tr_pathbuf{ config_dir, "/settings.json"sv };
@ -570,7 +572,8 @@ tr_session* tr_sessionInit(char const* config_dir, bool message_queueing_enabled
{
using namespace bandwidth_group_helpers;
TR_ASSERT(tr_variantIsDict(client_settings));
TR_ASSERT(client_settings != nullptr);
TR_ASSERT(client_settings->holds_alternative<tr_variant::Map>());
tr_timeUpdate(time(nullptr));
@ -622,7 +625,8 @@ void tr_session::initImpl(init_data& data)
TR_ASSERT(am_in_session_thread());
auto* const client_settings = data.client_settings;
TR_ASSERT(tr_variantIsDict(client_settings));
TR_ASSERT(client_settings != nullptr);
TR_ASSERT(client_settings->holds_alternative<tr_variant::Map>());
tr_logAddTrace(fmt::format("tr_sessionInit: the session's top-level bandwidth object is {}", fmt::ptr(&top_bandwidth_)));
@ -658,7 +662,8 @@ void tr_session::initImpl(init_data& data)
void tr_session::setSettings(tr_variant* settings_dict, bool force)
{
TR_ASSERT(am_in_session_thread());
TR_ASSERT(tr_variantIsDict(settings_dict));
TR_ASSERT(settings_dict != nullptr);
TR_ASSERT(settings_dict->holds_alternative<tr_variant::Map>());
// load the session settings
auto new_settings = tr_session_settings{};

4
libtransmission/variant-benc.cc
View File

@ -247,11 +247,11 @@ private:
{
node = top_;
}
else if (auto* parent = stack_.back(); tr_variantIsList(parent))
else if (auto* parent = stack_.back(); parent != nullptr && parent->holds_alternative<tr_variant::Vector>())
{
node = tr_variantListAdd(parent);
}
else if (key_ && tr_variantIsDict(parent))
else if (key_ && parent != nullptr && parent->holds_alternative<tr_variant::Map>())
{
node = tr_variantDictAdd(parent, *key_);
key_.reset();

12
libtransmission/variant-json.cc
View File

@ -74,11 +74,11 @@ tr_variant* get_node(struct jsonsl_st* jsn)
{
node = data->top;
}
else if (tr_variantIsList(parent))
else if (parent->holds_alternative<tr_variant::Vector>())
{
node = tr_variantListAdd(parent);
}
else if (tr_variantIsDict(parent) && !std::empty(data->key))
else if (parent->holds_alternative<tr_variant::Map>() && !std::empty(data->key))
{
node = tr_variantDictAdd(parent, tr_quark_new(data->key));
data->key = ""sv;
@ -416,7 +416,7 @@ std::optional<tr_variant> tr_variant_serde::parse_json(std::string_view input)
if (error_ == nullptr)
{
return std::move(top);
return std::optional<tr_variant>{ std::move(top) };
}
return {};
@ -505,8 +505,8 @@ void jsonChildFunc(struct JsonWalk* data)
void jsonPushParent(struct JsonWalk* data, tr_variant const& v)
{
auto const is_dict = tr_variantIsDict(&v);
auto const is_list = tr_variantIsList(&v);
auto const is_dict = v.holds_alternative<tr_variant::Map>();
auto const is_list = v.holds_alternative<tr_variant::Vector>();
auto const n_children = is_dict ? v.val.l.count * 2U : v.val.l.count;
data->parents.push_back({ is_dict, is_list, 0, n_children });
}
@ -685,7 +685,7 @@ void jsonContainerEndFunc(tr_variant const& var, void* vdata)
jsonIndent(data);
if (tr_variantIsDict(&var))
if (var.holds_alternative<tr_variant::Map>())
{
data->out.push_back('}');
}

100
libtransmission/variant.cc
View File

@ -31,14 +31,14 @@ namespace
{
constexpr bool variant_is_container(tr_variant const* const var)
{
return tr_variantIsList(var) || tr_variantIsDict(var);
return var != nullptr && (var->holds_alternative<tr_variant::Vector>() || var->holds_alternative<tr_variant::Map>());
}
// ---
constexpr std::optional<size_t> dict_index_of(tr_variant const* const var, tr_quark const key)
{
if (!tr_variantIsDict(var))
if (var == nullptr || !var->holds_alternative<tr_variant::Map>())
{
return {};
}
@ -56,8 +56,9 @@ constexpr std::optional<size_t> dict_index_of(tr_variant const* const var, tr_qu
bool dictFindType(tr_variant* const var, tr_quark key, tr_variant::Type type, tr_variant** setme)
{
*setme = tr_variantDictFind(var, key);
return tr_variantIsType(*setme, type);
auto* const res = tr_variantDictFind(var, key);
*setme = res;
return res != nullptr && res->type == type;
}
tr_variant* containerReserve(tr_variant* var, size_t count)
@ -129,9 +130,12 @@ tr_variant* tr_variantDictFind(tr_variant* const var, tr_quark key)
tr_variant* tr_variantListChild(tr_variant* const var, size_t pos)
{
if (tr_variantIsList(var) && pos < var->val.l.count)
if (var != nullptr && var->holds_alternative<tr_variant::Vector>())
{
return var->val.l.vals + pos;
if (auto& container = var->val.l; pos < container.count)
{
return container.vals + pos;
}
}
return {};
@ -149,7 +153,7 @@ bool tr_variantGetInt(tr_variant const* const var, int64_t* setme)
return false;
}
if (tr_variantIsInt(var))
if (var->holds_alternative<int64_t>())
{
if (setme != nullptr)
{
@ -159,7 +163,7 @@ bool tr_variantGetInt(tr_variant const* const var, int64_t* setme)
return true;
}
if (tr_variantIsBool(var))
if (var->holds_alternative<bool>())
{
if (setme != nullptr)
{
@ -174,7 +178,7 @@ bool tr_variantGetInt(tr_variant const* const var, int64_t* setme)
bool tr_variantGetStrView(tr_variant const* const var, std::string_view* setme)
{
if (tr_variantIsString(var))
if (var != nullptr && var->holds_alternative<std::string_view>())
{
*setme = var->val.s.get();
return true;
@ -214,13 +218,13 @@ bool tr_variantGetBool(tr_variant const* const var, bool* setme)
return false;
}
if (tr_variantIsBool(var))
if (var->holds_alternative<bool>())
{
*setme = var->val.b;
return true;
}
if (tr_variantIsInt(var) && (var->val.i == 0 || var->val.i == 1))
if (var->holds_alternative<int64_t>() && (var->val.i == 0 || var->val.i == 1))
{
*setme = var->val.i != 0;
return true;
@ -251,19 +255,19 @@ bool tr_variantGetReal(tr_variant const* const var, double* setme)
return false;
}
if (tr_variantIsReal(var))
if (var->holds_alternative<double>())
{
*setme = var->val.d;
return true;
}
if (tr_variantIsInt(var))
if (var->holds_alternative<int64_t>())
{
*setme = static_cast<double>(var->val.i);
return true;
}
if (tr_variantIsString(var))
if (var->holds_alternative<std::string_view>())
{
if (auto val = tr_num_parse<double>(var->val.s.get()); val)
{
@ -353,7 +357,8 @@ void tr_variantInitList(tr_variant* initme, size_t reserve_count)
void tr_variantListReserve(tr_variant* const var, size_t count)
{
TR_ASSERT(tr_variantIsList(var));
TR_ASSERT(var != nullptr);
TR_ASSERT(var->holds_alternative<tr_variant::Vector>());
containerReserve(var, count);
}
@ -366,14 +371,16 @@ void tr_variantInitDict(tr_variant* initme, size_t reserve_count)
void tr_variantDictReserve(tr_variant* const var, size_t reserve_count)
{
TR_ASSERT(tr_variantIsDict(var));
TR_ASSERT(var != nullptr);
TR_ASSERT(var->holds_alternative<tr_variant::Map>());
containerReserve(var, reserve_count);
}
tr_variant* tr_variantListAdd(tr_variant* const var)
{
TR_ASSERT(tr_variantIsList(var));
TR_ASSERT(var != nullptr);
TR_ASSERT(var->holds_alternative<tr_variant::Vector>());
auto* const child = containerReserve(var, 1);
++var->val.l.count;
@ -447,7 +454,8 @@ tr_variant* tr_variantListAddDict(tr_variant* const var, size_t reserve_count)
tr_variant* tr_variantDictAdd(tr_variant* const var, tr_quark key)
{
TR_ASSERT(tr_variantIsDict(var));
TR_ASSERT(var != nullptr);
TR_ASSERT(var->holds_alternative<tr_variant::Map>());
auto* const child = containerReserve(var, 1);
++var->val.l.count;
@ -600,7 +608,7 @@ protected:
template<typename Container>
void sort(Container& sortbuf)
{
if (!tr_variantIsDict(var_))
if (var_ == nullptr || !var_->holds_alternative<tr_variant::Map>())
{
return;
}
@ -696,7 +704,7 @@ void tr_variant_serde::walk(tr_variant const& top, WalkFuncs const& walk_funcs,
if (v != nullptr)
{
if (tr_variantIsDict(node.current()))
if (node.current()->holds_alternative<tr_variant::Map>())
{
auto const keystr = tr_quark_get_string_view(v->key);
auto tmp = tr_variant{};
@ -771,15 +779,19 @@ void tr_variant_serde::walk(tr_variant const& top, WalkFuncs const& walk_funcs,
bool tr_variantDictChild(tr_variant* const var, size_t pos, tr_quark* key, tr_variant** setme_value)
{
TR_ASSERT(tr_variantIsDict(var));
TR_ASSERT(var != nullptr);
TR_ASSERT(var->holds_alternative<tr_variant::Map>());
bool success = false;
if (tr_variantIsDict(var) && pos < var->val.l.count)
if (var != nullptr && var->holds_alternative<tr_variant::Map>())
{
*key = var->val.l.vals[pos].key;
*setme_value = var->val.l.vals + pos;
success = true;
if (auto& container = var->val.l; pos < container.count)
{
*key = container.vals[pos].key;
*setme_value = container.vals + pos;
success = true;
}
}
return success;
@ -799,35 +811,35 @@ void tr_variantListCopy(tr_variant* target, tr_variant const* src)
break;
}
if (tr_variantIsBool(child))
if (child->holds_alternative<bool>())
{
auto val = bool{};
tr_variantGetBool(child, &val);
tr_variantListAddBool(target, val);
}
else if (tr_variantIsReal(child))
else if (child->holds_alternative<double>())
{
auto val = double{};
tr_variantGetReal(child, &val);
tr_variantListAddReal(target, val);
}
else if (tr_variantIsInt(child))
else if (child->holds_alternative<int64_t>())
{
auto val = int64_t{};
tr_variantGetInt(child, &val);
tr_variantListAddInt(target, val);
}
else if (tr_variantIsString(child))
else if (child->holds_alternative<std::string_view>())
{
auto val = std::string_view{};
(void)tr_variantGetStrView(child, &val);
tr_variantListAddRaw(target, std::data(val), std::size(val));
}
else if (tr_variantIsDict(child))
else if (child->holds_alternative<tr_variant::Map>())
{
tr_variantMergeDicts(tr_variantListAddDict(target, 0), child);
}
else if (tr_variantIsList(child))
else if (child->holds_alternative<tr_variant::Vector>())
{
tr_variantListCopy(tr_variantListAddList(target, 0), child);
}
@ -840,7 +852,7 @@ void tr_variantListCopy(tr_variant* target, tr_variant const* src)
constexpr size_t tr_variantDictSize(tr_variant const* const var)
{
return tr_variantIsDict(var) ? var->val.l.count : 0U;
return var != nullptr && var->holds_alternative<tr_variant::Map>() ? var->val.l.count : 0U;
}
} // namespace merge_helpers
} // namespace
@ -849,8 +861,10 @@ void tr_variantMergeDicts(tr_variant* const tgt, tr_variant const* const src)
{
using namespace merge_helpers;
TR_ASSERT(tr_variantIsDict(tgt));
TR_ASSERT(tr_variantIsDict(src));
TR_ASSERT(tgt != nullptr);
TR_ASSERT(tgt->holds_alternative<tr_variant::Map>());
TR_ASSERT(src != nullptr);
TR_ASSERT(src->holds_alternative<tr_variant::Map>());
size_t const source_count = tr_variantDictSize(src);
@ -866,47 +880,47 @@ void tr_variantMergeDicts(tr_variant* const tgt, tr_variant const* const src)
// if types differ, ensure that target will overwrite source
auto const* const target_child = tr_variantDictFind(tgt, key);
if ((target_child != nullptr) && !tr_variantIsType(target_child, child->type))
if ((target_child != nullptr) && child->type != target_child->type)
{
tr_variantDictRemove(tgt, key);
}
if (tr_variantIsBool(child))
if (child->holds_alternative<bool>())
{
auto val = bool{};
tr_variantGetBool(child, &val);
tr_variantDictAddBool(tgt, key, val);
}
else if (tr_variantIsReal(child))
else if (child->holds_alternative<double>())
{
auto val = double{};
tr_variantGetReal(child, &val);
tr_variantDictAddReal(tgt, key, val);
}
else if (tr_variantIsInt(child))
else if (child->holds_alternative<int64_t>())
{
auto val = int64_t{};
tr_variantGetInt(child, &val);
tr_variantDictAddInt(tgt, key, val);
}
else if (tr_variantIsString(child))
else if (child->holds_alternative<std::string_view>())
{
auto val = std::string_view{};
(void)tr_variantGetStrView(child, &val);
tr_variantDictAddRaw(tgt, key, std::data(val), std::size(val));
}
else if (tr_variantIsDict(child) && tr_variantDictFindDict(tgt, key, &t))
else if (child->holds_alternative<tr_variant::Map>() && tr_variantDictFindDict(tgt, key, &t))
{
tr_variantMergeDicts(t, child);
}
else if (tr_variantIsList(child))
else if (child->holds_alternative<tr_variant::Vector>())
{
if (tr_variantDictFind(tgt, key) == nullptr)
{
tr_variantListCopy(tr_variantDictAddList(tgt, key, tr_variantListSize(child)), child);
}
}
else if (tr_variantIsDict(child))
else if (child->holds_alternative<tr_variant::Map>())
{
tr_variant* target_dict = tr_variantDictFind(tgt, key);
@ -915,7 +929,7 @@ void tr_variantMergeDicts(tr_variant* const tgt, tr_variant const* const src)
target_dict = tr_variantDictAddDict(tgt, key, tr_variantDictSize(child));
}
if (tr_variantIsDict(target_dict))
if (target_dict->holds_alternative<tr_variant::Map>())
{
tr_variantMergeDicts(target_dict, child);
}

128
libtransmission/variant.h
View File

@ -8,42 +8,24 @@
#include <algorithm>
#include <cstddef> // size_t
#include <cstdint> // int64_t
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
#include "libtransmission/quark.h"
struct tr_error;
/**
* @addtogroup tr_variant Variant
* A variant that holds typical benc/json types: bool, int, double, string,
* vectors of variants, and maps of string-to-variant.
* Useful when serializing / deserializing benc/json data.
*
* An object that acts like a union for
* integers, strings, lists, dictionaries, booleans, and floating-point numbers.
* The structure is named `tr_variant` due to the historical reason that it was
* originally tightly coupled with bencoded data. It currently supports
* being parsed from, and serialized to, both bencoded notation and json notation.
*
* @{
* @see tr_variant_serde
*/
/* these are PRIVATE IMPLEMENTATION details that should not be touched.
* I'll probably change them just to break your code! HA HA HA!
* it's included in the header for inlining and composition */
enum
{
TR_VARIANT_TYPE_INT = 1,
TR_VARIANT_TYPE_STR = 2,
TR_VARIANT_TYPE_LIST = 4,
TR_VARIANT_TYPE_DICT = 8,
TR_VARIANT_TYPE_BOOL = 16,
TR_VARIANT_TYPE_REAL = 32
};
/* These are PRIVATE IMPLEMENTATION details that should not be touched.
* I'll probably change them just to break your code! HA HA HA!
* it's included in the header for inlining and composition */
struct tr_variant
{
private:
@ -125,6 +107,9 @@ public:
Map
};
using Vector = std::vector<tr_variant>;
using Map = std::map<tr_quark, tr_variant>;
tr_variant() noexcept = default;
tr_variant(tr_variant const&) = delete;
@ -146,6 +131,51 @@ public:
return *this;
}
[[nodiscard]] constexpr auto has_value() const noexcept
{
return type != Type::None;
}
template<typename Val>
[[nodiscard]] constexpr bool holds_alternative() const noexcept
{
static_assert(
std::is_same_v<Val, bool> || std::is_same_v<Val, int64_t> || std::is_same_v<Val, double> ||
std::is_same_v<Val, std::string_view> || std::is_same_v<Val, Vector> || std::is_same_v<Val, Map>);
if constexpr (std::is_same_v<Val, bool>)
{
return type == Type::Bool;
}
if constexpr (std::is_same_v<Val, int64_t>)
{
return type == Type::Int;
}
if constexpr (std::is_same_v<Val, double>)
{
return type == Type::Double;
}
if constexpr (std::is_same_v<Val, std::string_view>)
{
return type == Type::String;
}
if constexpr (std::is_same_v<Val, Vector>)
{
return type == Type::Vector;
}
if constexpr (std::is_same_v<Val, Map>)
{
return type == Type::Map;
}
return false;
}
void clear()
{
*this = tr_variant{};
@ -174,23 +204,8 @@ public:
} val = {};
};
[[nodiscard]] constexpr bool tr_variantIsType(tr_variant const* const var, tr_variant::Type type)
{
return var != nullptr && var->type == type;
}
[[nodiscard]] constexpr bool tr_variantIsEmpty(tr_variant const* const var)
{
return var == nullptr || var->type == tr_variant::Type::None;
}
// --- Strings
[[nodiscard]] constexpr bool tr_variantIsString(tr_variant const* const var)
{
return var != nullptr && var->type == tr_variant::Type::String;
}
bool tr_variantGetStrView(tr_variant const* variant, std::string_view* setme);
void tr_variantInitStr(tr_variant* initme, std::string_view value);
@ -209,11 +224,6 @@ bool tr_variantGetRaw(tr_variant const* variant, uint8_t const** setme_raw, size
// --- Real Numbers
[[nodiscard]] constexpr bool tr_variantIsReal(tr_variant const* const var)
{
return var != nullptr && var->type == tr_variant::Type::Double;
}
bool tr_variantGetReal(tr_variant const* variant, double* value_setme);
constexpr void tr_variantInitReal(tr_variant* initme, double value)
@ -224,11 +234,6 @@ constexpr void tr_variantInitReal(tr_variant* initme, double value)
// --- Booleans
[[nodiscard]] constexpr bool tr_variantIsBool(tr_variant const* const var)
{
return var != nullptr && var->type == tr_variant::Type::Bool;
}
bool tr_variantGetBool(tr_variant const* variant, bool* setme);
constexpr void tr_variantInitBool(tr_variant* initme, bool value)
@ -239,11 +244,6 @@ constexpr void tr_variantInitBool(tr_variant* initme, bool value)
// --- Ints
[[nodiscard]] constexpr bool tr_variantIsInt(tr_variant const* const var)
{
return var != nullptr && var->type == tr_variant::Type::Int;
}
bool tr_variantGetInt(tr_variant const* var, int64_t* setme);
constexpr void tr_variantInitInt(tr_variant* initme, int64_t value)
@ -254,11 +254,6 @@ constexpr void tr_variantInitInt(tr_variant* initme, int64_t value)
// --- Lists
[[nodiscard]] constexpr bool tr_variantIsList(tr_variant const* const var)
{
return var != nullptr && var->type == tr_variant::Type::Vector;
}
void tr_variantInitList(tr_variant* initme, size_t reserve_count);
void tr_variantListReserve(tr_variant* var, size_t reserve_count);
@ -278,16 +273,11 @@ bool tr_variantListRemove(tr_variant* var, size_t pos);
[[nodiscard]] constexpr size_t tr_variantListSize(tr_variant const* const var)
{
return tr_variantIsList(var) ? var->val.l.count : 0;
return var != nullptr && var->holds_alternative<tr_variant::Vector>() ? var->val.l.count : 0;
}
// --- Dictionaries
[[nodiscard]] constexpr bool tr_variantIsDict(tr_variant const* const var)
{
return var != nullptr && var->type == tr_variant::Type::Map;
}
void tr_variantInitDict(tr_variant* initme, size_t reserve_count);
void tr_variantDictReserve(tr_variant* var, size_t reserve_count);
bool tr_variantDictRemove(tr_variant* var, tr_quark key);
@ -317,7 +307,11 @@ bool tr_variantDictFindRaw(tr_variant* var, tr_quark key, std::byte const** setm
/* this is only quasi-supported. don't rely on it too heavily outside of libT */
void tr_variantMergeDicts(tr_variant* tgt, tr_variant const* src);
// tr_variant serializer / deserializer
/**
* Helper class for serializing and deserializing benc/json data.
*
* @see tr_variant
*/
class tr_variant_serde
{
public:

2
qt/TorrentModel.cc
View File

@ -164,7 +164,7 @@ void TorrentModel::updateTorrents(tr_variant* torrent_list, bool is_complete_lis
// build a list of the property keys
tr_variant* const first_child = tr_variantListChild(torrent_list, 0);
bool const table = tr_variantIsList(first_child);
bool const table = first_child != nullptr && first_child->holds_alternative<tr_variant::Vector>();
std::vector<tr_quark> keys;
if (table)
{

2
qt/VariantHelpers.h
View File

@ -105,7 +105,7 @@ auto getValue(tr_variant const* var)
{
std::optional<C> ret;
if (tr_variantIsList(var))
if (var != nullptr && var->holds_alternative<tr_variant::Vector>())
{
auto list = C{};

26
tests/libtransmission/json-test.cc
View File

@ -60,7 +60,7 @@ TEST_P(JSONTest, testElements)
};
auto var = tr_variant_serde::json().inplace().parse(in).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Map>());
auto sv = std::string_view{};
auto key = tr_quark_new("string"sv);
@ -98,14 +98,14 @@ TEST_P(JSONTest, testUtf8)
auto serde = tr_variant_serde::json();
serde.inplace();
auto var = serde.parse(in).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Map>());
EXPECT_TRUE(tr_variantDictFindStrView(&var, key, &sv));
EXPECT_EQ("Letöltések"sv, sv);
var.clear();
in = R"({ "key": "\u005C" })"sv;
var = serde.parse(in).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Map>());
EXPECT_TRUE(tr_variantDictFindStrView(&var, key, &sv));
EXPECT_EQ("\\"sv, sv);
var.clear();
@ -120,7 +120,7 @@ TEST_P(JSONTest, testUtf8)
*/
in = R"({ "key": "Let\u00f6lt\u00e9sek" })"sv;
var = serde.parse(in).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Map>());
EXPECT_TRUE(tr_variantDictFindStrView(&var, key, &sv));
EXPECT_EQ("Letöltések"sv, sv);
auto json = serde.to_string(var);
@ -130,7 +130,7 @@ TEST_P(JSONTest, testUtf8)
EXPECT_NE(std::string::npos, json.find("\\u00f6"));
EXPECT_NE(std::string::npos, json.find("\\u00e9"));
var = serde.parse(json).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Map>());
EXPECT_TRUE(tr_variantDictFindStrView(&var, key, &sv));
EXPECT_EQ("Letöltések"sv, sv);
}
@ -149,7 +149,7 @@ TEST_P(JSONTest, testUtf16Surrogates)
EXPECT_NE(std::string::npos, json.find("udd14"));
auto parsed = serde.parse(json).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&parsed));
EXPECT_TRUE(parsed.holds_alternative<tr_variant::Map>());
auto value = std::string_view{};
EXPECT_TRUE(tr_variantDictFindStrView(&parsed, key, &value));
EXPECT_EQ(ThinkingFaceEmojiUtf8, value);
@ -173,13 +173,13 @@ TEST_P(JSONTest, test1)
auto serde = tr_variant_serde::json();
auto var = serde.inplace().parse(Input).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Map>());
auto sv = std::string_view{};
auto i = int64_t{};
auto* headers = tr_variantDictFind(&var, tr_quark_new("headers"sv));
EXPECT_NE(nullptr, headers);
EXPECT_TRUE(tr_variantIsDict(headers));
EXPECT_TRUE(headers->holds_alternative<tr_variant::Map>());
EXPECT_TRUE(tr_variantDictFindStrView(headers, tr_quark_new("type"sv), &sv));
EXPECT_EQ("request"sv, sv);
EXPECT_TRUE(tr_variantDictFindInt(headers, TR_KEY_tag, &i));
@ -190,10 +190,10 @@ TEST_P(JSONTest, test1)
EXPECT_EQ("torrent-info"sv, sv);
auto* args = tr_variantDictFind(body, tr_quark_new("arguments"sv));
EXPECT_NE(nullptr, args);
EXPECT_TRUE(tr_variantIsDict(args));
EXPECT_TRUE(args->holds_alternative<tr_variant::Map>());
auto* ids = tr_variantDictFind(args, TR_KEY_ids);
EXPECT_NE(nullptr, ids);
EXPECT_TRUE(tr_variantIsList(ids));
ASSERT_NE(nullptr, ids);
EXPECT_TRUE(ids->holds_alternative<tr_variant::Vector>());
EXPECT_EQ(2U, tr_variantListSize(ids));
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(ids, 0), &i));
EXPECT_EQ(7, i);
@ -218,7 +218,7 @@ TEST_P(JSONTest, test3)
" \"leftUntilDone\": 2275655680 }"sv;
auto var = tr_variant_serde::json().inplace().parse(Input).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Map>());
auto sv = std::string_view{};
EXPECT_TRUE(tr_variantDictFindStrView(&var, TR_KEY_errorString, &sv));
@ -230,7 +230,7 @@ TEST_P(JSONTest, unescape)
static auto constexpr Input = R"({ "string-1": "\/usr\/lib" })"sv;
auto var = tr_variant_serde::json().inplace().parse(Input).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsDict(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Map>());
auto sv = std::string_view{};
EXPECT_TRUE(tr_variantDictFindStrView(&var, tr_quark_new("string-1"sv), &sv));

10
tests/libtransmission/rpc-test.cc
View File

@ -35,13 +35,13 @@ TEST_F(RpcTest, list)
tr_variant top;
tr_rpc_parse_list_str(&top, "12"sv);
EXPECT_TRUE(tr_variantIsInt(&top));
EXPECT_TRUE(top.holds_alternative<int64_t>());
EXPECT_TRUE(tr_variantGetInt(&top, &i));
EXPECT_EQ(12, i);
top.clear();
tr_rpc_parse_list_str(&top, "6,7"sv);
EXPECT_TRUE(tr_variantIsList(&top));
EXPECT_TRUE(top.holds_alternative<tr_variant::Vector>());
EXPECT_EQ(2U, tr_variantListSize(&top));
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(&top, 0), &i));
EXPECT_EQ(6, i);
@ -50,13 +50,13 @@ TEST_F(RpcTest, list)
top.clear();
tr_rpc_parse_list_str(&top, "asdf"sv);
EXPECT_TRUE(tr_variantIsString(&top));
EXPECT_TRUE(top.holds_alternative<std::string_view>());
EXPECT_TRUE(tr_variantGetStrView(&top, &sv));
EXPECT_EQ("asdf"sv, sv);
top.clear();
tr_rpc_parse_list_str(&top, "1,3-5"sv);
EXPECT_TRUE(tr_variantIsList(&top));
EXPECT_TRUE(top.holds_alternative<tr_variant::Vector>());
EXPECT_EQ(4U, tr_variantListSize(&top));
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(&top, 0), &i));
EXPECT_EQ(1, i);
@ -88,7 +88,7 @@ TEST_F(RpcTest, sessionGet)
tr_variant response;
tr_rpc_request_exec_json(session_, &request, rpc_response_func, &response);
EXPECT_TRUE(tr_variantIsDict(&response));
EXPECT_TRUE(response.holds_alternative<tr_variant::Map>());
tr_variant* args = nullptr;
EXPECT_TRUE(tr_variantDictFindDict(&response, TR_KEY_arguments, &args));

8
tests/libtransmission/variant-test.cc
View File

@ -230,7 +230,7 @@ TEST_F(VariantTest, parse)
benc = "li64ei32ei16ee"sv;
var = serde.parse(benc).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsList(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Vector>());
EXPECT_EQ(std::data(benc) + std::size(benc), serde.end());
EXPECT_EQ(3, tr_variantListSize(&var));
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(&var, 0), &i));
@ -244,20 +244,20 @@ TEST_F(VariantTest, parse)
benc = "lllee"sv;
var = serde.parse(benc).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsEmpty(&var));
EXPECT_FALSE(var.has_value());
EXPECT_EQ(std::data(benc) + std::size(benc), serde.end());
var.clear();
benc = "le"sv;
var = serde.parse(benc).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsList(&var));
EXPECT_TRUE(var.holds_alternative<tr_variant::Vector>());
EXPECT_EQ(std::data(benc) + std::size(benc), serde.end());
EXPECT_EQ(benc, serde.to_string(var));
var.clear();
benc = "d20:"sv;
var = serde.parse(benc).value_or(tr_variant{});
EXPECT_TRUE(tr_variantIsEmpty(&var));
EXPECT_FALSE(var.has_value());
EXPECT_EQ(std::data(benc) + 1U, serde.end());
}

38
utils/remote.cc
View File

@ -2404,7 +2404,7 @@ static int flush(char const* rpcurl, tr_variant* benc, Config& config)
static tr_variant* ensure_sset(tr_variant& sset)
{
if (!tr_variantIsEmpty(&sset))
if (sset.has_value())
{
return tr_variantDictFind(&sset, Arguments);
}
@ -2416,7 +2416,7 @@ static tr_variant* ensure_sset(tr_variant& sset)
static tr_variant* ensure_tset(tr_variant& tset)
{
if (!tr_variantIsEmpty(&tset))
if (tset.has_value())
{
return tr_variantDictFind(&tset, Arguments);
}
@ -2449,17 +2449,17 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
switch (c)
{
case 'a': /* add torrent */
if (!tr_variantIsEmpty(&sset))
if (sset.has_value())
{
status |= flush(rpcurl, &sset, config);
}
if (!tr_variantIsEmpty(&tadd))
if (tadd.has_value())
{
status |= flush(rpcurl, &tadd, config);
}
if (!tr_variantIsEmpty(&tset))
if (tset.has_value())
{
addIdArg(tr_variantDictFind(&tset, Arguments), config);
status |= flush(rpcurl, &tset, config);
@ -2509,12 +2509,12 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
break;
case 't': /* set current torrent */
if (!tr_variantIsEmpty(&tadd))
if (tadd.has_value())
{
status |= flush(rpcurl, &tadd, config);
}
if (!tr_variantIsEmpty(&tset))
if (tset.has_value())
{
addIdArg(tr_variantDictFind(&tset, Arguments), config);
status |= flush(rpcurl, &tset, config);
@ -2538,7 +2538,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
break;
case TR_OPT_UNK:
if (!tr_variantIsEmpty(&tadd))
if (tadd.has_value())
{
tr_variant* args = tr_variantDictFind(&tadd, Arguments);
auto const tmp = getEncodedMetainfo(optarg);
@ -2571,7 +2571,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
args = tr_variantDictAddDict(&top, Arguments, 0);
fields = tr_variantDictAddList(args, TR_KEY_fields, 0);
if (!tr_variantIsEmpty(&tset))
if (tset.has_value())
{
addIdArg(tr_variantDictFind(&tset, Arguments), config);
status |= flush(rpcurl, &tset, config);
@ -2943,7 +2943,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
{
tr_variant* args;
if (!tr_variantIsEmpty(&tadd))
if (tadd.has_value())
{
args = tr_variantDictFind(&tadd, Arguments);
}
@ -3016,7 +3016,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
}
else if (c == 961) /* set location */
{
if (!tr_variantIsEmpty(&tadd))
if (tadd.has_value())
{
tr_variant* args = tr_variantDictFind(&tadd, Arguments);
tr_variantDictAddStr(args, TR_KEY_download_dir, optarg);
@ -3049,7 +3049,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
}
case 's': /* start */
if (!tr_variantIsEmpty(&tadd))
if (tadd.has_value())
{
tr_variantDictAddBool(tr_variantDictFind(&tadd, TR_KEY_arguments), TR_KEY_paused, false);
}
@ -3064,7 +3064,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
break;
case 'S': /* stop */
if (!tr_variantIsEmpty(&tadd))
if (tadd.has_value())
{
tr_variantDictAddBool(tr_variantDictFind(&tadd, TR_KEY_arguments), TR_KEY_paused, true);
}
@ -3081,7 +3081,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
case 'w':
{
auto* args = !tr_variantIsEmpty(&tadd) ? tr_variantDictFind(&tadd, TR_KEY_arguments) : ensure_sset(sset);
auto* args = tadd.has_value() ? tr_variantDictFind(&tadd, TR_KEY_arguments) : ensure_sset(sset);
tr_variantDictAddStr(args, TR_KEY_download_dir, optarg);
break;
}
@ -3126,7 +3126,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
case 600:
{
if (!tr_variantIsEmpty(&tset))
if (tset.has_value())
{
addIdArg(tr_variantDictFind(&tset, Arguments), config);
status |= flush(rpcurl, &tset, config);
@ -3142,7 +3142,7 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
case 'v':
{
if (!tr_variantIsEmpty(&tset))
if (tset.has_value())
{
addIdArg(tr_variantDictFind(&tset, Arguments), config);
status |= flush(rpcurl, &tset, config);
@ -3220,18 +3220,18 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv, Co
}
}
if (!tr_variantIsEmpty(&tadd))
if (tadd.has_value())
{
status |= flush(rpcurl, &tadd, config);
}
if (!tr_variantIsEmpty(&tset))
if (tset.has_value())
{
addIdArg(tr_variantDictFind(&tset, Arguments), config);
status |= flush(rpcurl, &tset, config);
}
if (!tr_variantIsEmpty(&sset))
if (sset.has_value())
{
status |= flush(rpcurl, &sset, config);
}