Transmission/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission.git synced 2025-12-26 21:29:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

build: add clang tidy modernize loop convert (#1949)

Browse Source 
* build: add clang-tidy check modernize-pass-by-value

* build: add clang-tidy check modernize-loop-convert

* refactor: constexpr

* refactor: make preallocGuess a std::array
This commit is contained in:
Charles Kerr
2021-10-14 10:36:49 -05:00
committed by GitHub
parent 5df6e4f88f
commit ab82e155be
7 changed files with 80 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
libtransmission/utils.cc
View File

@@ -1620,10 +1620,13 @@ struct formatter_unit
size_t value;
};
using formatter_units = std::array<formatter_unit, 4>;
/*
struct formatter_units
{
struct formatter_unit units[4];
};
*/
enum
{
@@ -1633,60 +1636,52 @@ enum
TR_FMT_TB
};
static void formatter_init(
struct formatter_units* units,
size_t kilo,
char const* kb,
char const* mb,
char const* gb,
char const* tb)
static void formatter_init(formatter_units& units, size_t kilo, char const* kb, char const* mb, char const* gb, char const* tb)
{
size_t value;
value = kilo;
units->units[TR_FMT_KB].name = tr_strdup(kb);
units->units[TR_FMT_KB].value = value;
units[TR_FMT_KB].name = tr_strdup(kb);
units[TR_FMT_KB].value = value;
value *= kilo;
units->units[TR_FMT_MB].name = tr_strdup(mb);
units->units[TR_FMT_MB].value = value;
units[TR_FMT_MB].name = tr_strdup(mb);
units[TR_FMT_MB].value = value;
value *= kilo;
units->units[TR_FMT_GB].name = tr_strdup(gb);
units->units[TR_FMT_GB].value = value;
units[TR_FMT_GB].name = tr_strdup(gb);
units[TR_FMT_GB].value = value;
value *= kilo;
units->units[TR_FMT_TB].name = tr_strdup(tb);
units->units[TR_FMT_TB].value = value;
units[TR_FMT_TB].name = tr_strdup(tb);
units[TR_FMT_TB].value = value;
}
static char* formatter_get_size_str(struct formatter_units const* u, char* buf, size_t bytes, size_t buflen)
static char* formatter_get_size_str(formatter_units const& u, char* buf, size_t bytes, size_t buflen)
{
int precision;
double value;
char const* units;
struct formatter_unit const* unit;
formatter_unit const* unit;
if (bytes < u->units[1].value)
if (bytes < u[1].value)
{
unit = &u->units[0];
unit = &u[0];
}
else if (bytes < u->units[2].value)
else if (bytes < u[2].value)
{
unit = &u->units[1];
unit = &u[1];
}
else if (bytes < u->units[3].value)
else if (bytes < u[3].value)
{
unit = &u->units[2];
unit = &u[2];
}
else
{
unit = &u->units[3];
unit = &u[3];
}
value = (double)bytes / unit->value;
units = unit->name;
double value = (double)bytes / unit->value;
char const* units = unit->name;
int precision = 0;
if (unit->value == 1)
{
precision = 0;
@@ -1704,36 +1699,36 @@ static char* formatter_get_size_str(struct formatter_units const* u, char* buf,
return buf;
}
static struct formatter_units size_units;
static formatter_units size_units;
void tr_formatter_size_init(size_t kilo, char const* kb, char const* mb, char const* gb, char const* tb)
{
formatter_init(&size_units, kilo, kb, mb, gb, tb);
formatter_init(size_units, kilo, kb, mb, gb, tb);
}
char* tr_formatter_size_B(char* buf, size_t bytes, size_t buflen)
{
return formatter_get_size_str(&size_units, buf, bytes, buflen);
return formatter_get_size_str(size_units, buf, bytes, buflen);
}
static struct formatter_units speed_units;
static formatter_units speed_units;
size_t tr_speed_K = 0;
void tr_formatter_speed_init(size_t kilo, char const* kb, char const* mb, char const* gb, char const* tb)
{
tr_speed_K = kilo;
formatter_init(&speed_units, kilo, kb, mb, gb, tb);
formatter_init(speed_units, kilo, kb, mb, gb, tb);
}
char* tr_formatter_speed_KBps(char* buf, double KBps, size_t buflen)
{
double const K = speed_units.units[TR_FMT_KB].value;
double const K = speed_units[TR_FMT_KB].value;
double speed = KBps;
if (speed <= 999.95) /* 0.0 KB to 999.9 KB */
{
tr_snprintf(buf, buflen, "%d %s", (int)speed, speed_units.units[TR_FMT_KB].name);
tr_snprintf(buf, buflen, "%d %s", (int)speed, speed_units[TR_FMT_KB].name);
}
else
{
@@ -1741,34 +1736,34 @@ char* tr_formatter_speed_KBps(char* buf, double KBps, size_t buflen)
if (speed <= 99.995) /* 0.98 MB to 99.99 MB */
{
tr_snprintf(buf, buflen, "%.2f %s", speed, speed_units.units[TR_FMT_MB].name);
tr_snprintf(buf, buflen, "%.2f %s", speed, speed_units[TR_FMT_MB].name);
}
else if (speed <= 999.95) /* 100.0 MB to 999.9 MB */
{
tr_snprintf(buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_MB].name);
tr_snprintf(buf, buflen, "%.1f %s", speed, speed_units[TR_FMT_MB].name);
}
else
{
tr_snprintf(buf, buflen, "%.1f %s", speed / K, speed_units.units[TR_FMT_GB].name);
tr_snprintf(buf, buflen, "%.1f %s", speed / K, speed_units[TR_FMT_GB].name);
}
}
return buf;
}
static struct formatter_units mem_units;
static formatter_units mem_units;
size_t tr_mem_K = 0;
void tr_formatter_mem_init(size_t kilo, char const* kb, char const* mb, char const* gb, char const* tb)
{
tr_mem_K = kilo;
formatter_init(&mem_units, kilo, kb, mb, gb, tb);
formatter_init(mem_units, kilo, kb, mb, gb, tb);
}
char* tr_formatter_mem_B(char* buf, size_t bytes_per_second, size_t buflen)
{
return formatter_get_size_str(&mem_units, buf, bytes_per_second, buflen);
return formatter_get_size_str(mem_units, buf, bytes_per_second, buflen);
}
void tr_formatter_get_units(void* vdict)
@@ -1778,28 +1773,25 @@ void tr_formatter_get_units(void* vdict)
tr_variantDictReserve(dict, 6);
tr_variantDictAddInt(dict, TR_KEY_memory_bytes, mem_units.units[TR_FMT_KB].value);
l = tr_variantDictAddList(dict, TR_KEY_memory_units, 4);
for (int i = 0; i < 4; i++)
tr_variantDictAddInt(dict, TR_KEY_memory_bytes, mem_units[TR_FMT_KB].value);
l = tr_variantDictAddList(dict, TR_KEY_memory_units, std::size(mem_units));
for (auto const& unit : mem_units)
{
tr_variantListAddStr(l, mem_units.units[i].name);
tr_variantListAddStr(l, unit.name);
}
tr_variantDictAddInt(dict, TR_KEY_size_bytes, size_units.units[TR_FMT_KB].value);
l = tr_variantDictAddList(dict, TR_KEY_size_units, 4);
for (int i = 0; i < 4; i++)
tr_variantDictAddInt(dict, TR_KEY_size_bytes, size_units[TR_FMT_KB].value);
l = tr_variantDictAddList(dict, TR_KEY_size_units, std::size(size_units));
for (auto const& unit : size_units)
{
tr_variantListAddStr(l, size_units.units[i].name);
tr_variantListAddStr(l, unit.name);
}
tr_variantDictAddInt(dict, TR_KEY_speed_bytes, speed_units.units[TR_FMT_KB].value);
l = tr_variantDictAddList(dict, TR_KEY_speed_units, 4);
for (int i = 0; i < 4; i++)
tr_variantDictAddInt(dict, TR_KEY_speed_bytes, speed_units[TR_FMT_KB].value);
l = tr_variantDictAddList(dict, TR_KEY_speed_units, std::size(speed_units));
for (auto const& unit : speed_units)
{
tr_variantListAddStr(l, speed_units.units[i].name);
tr_variantListAddStr(l, unit.name);
}
}