mirror of
https://github.com/h2zero/esp-nimble-cpp.git
synced 2024-11-21 20:50:55 +01:00
NimBLEUUID: Add operator == and != + correct equals() to test if values are set.
Adds convenience operators == and != to NimBLEUUID class. Tests if both values are not set in equals operation and returns true if so.
This commit is contained in:
h2zero
parent
1779a3f723
commit
04b524d1f8
2 changed files with 44 additions and 75 deletions
|
|
@ -18,6 +18,8 @@
|
|||
#include "NimBLEUUID.h"
|
||||
#include "NimBLELog.h"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
static const char* LOG_TAG = "NimBLEUUID";
|
||||
|
||||
|
||||
|
|
@ -42,50 +44,25 @@ static const char* LOG_TAG = "NimBLEUUID";
|
|||
m_valueSet = true;
|
||||
if (value.length() == 4) {
|
||||
m_uuid.u.type = BLE_UUID_TYPE_16;
|
||||
m_uuid.u16.value = 0;
|
||||
for(int i=0;i<value.length();){
|
||||
uint8_t MSB = value.c_str()[i];
|
||||
uint8_t LSB = value.c_str()[i+1];
|
||||
|
||||
if(MSB > '9') MSB -= 7;
|
||||
if(LSB > '9') LSB -= 7;
|
||||
m_uuid.u16.value += (((MSB&0x0F) <<4) | (LSB & 0x0F))<<(2-i)*4;
|
||||
i+=2;
|
||||
}
|
||||
m_uuid.u16.value = strtoul(value.c_str(), NULL, 16);
|
||||
}
|
||||
else if (value.length() == 8) {
|
||||
m_uuid.u.type = BLE_UUID_TYPE_32;
|
||||
m_uuid.u32.value = 0;
|
||||
for(int i=0;i<value.length();){
|
||||
uint8_t MSB = value.c_str()[i];
|
||||
uint8_t LSB = value.c_str()[i+1];
|
||||
|
||||
if(MSB > '9') MSB -= 7;
|
||||
if(LSB > '9') LSB -= 7;
|
||||
m_uuid.u32.value += (((MSB&0x0F) <<4) | (LSB & 0x0F))<<(6-i)*4;
|
||||
i+=2;
|
||||
m_uuid.u32.value = strtoul(value.c_str(), NULL, 16);
|
||||
}
|
||||
}
|
||||
else if (value.length() == 16) { // how we can have 16 byte length string reprezenting 128 bit uuid??? needs to be investigated (lack of time)
|
||||
m_uuid.u.type = BLE_UUID_TYPE_128;
|
||||
NimBLEUtils::memrcpy(m_uuid.u128.value, (uint8_t*)value.data(), 16);
|
||||
else if (value.length() == 16) {
|
||||
*this = NimBLEUUID((uint8_t*)value.data(), 16, true);
|
||||
}
|
||||
else if (value.length() == 36) {
|
||||
// If the length of the string is 36 bytes then we will assume it is a long hex string in
|
||||
// UUID format.
|
||||
m_uuid.u.type = BLE_UUID_TYPE_128;
|
||||
int n = 0;
|
||||
for(int i=0;i<value.length();){
|
||||
if(value.c_str()[i] == '-')
|
||||
i++;
|
||||
uint8_t MSB = value.c_str()[i];
|
||||
uint8_t LSB = value.c_str()[i+1];
|
||||
|
||||
if(MSB > '9') MSB -= 7;
|
||||
if(LSB > '9') LSB -= 7;
|
||||
m_uuid.u128.value[15-n++] = ((MSB&0x0F) <<4) | (LSB & 0x0F);
|
||||
i+=2;
|
||||
}
|
||||
char * position = const_cast<char *>(value.c_str());
|
||||
uint32_t first = strtoul(position, &position, 16);
|
||||
uint16_t second = strtoul(position + 1, &position, 16);
|
||||
uint16_t third = strtoul(position + 1, &position, 16);
|
||||
uint16_t fourth = strtoul(position + 1, &position, 16);
|
||||
uint64_t fifth = strtoull(position + 1, NULL, 16);
|
||||
*this = NimBLEUUID(first, second, third, (uint64_t(fourth) << 48) + fifth);
|
||||
}
|
||||
else {
|
||||
NIMBLE_LOGE(LOG_TAG,"ERROR: UUID value not 2, 4, 16 or 36 bytes");
|
||||
|
|
@ -110,8 +87,9 @@ NimBLEUUID::NimBLEUUID(uint8_t* pData, size_t size, bool msbFirst) {
|
|||
return;
|
||||
}
|
||||
m_uuid.u.type = BLE_UUID_TYPE_128;
|
||||
|
||||
if (msbFirst) {
|
||||
NimBLEUtils::memrcpy(m_uuid.u128.value, pData, 16);
|
||||
std::reverse_copy(pData, pData + 16, m_uuid.u128.value);
|
||||
} else {
|
||||
memcpy(m_uuid.u128.value, pData, 16);
|
||||
}
|
||||
|
|
@ -198,10 +176,7 @@ uint8_t NimBLEUUID::bitSize() {
|
|||
* @return True if the UUIDs are equal and false otherwise.
|
||||
*/
|
||||
bool NimBLEUUID::equals(NimBLEUUID uuid) {
|
||||
if(ble_uuid_cmp(&m_uuid.u, &uuid.getNative()->u) == 0){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
return *this == uuid;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -255,47 +230,20 @@ ble_uuid_any_t* NimBLEUUID::getNative() {
|
|||
* A UUID can be internally represented as 16bit, 32bit or the full 128bit. This method
|
||||
* will convert 16 or 32 bit representations to the full 128bit.
|
||||
*/
|
||||
NimBLEUUID NimBLEUUID::to128() {
|
||||
NimBLEUUID &NimBLEUUID::to128() {
|
||||
// If we either don't have a value or are already a 128 bit UUID, nothing further to do.
|
||||
if (!m_valueSet || m_uuid.u.type == BLE_UUID_TYPE_128) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
// If we are 16 bit or 32 bit, then set the 4 bytes of the variable part of the UUID.
|
||||
// If we are 16 bit or 32 bit, then set the other bytes of the UUID.
|
||||
if (m_uuid.u.type == BLE_UUID_TYPE_16) {
|
||||
uint16_t temp = m_uuid.u16.value;
|
||||
m_uuid.u128.value[15] = 0;
|
||||
m_uuid.u128.value[14] = 0;
|
||||
m_uuid.u128.value[13] = (temp >> 8) & 0xff;
|
||||
m_uuid.u128.value[12] = temp & 0xff;
|
||||
|
||||
*this = NimBLEUUID(m_uuid.u16.value, 0x0000, 0x1000, 0x800000805f9b34fb);
|
||||
}
|
||||
else if (m_uuid.u.type == BLE_UUID_TYPE_32) {
|
||||
uint32_t temp = m_uuid.u32.value;
|
||||
m_uuid.u128.value[15] = (temp >> 24) & 0xff;
|
||||
m_uuid.u128.value[14] = (temp >> 16) & 0xff;
|
||||
m_uuid.u128.value[13] = (temp >> 8) & 0xff;
|
||||
m_uuid.u128.value[12] = temp & 0xff;
|
||||
*this = NimBLEUUID(m_uuid.u32.value, 0x0000, 0x1000, 0x800000805f9b34fb);
|
||||
}
|
||||
|
||||
// Set the fixed parts of the UUID.
|
||||
m_uuid.u128.value[11] = 0x00;
|
||||
m_uuid.u128.value[10] = 0x00;
|
||||
|
||||
m_uuid.u128.value[9] = 0x10;
|
||||
m_uuid.u128.value[8] = 0x00;
|
||||
|
||||
m_uuid.u128.value[7] = 0x80;
|
||||
m_uuid.u128.value[6] = 0x00;
|
||||
|
||||
m_uuid.u128.value[5] = 0x00;
|
||||
m_uuid.u128.value[4] = 0x80;
|
||||
m_uuid.u128.value[3] = 0x5f;
|
||||
m_uuid.u128.value[2] = 0x9b;
|
||||
m_uuid.u128.value[1] = 0x34;
|
||||
m_uuid.u128.value[0] = 0xfb;
|
||||
|
||||
m_uuid.u.type = BLE_UUID_TYPE_128;
|
||||
return *this;
|
||||
} // to128
|
||||
|
||||
|
|
@ -311,11 +259,28 @@ NimBLEUUID NimBLEUUID::to128() {
|
|||
* @return A string representation of the UUID.
|
||||
*/
|
||||
std::string NimBLEUUID::toString() {
|
||||
if (!m_valueSet) return "<NULL>"; // If we have no value, nothing to format.
|
||||
return std::string(*this);
|
||||
} // toString
|
||||
|
||||
bool NimBLEUUID::operator ==(const NimBLEUUID & rhs) {
|
||||
if(m_valueSet && rhs.m_valueSet) {
|
||||
return ble_uuid_cmp(&m_uuid.u, &rhs.m_uuid.u) == 0;
|
||||
}
|
||||
|
||||
return m_valueSet == rhs.m_valueSet;
|
||||
}
|
||||
|
||||
bool NimBLEUUID::operator !=(const NimBLEUUID & rhs) {
|
||||
return !this->operator==(rhs);
|
||||
}
|
||||
|
||||
NimBLEUUID::operator std::string() const {
|
||||
if (!m_valueSet) return std::string(); // If we have no value, nothing to format.
|
||||
|
||||
char buf[BLE_UUID_STR_LEN];
|
||||
|
||||
return ble_uuid_to_str(&m_uuid.u, buf);
|
||||
} // toString
|
||||
}
|
||||
|
||||
|
||||
#endif /* CONFIG_BT_ENABLED */
|
||||
|
|
|
|||
|
|
@ -40,10 +40,14 @@ public:
|
|||
uint8_t bitSize(); // Get the number of bits in this uuid.
|
||||
bool equals(NimBLEUUID uuid);
|
||||
ble_uuid_any_t* getNative();
|
||||
NimBLEUUID to128();
|
||||
NimBLEUUID & to128();
|
||||
std::string toString();
|
||||
static NimBLEUUID fromString(std::string uuid); // Create a NimBLEUUID from a string
|
||||
|
||||
bool operator ==(const NimBLEUUID & rhs);
|
||||
bool operator !=(const NimBLEUUID & rhs);
|
||||
operator std::string() const;
|
||||
|
||||
private:
|
||||
ble_uuid_any_t m_uuid; // The underlying UUID structure that this class wraps.
|
||||
bool m_valueSet = false; // Is there a value set for this instance.
|
||||
|
|
|
|||
Loading…
Reference in a new issue