style: use std:: everywhere

Author: sophec

src/AT24CM02.cpp

@@ -2,13 +2,13 @@
 
 #include <algorithm>
 
-constexpr static uint32_t kAddrMask{(1U << 18U) - 1U};
+constexpr static std::uint32_t kAddrMask{(1U << 18U) - 1U};
 
-AT24CM02::AT24CM02(i2c_inst_t* i2c, bool addr_pin) noexcept
+AT24CM02::AT24CM02(::i2c_inst_t* i2c, bool addr_pin) noexcept
     : i2c_{i2c}, addr_pin_(addr_pin ? 1U : 0U) {}
 
-bool AT24CM02::Write(uint32_t addr, const uint8_t* buf,
-                     size_t len) const noexcept {
+bool AT24CM02::Write(std::uint32_t addr, const std::uint8_t* buf,
+                     std::size_t len) const noexcept {
   if (!i2c_ || !buf || len == 0 || (addr & ~kAddrMask)) {
     return false;
   }
@@ -17,15 +17,16 @@ bool AT24CM02::Write(uint32_t addr, const uint8_t* buf,
     return false;
   }
 
-  size_t page_remain = kBytesPerPage - (addr % kBytesPerPage);
+  std::size_t page_remain = kBytesPerPage - (addr % kBytesPerPage);
 
   if (len < page_remain) {
     page_remain = len;
   }
 
   while (len > 0) {
-    const uint8_t i2c_addr = (0xA0 | (addr_pin_ << 3U) | (addr >> 15U)) >> 1U;
-    uint8_t addr_bytes[2];
+    const std::uint8_t i2c_addr =
+        (0xA0 | (addr_pin_ << 3U) | (addr >> 15U)) >> 1U;
+    std::uint8_t addr_bytes[2];
 
     addr_bytes[0] = (addr & 0x0FF00) >> 8;
     addr_bytes[1] = addr & 0x000FF;
@@ -54,7 +55,8 @@ bool AT24CM02::Write(uint32_t addr, const uint8_t* buf,
   return true;
 }
 
-bool AT24CM02::Read(uint32_t addr, uint8_t* buf, size_t len) const noexcept {
+bool AT24CM02::Read(std::uint32_t addr, std::uint8_t* buf,
+                    std::size_t len) const noexcept {
   if (!i2c_ || !buf || len == 0 || (addr & ~kAddrMask)) {
     return false;
   }
@@ -63,8 +65,9 @@ bool AT24CM02::Read(uint32_t addr, uint8_t* buf, size_t len) const noexcept {
     return false;
   }
 
-  const uint8_t i2c_addr = (0xA0 | (addr_pin_ << 3U) | (addr >> 15U)) >> 1U;
-  uint8_t addr_bytes[2];
+  const std::uint8_t i2c_addr =
+      (0xA0 | (addr_pin_ << 3U) | (addr >> 15U)) >> 1U;
+  std::uint8_t addr_bytes[2];
 
   addr_bytes[0] = (addr & 0x0FF00) >> 8;
   addr_bytes[1] = addr & 0x000FF;

src/AT24CM02.h

@@ -1,27 +1,29 @@
 #ifndef PICO_IDENT_SRC_AT24CM02_H
 #define PICO_IDENT_SRC_AT24CM02_H
 
-#include "hardware/i2c.h"
-
 #include <cstddef>
 #include <cstdint>
 
+#include "hardware/i2c.h"
+
 class AT24CM02 {
  public:
-  static constexpr size_t kPages{1024U};
-  static constexpr size_t kBytesPerPage{256U};
+  static constexpr std::size_t kPages{1024U};
+  static constexpr std::size_t kBytesPerPage{256U};
 
-  explicit AT24CM02(i2c_inst_t* i2c, bool addr_pin) noexcept;
+  explicit AT24CM02(::i2c_inst_t* i2c, bool addr_pin) noexcept;
 
   explicit AT24CM02(std::nullptr_t, bool) = delete;
 
-  bool Write(uint32_t addr, const uint8_t* buf, size_t len) const noexcept;
+  bool Write(std::uint32_t addr, const std::uint8_t* buf,
+             std::size_t len) const noexcept;
 
-  bool Read(uint32_t addr, uint8_t* buf, size_t len) const noexcept;
+  bool Read(std::uint32_t addr, std::uint8_t* buf,
+            std::size_t len) const noexcept;
 
  private:
-  const uint8_t addr_pin_;
-  i2c_inst_t* i2c_;
+  const std::uint8_t addr_pin_;
+  ::i2c_inst_t* i2c_;
 };
 
-#endif  /* PICO_IDENT_SRC_AT24CM02_H */
+#endif /* PICO_IDENT_SRC_AT24CM02_H */

src/DeviceInfo.h

@@ -38,10 +38,10 @@ struct DeviceInfoString {
     return sv;
   }
 
-  [[nodiscard]] uint8_t Sum() const noexcept {
-    uint8_t sum{};
+  [[nodiscard]] std::uint8_t Sum() const noexcept {
+    std::uint8_t sum{};
     for (char c : data) {
-      sum += static_cast<uint8_t>(c);
+      sum += static_cast<std::uint8_t>(c);
     }
     return sum;
   }
@@ -67,7 +67,7 @@ struct DeviceInfoBlock {
   // This checksum field is calculated by summing up all of the previous bytes
   // in this structure. It's crude, but should be good enough for such a basic
   // device.
-  uint8_t checksum;
+  std::uint8_t checksum;
 
   // If any field was not valid and was updated, returns false.
   [[nodiscard]] bool Validate() noexcept {
@@ -86,8 +86,8 @@ struct DeviceInfoBlock {
   }
 
   // Computes (but does not update!) the checksum.
-  [[nodiscard]] uint8_t ComputeChecksum() const noexcept {
-    uint8_t sum{};
+  [[nodiscard]] std::uint8_t ComputeChecksum() const noexcept {
+    std::uint8_t sum{};
     sum += mfg.Sum();
     sum += name.Sum();
     sum += ver.Sum();

src/main.cpp

@@ -35,8 +35,8 @@
 
 #define I2C_INST i2c0
 
-static constexpr uint32_t kDeviceInfoAddr{0x0};
-static constexpr uint32_t kEdgeCountAddr{0x800};
+static constexpr std::uint32_t kDeviceInfoAddr{0x0};
+static constexpr std::uint32_t kEdgeCountAddr{0x800};
 
 // Board ID (this is set only once and stored here).
 static char board_id[PICO_UNIQUE_BOARD_ID_SIZE_BYTES * 2 + 1];
@@ -47,8 +47,8 @@ static DeviceInfoBlock data;
 // EEPROM peripheral.
 static AT24CM02 eeprom{I2C_INST, true};
 
-static volatile uint32_t edgecount;
-static uint32_t last_edgecount;
+static volatile std::uint32_t edgecount;
+static std::uint32_t last_edgecount;
 static volatile ::absolute_time_t last_edge_time;
 
 [[noreturn]] static void Panic() noexcept {
@@ -59,14 +59,15 @@ static volatile ::absolute_time_t last_edge_time;
 }
 
 static void StoreDeviceInfo() noexcept {
-  if (!eeprom.Write(kDeviceInfoAddr, reinterpret_cast<const uint8_t*>(&data),
+  if (!eeprom.Write(kDeviceInfoAddr,
+                    reinterpret_cast<const std::uint8_t*>(&data),
                     sizeof(data))) {
     Panic();
   }
 }
 
 static void LoadDeviceInfo() noexcept {
-  if (!eeprom.Read(kDeviceInfoAddr, reinterpret_cast<uint8_t*>(&data),
+  if (!eeprom.Read(kDeviceInfoAddr, reinterpret_cast<std::uint8_t*>(&data),
                    sizeof(data))) {
     Panic();
   }
@@ -81,16 +82,16 @@ static void ValidateDeviceInfo() noexcept {
   }
 }
 
-static void StoreEdgeCount(uint32_t ec) noexcept {
-  if (!eeprom.Write(kEdgeCountAddr, reinterpret_cast<const uint8_t*>(&ec),
+static void StoreEdgeCount(std::uint32_t ec) noexcept {
+  if (!eeprom.Write(kEdgeCountAddr, reinterpret_cast<const std::uint8_t*>(&ec),
                     sizeof(ec))) {
     Panic();
   }
 }
 
 static void LoadEdgeCount() noexcept {
-  uint32_t ec;
-  if (!eeprom.Read(kEdgeCountAddr, reinterpret_cast<uint8_t*>(&ec),
+  std::uint32_t ec;
+  if (!eeprom.Read(kEdgeCountAddr, reinterpret_cast<std::uint8_t*>(&ec),
                    sizeof(ec))) {
     Panic();
   }
@@ -217,8 +218,7 @@ int main(void) {
 
   // Falling edges increase the edge count.
   ::gpio_set_irq_enabled_with_callback(
-      PIN_SWITCH, GPIO_IRQ_EDGE_FALL, true,
-      [](uint, uint32_t) {
+      PIN_SWITCH, GPIO_IRQ_EDGE_FALL, true, [](::uint, std::uint32_t) {
         const auto now = ::get_absolute_time();
         const auto diff = ::absolute_time_diff_us(last_edge_time, now);
         // 50ms debounce
@@ -229,7 +229,7 @@ int main(void) {
       });
 
   char rdbuf[512] = {0};
-  size_t idx = 0;
+  std::size_t idx = 0;
   int c;
   while (1) {
     c = ::getchar_timeout_us(10);