[BREAKING] Refactor NimBLEAddress - use NimBLE core representation.

This simplifies the NimBLEAddress code by directly using the NimBLE core `ble_addr_t` type to hold the address
and allows using NimBLE core functions and macros to replace code in some methods.

* `getNative()` replaced with `getBase()` and now returns a pointer to `const ble_addr_t` instead of a pointer to the address value.
* Adds `isNrpa()` method to test if an address is random non-resolvable.
* Adds `isStatic()` method to test if an address is random static.
* Adds `isPublic()` method to test if an address is a public address.
* Adds `isNull()` methods to test if an address is NULL.
* Adds `getValue()` method which returns a read-only pointer to the address value.
* Adds `reverseByteOrder()` method which will reverse the byte order of the address value.
* `equals()` method and == operator will now also test if the address types are the same.
* Code cleanup.

src/NimBLEAddress.cpp

@@ -14,192 +14,209 @@
 #include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
-#include <algorithm>
+# include "NimBLEAddress.h"
+# include "NimBLELog.h"
 
-#include "NimBLEAddress.h"
-#include "NimBLEUtils.h"
-#include "NimBLELog.h"
+# include <algorithm>
 
 static const char* LOG_TAG = "NimBLEAddress";
 
 /*************************************************
  * NOTE: NimBLE address bytes are in INVERSE ORDER!
- * We will accomodate that fact in these methods.
-*************************************************/
+ * We will accommodate that fact in these methods.
+ *************************************************/
 
 /**
  * @brief Create an address from the native NimBLE representation.
  * @param [in] address The native NimBLE address.
  */
-NimBLEAddress::NimBLEAddress(ble_addr_t address) {
-    memcpy(m_address, address.val, 6);
-    m_addrType = address.type;
-} // NimBLEAddress
-
+NimBLEAddress::NimBLEAddress(ble_addr_t address) : ble_addr_t{address} {}
 
 /**
- * @brief Create a blank address, i.e. 00:00:00:00:00:00, type 0.
- */
-NimBLEAddress::NimBLEAddress() {
-    NimBLEAddress("");
-} // NimBLEAddress
-
-
-/**
- * @brief Create an address from a hex string
+ * @brief Create an address from a hex string.
  *
  * A hex string is of the format:
  * ```
  * 00:00:00:00:00:00
  * ```
  * which is 17 characters in length.
- *
- * @param [in] stringAddress The hex string representation of the address.
+ * @param [in] addr The hex string representation of the address.
  * @param [in] type The type of the address.
  */
-NimBLEAddress::NimBLEAddress(const std::string &stringAddress, uint8_t type) {
-    m_addrType = type;
-
-    if (stringAddress.length() == 0) {
-        memset(m_address, 0, 6);
-        return;
-    }
+NimBLEAddress::NimBLEAddress(const std::string& addr, uint8_t type) {
+    this->type = type;
 
-    if (stringAddress.length() == 6) {
-        std::reverse_copy(stringAddress.data(), stringAddress.data() + 6, m_address);
+    if (addr.length() == BLE_DEV_ADDR_LEN) {
+        std::reverse_copy(addr.data(), addr.data() + BLE_DEV_ADDR_LEN, this->val);
         return;
     }
 
-    if (stringAddress.length() != 17) {
-        memset(m_address, 0, sizeof m_address); // "00:00:00:00:00:00" represents an invalid address
-        NIMBLE_LOGD(LOG_TAG, "Invalid address '%s'", stringAddress.c_str());
+    if (addr.length() == 17) {
+        std::string mac{addr};
+        mac.erase(std::remove(mac.begin(), mac.end(), ':'), mac.end());
+        uint64_t address = std::stoul(mac, nullptr, 16);
+        memcpy(this->val, &address, sizeof this->val);
         return;
     }
 
-    int data[6];
-    if(sscanf(stringAddress.c_str(), "%x:%x:%x:%x:%x:%x", &data[5], &data[4], &data[3], &data[2], &data[1], &data[0]) != 6) {
-        memset(m_address, 0, sizeof m_address); // "00:00:00:00:00:00" represents an invalid address
-        NIMBLE_LOGD(LOG_TAG, "Invalid address '%s'", stringAddress.c_str());
-    }
-    for(size_t index = 0; index < sizeof m_address; index++) {
-        m_address[index] = data[index];
-    }
+    *this = NimBLEAddress{};
+    NIMBLE_LOGE(LOG_TAG, "Invalid address '%s'", addr.c_str());
 } // NimBLEAddress
 
-
 /**
  * @brief Constructor for compatibility with bluedroid esp library using native ESP representation.
  * @param [in] address A uint8_t[6] or esp_bd_addr_t containing the address.
  * @param [in] type The type of the address.
  */
-NimBLEAddress::NimBLEAddress(uint8_t address[6], uint8_t type) {
-    std::reverse_copy(address, address + sizeof m_address, m_address);
-    m_addrType = type;
+NimBLEAddress::NimBLEAddress(const uint8_t address[BLE_DEV_ADDR_LEN], uint8_t type) {
+    std::reverse_copy(address, address + BLE_DEV_ADDR_LEN, this->val);
+    this->type = type;
 } // NimBLEAddress
 
-
 /**
  * @brief Constructor for address using a hex value.\n
  * Use the same byte order, so use 0xa4c1385def16 for "a4:c1:38:5d:ef:16"
  * @param [in] address uint64_t containing the address.
  * @param [in] type The type of the address.
  */
-NimBLEAddress::NimBLEAddress(const uint64_t &address, uint8_t type) {
-    memcpy(m_address, &address, sizeof m_address);
-    m_addrType = type;
+NimBLEAddress::NimBLEAddress(const uint64_t& address, uint8_t type) {
+    memcpy(this->val, &address, sizeof this->val);
+    this->type = type;
 } // NimBLEAddress
 
-
 /**
  * @brief Determine if this address equals another.
  * @param [in] otherAddress The other address to compare against.
  * @return True if the addresses are equal.
  */
-bool NimBLEAddress::equals(const NimBLEAddress &otherAddress) const {
+bool NimBLEAddress::equals(const NimBLEAddress& otherAddress) const {
     return *this == otherAddress;
 } // equals
 
-
 /**
- * @brief Get the native representation of the address.
- * @return a pointer to the uint8_t[6] array of the address.
+ * @brief Get the NimBLE base struct of the address.
+ * @return A read only reference to the NimBLE base struct of the address.
  */
-const uint8_t *NimBLEAddress::getNative() const {
-    return m_address;
-} // getNative
-
+const ble_addr_t* NimBLEAddress::getBase() const {
+    return reinterpret_cast<const ble_addr_t*>(this);
+} // getBase
 
 /**
  * @brief Get the address type.
  * @return The address type.
  */
 uint8_t NimBLEAddress::getType() const {
-    return m_addrType;
+    return this->type;
 } // getType
 
+/**
+ * @brief Get the address value.
+ * @return A read only reference to the address value.
+ */
+const uint8_t* NimBLEAddress::getVal() const {
+    return this->val;
+} // getVal
 
 /**
  * @brief Determine if this address is a Resolvable Private Address.
  * @return True if the address is a RPA.
  */
 bool NimBLEAddress::isRpa() const {
-    return (m_addrType && ((m_address[5] & 0xc0) == 0x40));
+    return BLE_ADDR_IS_RPA(this);
 } // isRpa
 
+/**
+ * @brief Determine if this address is a Non-Resolvable Private Address.
+ * @return True if the address is a NRPA.
+ */
+bool NimBLEAddress::isNrpa() const {
+    return BLE_ADDR_IS_NRPA(this);
+} // isNrpa
+
+/**
+ * @brief Determine if this address is a Static Address.
+ * @return True if the address is a Static Address.
+ */
+bool NimBLEAddress::isStatic() const {
+    return BLE_ADDR_IS_STATIC(this);
+} // isStatic
+
+/**
+ * @brief Determine if this address is a Public Address.
+ * @return True if the address is a Public Address.
+ */
+bool NimBLEAddress::isPublic() const {
+    return this->type == BLE_ADDR_PUBLIC;
+} // isPublic
+
+/**
+ * @brief Determine if this address is a NULL Address.
+ * @return True if the address is a NULL Address.
+ */
+bool NimBLEAddress::isNull() const {
+    return *this == NimBLEAddress{};
+} // isNull
 
 /**
  * @brief Convert a BLE address to a string.
- *
- * A string representation of an address is in the format:
- *
- * ```
- * xx:xx:xx:xx:xx:xx
- * ```
- *
  * @return The string representation of the address.
  * @deprecated Use std::string() operator instead.
  */
 std::string NimBLEAddress::toString() const {
     return std::string(*this);
 } // toString
 
+/**
+ * @brief Reverse the byte order of the address.
+ * @return A reference to this address.
+ */
+const NimBLEAddress& NimBLEAddress::reverseByteOrder() {
+    std::reverse(this->val, this->val + BLE_DEV_ADDR_LEN);
+    return *this;
+} // reverseByteOrder
 
 /**
  * @brief Convenience operator to check if this address is equal to another.
  */
-bool NimBLEAddress::operator ==(const NimBLEAddress & rhs) const {
-    return memcmp(rhs.m_address, m_address, sizeof m_address) == 0;
-} // operator ==
+bool NimBLEAddress::operator==(const NimBLEAddress& rhs) const {
+    if (this->type != rhs.type) {
+        return false;
+    }
 
+    return memcmp(rhs.val, this->val, sizeof this->val) == 0;
+} // operator ==
 
 /**
  * @brief Convenience operator to check if this address is not equal to another.
  */
-bool NimBLEAddress::operator !=(const NimBLEAddress & rhs) const {
+bool NimBLEAddress::operator!=(const NimBLEAddress& rhs) const {
     return !this->operator==(rhs);
 } // operator !=
 
-
 /**
- * @brief Convienience operator to convert this address to string representation.
- * @details This allows passing NimBLEAddress to functions
- * that accept std::string and/or or it's methods as a parameter.
+ * @brief Convenience operator to convert this address to string representation.
+ * @details This allows passing NimBLEAddress to functions that accept std::string and/or it's methods as a parameter.
  */
 NimBLEAddress::operator std::string() const {
     char buffer[18];
-    snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
-                                     m_address[5], m_address[4], m_address[3],
-                                     m_address[2], m_address[1], m_address[0]);
-    return std::string(buffer);
+    snprintf(buffer,
+             sizeof(buffer),
+             "%02x:%02x:%02x:%02x:%02x:%02x",
+             this->val[5],
+             this->val[4],
+             this->val[3],
+             this->val[2],
+             this->val[1],
+             this->val[0]);
+    return std::string{buffer};
 } // operator std::string
 
-
 /**
  * @brief Convenience operator to convert the native address representation to uint_64.
  */
 NimBLEAddress::operator uint64_t() const {
     uint64_t address = 0;
-    memcpy(&address, m_address, sizeof m_address);
+    memcpy(&address, this->val, sizeof this->val);
     return address;
 } // operator uint64_t
 

src/NimBLEAddress.h

@@ -12,52 +12,56 @@
  *      Author: kolban
  */
 
-#ifndef COMPONENTS_NIMBLEADDRESS_H_
-#define COMPONENTS_NIMBLEADDRESS_H_
+#ifndef NIMBLE_CPP_ADDRESS_H_
+#define NIMBLE_CPP_ADDRESS_H_
 #include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
-#if defined(CONFIG_NIMBLE_CPP_IDF)
-#include "nimble/ble.h"
-#else
-#include "nimble/nimble/include/nimble/ble.h"
-#endif
+# if defined(CONFIG_NIMBLE_CPP_IDF)
+#  include "nimble/ble.h"
+# else
+#  include "nimble/nimble/include/nimble/ble.h"
+# endif
 
 /****  FIX COMPILATION ****/
-#undef min
-#undef max
+# undef min
+# undef max
 /**************************/
 
-#include <string>
-#include <algorithm>
+# include <string>
 
 /**
  * @brief A %BLE device address.
  *
  * Every %BLE device has a unique address which can be used to identify it and form connections.
  */
-class NimBLEAddress {
-public:
-    NimBLEAddress();
-    NimBLEAddress(ble_addr_t address);
-    NimBLEAddress(uint8_t address[6], uint8_t type = BLE_ADDR_PUBLIC);
-    NimBLEAddress(const std::string &stringAddress, uint8_t type = BLE_ADDR_PUBLIC);
-    NimBLEAddress(const uint64_t &address, uint8_t type = BLE_ADDR_PUBLIC);
-    bool            isRpa() const;
-    bool            equals(const NimBLEAddress &otherAddress) const;
-    const uint8_t*  getNative() const;
-    std::string     toString() const;
-    uint8_t         getType() const;
+class NimBLEAddress : private ble_addr_t {
+  public:
+    /**
+     * @brief Create a blank address, i.e. 00:00:00:00:00:00, type 0.
+     */
+    NimBLEAddress() = default;
+    NimBLEAddress(const ble_addr_t address);
+    NimBLEAddress(const uint8_t address[BLE_DEV_ADDR_LEN], uint8_t type = BLE_ADDR_PUBLIC);
+    NimBLEAddress(const std::string& stringAddress, uint8_t type = BLE_ADDR_PUBLIC);
+    NimBLEAddress(const uint64_t& address, uint8_t type = BLE_ADDR_PUBLIC);
 
-    bool operator   ==(const NimBLEAddress & rhs) const;
-    bool operator   !=(const NimBLEAddress & rhs) const;
-    operator        std::string() const;
-    operator        uint64_t() const;
-
-private:
-    uint8_t        m_address[6];
-    uint8_t        m_addrType;
+    bool                 isRpa() const;
+    bool                 isNrpa() const;
+    bool                 isStatic() const;
+    bool                 isPublic() const;
+    bool                 isNull() const;
+    bool                 equals(const NimBLEAddress& otherAddress) const;
+    const ble_addr_t*    getBase() const;
+    std::string          toString() const;
+    uint8_t              getType() const;
+    const uint8_t*       getVal() const;
+    const NimBLEAddress& reverseByteOrder();
+    bool                 operator==(const NimBLEAddress& rhs) const;
+    bool                 operator!=(const NimBLEAddress& rhs) const;
+                         operator std::string() const;
+                         operator uint64_t() const;
 };
 
 #endif /* CONFIG_BT_ENABLED */
-#endif /* COMPONENTS_NIMBLEADDRESS_H_ */
+#endif /* NIMBLE_CPP_ADDRESS_H_ */

src/NimBLEAdvertisedDevice.cpp

@@ -302,7 +302,7 @@ NimBLEAddress NimBLEAdvertisedDevice::getTargetAddress(uint8_t index) {
         }
     }
 
-    return NimBLEAddress("");
+    return NimBLEAddress();
 }
 
 

src/NimBLEAdvertisedDevice.h

@@ -162,7 +162,7 @@ class NimBLEAdvertisedDevice {
     uint8_t findAdvField(uint8_t type, uint8_t index = 0, size_t * data_loc = nullptr);
     size_t  findServiceData(uint8_t index, uint8_t* bytes);
 
-    NimBLEAddress   m_address = NimBLEAddress("");
+    NimBLEAddress   m_address;
     uint8_t         m_advType;
     int             m_rssi;
     time_t          m_timestamp;