Clean-up: ensure all template parameter names end with Type

Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
Change-Id: I1d3f307b173fe5fd8796cdaa89a8405217e251db

diff --git a/src/bin/lttng-sessiond/consumer.hpp b/src/bin/lttng-sessiond/consumer.hpp
index 5d05c1cbf985327ae1dbd77336efe6683c14bf7d..6851edbf6c8e5dbd82c09b44f8f6ee296780f049 100644 (file)
--- 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 <typename T>
-constexpr T max_constexpr(T l, T r)
+template <typename NumericalType>
+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 6a5fa162b702837649246920bdc5e1ac2b75355b..2d7f9deaca9c89b9f7916ace43407272fbc83918 100644 (file)
--- 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 <class FieldTypeSet>
-bool fields_are_equal(const FieldTypeSet& a, const FieldTypeSet& b)
+template <class FieldTypeContainerType>
+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 fdebe3acc3bd24ca69b52f71bf0b259363dd1920..207592b3f2af83ca9e3262222f2365828364951d 100644 (file)
--- a/src/bin/lttng-sessiond/field.hpp
+++ b/src/bin/lttng-sessiond/field.hpp
@@ -560,9 +560,9 @@ protected:
 namespace fmt {
 template <>
 struct formatter<lttng::sessiond::trace::field_location> : formatter<std::string> {
-       template <typename FormatCtx>
-       typename FormatCtx::iterator format(
-                       const lttng::sessiond::trace::field_location& location, FormatCtx& ctx)
+       template <typename FormatContextType>
+       typename FormatContextType::iterator format(
+                       const lttng::sessiond::trace::field_location& location, FormatContextType& ctx)
        {
                std::string location_str{"["};
 
@@ -612,10 +612,10 @@ template <typename MappingIntegerType>
 template <>
 struct formatter<typename lttng::sessiond::trace::signed_enumeration_type::mapping::range_t>
        : formatter<std::string> {
-       template <typename FormatCtx>
-       typename FormatCtx::iterator
+       template <typename FormatContextType>
+       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<typename lttng::sessiond::trace::signed_enumeration_type::mappi
 template <>
 struct formatter<typename lttng::sessiond::trace::unsigned_enumeration_type::mapping::range_t>
        : formatter<std::string> {
-       template <typename FormatCtx>
-       typename FormatCtx::iterator
+       template <typename FormatContextType>
+       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 ab00b1c195df52b3f7c35e079f20f2a2a65fb51c..2071a8984495b93026b49f16b2e478cd956c7bed 100644 (file)
--- 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<ust_app> : formatter<std::string> {
-       template <typename FormatCtx>
-       typename FormatCtx::iterator format(const ust_app& app, FormatCtx& ctx)
+       template <typename FormatContextType>
+       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 6b2ebc8434a8428dfea27626713988aba7d4cf85..b38b09553c18d432f96b98a9a49eb254fdf2a4f3 100644 (file)
--- 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<lttng::sessiond::ust::registry_event> : formatter<std::string> {
-       template <typename FormatCtx>
-       typename FormatCtx::iterator format(
-                       const lttng::sessiond::ust::registry_event& event, FormatCtx& ctx)
+       template <typename FormatContextType>
+       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 b586fd489f8f934f8ace25808c7e19ce2acd4fe9..67509c275bad365ee23c2bd86ec7ab6fe44df5aa 100644 (file)
--- a/src/common/format.hpp
+++ b/src/common/format.hpp
@@ -26,8 +26,9 @@ DIAGNOSTIC_POP
 namespace fmt {
 template <>
 struct formatter<std::type_info> : formatter<std::string> {
-       template <typename FormatCtx>
-       typename FormatCtx::iterator format(const std::type_info& type_info, FormatCtx& ctx)
+       template <typename FormatContextType>
+       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 031d2a0564da7da1da1b999a7bac47018c8c50bc..dab6e6df014b7ee1c6976e171423c187f7ff1c91 100644 (file)
--- 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 <typename T>
-struct can_malloc
-{
+template <typename MallocableType>
+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<T>::value;
+       static constexpr bool value = std::is_trivially_constructible<MallocableType>::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<typename T>
-T *zmalloc()
+template <typename MallocableType>
+MallocableType *zmalloc()
 {
-       static_assert (can_malloc<T>::value, "type can be malloc'ed");
-       return (T *) zmalloc_internal(sizeof(T)); /* NOLINT sizeof potentially used on a pointer. */
+       static_assert(can_malloc<MallocableType>::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<typename T>
-T *zmalloc(size_t size)
+template <typename AllocatedType>
+AllocatedType *zmalloc(size_t size)
 {
-       static_assert (can_malloc<T>::value, "type can be malloc'ed");
-       LTTNG_ASSERT(size >= sizeof(T));
-       return (T *) zmalloc_internal(size);
+       static_assert(can_malloc<AllocatedType>::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<typename T>
-T *calloc(size_t nmemb)
+template <typename AllocatedType>
+AllocatedType *calloc(size_t nmemb)
 {
-       static_assert (can_malloc<T>::value, "type can be malloc'ed");
-       return (T *) zmalloc_internal(nmemb * sizeof(T)); /* NOLINT sizeof potentially used on a pointer. */
+       static_assert(can_malloc<AllocatedType>::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<typename T>
-T *malloc()
+template <typename AllocatedType>
+AllocatedType *malloc()
 {
-       static_assert (can_malloc<T>::value, "type can be malloc'ed");
-       return (T *) malloc(sizeof(T));
+       static_assert(can_malloc<AllocatedType>::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<typename T>
-T *malloc(size_t size)
+template<typename AllocatedType>
+AllocatedType *malloc(size_t size)
 {
-       static_assert (can_malloc<T>::value, "type can be malloc'ed");
-       return (T *) malloc(size);
+       static_assert (can_malloc<AllocatedType>::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<typename T>
+template<typename FreedType>
 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<T>::value || std::is_void<T>::value;
+       static constexpr bool value = std::is_trivially_destructible<FreedType>::value ||
+               std::is_void<FreedType>::value;
 #endif
 };
 
-template<typename T, typename = typename std::enable_if<!can_free<T>::value>::type>
-void free(T *p) = delete;
+template <typename FreedType, typename = typename std::enable_if<!can_free<FreedType>::value>::type>
+void free(FreedType *p) = delete;
 
-template<typename T>
-struct can_memset
-{
-       static constexpr bool value = std::is_pod<T>::value || std::is_void<T>::value;
+template <typename InitializedType>
+struct can_memset {
+       static constexpr bool value = std::is_pod<InitializedType>::value ||
+               std::is_void<InitializedType>::value;
 };
 
-template <typename T, typename = typename std::enable_if<!can_memset<T>::value>::type>
-void *memset(T *s, int c, size_t n) = delete;
+template <typename InitializedType,
+         typename = typename std::enable_if<!can_memset<InitializedType>::value>::type>
+void *memset(InitializedType *s, int c, size_t n) = delete;
 
 template<typename T>
 struct can_memcpy
@@ -197,14 +203,14 @@ struct can_memcpy
 #endif
 };
 
-template <typename T, typename U,
-               typename = typename std::enable_if<!can_memcpy<T>::value>::type,
-               typename = typename std::enable_if<!can_memcpy<U>::value>::type>
-void *memcpy(T *d, const U *s, size_t n) = delete;
+template <typename DestinationType,
+         typename SourceType,
+         typename = typename std::enable_if<!can_memcpy<DestinationType>::value>::type,
+         typename = typename std::enable_if<!can_memcpy<SourceType>::value>::type>
+void *memcpy(DestinationType *d, const SourceType *s, size_t n) = delete;
 
-template<typename T>
-struct can_memmove
-{
+template <typename MovedType>
+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<T>::value;
+       static constexpr bool value = std::is_trivially_copyable<MovedType>::value;
 #endif
 };
 
-template <typename T, typename U,
-               typename = typename std::enable_if<!can_memmove<T>::value>::type,
-               typename = typename std::enable_if<!can_memmove<U>::value>::type>
-void *memmove(T *d, const U *s, size_t n) = delete;
+template <typename DestinationType,
+         typename SourceType,
+         typename = typename std::enable_if<!can_memmove<DestinationType>::value>::type,
+         typename = typename std::enable_if<!can_memmove<SourceType>::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 <class Parent, class Member>
-Parent *container_of(const Member *member, const Member Parent::*ptr_to_member)
+template <class ParentType, class MemberType>
+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<const char *>(&(dummy_parent->*ptr_to_member));
        auto address_of_parent = reinterpret_cast<const char *>(member) - offset_of_member;
 
-       return reinterpret_cast<Parent *>(address_of_parent);
+       return reinterpret_cast<ParentType *>(address_of_parent);
 }
 } /* namespace utils */
 } /* namespace lttng */