From: Jérémie Galarneau Date: Mon, 16 Jan 2023 19:12:28 +0000 (-0500) Subject: Clean-up: ensure all template parameter names end with Type X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=31375c424ac115fc0373237207fed795849e26ba;p=lttng-tools.git Clean-up: ensure all template parameter names end with Type Signed-off-by: Jérémie Galarneau Change-Id: I1d3f307b173fe5fd8796cdaa89a8405217e251db --- diff --git a/src/bin/lttng-sessiond/consumer.hpp b/src/bin/lttng-sessiond/consumer.hpp index 5d05c1cbf..6851edbf6 100644 --- a/src/bin/lttng-sessiond/consumer.hpp +++ b/src/bin/lttng-sessiond/consumer.hpp @@ -27,8 +27,8 @@ struct ltt_session; * C++. */ static_assert(__cplusplus == 201103L, ""); -template -constexpr T max_constexpr(T l, T r) +template +constexpr NumericalType max_constexpr(NumericalType l, NumericalType r) { return l > r ? l : r; } diff --git a/src/bin/lttng-sessiond/field.cpp b/src/bin/lttng-sessiond/field.cpp index 6a5fa162b..2d7f9deac 100644 --- a/src/bin/lttng-sessiond/field.cpp +++ b/src/bin/lttng-sessiond/field.cpp @@ -15,8 +15,8 @@ namespace lst = lttng::sessiond::trace; namespace { -template -bool fields_are_equal(const FieldTypeSet& a, const FieldTypeSet& b) +template +bool fields_are_equal(const FieldTypeContainerType& a, const FieldTypeContainerType& b) { if (a.size() != b.size()) { return false; @@ -25,8 +25,8 @@ bool fields_are_equal(const FieldTypeSet& a, const FieldTypeSet& b) return std::equal(a.cbegin(), a.cend(), b.cbegin(), - [](typename FieldTypeSet::const_reference field_a, - typename FieldTypeSet::const_reference field_b) { + [](typename FieldTypeContainerType::const_reference field_a, + typename FieldTypeContainerType::const_reference field_b) { return *field_a == *field_b; }); } diff --git a/src/bin/lttng-sessiond/field.hpp b/src/bin/lttng-sessiond/field.hpp index fdebe3acc..207592b3f 100644 --- a/src/bin/lttng-sessiond/field.hpp +++ b/src/bin/lttng-sessiond/field.hpp @@ -560,9 +560,9 @@ protected: namespace fmt { template <> struct formatter : formatter { - template - typename FormatCtx::iterator format( - const lttng::sessiond::trace::field_location& location, FormatCtx& ctx) + template + typename FormatContextType::iterator format( + const lttng::sessiond::trace::field_location& location, FormatContextType& ctx) { std::string location_str{"["}; @@ -612,10 +612,10 @@ template template <> struct formatter : formatter { - template - typename FormatCtx::iterator + template + typename FormatContextType::iterator format(typename lttng::sessiond::trace::signed_enumeration_type::mapping::range_t range, - FormatCtx& ctx) + FormatContextType& ctx) { return format_to(ctx.out(), details::format_mapping_range< @@ -628,10 +628,10 @@ struct formatter struct formatter : formatter { - template - typename FormatCtx::iterator + template + typename FormatContextType::iterator format(typename lttng::sessiond::trace::unsigned_enumeration_type::mapping::range_t range, - FormatCtx& ctx) + FormatContextType& ctx) { return format_to(ctx.out(), details::format_mapping_range< diff --git a/src/bin/lttng-sessiond/ust-app.hpp b/src/bin/lttng-sessiond/ust-app.hpp index ab00b1c19..2071a8984 100644 --- a/src/bin/lttng-sessiond/ust-app.hpp +++ b/src/bin/lttng-sessiond/ust-app.hpp @@ -336,8 +336,8 @@ struct ust_app { namespace fmt { template <> struct formatter : formatter { - template - typename FormatCtx::iterator format(const ust_app& app, FormatCtx& ctx) + template + typename FormatContextType::iterator format(const ust_app& app, FormatContextType& ctx) { return format_to(ctx.out(), "{{ procname = `{}`, ppid = {}, pid = {}, uid = {}, gid = {}, version = {}.{}, registration time = {} }}", diff --git a/src/bin/lttng-sessiond/ust-registry-event.hpp b/src/bin/lttng-sessiond/ust-registry-event.hpp index 6b2ebc843..b38b09553 100644 --- a/src/bin/lttng-sessiond/ust-registry-event.hpp +++ b/src/bin/lttng-sessiond/ust-registry-event.hpp @@ -70,9 +70,9 @@ void registry_event_destroy(registry_event *event); namespace fmt { template <> struct formatter : formatter { - template - typename FormatCtx::iterator format( - const lttng::sessiond::ust::registry_event& event, FormatCtx& ctx) + template + typename FormatContextType::iterator format( + const lttng::sessiond::ust::registry_event& event, FormatContextType& ctx) { return format_to(ctx.out(), "{{ name = `{}`, signature = `{}`, id = {}, session objd = {}, channel objd = {} }}", diff --git a/src/common/format.hpp b/src/common/format.hpp index b586fd489..67509c275 100644 --- a/src/common/format.hpp +++ b/src/common/format.hpp @@ -26,8 +26,9 @@ DIAGNOSTIC_POP namespace fmt { template <> struct formatter : formatter { - template - typename FormatCtx::iterator format(const std::type_info& type_info, FormatCtx& ctx) + template + typename FormatContextType::iterator format(const std::type_info& type_info, + FormatContextType& ctx) { int status; auto demangled_name = diff --git a/src/common/macros.hpp b/src/common/macros.hpp index 031d2a056..dab6e6df0 100644 --- a/src/common/macros.hpp +++ b/src/common/macros.hpp @@ -62,9 +62,8 @@ void *zmalloc_internal(size_t size) return calloc(1, size); } -template -struct can_malloc -{ +template +struct can_malloc { /* * gcc versions before 5.0 lack some type traits defined in C++11. * Since in this instance we use the trait to prevent misuses @@ -76,64 +75,69 @@ struct can_malloc #if __GNUG__ && __GNUC__ < 5 static constexpr bool value = true; #else - static constexpr bool value = std::is_trivially_constructible::value; + static constexpr bool value = std::is_trivially_constructible::value; #endif }; /* - * Malloc and zero-initialize an object of type T, asserting that T can be + * Malloc and zero-initialize an object of type T, asserting that MallocableType can be * safely malloc-ed (is trivially constructible). */ -template -T *zmalloc() +template +MallocableType *zmalloc() { - static_assert (can_malloc::value, "type can be malloc'ed"); - return (T *) zmalloc_internal(sizeof(T)); /* NOLINT sizeof potentially used on a pointer. */ + static_assert(can_malloc::value, "type can be malloc'ed"); + return (MallocableType *) zmalloc_internal(sizeof(MallocableType)); /* NOLINT sizeof + potentially used on a + pointer. */ } /* - * Malloc and zero-initialize a buffer of size `size`, asserting that type T + * Malloc and zero-initialize a buffer of size `size`, asserting that type AllocatedType * can be safely malloc-ed (is trivially constructible). */ -template -T *zmalloc(size_t size) +template +AllocatedType *zmalloc(size_t size) { - static_assert (can_malloc::value, "type can be malloc'ed"); - LTTNG_ASSERT(size >= sizeof(T)); - return (T *) zmalloc_internal(size); + static_assert(can_malloc::value, "type can be malloc'ed"); + LTTNG_ASSERT(size >= sizeof(AllocatedType)); + return (AllocatedType *) zmalloc_internal(size); } /* - * Malloc and zero-initialize an array of `nmemb` elements of type T, - * asserting that T can be safely malloc-ed (is trivially constructible). + * Malloc and zero-initialize an array of `nmemb` elements of type AllocatedType, + * asserting that AllocatedType can be safely malloc-ed (is trivially constructible). */ -template -T *calloc(size_t nmemb) +template +AllocatedType *calloc(size_t nmemb) { - static_assert (can_malloc::value, "type can be malloc'ed"); - return (T *) zmalloc_internal(nmemb * sizeof(T)); /* NOLINT sizeof potentially used on a pointer. */ + static_assert(can_malloc::value, "type can be malloc'ed"); + return (AllocatedType *) zmalloc_internal(nmemb * sizeof(AllocatedType)); /* NOLINT sizeof + potentially + used on a + pointer. */ } /* - * Malloc an object of type T, asserting that T can be safely malloc-ed (is + * Malloc an object of type AllocatedType, asserting that AllocatedType can be safely malloc-ed (is * trivially constructible). */ -template -T *malloc() +template +AllocatedType *malloc() { - static_assert (can_malloc::value, "type can be malloc'ed"); - return (T *) malloc(sizeof(T)); + static_assert(can_malloc::value, "type can be malloc'ed"); + return (AllocatedType *) malloc(sizeof(AllocatedType)); } /* - * Malloc a buffer of size `size`, asserting that type T can be safely + * Malloc a buffer of size `size`, asserting that AllocatedType can be safely * malloc-ed (is trivially constructible). */ -template -T *malloc(size_t size) +template +AllocatedType *malloc(size_t size) { - static_assert (can_malloc::value, "type can be malloc'ed"); - return (T *) malloc(size); + static_assert (can_malloc::value, "type can be malloc'ed"); + return (AllocatedType *) malloc(size); } /* @@ -149,7 +153,7 @@ T *malloc(size_t size) * pointers to void, these will not be checked. */ -template +template struct can_free { /* @@ -163,21 +167,23 @@ struct can_free #if __GNUG__ && __GNUC__ < 5 static constexpr bool value = true; #else - static constexpr bool value = std::is_trivially_destructible::value || std::is_void::value; + static constexpr bool value = std::is_trivially_destructible::value || + std::is_void::value; #endif }; -template::value>::type> -void free(T *p) = delete; +template ::value>::type> +void free(FreedType *p) = delete; -template -struct can_memset -{ - static constexpr bool value = std::is_pod::value || std::is_void::value; +template +struct can_memset { + static constexpr bool value = std::is_pod::value || + std::is_void::value; }; -template ::value>::type> -void *memset(T *s, int c, size_t n) = delete; +template ::value>::type> +void *memset(InitializedType *s, int c, size_t n) = delete; template struct can_memcpy @@ -197,14 +203,14 @@ struct can_memcpy #endif }; -template ::value>::type, - typename = typename std::enable_if::value>::type> -void *memcpy(T *d, const U *s, size_t n) = delete; +template ::value>::type, + typename = typename std::enable_if::value>::type> +void *memcpy(DestinationType *d, const SourceType *s, size_t n) = delete; -template -struct can_memmove -{ +template +struct can_memmove { /* * gcc versions before 5.0 lack some type traits defined in C++11. * Since in this instance we use the trait to prevent misuses @@ -216,14 +222,15 @@ struct can_memmove #if __GNUG__ && __GNUC__ < 5 static constexpr bool value = true; #else - static constexpr bool value = std::is_trivially_copyable::value; + static constexpr bool value = std::is_trivially_copyable::value; #endif }; -template ::value>::type, - typename = typename std::enable_if::value>::type> -void *memmove(T *d, const U *s, size_t n) = delete; +template ::value>::type, + typename = typename std::enable_if::value>::type> +void *memmove(DestinationType *d, const SourceType *s, size_t n) = delete; #ifndef ARRAY_SIZE #define ARRAY_SIZE(array) (sizeof(array) / (sizeof((array)[0]))) @@ -315,14 +322,14 @@ int lttng_strncpy(char *dst, const char *src, size_t dst_len) namespace lttng { namespace utils { -template -Parent *container_of(const Member *member, const Member Parent::*ptr_to_member) +template +ParentType *container_of(const MemberType *member, const MemberType ParentType::*ptr_to_member) { - const Parent *dummy_parent = nullptr; + const ParentType *dummy_parent = nullptr; auto *offset_of_member = reinterpret_cast(&(dummy_parent->*ptr_to_member)); auto address_of_parent = reinterpret_cast(member) - offset_of_member; - return reinterpret_cast(address_of_parent); + return reinterpret_cast(address_of_parent); } } /* namespace utils */ } /* namespace lttng */