uuid.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************
 * This file is a part of EtcPal. For more information, go to:
 * https://github.com/ETCLabs/EtcPal
 ******************************************************************************/
 
 
#ifndef ETCPAL_CPP_UUID_H_
#define ETCPAL_CPP_UUID_H_
 
#include <cstdint>
#include <cstring>
#include <array>
#include <string>
#include "etcpal/pack.h"
#include "etcpal/uuid.h"
 
namespace etcpal
{
// clang-format off
// clang-format on
 
enum class UuidVersion
{
  V1 = 1,  
  V2 = 2,  
  V3 = 3,  
  V4 = 4,  
  V5 = 5,  
  Unknown  
};
 
class Uuid
{
public:
  Uuid() = default;
 
  Uuid(const uint8_t* data) noexcept;
  Uuid(uint32_t time_low, uint16_t time_mid, uint16_t time_hi_and_version, const uint8_t clock_seq_and_node[8]);
  Uuid(uint32_t                      time_low,
       uint16_t                      time_mid,
       uint16_t                      time_hi_and_version,
       const std::array<uint8_t, 8>& clock_seq_and_node);
 
  // Note: this constructor is not explicit by design, to allow implicit conversions e.g.
  //   etcpal::Uuid uuid = etcpal_c_function_that_returns_uuid();
  constexpr Uuid(const EtcPalUuid& c_uuid) noexcept;
  Uuid& operator=(const EtcPalUuid& c_uuid) noexcept;
 
  constexpr const EtcPalUuid& get() const noexcept;
  const uint8_t*              data() const noexcept;
  std::string                 ToString() const;
  bool                        IsNull() const noexcept;
  UuidVersion                 version() const noexcept;
 
  uint32_t               time_low() const noexcept;
  uint16_t               time_mid() const noexcept;
  uint16_t               time_hi_and_version() const noexcept;
  std::array<uint8_t, 8> clock_seq_and_node() const noexcept;
 
  static Uuid FromString(const char* uuid_str) noexcept;
  static Uuid FromString(const std::string& uuid_str) noexcept;
  static Uuid V1() noexcept;
  static Uuid V3(const Uuid& ns, const void* name, size_t name_len) noexcept;
  static Uuid V3(const Uuid& ns, const char* name) noexcept;
  static Uuid V3(const Uuid& ns, const std::string& name) noexcept;
  static Uuid V4() noexcept;
  static Uuid V5(const Uuid& ns, const void* name, size_t name_len) noexcept;
  static Uuid V5(const Uuid& ns, const char* name) noexcept;
  static Uuid V5(const Uuid& ns, const std::string& name) noexcept;
  static Uuid OsPreferred() noexcept;
  static Uuid Device(const std::string& device_str, const uint8_t* mac_addr, uint32_t uuid_num) noexcept;
  static Uuid Device(const std::string& device_str, const std::array<uint8_t, 6>& mac_addr, uint32_t uuid_num) noexcept;
 
private:
  EtcPalUuid uuid_{kEtcPalNullUuid};
};
 
constexpr Uuid::Uuid(const EtcPalUuid& c_uuid) noexcept : uuid_(c_uuid)
{
}
 
inline Uuid::Uuid(const uint8_t* data) noexcept
{
  std::memcpy(uuid_.data, data, ETCPAL_UUID_BYTES);
}
 
inline Uuid::Uuid(uint32_t      time_low,
                  uint16_t      time_mid,
                  uint16_t      time_hi_and_version,
                  const uint8_t clock_seq_and_node[8])
{
  etcpal_pack_u32b(&uuid_.data[0], time_low);
  etcpal_pack_u16b(&uuid_.data[4], time_mid);
  etcpal_pack_u16b(&uuid_.data[6], time_hi_and_version);
  std::memcpy(&uuid_.data[8], clock_seq_and_node, 8);
}
 
inline Uuid::Uuid(uint32_t                      time_low,
                  uint16_t                      time_mid,
                  uint16_t                      time_hi_and_version,
                  const std::array<uint8_t, 8>& clock_seq_and_node)
    : Uuid(time_low, time_mid, time_hi_and_version, clock_seq_and_node.data())
{
}
 
inline Uuid& Uuid::operator=(const EtcPalUuid& c_uuid) noexcept
{
  uuid_ = c_uuid;
  return *this;
}
 
constexpr const EtcPalUuid& Uuid::get() const noexcept
{
  return uuid_;
}
 
inline const uint8_t* Uuid::data() const noexcept
{
  return uuid_.data;
}
 
inline std::string Uuid::ToString() const
{
  char str_buf[ETCPAL_UUID_STRING_BYTES];
  if (etcpal_uuid_to_string(&uuid_, str_buf))
    return str_buf;
  else
    return std::string();
}
 
inline bool Uuid::IsNull() const noexcept
{
  return ETCPAL_UUID_IS_NULL(&uuid_);
}
 
inline UuidVersion Uuid::version() const noexcept
{
  uint8_t vers_val = uuid_.data[6] >> 4;
  return (vers_val >= 1 && vers_val <= 5) ? static_cast<UuidVersion>(vers_val) : UuidVersion::Unknown;
}
 
inline uint32_t Uuid::time_low() const noexcept
{
  return etcpal_unpack_u32b(&uuid_.data[0]);
}
 
inline uint16_t Uuid::time_mid() const noexcept
{
  return etcpal_unpack_u16b(&uuid_.data[4]);
}
 
inline uint16_t Uuid::time_hi_and_version() const noexcept
{
  return etcpal_unpack_u16b(&uuid_.data[6]);
}
 
inline std::array<uint8_t, 8> Uuid::clock_seq_and_node() const noexcept
{
  std::array<uint8_t, 8> res;
  std::memcpy(res.data(), &uuid_.data[8], 8);
  return res;
}
 
inline Uuid Uuid::FromString(const char* uuid_str) noexcept
{
  Uuid uuid;
  etcpal_string_to_uuid(uuid_str, &uuid.uuid_);
  return uuid;
}
 
inline Uuid Uuid::FromString(const std::string& uuid_str) noexcept
{
  return FromString(uuid_str.c_str());
}
 
inline Uuid Uuid::V1() noexcept
{
  Uuid uuid;
  etcpal_generate_v1_uuid(&uuid.uuid_);
  return uuid;
}
 
inline Uuid Uuid::V3(const Uuid& ns, const void* name, size_t name_len) noexcept
{
  Uuid uuid;
  etcpal_generate_v3_uuid(&ns.get(), name, name_len, &uuid.uuid_);
  return uuid;
}
 
inline Uuid Uuid::V3(const Uuid& ns, const char* name) noexcept
{
  return V3(ns, name, std::strlen(name));
}
 
inline Uuid Uuid::V3(const Uuid& ns, const std::string& name) noexcept
{
  return V3(ns, name.c_str(), name.length());
}
 
inline Uuid Uuid::V4() noexcept
{
  Uuid uuid;
  etcpal_generate_v4_uuid(&uuid.uuid_);
  return uuid;
}
 
inline Uuid Uuid::V5(const Uuid& ns, const void* name, size_t name_len) noexcept
{
  Uuid uuid;
  etcpal_generate_v5_uuid(&ns.get(), name, name_len, &uuid.uuid_);
  return uuid;
}
 
inline Uuid Uuid::V5(const Uuid& ns, const char* name) noexcept
{
  return V5(ns, name, std::strlen(name));
}
 
inline Uuid Uuid::V5(const Uuid& ns, const std::string& name) noexcept
{
  return V5(ns, name.c_str(), name.length());
}
 
inline Uuid Uuid::OsPreferred() noexcept
{
  Uuid uuid;
  etcpal_generate_os_preferred_uuid(&uuid.uuid_);
  return uuid;
}
 
inline Uuid Uuid::Device(const std::string& device_str, const uint8_t* mac_addr, uint32_t uuid_num) noexcept
{
  Uuid uuid;
  etcpal_generate_device_uuid(device_str.c_str(), mac_addr, uuid_num, &uuid.uuid_);
  return uuid;
}
 
inline Uuid Uuid::Device(const std::string&            device_str,
                         const std::array<uint8_t, 6>& mac_addr,
                         uint32_t                      uuid_num) noexcept
{
  Uuid uuid;
  etcpal_generate_device_uuid(device_str.c_str(), mac_addr.data(), uuid_num, &uuid.uuid_);
  return uuid;
}
 
 
 
// Special operators for comparing with EtcPalUuids
 
inline bool operator==(const EtcPalUuid& c_uuid, const Uuid& uuid) noexcept
{
  return c_uuid == uuid.get();
}
 
inline bool operator!=(const EtcPalUuid& c_uuid, const Uuid& uuid) noexcept
{
  return !(c_uuid == uuid);
}
 
inline bool operator==(const Uuid& uuid, const EtcPalUuid& c_uuid) noexcept
{
  return uuid.get() == c_uuid;
}
 
inline bool operator!=(const Uuid& uuid, const EtcPalUuid& c_uuid) noexcept
{
  return !(uuid == c_uuid);
}
 
// Standard operators
 
inline bool operator==(const Uuid& a, const Uuid& b) noexcept
{
  return a.get() == b.get();
}
 
inline bool operator!=(const Uuid& a, const Uuid& b) noexcept
{
  return !(a == b);
}
 
inline bool operator<(const Uuid& a, const Uuid& b) noexcept
{
  return a.get() < b.get();
}
 
inline bool operator>(const Uuid& a, const Uuid& b) noexcept
{
  return b < a;
}
 
inline bool operator<=(const Uuid& a, const Uuid& b) noexcept
{
  return !(b < a);
}
 
inline bool operator>=(const Uuid& a, const Uuid& b) noexcept
{
  return !(a < b);
}
 
 
};  // namespace etcpal
 
#endif  // ETCPAL_CPP_UUID_H_