[numeric-limits] use constexpr variables for min/max (#6720)

src/cli/cli.cpp

@@ -3211,7 +3211,7 @@ otError Interpreter::ProcessPing(uint8_t aArgsLength, Arg aArgs[])
     {
         uint32_t timeout;
         SuccessOrExit(error = ParsePingInterval(aArgs[5], timeout));
-        VerifyOrExit(timeout <= NumericLimits<uint16_t>::Max(), error = OT_ERROR_INVALID_ARGS);
+        VerifyOrExit(timeout <= NumericLimits<uint16_t>::kMax, error = OT_ERROR_INVALID_ARGS);
         config.mTimeout = static_cast<uint16_t>(timeout);
     }
 

src/core/common/numeric_limits.hpp

@@ -28,7 +28,7 @@
 
 /**
  * @file
- *   This file includes definitions for NumericLimits class.
+ *   This file includes definitions for numeric limits.
  */
 
 #ifndef NUMERIC_LIMITS_HPP_
@@ -44,64 +44,58 @@ namespace ot {
  * There are no members if `Type` is not a supported arithmetic type.
  *
  */
-template <typename Type> class NumericLimits
+template <typename Type> struct NumericLimits
 {
 };
 
-template <> class NumericLimits<int8_t>
+// Specialization for different integral types.
+
+template <> struct NumericLimits<int8_t>
 {
-public:
-    static constexpr int8_t Min(void) { return INT8_MIN; }
-    static constexpr int8_t Max(void) { return INT8_MAX; }
+    static constexpr int8_t kMin = INT8_MIN;
+    static constexpr int8_t kMax = INT8_MAX;
 };
 
-template <> class NumericLimits<int16_t>
+template <> struct NumericLimits<int16_t>
 {
-public:
-    static constexpr int16_t Min(void) { return INT16_MIN; }
-    static constexpr int16_t Max(void) { return INT16_MAX; }
+    static constexpr int16_t kMin = INT16_MIN;
+    static constexpr int16_t kMax = INT16_MAX;
 };
 
-template <> class NumericLimits<int32_t>
+template <> struct NumericLimits<int32_t>
 {
-public:
-    static constexpr int32_t Min(void) { return INT32_MIN; }
-    static constexpr int32_t Max(void) { return INT32_MAX; }
+    static constexpr int32_t kMin = INT32_MIN;
+    static constexpr int32_t kMax = INT32_MAX;
 };
 
-template <> class NumericLimits<int64_t>
+template <> struct NumericLimits<int64_t>
 {
-public:
-    static constexpr int64_t Min(void) { return INT64_MIN; }
-    static constexpr int64_t Max(void) { return INT64_MAX; }
+    static constexpr int64_t kMin = INT64_MIN;
+    static constexpr int64_t kMax = INT64_MAX;
 };
 
-template <> class NumericLimits<uint8_t>
+template <> struct NumericLimits<uint8_t>
 {
-public:
-    static constexpr uint8_t Min(void) { return 0; }
-    static constexpr uint8_t Max(void) { return UINT8_MAX; }
+    static constexpr uint8_t kMin = 0;
+    static constexpr uint8_t kMax = UINT8_MAX;
 };
 
-template <> class NumericLimits<uint16_t>
+template <> struct NumericLimits<uint16_t>
 {
-public:
-    static constexpr uint16_t Min(void) { return 0; }
-    static constexpr uint16_t Max(void) { return UINT16_MAX; }
+    static constexpr uint16_t kMin = 0;
+    static constexpr uint16_t kMax = UINT16_MAX;
 };
 
-template <> class NumericLimits<uint32_t>
+template <> struct NumericLimits<uint32_t>
 {
-public:
-    static constexpr uint32_t Min(void) { return 0; }
-    static constexpr uint32_t Max(void) { return UINT32_MAX; }
+    static constexpr uint32_t kMin = 0;
+    static constexpr uint32_t kMax = UINT32_MAX;
 };
 
-template <> class NumericLimits<uint64_t>
+template <> struct NumericLimits<uint64_t>
 {
-public:
-    static constexpr uint64_t Min(void) { return 0; }
-    static constexpr uint64_t Max(void) { return UINT64_MAX; }
+    static constexpr uint64_t kMin = 0;
+    static constexpr uint64_t kMax = UINT64_MAX;
 };
 
 } // namespace ot

src/core/common/trickle_timer.hpp

@@ -75,7 +75,7 @@ public:
          * suppression behavior, invoking the handler callback independent of number of "consistent" events).
          *
          */
-        kInfiniteRedundancyConstant = NumericLimits<uint16_t>::Max(),
+        kInfiniteRedundancyConstant = NumericLimits<uint16_t>::kMax,
     };
 
     /**

src/core/net/ip4_address.cpp

@@ -62,7 +62,7 @@ Error Address::FromString(const char *aString)
             }
 
             value = static_cast<uint16_t>((value * 10) + static_cast<uint8_t>(digitChar - '0'));
-            VerifyOrExit(value <= NumericLimits<uint8_t>::Max());
+            VerifyOrExit(value <= NumericLimits<uint8_t>::kMax);
             hasFirstDigit = true;
         }
 

src/core/net/ip6_address.cpp

@@ -578,7 +578,7 @@ Error Address::FromString(const char *aString)
             aString++;
             value = (value << 4) + digit;
 
-            VerifyOrExit(value <= NumericLimits<uint16_t>::Max());
+            VerifyOrExit(value <= NumericLimits<uint16_t>::kMax);
         }
 
         VerifyOrExit(aString != start);

src/core/utils/parse_cmdline.cpp

@@ -122,7 +122,7 @@ template <typename UintType> Error ParseUint(const char *aString, UintType &aUin
 
     SuccessOrExit(error = ParseAsUint64(aString, value));
 
-    VerifyOrExit(value <= NumericLimits<UintType>::Max(), error = kErrorInvalidArgs);
+    VerifyOrExit(value <= NumericLimits<UintType>::kMax, error = kErrorInvalidArgs);
     aUint = static_cast<UintType>(value);
 
 exit:
@@ -190,7 +190,7 @@ template <typename IntType> Error ParseInt(const char *aString, IntType &aInt)
 
     SuccessOrExit(error = ParseAsInt32(aString, value));
 
-    VerifyOrExit((NumericLimits<IntType>::Min() <= value) && (value <= NumericLimits<IntType>::Max()),
+    VerifyOrExit((NumericLimits<IntType>::kMin <= value) && (value <= NumericLimits<IntType>::kMax),
                  error = kErrorInvalidArgs);
     aInt = static_cast<IntType>(value);
 
@@ -225,8 +225,8 @@ Error ParseAsInt32(const char *aString, int32_t &aInt32)
     }
 
     SuccessOrExit(error = ParseAsUint64(aString, value));
-    VerifyOrExit(value <= (isNegavtive ? static_cast<uint64_t>(-static_cast<int64_t>(NumericLimits<int32_t>::Min()))
-                                       : static_cast<uint64_t>(NumericLimits<int32_t>::Max())),
+    VerifyOrExit(value <= (isNegavtive ? static_cast<uint64_t>(-static_cast<int64_t>(NumericLimits<int32_t>::kMin))
+                                       : static_cast<uint64_t>(NumericLimits<int32_t>::kMax)),
                  error = kErrorInvalidArgs);
     aInt32 = static_cast<int32_t>(isNegavtive ? -static_cast<int64_t>(value) : static_cast<int64_t>(value));
 

src/core/utils/ping_sender.cpp

@@ -210,7 +210,7 @@ void PingSender::HandleIcmpReceive(const Message &          aMessage,
 
     reply.mSenderAddress = aMessageInfo.GetPeerAddr();
     reply.mRoundTripTime =
-        static_cast<uint16_t>(OT_MIN(TimerMilli::GetNow() - TimeMilli(timestamp), NumericLimits<uint16_t>::Max()));
+        static_cast<uint16_t>(OT_MIN(TimerMilli::GetNow() - TimeMilli(timestamp), NumericLimits<uint16_t>::kMax));
     reply.mSize           = aMessage.GetLength() - aMessage.GetOffset();
     reply.mSequenceNumber = aIcmpHeader.GetSequence();
     reply.mHopLimit       = aMessageInfo.GetHopLimit();

src/core/utils/ping_sender.hpp

@@ -79,8 +79,8 @@ public:
             mSentCount          = 0;
             mReceivedCount      = 0;
             mTotalRoundTripTime = 0;
-            mMinRoundTripTime   = NumericLimits<uint16_t>::Max();
-            mMaxRoundTripTime   = NumericLimits<uint16_t>::Min();
+            mMinRoundTripTime   = NumericLimits<uint16_t>::kMax;
+            mMaxRoundTripTime   = NumericLimits<uint16_t>::kMin;
             mIsMulticast        = false;
         }
     };