style: establish governed C++ baseline

include/vnm_plot/core/access_policy.h

@@ -19,7 +19,7 @@ template<typename>
 struct always_false : std::false_type {};
 
 constexpr std::uint64_t k_fnv_offset_basis = 1469598103934665603ULL;
-constexpr std::uint64_t k_fnv_prime = 1099511628211ULL;
+constexpr std::uint64_t k_fnv_prime        = 1099511628211ULL;
 
 // Member-pointer policies derive offsets from a real object; keep support to
 // sample shapes whose default-initialization cannot execute user code.
@@ -79,17 +79,17 @@ constexpr std::int64_t timestamp_member_to_ns(Timestamp value)
 
 template<typename Member>
 const std::decay_t<Member>& member_at_offset(
-    const void* sample,
-    std::size_t offset)
+    const void*    sample,
+    std::size_t    offset)
 {
     const auto* bytes = static_cast<const std::uint8_t*>(sample);
     return *reinterpret_cast<const std::decay_t<Member>*>(bytes + offset);
 }
 
 template<typename Timestamp_member>
 std::int64_t member_timestamp_access(
-    const erased_access_policy_t& access,
-    const void* sample)
+    const erased_access_policy_t&  access,
+    const void*                    sample)
 {
     using timestamp_t = std::decay_t<Timestamp_member>;
     return timestamp_member_to_ns<timestamp_t>(
@@ -98,8 +98,8 @@ std::int64_t member_timestamp_access(
 
 template<typename Value_member>
 float member_value_access(
-    const erased_access_policy_t& access,
-    const void* sample)
+    const erased_access_policy_t&  access,
+    const void*                    sample)
 {
     using value_t = std::decay_t<Value_member>;
     return static_cast<float>(
@@ -108,16 +108,15 @@ float member_value_access(
 
 template<typename Range_min_member, typename Range_max_member>
 std::pair<float, float> member_range_access(
-    const erased_access_policy_t& access,
-    const void* sample)
+    const erased_access_policy_t&  access,
+    const void*                    sample)
 {
     using range_min_t = std::decay_t<Range_min_member>;
     using range_max_t = std::decay_t<Range_max_member>;
-    return std::make_pair(
-        static_cast<float>(
-            member_at_offset<range_min_t>(sample, access.range_min_offset)),
-        static_cast<float>(
-            member_at_offset<range_max_t>(sample, access.range_max_offset)));
+    return
+        std::make_pair(
+            static_cast<float>(member_at_offset<range_min_t>(sample, access.range_min_offset)),
+            static_cast<float>(member_at_offset<range_max_t>(sample, access.range_max_offset)));
 }
 
 // Produces a stable cache key from the byte-level identity of a Sample type's
@@ -126,12 +125,12 @@ std::pair<float, float> member_range_access(
 // distinguishes user sample types so caches stay correct across mixed-type
 // series.
 inline std::uint64_t compute_sample_layout_key(
-    std::size_t sample_stride,
-    std::size_t timestamp_offset,
-    std::size_t value_offset,
-    bool has_range,
-    std::size_t range_min_offset,
-    std::size_t range_max_offset)
+    std::size_t    sample_stride,
+    std::size_t    timestamp_offset,
+    std::size_t    value_offset,
+    bool           has_range,
+    std::size_t    range_min_offset,
+    std::size_t    range_max_offset)
 {
     std::uint64_t h = k_fnv_offset_basis;
     h = fnv1a_mix(h, sample_stride);
@@ -147,10 +146,10 @@ template<typename Member>
 constexpr std::uint64_t member_semantics_tag()
 {
     using member_t = std::decay_t<Member>;
-    constexpr std::uint64_t k_floating_tag = 1ULL << 56;
-    constexpr std::uint64_t k_signed_integral_tag = 2ULL << 56;
+    constexpr std::uint64_t k_floating_tag          = 1ULL << 56;
+    constexpr std::uint64_t k_signed_integral_tag   = 2ULL << 56;
     constexpr std::uint64_t k_unsigned_integral_tag = 3ULL << 56;
-    constexpr std::uint64_t k_other_arithmetic_tag = 4ULL << 56;
+    constexpr std::uint64_t k_other_arithmetic_tag  = 4ULL << 56;
 
     if constexpr (std::is_floating_point_v<member_t>) {
         return k_floating_tag | sizeof(member_t);
@@ -169,16 +168,16 @@ constexpr std::uint64_t member_semantics_tag()
 }
 
 inline std::uint64_t compute_sample_semantics_key(
-    std::size_t sample_stride,
-    std::size_t timestamp_offset,
-    std::uint64_t timestamp_tag,
-    std::size_t value_offset,
-    std::uint64_t value_tag,
-    bool has_range,
-    std::size_t range_min_offset,
-    std::uint64_t range_min_tag,
-    std::size_t range_max_offset,
-    std::uint64_t range_max_tag)
+    std::size_t    sample_stride,
+    std::size_t    timestamp_offset,
+    std::uint64_t  timestamp_tag,
+    std::size_t    value_offset,
+    std::uint64_t  value_tag,
+    bool           has_range,
+    std::size_t    range_min_offset,
+    std::uint64_t  range_min_tag,
+    std::size_t    range_max_offset,
+    std::uint64_t  range_max_tag)
 {
     std::uint64_t h = k_fnv_offset_basis;
     h = fnv1a_mix(h, 0x53454D414E544943ULL);
@@ -202,9 +201,9 @@ struct Data_access_policy_typed
 {
     using timestamp_accessor_t =
         detail::access_function_slot_t<std::int64_t(const Sample&)>;
-    using value_accessor_t =
+    using value_accessor_t     =
         detail::access_function_slot_t<float(const Sample&)>;
-    using range_accessor_t =
+    using range_accessor_t     =
         detail::access_function_slot_t<std::pair<float, float>(const Sample&)>;
 
     Data_access_policy_typed()
@@ -241,11 +240,11 @@ struct Data_access_policy_typed
     Data_access_policy_typed& operator=(const Data_access_policy_typed& other)
     {
         if (this != &other) {
-            get_timestamp = other.get_timestamp;
-            get_value = other.get_value;
-            get_range = other.get_range;
-            layout_key = other.layout_key;
-            semantics_key = other.semantics_key;
+            get_timestamp   = other.get_timestamp;
+            get_value       = other.get_value;
+            get_range       = other.get_range;
+            layout_key      = other.layout_key;
+            semantics_key   = other.semantics_key;
             internal_access = other.internal_access;
             ++access_revision;
             bind_accessor_slots();
@@ -256,11 +255,11 @@ struct Data_access_policy_typed
     Data_access_policy_typed& operator=(Data_access_policy_typed&& other)
     {
         if (this != &other) {
-            get_timestamp = other.get_timestamp;
-            get_value = other.get_value;
-            get_range = other.get_range;
-            layout_key = other.layout_key;
-            semantics_key = other.semantics_key;
+            get_timestamp   = other.get_timestamp;
+            get_value       = other.get_value;
+            get_range       = other.get_range;
+            layout_key      = other.layout_key;
+            semantics_key   = other.semantics_key;
             internal_access = other.internal_access;
             ++access_revision;
             bind_accessor_slots();
@@ -269,11 +268,11 @@ struct Data_access_policy_typed
     }
 
     // Timestamps are int64_t nanoseconds (API convention).
-    timestamp_accessor_t get_timestamp;
-    value_accessor_t get_value;
-    range_accessor_t get_range;
+    timestamp_accessor_t   get_timestamp;
+    value_accessor_t       get_value;
+    range_accessor_t       get_range;
 
-    uint64_t layout_key = 0;
+    uint64_t               layout_key = 0;
     sample_semantics_key_t semantics_key;
 
     bool is_valid() const
@@ -282,8 +281,8 @@ struct Data_access_policy_typed
     }
 
     Data_access_policy_typed& set_semantics_key(
-        std::uint64_t value,
-        std::uint64_t revision = 0) noexcept
+        std::uint64_t  value,
+        std::uint64_t  revision = 0) noexcept
     {
         semantics_key =
             detail::make_explicit_sample_semantics_key(value, revision);
@@ -308,7 +307,7 @@ struct Data_access_policy_typed
         if (get_range) {
             policy.get_range = erase_accessor(get_range);
         }
-        policy.layout_key = layout_key;
+        policy.layout_key    = layout_key;
         policy.semantics_key = semantics_key;
         policy.set_internal_access(internal_access);
         return policy;
@@ -317,22 +316,22 @@ struct Data_access_policy_typed
 private:
     template<typename S, typename Timestamp_member, typename Value_member>
     friend void assign_standard_accessors(
-        Data_access_policy_typed<S>& policy,
-        Timestamp_member S::* timestamp_member,
-        Value_member S::* value_member);
+        Data_access_policy_typed<S>&   policy,
+        Timestamp_member S::*          timestamp_member,
+        Value_member S::*              value_member);
 
     template<typename S, typename Timestamp_member, typename Value_member>
     friend Data_access_policy_typed<S> make_access_policy(
-        Timestamp_member S::* timestamp_member,
-        Value_member S::* value_member);
+        Timestamp_member S::*  timestamp_member,
+        Value_member S::*      value_member);
 
     template<typename S, typename Timestamp_member, typename Value_member,
              typename Range_min_member, typename Range_max_member>
     friend Data_access_policy_typed<S> make_access_policy(
-        Timestamp_member S::* timestamp_member,
-        Value_member S::* value_member,
-        Range_min_member S::* range_min_member,
-        Range_max_member S::* range_max_member);
+        Timestamp_member S::*  timestamp_member,
+        Value_member S::*      value_member,
+        Range_min_member S::*  range_min_member,
+        Range_max_member S::*  range_max_member);
 
     void set_internal_access(detail::erased_access_policy_t access)
     {
@@ -363,9 +362,9 @@ struct Data_access_policy_typed
 
 template<typename Sample, typename Timestamp_member, typename Value_member>
 inline void assign_standard_accessors(
-    Data_access_policy_typed<Sample>& policy,
-    Timestamp_member Sample::* timestamp_member,
-    Value_member Sample::* value_member)
+    Data_access_policy_typed<Sample>&  policy,
+    Timestamp_member Sample::*         timestamp_member,
+    Value_member Sample::*             value_member)
 {
     policy.get_timestamp = [timestamp_member](const Sample& sample) -> std::int64_t {
         using timestamp_t = std::decay_t<decltype(sample.*timestamp_member)>;
@@ -391,19 +390,19 @@ template<typename Sample, typename Timestamp_member, typename Value_member,
          typename Range_min_member, typename Range_max_member>
 inline Data_access_policy_typed<Sample> make_access_policy(
     Timestamp_member Sample::* timestamp_member,
-    Value_member Sample::* value_member,
+    Value_member Sample::*     value_member,
     Range_min_member Sample::* range_min_member,
     Range_max_member Sample::* range_max_member)
 {
     Data_access_policy_typed<Sample> policy;
     const std::size_t timestamp_offset = detail::member_offset(timestamp_member);
-    const std::size_t value_offset = detail::member_offset(value_member);
+    const std::size_t value_offset     = detail::member_offset(value_member);
     const std::size_t range_min_offset = detail::member_offset(range_min_member);
     const std::size_t range_max_offset = detail::member_offset(range_max_member);
 
     assign_standard_accessors(policy, timestamp_member, value_member);
     policy.get_range = [range_min_member, range_max_member](const Sample& sample) {
-        const float low = static_cast<float>(sample.*range_min_member);
+        const float low  = static_cast<float>(sample.*range_min_member);
         const float high = static_cast<float>(sample.*range_max_member);
         return std::make_pair(low, high);
     };
@@ -415,20 +414,20 @@ inline Data_access_policy_typed<Sample> make_access_policy(
     internal_access.get_range =
         &detail::member_range_access<Range_min_member, Range_max_member>;
     internal_access.timestamp_offset = timestamp_offset;
-    internal_access.value_offset = value_offset;
+    internal_access.value_offset     = value_offset;
     internal_access.range_min_offset = range_min_offset;
     internal_access.range_max_offset = range_max_offset;
     internal_access.dispatch_kind =
         detail::access_dispatch_kind_t::MEMBER_POINTER;
     policy.set_internal_access(internal_access);
-    policy.layout_key = detail::compute_sample_layout_key(
+    policy.layout_key                 = detail::compute_sample_layout_key(
         sizeof(Sample),
         timestamp_offset,
         value_offset,
         true,
         range_min_offset,
         range_max_offset);
-    policy.semantics_key.value = detail::compute_sample_semantics_key(
+    policy.semantics_key.value        = detail::compute_sample_semantics_key(
         sizeof(Sample),
         timestamp_offset,
         detail::member_semantics_tag<Timestamp_member>(),
@@ -439,29 +438,29 @@ inline Data_access_policy_typed<Sample> make_access_policy(
         detail::member_semantics_tag<Range_min_member>(),
         range_max_offset,
         detail::member_semantics_tag<Range_max_member>());
-    policy.semantics_key.revision = 0;
+    policy.semantics_key.revision     = 0;
     policy.semantics_key.conservative = false;
     return policy;
 }
 
 template<typename Sample, typename Timestamp_member, typename Value_member>
 inline Data_access_policy_typed<Sample> make_access_policy(
     Timestamp_member Sample::* timestamp_member,
-    Value_member Sample::* value_member)
+    Value_member Sample::*     value_member)
 {
     Data_access_policy_typed<Sample> policy;
     const std::size_t timestamp_offset = detail::member_offset(timestamp_member);
-    const std::size_t value_offset = detail::member_offset(value_member);
+    const std::size_t value_offset     = detail::member_offset(value_member);
 
     assign_standard_accessors(policy, timestamp_member, value_member);
-    policy.layout_key = detail::compute_sample_layout_key(
+    policy.layout_key                 = detail::compute_sample_layout_key(
         sizeof(Sample),
         timestamp_offset,
         value_offset,
         false,
         0,
         0);
-    policy.semantics_key.value = detail::compute_sample_semantics_key(
+    policy.semantics_key.value        = detail::compute_sample_semantics_key(
         sizeof(Sample),
         timestamp_offset,
         detail::member_semantics_tag<Timestamp_member>(),
@@ -472,7 +471,7 @@ inline Data_access_policy_typed<Sample> make_access_policy(
         0,
         0,
         0);
-    policy.semantics_key.revision = 0;
+    policy.semantics_key.revision     = 0;
     policy.semantics_key.conservative = false;
     return policy;
 }