Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-15 23:20:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/Misc: C++17 cleanups, commit 2, the advstd commit

Browse Source 
(cherry picked from commit 857f8d9231)
This commit is contained in:
Treeston
2020-03-19 17:18:01 +01:00
committed by Shauren
parent 632609b897
commit ea0aa63d96
19 changed files with 40 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/common/Cryptography/ARC4.h
View File

@@ -21,7 +21,6 @@
#include "Define.h"
#include <array>
#include <openssl/evp.h>
#include "advstd.h" // data/size
namespace Trinity
{
@@ -35,11 +34,11 @@ namespace Crypto
void Init(uint8 const* seed, size_t len);
template <typename Container>
void Init(Container const& c) { Init(advstd::data(c), advstd::size(c)); }
void Init(Container const& c) { Init(std::data(c), std::size(c)); }
void UpdateData(uint8* data, size_t len);
template <typename Container>
void UpdateData(Container& c) { UpdateData(advstd::data(c), advstd::size(c)); }
void UpdateData(Container& c) { UpdateData(std::data(c), std::size(c)); }
private:
EVP_CIPHER_CTX* _ctx;
};

3
src/common/Cryptography/BigNumber.h
View File

@@ -23,7 +23,6 @@
#include <memory>
#include <string>
#include <vector>
#include "advstd.h" // data/size
struct bignum_st;
@@ -45,7 +44,7 @@ class TC_COMMON_API BigNumber
void SetQword(uint64);
void SetBinary(uint8 const* bytes, int32 len, bool littleEndian = true);
template <typename Container>
auto SetBinary(Container const& c, bool littleEndian = true) -> std::enable_if_t<!advstd::is_pointer_v<std::decay_t<Container>>> { SetBinary(advstd::data(c), advstd::size(c), littleEndian); }
auto SetBinary(Container const& c, bool littleEndian = true) -> std::enable_if_t<!std::is_pointer_v<std::decay_t<Container>>> { SetBinary(std::data(c), std::size(c), littleEndian); }
bool SetHexStr(char const* str);
bool SetHexStr(std::string const& str) { return SetHexStr(str.c_str()); }

4
src/common/Cryptography/CryptoGenerics.h
View File

@@ -48,8 +48,8 @@ namespace Impl
template <typename Container>
static void SplitFromBack(std::vector<uint8>& data, Container& tail)
{
ASSERT(data.size() >= advstd::size(tail));
for (size_t i = 1, N = advstd::size(tail); i <= N; ++i)
ASSERT(data.size() >= std::size(tail));
for (size_t i = 1, N = std::size(tail); i <= N; ++i)
{
tail[N - i] = data.back();
data.pop_back();

3
src/common/Cryptography/CryptoRandom.h
View File

@@ -20,7 +20,6 @@
#include "Define.h"
#include <array>
#include "advstd.h"
namespace Trinity
{
@@ -31,7 +30,7 @@ namespace Crypto
template <typename Container>
void GetRandomBytes(Container& c)
{
GetRandomBytes(advstd::data(c), advstd::size(c));
GetRandomBytes(std::data(c), std::size(c));
}
template <size_t S>

5
src/common/Cryptography/SessionKeyGenerator.h
View File

@@ -20,7 +20,6 @@
#include "CryptoHash.h"
#include <cstring>
#include "advstd.h" // for data/size
template <typename Hash>
class SessionKeyGenerator
@@ -30,8 +29,8 @@ class SessionKeyGenerator
SessionKeyGenerator(C const& buf) :
o0it(o0.begin())
{
uint8 const* data = advstd::data(buf);
size_t const len = advstd::size(buf);
uint8 const* data = std::data(buf);
size_t const len = std::size(buf);
size_t const halflen = (len / 2);
o1 = Hash::GetDigestOf(data, halflen);

4
src/common/Encoding/BaseEncoding.h
View File

@@ -18,9 +18,9 @@
#ifndef TRINITY_BASE_ENCODING_HPP
#define TRINITY_BASE_ENCODING_HPP
#include "advstd.h"
#include "Define.h"
#include "Optional.h"
#include <numeric>
#include <string>
#include <vector>
@@ -32,7 +32,7 @@ template <typename Encoding>
struct GenericBaseEncoding
{
static constexpr std::size_t BITS_PER_CHAR = Encoding::BITS_PER_CHAR;
static constexpr std::size_t PAD_TO = advstd::lcm(8u, BITS_PER_CHAR);
static constexpr std::size_t PAD_TO = std::lcm(8u, BITS_PER_CHAR);
static_assert(BITS_PER_CHAR < 8, "Encoding parameters are invalid");

15
src/common/Utilities/Containers.h
View File

@@ -18,7 +18,6 @@
#ifndef TRINITY_CONTAINERS_H
#define TRINITY_CONTAINERS_H
#include "advstd.h"
#include "Define.h"
#include "Random.h"
#include <algorithm>
@@ -77,10 +76,10 @@ namespace Trinity
void RandomResize(C& container, std::size_t requestedSize)
{
static_assert(std::is_base_of<std::forward_iterator_tag, typename std::iterator_traits<typename C::iterator>::iterator_category>::value, "Invalid container passed to Trinity::Containers::RandomResize");
if (advstd::size(container) <= requestedSize)
if (std::size(container) <= requestedSize)
return;
auto keepIt = std::begin(container), curIt = std::begin(container);
uint32 elementsToKeep = requestedSize, elementsToProcess = advstd::size(container);
uint32 elementsToKeep = requestedSize, elementsToProcess = std::size(container);
while (elementsToProcess)
{
// this element has chance (elementsToKeep / elementsToProcess) of being kept
@@ -119,7 +118,7 @@ namespace Trinity
inline auto SelectRandomContainerElement(C const& container) -> typename std::add_const<decltype(*std::begin(container))>::type&
{
auto it = std::begin(container);
std::advance(it, urand(0, uint32(advstd::size(container)) - 1));
std::advance(it, urand(0, uint32(std::size(container)) - 1));
return *it;
}
@@ -152,7 +151,7 @@ namespace Trinity
inline auto SelectRandomWeightedContainerElement(C const& container, Fn weightExtractor) -> decltype(std::begin(container))
{
std::vector<double> weights;
weights.reserve(advstd::size(container));
weights.reserve(std::size(container));
double weightSum = 0.0;
for (auto& val : container)
{
@@ -161,7 +160,7 @@ namespace Trinity
weightSum += weight;
}
if (weightSum <= 0.0)
weights.assign(advstd::size(container), 1.0);
weights.assign(std::size(container), 1.0);
return SelectRandomWeightedContainerElement(container, weights);
}
@@ -262,7 +261,7 @@ namespace Trinity
}
template <typename Container, typename Predicate>
std::enable_if_t<advstd::is_move_assignable_v<decltype(*std::declval<Container>().begin())>, void> EraseIf(Container& c, Predicate p)
std::enable_if_t<std::is_move_assignable_v<decltype(*std::declval<Container>().begin())>, void> EraseIf(Container& c, Predicate p)
{
auto wpos = c.begin();
for (auto rpos = c.begin(), end = c.end(); rpos != end; ++rpos)
@@ -278,7 +277,7 @@ namespace Trinity
}
template <typename Container, typename Predicate>
std::enable_if_t<!advstd::is_move_assignable_v<decltype(*std::declval<Container>().begin())>, void> EraseIf(Container& c, Predicate p)
std::enable_if_t<!std::is_move_assignable_v<decltype(*std::declval<Container>().begin())>, void> EraseIf(Container& c, Predicate p)
{
for (auto it = c.begin(); it != c.end();)
{

2
src/common/Utilities/EventProcessor.h
View File

@@ -88,7 +88,7 @@ private:
};
template<typename T>
using is_lambda_event = std::enable_if_t<!advstd::is_base_of_v<BasicEvent, std::remove_pointer_t<advstd::remove_cvref_t<T>>>>;
using is_lambda_event = std::enable_if_t<!std::is_base_of_v<BasicEvent, std::remove_pointer_t<advstd::remove_cvref_t<T>>>>;
class TC_COMMON_API EventProcessor
{

3
src/common/Utilities/FuzzyFind.h
View File

@@ -18,7 +18,6 @@
#ifndef TRINITY_FUZZYFIND_H
#define TRINITY_FUZZYFIND_H
#include "advstd.h"
#include <map>
#include <string>
@@ -30,7 +29,7 @@ namespace Trinity
auto FuzzyFindIn(Container const& container, NeedleContainer const& needles, ContainsOperator const& contains = StringContainsStringI, int(*bonus)(decltype((*std::begin(std::declval<Container>())))) = nullptr)
{
using IteratorResult = decltype((*std::begin(container)));
using MappedType = std::conditional_t<advstd::is_reference_v<IteratorResult>, std::reference_wrapper<std::remove_reference_t<IteratorResult>>, IteratorResult>;
using MappedType = std::conditional_t<std::is_reference_v<IteratorResult>, std::reference_wrapper<std::remove_reference_t<IteratorResult>>, IteratorResult>;
std::multimap<size_t, MappedType, std::greater<size_t>> results;
for (auto outerIt = std::begin(container), outerEnd = std::end(container); outerIt != outerEnd; ++outerIt)

3
src/common/Utilities/Util.h
View File

@@ -24,7 +24,6 @@
#include <string>
#include <utility>
#include <vector>
#include "advstd.h"
enum LocaleConstant : uint8;
@@ -343,7 +342,7 @@ TC_COMMON_API uint32 GetPID();
TC_COMMON_API std::string ByteArrayToHexStr(uint8 const* bytes, size_t length, bool reverse = false);
template <typename Container>
std::string ByteArrayToHexStr(Container const& c, bool reverse = false) { return ByteArrayToHexStr(advstd::data(c), advstd::size(c), reverse); }
std::string ByteArrayToHexStr(Container const& c, bool reverse = false) { return ByteArrayToHexStr(std::data(c), std::size(c), reverse); }
TC_COMMON_API void HexStrToByteArray(std::string const& str, uint8* out, bool reverse = false);
template <size_t Size>
void HexStrToByteArray(std::string const& str, std::array<uint8, Size>& buf, bool reverse = false)

106
src/common/Utilities/advstd.h
View File

@@ -19,117 +19,11 @@
#define TRINITY_ADVSTD_H
#include <cstddef>
#include <initializer_list>
#include <type_traits>
#include <utility>
// this namespace holds implementations of upcoming stdlib features that our c++ version doesn't have yet
namespace advstd
{
// C++17 std::apply (constrained to only function pointers, not all callable)
template <typename... Ts>
using apply_tuple_type = std::tuple<std::remove_cv_t<std::remove_reference_t<Ts>>...>;
template <typename R, typename... Ts, std::size_t... I>
R apply_impl(R(*func)(Ts...), apply_tuple_type<Ts...>&& args, std::index_sequence<I...>)
{
return func(std::get<I>(std::forward<apply_tuple_type<Ts...>>(args))...);
}
template <typename R, typename... Ts>
R apply(R(*func)(Ts...), apply_tuple_type<Ts...>&& args)
{
return apply_impl(func, std::forward<apply_tuple_type<Ts...>>(args), std::index_sequence_for<Ts...>{});
}
#define forward_1v(stdname, type) template <typename T> constexpr type stdname ## _v = std::stdname<T>::value
#define forward_2v(stdname, type) template <typename U, typename V> constexpr type stdname ## _v = std::stdname<U,V>::value
// C++17 std::is_same_v
forward_2v(is_same, bool);
// C++17 std::is_integral_v
forward_1v(is_integral, bool);
// C++17 std::is_assignable_v
forward_2v(is_assignable, bool);
// C++17 std::is_signed_v
forward_1v(is_signed, bool);
// C++17 std::is_unsigned_v
forward_1v(is_unsigned, bool);
// C++17 std::is_base_of_v
forward_2v(is_base_of, bool);
// C++17 std::is_floating_point_v
forward_1v(is_floating_point, bool);
// C++17 std::is_pointer_v
forward_1v(is_pointer, bool);
// C++17 std::is_reference_v
forward_1v(is_reference, bool);
// C++17 std::tuple_size_v
forward_1v(tuple_size, size_t);
// C++17 std::is_enum_v
forward_1v(is_enum, bool);
// C++17 std::is_arithmetic_v
forward_1v(is_arithmetic, bool);
// C++17 std::is_move_assignable_v
forward_1v(is_move_assignable, bool);
#undef forward_1v
#undef forward_2v
// C++17 std::size
template <typename C>
constexpr auto size(const C& c) { return c.size(); }
template <typename T, std::size_t N>
constexpr std::size_t size(const T(&)[N]) noexcept { return N; }
// C++17 std::data
template <typename C>
constexpr auto data(C& c) { return c.data(); }
template <typename C>
constexpr auto data(C const& c) { return c.data(); }
template <typename T, std::size_t N>
constexpr T* data(T(&a)[N]) noexcept { return a; }
template <typename T, std::size_t N>
constexpr T const* data(const T(&a)[N]) noexcept { return a; }
template <typename T>
constexpr T const* data(std::initializer_list<T> l) noexcept { return l.begin(); }
// C++17 std::gcd
template <typename T1, typename T2>
constexpr std::enable_if_t<advstd::is_unsigned_v<T1> && advstd::is_unsigned_v<T2>, std::common_type_t<T1, T2>> gcd(T1 _m, T2 _n)
{
using T = std::common_type_t<T1, T2>;
T n=_n, m=_m;
while (n)
{
T o = m;
m = n;
n = o%n;
}
return m;
}
// C++17 std::lcm
template <typename T1, typename T2>
constexpr std::enable_if_t<advstd::is_unsigned_v<T1> && advstd::is_unsigned_v<T2>, std::common_type_t<T1, T2>> lcm(T1 m, T2 n)
{
return (m/gcd(m, n))*n;
}
// C++20 std::remove_cvref_t
template <class T>
using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;

6
src/server/game/Chat/ChatCommands/ChatCommand.h
View File

@@ -203,7 +203,7 @@ class TC_GAME_API CommandArgs
char const* _args;
};
template <typename T> struct ChatCommandHandlerToTuple { static_assert(!advstd::is_same_v<T,T>, "Invalid command handler signature"); };
template <typename T> struct ChatCommandHandlerToTuple { static_assert(!std::is_same_v<T,T>, "Invalid command handler signature"); };
template <typename... Ts> struct ChatCommandHandlerToTuple<bool(*)(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; };
template <typename T> struct ChatCommandStoreLastArg { static void store(T&, CommandArgs&) {} };
@@ -229,9 +229,9 @@ class TC_GAME_API ChatCommand
CommandArgs args(argsStr);
if (args.TryConsumeToTuple<1>(arguments))
{
auto& last = std::get<advstd::tuple_size_v<tuple_type>-1>(arguments);
auto& last = std::get<std::tuple_size_v<tuple_type>-1>(arguments);
ChatCommandStoreLastArg<advstd::remove_cvref_t<decltype(last)>>::store(last, args);
return advstd::apply(reinterpret_cast<TypedHandler>(handler), std::move(arguments));
return std::apply(reinterpret_cast<TypedHandler>(handler), std::move(arguments));
}
else
return false;

10
src/server/game/Chat/ChatCommands/ChatCommandArgs.h
View File

@@ -38,11 +38,11 @@ namespace ChatCommands
|* *|
\****************************************************************************************/
template <typename T, typename = void>
struct ArgInfo { static_assert(!advstd::is_same_v<T,T>, "Invalid command parameter type - see ChatCommandArgs.h for possible types"); };
struct ArgInfo { static_assert(!std::is_same_v<T,T>, "Invalid command parameter type - see ChatCommandArgs.h for possible types"); };
// catch-all for signed integral types
template <typename T>
struct ArgInfo<T, std::enable_if_t<advstd::is_integral_v<T> && advstd::is_signed_v<T>>>
struct ArgInfo<T, std::enable_if_t<std::is_integral_v<T> && std::is_signed_v<T>>>
{
static char const* TryConsume(T& val, char const* args)
{
@@ -56,7 +56,7 @@ struct ArgInfo<T, std::enable_if_t<advstd::is_integral_v<T> && advstd::is_signed
// catch-all for unsigned integral types
template <typename T>
struct ArgInfo<T, std::enable_if_t<advstd::is_integral_v<T> && advstd::is_unsigned_v<T>>>
struct ArgInfo<T, std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T>>>
{
static char const* TryConsume(T& val, char const* args)
{
@@ -70,7 +70,7 @@ struct ArgInfo<T, std::enable_if_t<advstd::is_integral_v<T> && advstd::is_unsign
// catch-all for floating point types
template <typename T>
struct ArgInfo<T, std::enable_if_t<advstd::is_floating_point_v<T>>>
struct ArgInfo<T, std::enable_if_t<std::is_floating_point_v<T>>>
{
static char const* TryConsume(T& val, char const* args)
{
@@ -101,7 +101,7 @@ struct ArgInfo<std::string, void>
// a container tag
template <typename T>
struct ArgInfo<T, std::enable_if_t<advstd::is_base_of_v<ContainerTag, T>>>
struct ArgInfo<T, std::enable_if_t<std::is_base_of_v<ContainerTag, T>>>
{
static char const* TryConsume(T& tag, char const* args)
{

11
src/server/game/Chat/ChatCommands/ChatCommandHelpers.h
View File

@@ -18,7 +18,6 @@
#ifndef TRINITY_CHATCOMMANDHELPERS_H
#define TRINITY_CHATCOMMANDHELPERS_H
#include "advstd.h"
#include <type_traits>
namespace Trinity
@@ -31,9 +30,9 @@ static constexpr char COMMAND_DELIMITER = ' ';
/***************** HELPERS *************************\
|* These really aren't for outside use... *|
\***************************************************/
inline size_t tokenize(char const*& end)
inline std::size_t tokenize(char const*& end)
{
size_t len = 0;
std::size_t len = 0;
for (; *end && *end != COMMAND_DELIMITER; ++end, ++len);
for (; *end && *end == COMMAND_DELIMITER; ++end);
return len;
@@ -57,10 +56,10 @@ struct are_all_assignable
template <typename T1, typename T2, typename... Ts>
struct are_all_assignable<T1, T2, Ts...>
{
static constexpr bool value = advstd::is_assignable_v<T1&, T2> && are_all_assignable<T1, Ts...>::value;
static constexpr bool value = std::is_assignable_v<T1&, T2> && are_all_assignable<T1, Ts...>::value;
};
template <size_t index, typename T1, typename... Ts>
template <std::size_t index, typename T1, typename... Ts>
struct get_nth : get_nth<index-1, Ts...> { };
template <typename T1, typename... Ts>
@@ -69,7 +68,7 @@ struct get_nth<0, T1, Ts...>
using type = T1;
};
template <size_t index, typename... Ts>
template <std::size_t index, typename... Ts>
using get_nth_t = typename get_nth<index, Ts...>::type;
}

2
src/server/game/Chat/ChatCommands/ChatCommandTags.h
View File

@@ -45,7 +45,7 @@ namespace ChatCommands
\****************************************************************************************/
struct ContainerTag {};
template <typename T>
struct tag_base<T, std::enable_if_t<advstd::is_base_of_v<ContainerTag, T>>>
struct tag_base<T, std::enable_if_t<std::is_base_of_v<ContainerTag, T>>>
{
using type = typename T::value_type;
};

5
src/server/game/Chat/Hyperlinks.h
View File

@@ -18,7 +18,6 @@
#ifndef TRINITY_HYPERLINKS_H
#define TRINITY_HYPERLINKS_H
#include "advstd.h"
#include "ObjectGuid.h"
#include "Optional.h"
#include <string>
@@ -229,7 +228,7 @@ namespace LinkTags {
}
template <typename T>
static std::enable_if_t<advstd::is_integral_v<T> && advstd::is_unsigned_v<T>, bool> StoreTo(T& val, char const* pos, size_t len)
static std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T>, bool> StoreTo(T& val, char const* pos, size_t len)
{
try { val = std::stoull(std::string(pos, len)); }
catch (...) { return false; }
@@ -237,7 +236,7 @@ namespace LinkTags {
}
template <typename T>
static std::enable_if_t<advstd::is_integral_v<T> && advstd::is_signed_v<T>, bool> StoreTo(T& val, char const* pos, size_t len)
static std::enable_if_t<std::is_integral_v<T> && std::is_signed_v<T>, bool> StoreTo(T& val, char const* pos, size_t len)
{
try { val = std::stoll(std::string(pos, len)); }
catch (...) { return false; }

5
src/server/game/Entities/Object/ObjectGuid.cpp
View File

@@ -23,7 +23,6 @@
#include "Realm.h"
#include "Util.h"
#include "World.h"
#include "advstd.h"
static_assert(sizeof(ObjectGuid) == sizeof(uint64) * 2, "ObjectGuid must be exactly 16 bytes");
@@ -104,7 +103,7 @@ namespace
};
ObjectGuid::LowType id = guid.GetCounter();
if (id >= advstd::size(uniqNames))
if (id >= std::size(uniqNames))
id = 3;
return Trinity::StringFormat("%s-%s", typeName, uniqNames[id]);
@@ -134,7 +133,7 @@ namespace
"WOWGUID_UNIQUE_ACCOUNT_OBJ_INITIALIZATION"
};
for (std::size_t id = 0; id < advstd::size(uniqNames); ++id)
for (std::size_t id = 0; id < std::size(uniqNames); ++id)
{
if (!uniqNames[id])
continue;

2
src/server/game/Entities/Player/CinematicMgr.cpp
View File

@@ -46,7 +46,7 @@ CinematicMgr::~CinematicMgr()
void CinematicMgr::NextCinematicCamera()
{
// Sanity check for active camera set
if (!m_activeCinematic || m_activeCinematicCameraIndex >= int32(advstd::size(m_activeCinematic->Camera)))
if (!m_activeCinematic || m_activeCinematicCameraIndex >= int32(std::size(m_activeCinematic->Camera)))
return;
uint32 cinematicCameraId = m_activeCinematic->Camera[++m_activeCinematicCameraIndex];

2
src/server/game/Maps/Map.cpp
View File

@@ -113,7 +113,7 @@ void Map::DiscoverGridMapFiles()
&& fread(&build, sizeof(build), 1, tileList) == 1
&& fread(&tilesData[0], MAX_NUMBER_OF_GRIDS * MAX_NUMBER_OF_GRIDS, 1, tileList) == 1)
{
i_gridFileExists = std::bitset<MAX_NUMBER_OF_GRIDS * MAX_NUMBER_OF_GRIDS>(tilesData, advstd::size(tilesData));
i_gridFileExists = std::bitset<MAX_NUMBER_OF_GRIDS * MAX_NUMBER_OF_GRIDS>(tilesData, std::size(tilesData));
fclose(tileList);
return;
}