Phase 2 support C2/C6

lib/libesp32_div/esp-nimble-cpp/src/NimBLEAddress.cpp

@@ -0,0 +1,197 @@
+/*
+ * NimBLEAddress.cpp
+ *
+ *  Created: on Jan 24 2020
+ *      Author H2zero
+ *
+ * Originally:
+ *
+ * BLEAddress.cpp
+ *
+ *  Created on: Jul 2, 2017
+ *      Author: kolban
+ */
+#include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#include <algorithm>
+
+#include "NimBLEAddress.h"
+#include "NimBLEUtils.h"
+#include "NimBLELog.h"
+
+static const char* LOG_TAG = "NimBLEAddress";
+
+/*************************************************
+ * NOTE: NimBLE address bytes are in INVERSE ORDER!
+ * We will accomodate 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
+
+
+/**
+ * @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
+ *
+ * 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] 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;
+    }
+
+    if (stringAddress.length() == 6) {
+        std::reverse_copy(stringAddress.data(), stringAddress.data() + 6, m_address);
+        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());
+        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];
+    }
+} // 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
+
+
+/**
+ * @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
+
+
+/**
+ * @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 {
+    return *this == otherAddress;
+} // equals
+
+
+/**
+ * @brief Get the native representation of the address.
+ * @return a pointer to the uint8_t[6] array of the address.
+ */
+const uint8_t *NimBLEAddress::getNative() const {
+    return m_address;
+} // getNative
+
+
+/**
+ * @brief Get the address type.
+ * @return The address type.
+ */
+uint8_t NimBLEAddress::getType() const {
+    return m_addrType;
+} // getType
+
+
+/**
+ * @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 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 ==
+
+
+/**
+ * @brief Convenience operator to check if this address is not equal to another.
+ */
+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.
+ */
+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);
+} // 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);
+    return address;
+} // operator uint64_t
+
+#endif