EL4121 Embedded System / mbed-os

mbed-os

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

features/FEATURE_BLE/ble/UUID.h@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
be_bryan 0:b74591d5ab33 1 /* mbed Microcontroller Library
be_bryan 0:b74591d5ab33 2 * Copyright (c) 2006-2013 ARM Limited
be_bryan 0:b74591d5ab33 3 *
be_bryan 0:b74591d5ab33 4 * Licensed under the Apache License, Version 2.0 (the "License");
be_bryan 0:b74591d5ab33 5 * you may not use this file except in compliance with the License.
be_bryan 0:b74591d5ab33 6 * You may obtain a copy of the License at
be_bryan 0:b74591d5ab33 7 *
be_bryan 0:b74591d5ab33 8 * http://www.apache.org/licenses/LICENSE-2.0
be_bryan 0:b74591d5ab33 9 *
be_bryan 0:b74591d5ab33 10 * Unless required by applicable law or agreed to in writing, software
be_bryan 0:b74591d5ab33 11 * distributed under the License is distributed on an "AS IS" BASIS,
be_bryan 0:b74591d5ab33 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
be_bryan 0:b74591d5ab33 13 * See the License for the specific language governing permissions and
be_bryan 0:b74591d5ab33 14 * limitations under the License.
be_bryan 0:b74591d5ab33 15 */
be_bryan 0:b74591d5ab33 16
be_bryan 0:b74591d5ab33 17 #ifndef MBED_UUID_H__
be_bryan 0:b74591d5ab33 18 #define MBED_UUID_H__
be_bryan 0:b74591d5ab33 19
be_bryan 0:b74591d5ab33 20 #include <stdint.h>
be_bryan 0:b74591d5ab33 21 #include <string.h>
be_bryan 0:b74591d5ab33 22 #include <algorithm>
be_bryan 0:b74591d5ab33 23
be_bryan 0:b74591d5ab33 24 #include "blecommon.h"
be_bryan 0:b74591d5ab33 25
be_bryan 0:b74591d5ab33 26 /**
be_bryan 0:b74591d5ab33 27 * @file
be_bryan 0:b74591d5ab33 28 * @addtogroup ble
be_bryan 0:b74591d5ab33 29 * @{
be_bryan 0:b74591d5ab33 30 * @addtogroup common
be_bryan 0:b74591d5ab33 31 * @{
be_bryan 0:b74591d5ab33 32 */
be_bryan 0:b74591d5ab33 33
be_bryan 0:b74591d5ab33 34 /**
be_bryan 0:b74591d5ab33 35 * Convert a character containing an hexadecimal digit into an unsigned integer.
be_bryan 0:b74591d5ab33 36 *
be_bryan 0:b74591d5ab33 37 * @param[in] c Hexadecimal digit in a character representation.
be_bryan 0:b74591d5ab33 38 *
be_bryan 0:b74591d5ab33 39 * @return The corresponding value as unsigned integer.
be_bryan 0:b74591d5ab33 40 */
be_bryan 0:b74591d5ab33 41 static uint8_t char2int(char c)
be_bryan 0:b74591d5ab33 42 {
be_bryan 0:b74591d5ab33 43 if ((c >= '0') && (c <= '9')) {
be_bryan 0:b74591d5ab33 44 return c - '0';
be_bryan 0:b74591d5ab33 45 } else if ((c >= 'a') && (c <= 'f')) {
be_bryan 0:b74591d5ab33 46 return c - 'a' + 10;
be_bryan 0:b74591d5ab33 47 } else if ((c >= 'A') && (c <= 'F')) {
be_bryan 0:b74591d5ab33 48 return c - 'A' + 10;
be_bryan 0:b74591d5ab33 49 } else {
be_bryan 0:b74591d5ab33 50 return 0;
be_bryan 0:b74591d5ab33 51 }
be_bryan 0:b74591d5ab33 52 }
be_bryan 0:b74591d5ab33 53
be_bryan 0:b74591d5ab33 54 /**
be_bryan 0:b74591d5ab33 55 * Representation of a Universally Unique Identifier (UUID).
be_bryan 0:b74591d5ab33 56 *
be_bryan 0:b74591d5ab33 57 * UUIDs are 128-bit wide numbers used to identify data type and elements in
be_bryan 0:b74591d5ab33 58 * many layers of the Bluetooth specification.
be_bryan 0:b74591d5ab33 59 *
be_bryan 0:b74591d5ab33 60 * Two representations of UUIDS exist:
be_bryan 0:b74591d5ab33 61 * - 16-bit UUIDs: Shortened representation of the 128 bit UUID
be_bryan 0:b74591d5ab33 62 * 0000xxxx-0000-1000-8000-00805F9B34FB where xxxx is the 16 bit UUID.
be_bryan 0:b74591d5ab33 63 * Values of those UUIDs are defined by the Bluetooth body. The short
be_bryan 0:b74591d5ab33 64 * representation saves bandwidth during protocol transactions.
be_bryan 0:b74591d5ab33 65 * - 128-bit UUIDs: Complete representation of a UUID. They are commonly
be_bryan 0:b74591d5ab33 66 * used for user defined UUID.
be_bryan 0:b74591d5ab33 67 *
be_bryan 0:b74591d5ab33 68 * This class acts as an adapter over these two kinds of UUIDs to allow
be_bryan 0:b74591d5ab33 69 * indiscriminate use of both forms in Mbed BLE APIs.
be_bryan 0:b74591d5ab33 70 *
be_bryan 0:b74591d5ab33 71 * @note 32-bit UUID representation is not supported currently.
be_bryan 0:b74591d5ab33 72 */
be_bryan 0:b74591d5ab33 73 class UUID {
be_bryan 0:b74591d5ab33 74 public:
be_bryan 0:b74591d5ab33 75
be_bryan 0:b74591d5ab33 76 /**
be_bryan 0:b74591d5ab33 77 * Enumeration of the types of UUIDs.
be_bryan 0:b74591d5ab33 78 */
be_bryan 0:b74591d5ab33 79 enum UUID_Type_t {
be_bryan 0:b74591d5ab33 80 /**
be_bryan 0:b74591d5ab33 81 * 16-bit wide UUID representation.
be_bryan 0:b74591d5ab33 82 */
be_bryan 0:b74591d5ab33 83 UUID_TYPE_SHORT = 0,
be_bryan 0:b74591d5ab33 84
be_bryan 0:b74591d5ab33 85 /**
be_bryan 0:b74591d5ab33 86 * 128-bit wide UUID representation.
be_bryan 0:b74591d5ab33 87 */
be_bryan 0:b74591d5ab33 88 UUID_TYPE_LONG = 1
be_bryan 0:b74591d5ab33 89 };
be_bryan 0:b74591d5ab33 90
be_bryan 0:b74591d5ab33 91 /**
be_bryan 0:b74591d5ab33 92 * Enumeration of byte ordering.
be_bryan 0:b74591d5ab33 93 *
be_bryan 0:b74591d5ab33 94 * It is used to construct 128-byte UUIDs.
be_bryan 0:b74591d5ab33 95 */
be_bryan 0:b74591d5ab33 96 typedef enum {
be_bryan 0:b74591d5ab33 97 /**
be_bryan 0:b74591d5ab33 98 * Most significant byte first (at the smallest address).
be_bryan 0:b74591d5ab33 99 */
be_bryan 0:b74591d5ab33 100 MSB,
be_bryan 0:b74591d5ab33 101
be_bryan 0:b74591d5ab33 102 /**
be_bryan 0:b74591d5ab33 103 * Least significant byte first (at the smallest address).
be_bryan 0:b74591d5ab33 104 */
be_bryan 0:b74591d5ab33 105 LSB
be_bryan 0:b74591d5ab33 106 } ByteOrder_t;
be_bryan 0:b74591d5ab33 107
be_bryan 0:b74591d5ab33 108 /**
be_bryan 0:b74591d5ab33 109 * Type for a 16-bit UUID.
be_bryan 0:b74591d5ab33 110 */
be_bryan 0:b74591d5ab33 111 typedef uint16_t ShortUUIDBytes_t;
be_bryan 0:b74591d5ab33 112
be_bryan 0:b74591d5ab33 113 /**
be_bryan 0:b74591d5ab33 114 * Length in bytes of a long UUID.
be_bryan 0:b74591d5ab33 115 */
be_bryan 0:b74591d5ab33 116 static const unsigned LENGTH_OF_LONG_UUID = 16;
be_bryan 0:b74591d5ab33 117
be_bryan 0:b74591d5ab33 118 /**
be_bryan 0:b74591d5ab33 119 * Type for a 128-bit UUID.
be_bryan 0:b74591d5ab33 120 */
be_bryan 0:b74591d5ab33 121 typedef uint8_t LongUUIDBytes_t[LENGTH_OF_LONG_UUID];
be_bryan 0:b74591d5ab33 122
be_bryan 0:b74591d5ab33 123 /**
be_bryan 0:b74591d5ab33 124 * Maximum length for the string representation of a UUID excluding the null
be_bryan 0:b74591d5ab33 125 * terminator.
be_bryan 0:b74591d5ab33 126 *
be_bryan 0:b74591d5ab33 127 * The string is composed of two characters per byte plus four '-'
be_bryan 0:b74591d5ab33 128 * characters.
be_bryan 0:b74591d5ab33 129 */
be_bryan 0:b74591d5ab33 130 static const unsigned MAX_UUID_STRING_LENGTH = LENGTH_OF_LONG_UUID * 2 + 4;
be_bryan 0:b74591d5ab33 131
be_bryan 0:b74591d5ab33 132 public:
be_bryan 0:b74591d5ab33 133
be_bryan 0:b74591d5ab33 134 /**
be_bryan 0:b74591d5ab33 135 * Construct a 128-bit UUID from a string.
be_bryan 0:b74591d5ab33 136 *
be_bryan 0:b74591d5ab33 137 * @param[in] stringUUID Human readable representation of the UUID following
be_bryan 0:b74591d5ab33 138 * the format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.
be_bryan 0:b74591d5ab33 139 *
be_bryan 0:b74591d5ab33 140 * @note Upper and lower case are supported.
be_bryan 0:b74591d5ab33 141 * @note Hyphens are optional. The string must include at most four hyphens.
be_bryan 0:b74591d5ab33 142 *
be_bryan 0:b74591d5ab33 143 * @note Internally, the UUID is stored in the little endian order as a
be_bryan 0:b74591d5ab33 144 * 16-byte array.
be_bryan 0:b74591d5ab33 145 */
be_bryan 0:b74591d5ab33 146 UUID(const char* stringUUID) :
be_bryan 0:b74591d5ab33 147 type(UUID_TYPE_LONG),
be_bryan 0:b74591d5ab33 148 baseUUID(),
be_bryan 0:b74591d5ab33 149 shortUUID(0)
be_bryan 0:b74591d5ab33 150 {
be_bryan 0:b74591d5ab33 151 bool nibble = false;
be_bryan 0:b74591d5ab33 152 uint8_t byte = 0;
be_bryan 0:b74591d5ab33 153 size_t baseIndex = 0;
be_bryan 0:b74591d5ab33 154 uint8_t tempUUID[LENGTH_OF_LONG_UUID];
be_bryan 0:b74591d5ab33 155
be_bryan 0:b74591d5ab33 156 /*
be_bryan 0:b74591d5ab33 157 * Iterate through string; abort if NULL is encountered prematurely.
be_bryan 0:b74591d5ab33 158 * Ignore up to four hyphens.
be_bryan 0:b74591d5ab33 159 */
be_bryan 0:b74591d5ab33 160 for (size_t index = 0; (index < MAX_UUID_STRING_LENGTH) && (baseIndex < LENGTH_OF_LONG_UUID); index++) {
be_bryan 0:b74591d5ab33 161 if (stringUUID[index] == '\0') {
be_bryan 0:b74591d5ab33 162 /* Error abort */
be_bryan 0:b74591d5ab33 163 break;
be_bryan 0:b74591d5ab33 164 } else if (stringUUID[index] == '-') {
be_bryan 0:b74591d5ab33 165 /* Ignore hyphen */
be_bryan 0:b74591d5ab33 166 continue;
be_bryan 0:b74591d5ab33 167 } else if (nibble) {
be_bryan 0:b74591d5ab33 168 /* Got second nibble */
be_bryan 0:b74591d5ab33 169 byte |= char2int(stringUUID[index]);
be_bryan 0:b74591d5ab33 170 nibble = false;
be_bryan 0:b74591d5ab33 171
be_bryan 0:b74591d5ab33 172 /* Store copy */
be_bryan 0:b74591d5ab33 173 tempUUID[baseIndex++] = byte;
be_bryan 0:b74591d5ab33 174 } else {
be_bryan 0:b74591d5ab33 175 /* Got first nibble */
be_bryan 0:b74591d5ab33 176 byte = char2int(stringUUID[index]) << 4;
be_bryan 0:b74591d5ab33 177 nibble = true;
be_bryan 0:b74591d5ab33 178 }
be_bryan 0:b74591d5ab33 179 }
be_bryan 0:b74591d5ab33 180
be_bryan 0:b74591d5ab33 181 /* Populate internal variables if string was successfully parsed */
be_bryan 0:b74591d5ab33 182 if (baseIndex == LENGTH_OF_LONG_UUID) {
be_bryan 0:b74591d5ab33 183 setupLong(tempUUID, UUID::MSB);
be_bryan 0:b74591d5ab33 184 } else {
be_bryan 0:b74591d5ab33 185 const uint8_t sig[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
be_bryan 0:b74591d5ab33 186 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB };
be_bryan 0:b74591d5ab33 187 setupLong(sig, UUID::MSB);
be_bryan 0:b74591d5ab33 188 }
be_bryan 0:b74591d5ab33 189 }
be_bryan 0:b74591d5ab33 190
be_bryan 0:b74591d5ab33 191 /**
be_bryan 0:b74591d5ab33 192 * Construct a new UUID from a 128-bit representation.
be_bryan 0:b74591d5ab33 193 *
be_bryan 0:b74591d5ab33 194 * @param[in] longUUID The 128-bit (16-byte) of the UUID value.
be_bryan 0:b74591d5ab33 195 * @param[in] order Bytes order of @p longUUID.
be_bryan 0:b74591d5ab33 196 */
be_bryan 0:b74591d5ab33 197 UUID(const LongUUIDBytes_t longUUID, ByteOrder_t order = UUID::MSB) : type(UUID_TYPE_LONG), baseUUID(), shortUUID(0) {
be_bryan 0:b74591d5ab33 198 setupLong(longUUID, order);
be_bryan 0:b74591d5ab33 199 }
be_bryan 0:b74591d5ab33 200
be_bryan 0:b74591d5ab33 201 /**
be_bryan 0:b74591d5ab33 202 * Creates a new 16-bit UUID.
be_bryan 0:b74591d5ab33 203 *
be_bryan 0:b74591d5ab33 204 * The Bluetooth standard body defines 16-bit wide UUIDs. They are the
be_bryan 0:b74591d5ab33 205 * shortened version of the UUID 0000xxxx-0000-1000-8000-00805F9B34FB, where
be_bryan 0:b74591d5ab33 206 * xxxx is the value of the 16-bit UUID.
be_bryan 0:b74591d5ab33 207 *
be_bryan 0:b74591d5ab33 208 * @important 16-bit UUIDs are not used in user defined data type or
be_bryan 0:b74591d5ab33 209 * user defined element ID.
be_bryan 0:b74591d5ab33 210 *
be_bryan 0:b74591d5ab33 211 * @param[in] _shortUUID 16-bit part of the standard UUID.
be_bryan 0:b74591d5ab33 212 * The short UUID value.
be_bryan 0:b74591d5ab33 213 *
be_bryan 0:b74591d5ab33 214 * @note User defined UUIDs are commonly named vendor-specific UUIDs across
be_bryan 0:b74591d5ab33 215 * the Bluetooth literature.
be_bryan 0:b74591d5ab33 216 */
be_bryan 0:b74591d5ab33 217 UUID(ShortUUIDBytes_t _shortUUID) :
be_bryan 0:b74591d5ab33 218 type(UUID_TYPE_SHORT),
be_bryan 0:b74591d5ab33 219 baseUUID(),
be_bryan 0:b74591d5ab33 220 shortUUID(_shortUUID) {
be_bryan 0:b74591d5ab33 221 }
be_bryan 0:b74591d5ab33 222
be_bryan 0:b74591d5ab33 223 /**
be_bryan 0:b74591d5ab33 224 * UUID copy constructor.
be_bryan 0:b74591d5ab33 225 *
be_bryan 0:b74591d5ab33 226 * @param[in] source The UUID to copy.
be_bryan 0:b74591d5ab33 227 */
be_bryan 0:b74591d5ab33 228 UUID(const UUID &source)
be_bryan 0:b74591d5ab33 229 {
be_bryan 0:b74591d5ab33 230 type = source.type;
be_bryan 0:b74591d5ab33 231 shortUUID = source.shortUUID;
be_bryan 0:b74591d5ab33 232 memcpy(baseUUID, source.baseUUID, LENGTH_OF_LONG_UUID);
be_bryan 0:b74591d5ab33 233 }
be_bryan 0:b74591d5ab33 234
be_bryan 0:b74591d5ab33 235 /**
be_bryan 0:b74591d5ab33 236 * Default constructor.
be_bryan 0:b74591d5ab33 237 *
be_bryan 0:b74591d5ab33 238 * Construct an invalid UUID.
be_bryan 0:b74591d5ab33 239 *
be_bryan 0:b74591d5ab33 240 * @post shortOrLong() returns the value UUID_TYPE_SHORT.
be_bryan 0:b74591d5ab33 241 * @post getShortUUID() returns the value BLE_UUID_UNKNOWN.
be_bryan 0:b74591d5ab33 242 */
be_bryan 0:b74591d5ab33 243 UUID(void) :
be_bryan 0:b74591d5ab33 244 type(UUID_TYPE_SHORT),
be_bryan 0:b74591d5ab33 245 shortUUID(BLE_UUID_UNKNOWN) {
be_bryan 0:b74591d5ab33 246 }
be_bryan 0:b74591d5ab33 247
be_bryan 0:b74591d5ab33 248 /**
be_bryan 0:b74591d5ab33 249 * Replace existing value with a 128-bit UUID.
be_bryan 0:b74591d5ab33 250 *
be_bryan 0:b74591d5ab33 251 * @param[in] longUUID New 16-byte wide UUID value.
be_bryan 0:b74591d5ab33 252 * @param[in] order Byte ordering of @p longUUID.
be_bryan 0:b74591d5ab33 253 */
be_bryan 0:b74591d5ab33 254 void setupLong(const LongUUIDBytes_t longUUID, ByteOrder_t order = UUID::MSB)
be_bryan 0:b74591d5ab33 255 {
be_bryan 0:b74591d5ab33 256 type = UUID_TYPE_LONG;
be_bryan 0:b74591d5ab33 257 if (order == UUID::MSB) {
be_bryan 0:b74591d5ab33 258 /*
be_bryan 0:b74591d5ab33 259 * Switch endian. Input is big-endian, internal representation
be_bryan 0:b74591d5ab33 260 * is little endian.
be_bryan 0:b74591d5ab33 261 */
be_bryan 0:b74591d5ab33 262 std::reverse_copy(longUUID, longUUID + LENGTH_OF_LONG_UUID, baseUUID);
be_bryan 0:b74591d5ab33 263 } else {
be_bryan 0:b74591d5ab33 264 std::copy(longUUID, longUUID + LENGTH_OF_LONG_UUID, baseUUID);
be_bryan 0:b74591d5ab33 265 }
be_bryan 0:b74591d5ab33 266 shortUUID = (uint16_t)((baseUUID[13] << 8) | (baseUUID[12]));
be_bryan 0:b74591d5ab33 267 }
be_bryan 0:b74591d5ab33 268
be_bryan 0:b74591d5ab33 269 public:
be_bryan 0:b74591d5ab33 270 /**
be_bryan 0:b74591d5ab33 271 * Return the internal type of the UUID.
be_bryan 0:b74591d5ab33 272 *
be_bryan 0:b74591d5ab33 273 * @return UUID_TYPE_SHORT if the UUID is 16-bit wide.
be_bryan 0:b74591d5ab33 274 * @return UUID_TYPE_LONG if the UUID is 128-bit wide.
be_bryan 0:b74591d5ab33 275 */
be_bryan 0:b74591d5ab33 276 UUID_Type_t shortOrLong(void) const
be_bryan 0:b74591d5ab33 277 {
be_bryan 0:b74591d5ab33 278 return type;
be_bryan 0:b74591d5ab33 279 }
be_bryan 0:b74591d5ab33 280
be_bryan 0:b74591d5ab33 281 /**
be_bryan 0:b74591d5ab33 282 * Get a pointer to the UUID value based on the current UUID type.
be_bryan 0:b74591d5ab33 283 *
be_bryan 0:b74591d5ab33 284 * @return A pointer to an uint16_t object if the UUID is 16 bits long.
be_bryan 0:b74591d5ab33 285 * @return A pointer to an array of 16 bytes if the UUID is 128 bits long.
be_bryan 0:b74591d5ab33 286 */
be_bryan 0:b74591d5ab33 287 const uint8_t *getBaseUUID(void) const
be_bryan 0:b74591d5ab33 288 {
be_bryan 0:b74591d5ab33 289 if (type == UUID_TYPE_SHORT) {
be_bryan 0:b74591d5ab33 290 return (const uint8_t*)&shortUUID;
be_bryan 0:b74591d5ab33 291 } else {
be_bryan 0:b74591d5ab33 292 return baseUUID;
be_bryan 0:b74591d5ab33 293 }
be_bryan 0:b74591d5ab33 294 }
be_bryan 0:b74591d5ab33 295
be_bryan 0:b74591d5ab33 296 /**
be_bryan 0:b74591d5ab33 297 * Get the uint16_t value of the UUID.
be_bryan 0:b74591d5ab33 298 *
be_bryan 0:b74591d5ab33 299 * @important This function is not used on long UUIDs.
be_bryan 0:b74591d5ab33 300 *
be_bryan 0:b74591d5ab33 301 * @return The value of the shortened UUID.
be_bryan 0:b74591d5ab33 302 */
be_bryan 0:b74591d5ab33 303 ShortUUIDBytes_t getShortUUID(void) const
be_bryan 0:b74591d5ab33 304 {
be_bryan 0:b74591d5ab33 305 return shortUUID;
be_bryan 0:b74591d5ab33 306 }
be_bryan 0:b74591d5ab33 307
be_bryan 0:b74591d5ab33 308 /**
be_bryan 0:b74591d5ab33 309 * Get the length (in bytes) of the internal UUID representation.
be_bryan 0:b74591d5ab33 310 *
be_bryan 0:b74591d5ab33 311 * @return sizeof(ShortUUIDBytes_t) if the UUID type is UUID_TYPE_SHORT.
be_bryan 0:b74591d5ab33 312 * @return LENGTH_OF_LONG_UUID if the UUID type is UUID_TYPE_LONG.
be_bryan 0:b74591d5ab33 313 */
be_bryan 0:b74591d5ab33 314 uint8_t getLen(void) const
be_bryan 0:b74591d5ab33 315 {
be_bryan 0:b74591d5ab33 316 return ((type == UUID_TYPE_SHORT) ?
be_bryan 0:b74591d5ab33 317 sizeof(ShortUUIDBytes_t) :
be_bryan 0:b74591d5ab33 318 LENGTH_OF_LONG_UUID);
be_bryan 0:b74591d5ab33 319 }
be_bryan 0:b74591d5ab33 320
be_bryan 0:b74591d5ab33 321 /**
be_bryan 0:b74591d5ab33 322 * Equal to operator between UUIDs.
be_bryan 0:b74591d5ab33 323 *
be_bryan 0:b74591d5ab33 324 * @param[in] other The UUID to compare to this.
be_bryan 0:b74591d5ab33 325 *
be_bryan 0:b74591d5ab33 326 * @return true if both UUIDs are equal and false otherwise.
be_bryan 0:b74591d5ab33 327 */
be_bryan 0:b74591d5ab33 328 bool operator== (const UUID &other) const
be_bryan 0:b74591d5ab33 329 {
be_bryan 0:b74591d5ab33 330 if ((this->type == UUID_TYPE_SHORT) && (other.type == UUID_TYPE_SHORT) &&
be_bryan 0:b74591d5ab33 331 (this->shortUUID == other.shortUUID)) {
be_bryan 0:b74591d5ab33 332 return true;
be_bryan 0:b74591d5ab33 333 }
be_bryan 0:b74591d5ab33 334
be_bryan 0:b74591d5ab33 335 if ((this->type == UUID_TYPE_LONG) && (other.type == UUID_TYPE_LONG) &&
be_bryan 0:b74591d5ab33 336 (memcmp(this->baseUUID, other.baseUUID, LENGTH_OF_LONG_UUID) == 0)) {
be_bryan 0:b74591d5ab33 337 return true;
be_bryan 0:b74591d5ab33 338 }
be_bryan 0:b74591d5ab33 339
be_bryan 0:b74591d5ab33 340 return false;
be_bryan 0:b74591d5ab33 341 }
be_bryan 0:b74591d5ab33 342
be_bryan 0:b74591d5ab33 343 /**
be_bryan 0:b74591d5ab33 344 * Not equal to operator.
be_bryan 0:b74591d5ab33 345 *
be_bryan 0:b74591d5ab33 346 * @param[in] other The UUID compared to this.
be_bryan 0:b74591d5ab33 347 *
be_bryan 0:b74591d5ab33 348 * @return true if both UUIDs are not equal and false otherwise.
be_bryan 0:b74591d5ab33 349 */
be_bryan 0:b74591d5ab33 350 bool operator!= (const UUID &other) const
be_bryan 0:b74591d5ab33 351 {
be_bryan 0:b74591d5ab33 352 return !(*this == other);
be_bryan 0:b74591d5ab33 353 }
be_bryan 0:b74591d5ab33 354
be_bryan 0:b74591d5ab33 355 private:
be_bryan 0:b74591d5ab33 356 /**
be_bryan 0:b74591d5ab33 357 * Representation type of the UUID.
be_bryan 0:b74591d5ab33 358 */
be_bryan 0:b74591d5ab33 359 UUID_Type_t type;
be_bryan 0:b74591d5ab33 360
be_bryan 0:b74591d5ab33 361 /**
be_bryan 0:b74591d5ab33 362 * Container of UUID value if the UUID type is equal to UUID_TYPE_LONG.
be_bryan 0:b74591d5ab33 363 */
be_bryan 0:b74591d5ab33 364 LongUUIDBytes_t baseUUID;
be_bryan 0:b74591d5ab33 365
be_bryan 0:b74591d5ab33 366 /**
be_bryan 0:b74591d5ab33 367 * Container of UUID value if the UUID type is equal to UUID_TYPE_SHORT.
be_bryan 0:b74591d5ab33 368 */
be_bryan 0:b74591d5ab33 369 ShortUUIDBytes_t shortUUID;
be_bryan 0:b74591d5ab33 370 };
be_bryan 0:b74591d5ab33 371
be_bryan 0:b74591d5ab33 372 /**
be_bryan 0:b74591d5ab33 373 * @}
be_bryan 0:b74591d5ab33 374 * @}
be_bryan 0:b74591d5ab33 375 */
be_bryan 0:b74591d5ab33 376
be_bryan 0:b74591d5ab33 377 #endif // ifndef MBED_UUID_H__