Add explicit keyword to constructors

src/NimBLE2904.h

@@ -38,7 +38,7 @@ struct NimBLE2904Data {
  */
 class NimBLE2904 : public NimBLEDescriptor {
   public:
-    NimBLE2904(NimBLECharacteristic* pChr = nullptr);
+    explicit NimBLE2904(NimBLECharacteristic* pChr = nullptr);
     static const uint8_t FORMAT_BOOLEAN   = 1;
     static const uint8_t FORMAT_UINT2     = 2;
     static const uint8_t FORMAT_UINT4     = 3;

src/NimBLEAddress.h

@@ -44,10 +44,10 @@ class NimBLEAddress : private ble_addr_t {
      * @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);
     NimBLEAddress(const std::string& stringAddress, uint8_t type);
     NimBLEAddress(const uint64_t& address, uint8_t type);
+    explicit NimBLEAddress(const ble_addr_t address);
 
     bool                 isRpa() const;
     bool                 isNrpa() const;

src/NimBLEAttValue.h

@@ -84,7 +84,7 @@ class NimBLEAttValue {
      * @param[in] init_len The initial size in bytes.
      * @param[in] max_len The max size in bytes that the value can be.
      */
-    NimBLEAttValue(uint16_t init_len = CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
+    explicit NimBLEAttValue(uint16_t init_len = CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
 
     /**
      * @brief Construct with an initial value from a buffer.
@@ -99,7 +99,7 @@ class NimBLEAttValue {
      * @param value A pointer to the initial value to set.
      * @param[in] max_len The max size in bytes that the value can be.
      */
-    NimBLEAttValue(const char* value, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+    explicit NimBLEAttValue(const char* value, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
         : NimBLEAttValue((uint8_t*)value, (uint16_t)strlen(value), max_len) {}
 
     /**
@@ -115,15 +115,15 @@ class NimBLEAttValue {
      * @param str A std::string containing to the initial value to set.
      * @param[in] max_len The max size in bytes that the value can be.
      */
-    NimBLEAttValue(const std::string str, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+    explicit NimBLEAttValue(const std::string& str, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
         : NimBLEAttValue(reinterpret_cast<const uint8_t*>(&str[0]), str.length(), max_len) {}
 
     /**
      * @brief Construct with an initial value from a std::vector<uint8_t>.
      * @param vec A std::vector<uint8_t> containing to the initial value to set.
      * @param[in] max_len The max size in bytes that the value can be.
      */
-    NimBLEAttValue(const std::vector<uint8_t> vec, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+    explicit NimBLEAttValue(const std::vector<uint8_t>& vec, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
         : NimBLEAttValue(&vec[0], vec.size(), max_len) {}
 
 # ifdef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE

src/NimBLECharacteristic.h

@@ -39,14 +39,14 @@ class NimBLE2904;
  */
 class NimBLECharacteristic : public NimBLELocalValueAttribute {
   public:
-    NimBLECharacteristic(const char*    uuid,
-                         uint16_t       properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
-                         uint16_t       maxLen     = BLE_ATT_ATTR_MAX_LEN,
-                         NimBLEService* pService   = nullptr);
-    NimBLECharacteristic(const NimBLEUUID& uuid,
-                         uint16_t          properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
-                         uint16_t          maxLen     = BLE_ATT_ATTR_MAX_LEN,
-                         NimBLEService*    pService   = nullptr);
+    explicit NimBLECharacteristic(const char*    uuid,
+                                  uint16_t       properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
+                                  uint16_t       maxLen     = BLE_ATT_ATTR_MAX_LEN,
+                                  NimBLEService* pService   = nullptr);
+    explicit NimBLECharacteristic(const NimBLEUUID& uuid,
+                                  uint16_t          properties = NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE,
+                                  uint16_t          maxLen     = BLE_ATT_ATTR_MAX_LEN,
+                                  NimBLEService*    pService   = nullptr);
 
     ~NimBLECharacteristic();
 

src/NimBLEConnInfo.h

@@ -78,6 +78,6 @@ class NimBLEConnInfo {
 
     ble_gap_conn_desc m_desc{};
     NimBLEConnInfo() {};
-    NimBLEConnInfo(ble_gap_conn_desc desc) { m_desc = desc; }
+    explicit NimBLEConnInfo(ble_gap_conn_desc desc) : m_desc(desc) {}
 };
 #endif

src/NimBLEHIDDevice.cpp

@@ -46,23 +46,23 @@ static constexpr uint16_t bootOutputChrUuid     = 0x2a32;
  */
 NimBLEHIDDevice::NimBLEHIDDevice(NimBLEServer* server) {
     // Here we create mandatory services described in bluetooth specification
-    m_deviceInfoSvc = server->createService(deviceInfoSvcUuid);
-    m_hidSvc        = server->createService(hidSvcUuid);
-    m_batterySvc    = server->createService(batterySvcUuid);
+    m_deviceInfoSvc = server->createService(NimBLEUUID(deviceInfoSvcUuid));
+    m_hidSvc        = server->createService(NimBLEUUID(hidSvcUuid));
+    m_batterySvc    = server->createService(NimBLEUUID(batterySvcUuid));
 
     // Mandatory characteristic for device info service
-    m_pnpChr = m_deviceInfoSvc->createCharacteristic(pnpCharUuid, NIMBLE_PROPERTY::READ);
+    m_pnpChr = m_deviceInfoSvc->createCharacteristic(NimBLEUUID(pnpCharUuid), NIMBLE_PROPERTY::READ);
 
     // Mandatory characteristics for HID service
-    m_hidInfoChr    = m_hidSvc->createCharacteristic(hidInfoCharUuid, NIMBLE_PROPERTY::READ);
-    m_reportMapChr  = m_hidSvc->createCharacteristic(reportMapCharUuid, NIMBLE_PROPERTY::READ);
-    m_hidControlChr = m_hidSvc->createCharacteristic(hidControlCharUuid, NIMBLE_PROPERTY::WRITE_NR);
+    m_hidInfoChr    = m_hidSvc->createCharacteristic(NimBLEUUID(hidInfoCharUuid), NIMBLE_PROPERTY::READ);
+    m_reportMapChr  = m_hidSvc->createCharacteristic(NimBLEUUID(reportMapCharUuid), NIMBLE_PROPERTY::READ);
+    m_hidControlChr = m_hidSvc->createCharacteristic(NimBLEUUID(hidControlCharUuid), NIMBLE_PROPERTY::WRITE_NR);
     m_protocolModeChr =
-        m_hidSvc->createCharacteristic(protocolModeCharUuid, NIMBLE_PROPERTY::WRITE_NR | NIMBLE_PROPERTY::READ);
+        m_hidSvc->createCharacteristic(NimBLEUUID(protocolModeCharUuid), NIMBLE_PROPERTY::WRITE_NR | NIMBLE_PROPERTY::READ);
 
     // Mandatory battery level characteristic with notification and presence descriptor
     m_batteryLevelChr =
-        m_batterySvc->createCharacteristic(batteryLevelCharUuid, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY);
+        m_batterySvc->createCharacteristic(NimBLEUUID(batteryLevelCharUuid), NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY);
     NimBLE2904* batteryLevelDescriptor = m_batteryLevelChr->create2904();
     batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
     batteryLevelDescriptor->setUnit(0x27ad); // percentage
@@ -97,7 +97,7 @@ void NimBLEHIDDevice::startServices() {
  */
 bool NimBLEHIDDevice::setManufacturer(const std::string& name) {
     if (m_manufacturerChr == nullptr) {
-        m_manufacturerChr = m_deviceInfoSvc->createCharacteristic(m_manufacturerChrUuid, NIMBLE_PROPERTY::READ);
+        m_manufacturerChr = m_deviceInfoSvc->createCharacteristic(NimBLEUUID(m_manufacturerChrUuid), NIMBLE_PROPERTY::READ);
     }
 
     if (m_manufacturerChr) {
@@ -158,13 +158,13 @@ void NimBLEHIDDevice::setBatteryLevel(uint8_t level, bool notify) {
  * @return nullptr If the characteristic does not exist.
  */
 NimBLECharacteristic* NimBLEHIDDevice::locateReportCharacteristicByIdAndType(uint8_t reportId, uint8_t reportType) {
-    NimBLECharacteristic* candidate = m_hidSvc->getCharacteristic(inputReportChrUuid, 0);
+    NimBLECharacteristic* candidate = m_hidSvc->getCharacteristic(NimBLEUUID(inputReportChrUuid), 0);
     for (uint16_t i = 1; (candidate != nullptr) && (i != 0); i++) {
-        NimBLEDescriptor* dsc           = candidate->getDescriptorByUUID(featureReportDscUuid);
+        NimBLEDescriptor* dsc           = candidate->getDescriptorByUUID(NimBLEUUID(featureReportDscUuid));
         NimBLEAttValue    desc1_val_att = dsc->getValue();
         const uint8_t*    desc1_val     = desc1_val_att.data();
         if ((desc1_val[0] == reportId) && (desc1_val[1] == reportType)) return candidate;
-        candidate = m_hidSvc->getCharacteristic(inputReportChrUuid, i);
+        candidate = m_hidSvc->getCharacteristic(NimBLEUUID(inputReportChrUuid), i);
     }
     return nullptr;
 }
@@ -180,10 +180,10 @@ NimBLECharacteristic* NimBLEHIDDevice::getInputReport(uint8_t reportId) {
     NimBLECharacteristic* inputReportChr = locateReportCharacteristicByIdAndType(reportId, 0x01);
     if (inputReportChr == nullptr) {
         inputReportChr =
-            m_hidSvc->createCharacteristic(inputReportChrUuid,
+            m_hidSvc->createCharacteristic(NimBLEUUID(inputReportChrUuid),
                                            NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ_ENC);
         NimBLEDescriptor* inputReportDsc =
-            inputReportChr->createDescriptor(featureReportDscUuid, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_ENC);
+            inputReportChr->createDescriptor(NimBLEUUID(featureReportDscUuid), NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_ENC);
 
         uint8_t desc1_val[] = {reportId, 0x01};
         inputReportDsc->setValue(desc1_val, 2);
@@ -203,11 +203,11 @@ NimBLECharacteristic* NimBLEHIDDevice::getOutputReport(uint8_t reportId) {
     NimBLECharacteristic* outputReportChr = locateReportCharacteristicByIdAndType(reportId, 0x02);
     if (outputReportChr == nullptr) {
         outputReportChr =
-            m_hidSvc->createCharacteristic(inputReportChrUuid,
+            m_hidSvc->createCharacteristic(NimBLEUUID(inputReportChrUuid),
                                            NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR |
                                                NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
         NimBLEDescriptor* outputReportDsc = outputReportChr->createDescriptor(
-            featureReportDscUuid,
+            NimBLEUUID(featureReportDscUuid),
             NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
         uint8_t desc1_val[] = {reportId, 0x02};
         outputReportDsc->setValue(desc1_val, 2);
@@ -227,10 +227,10 @@ NimBLECharacteristic* NimBLEHIDDevice::getFeatureReport(uint8_t reportId) {
     NimBLECharacteristic* featureReportChr = locateReportCharacteristicByIdAndType(reportId, 0x03);
     if (featureReportChr == nullptr) {
         featureReportChr = m_hidSvc->createCharacteristic(
-            inputReportChrUuid,
+            NimBLEUUID(inputReportChrUuid),
             NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
         NimBLEDescriptor* featureReportDsc = featureReportChr->createDescriptor(
-            featureReportDscUuid,
+            NimBLEUUID(featureReportDscUuid),
             NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
 
         uint8_t desc1_val[] = {reportId, 0x03};
@@ -246,12 +246,12 @@ NimBLECharacteristic* NimBLEHIDDevice::getFeatureReport(uint8_t reportId) {
  * @details This will create the characteristic if not already created.
  */
 NimBLECharacteristic* NimBLEHIDDevice::getBootInput() {
-    NimBLECharacteristic* bootInputChr = m_hidSvc->getCharacteristic(bootInputChrUuid);
+    NimBLECharacteristic* bootInputChr = m_hidSvc->getCharacteristic(NimBLEUUID(bootInputChrUuid));
     if (bootInputChr) {
         return bootInputChr;
     }
 
-    return m_hidSvc->createCharacteristic(bootInputChrUuid, NIMBLE_PROPERTY::NOTIFY);
+    return m_hidSvc->createCharacteristic(NimBLEUUID(bootInputChrUuid), NIMBLE_PROPERTY::NOTIFY);
 } // getBootInput
 
 /**
@@ -260,12 +260,12 @@ NimBLECharacteristic* NimBLEHIDDevice::getBootInput() {
  * @details This will create the characteristic if not already created.
  */
 NimBLECharacteristic* NimBLEHIDDevice::getBootOutput() {
-    NimBLECharacteristic* bootOutputChr = m_hidSvc->getCharacteristic(bootOutputChrUuid);
+    NimBLECharacteristic* bootOutputChr = m_hidSvc->getCharacteristic(NimBLEUUID(bootOutputChrUuid));
     if (bootOutputChr) {
         return bootOutputChr;
     }
 
-    return m_hidSvc->createCharacteristic(bootOutputChrUuid,
+    return m_hidSvc->createCharacteristic(NimBLEUUID(bootOutputChrUuid),
                                           NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR);
 } // getBootOutput
 

src/NimBLERemoteService.cpp

@@ -35,7 +35,7 @@ static const char* LOG_TAG = "NimBLERemoteService";
  * @param [in] service A pointer to the structure with the service information.
  */
 NimBLERemoteService::NimBLERemoteService(NimBLEClient* pClient, const ble_gatt_svc* service)
-    : NimBLEAttribute{service->uuid, service->start_handle}, m_pClient{pClient}, m_endHandle{service->end_handle} {}
+    : NimBLEAttribute{NimBLEUUID(service->uuid), service->start_handle}, m_pClient{pClient}, m_endHandle{service->end_handle} {}
 
 /**
  * @brief When deleting the service make sure we delete all characteristics and descriptors.

src/NimBLERemoteValueAttribute.h

@@ -186,7 +186,7 @@ class NimBLERemoteValueAttribute : public NimBLEAttribute {
     /**
      * @brief Construct a new NimBLERemoteValueAttribute object.
      */
-    NimBLERemoteValueAttribute(const ble_uuid_any_t& uuid, uint16_t handle) : NimBLEAttribute(uuid, handle) {}
+    NimBLERemoteValueAttribute(const ble_uuid_any_t& uuid, uint16_t handle) : NimBLEAttribute(NimBLEUUID(uuid), handle) {}
 
     /**
      * @brief Destroy the NimBLERemoteValueAttribute object.

src/NimBLEService.h

@@ -33,8 +33,8 @@ class NimBLEService;
  */
 class NimBLEService : public NimBLELocalAttribute {
   public:
-    NimBLEService(const char* uuid);
-    NimBLEService(const NimBLEUUID& uuid);
+    explicit NimBLEService(const char* uuid);
+    explicit NimBLEService(const NimBLEUUID& uuid);
     ~NimBLEService();
 
     NimBLEServer*         getServer() const;

src/NimBLEUUID.h

@@ -44,13 +44,13 @@ class NimBLEUUID {
      * @brief Created a blank UUID.
      */
     NimBLEUUID() = default;
-    NimBLEUUID(const ble_uuid_any_t& uuid);
-    NimBLEUUID(const std::string& uuid);
-    NimBLEUUID(uint16_t uuid);
-    NimBLEUUID(uint32_t uuid);
-    NimBLEUUID(const ble_uuid128_t* uuid);
     NimBLEUUID(const uint8_t* pData, size_t size);
     NimBLEUUID(uint32_t first, uint16_t second, uint16_t third, uint64_t fourth);
+    explicit NimBLEUUID(const std::string& uuid);
+    explicit NimBLEUUID(uint16_t uuid);
+    explicit NimBLEUUID(uint32_t uuid);
+    explicit NimBLEUUID(const ble_uuid128_t* uuid);
+    explicit NimBLEUUID(const ble_uuid_any_t& uuid);
 
     uint8_t           bitSize() const;
     const uint8_t*    getValue() const;

src/NimBLEUtils.h

@@ -30,7 +30,7 @@ class NimBLEAddress;
  * All items are optional, the m_pHandle will be set in taskWait().
  */
 struct NimBLETaskData {
-    NimBLETaskData(void* pInstance = nullptr, int flags = 0, void* buf = nullptr);
+    explicit NimBLETaskData(void* pInstance = nullptr, int flags = 0, void* buf = nullptr);
     ~NimBLETaskData();
     void*       m_pInstance{nullptr};
     mutable int m_flags{0};