uid.hpp

Go to the documentation of this file.

// Copyright (c) 2026 Capgemini Engineering Research and Development.
//
// This file is part of OCCT-Light software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Affero General Public License version 3 as published
// by the Free Software Foundation, with an option to use any later version.
// Consult the file LICENSE_AGPL_30.txt included in OCCT-Light distribution
// for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of a commercial
// license or contractual agreement.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef OCCTL_HPP_UID_HPP
#define OCCTL_HPP_UID_HPP
 
#include <occtl-hpp/core.hpp>
 
#include <occtl/occtl_topo.h>
 
#include <array>
#include <cstdint>
 
namespace occtl
{
 
class UID
{
public:
  explicit UID(const ::occtl_uid_t theUid) noexcept
      : myUid(theUid)
  {
  }
 
  static UID invalid() noexcept { return UID(OCCTL_UID_INVALID); }
 
  ::occtl_uid_t get() const noexcept { return myUid; }
 
  bool is_valid() const noexcept
  {
    return myUid.bits != 0;
  } 
 
  bool operator==(const UID& theOther) const noexcept
  {
    return myUid.bits == theOther.myUid.bits;
  } 
 
  bool operator!=(const UID& theOther) const noexcept
  {
    return myUid.bits != theOther.myUid.bits;
  } 
 
private:
  ::occtl_uid_t myUid;
};
 
class RefUID
{
public:
  explicit RefUID(const ::occtl_ref_uid_t theUid) noexcept
      : myUid(theUid)
  {
  }
 
  static RefUID invalid() noexcept { return RefUID(OCCTL_REF_UID_INVALID); }
 
  ::occtl_ref_uid_t get() const noexcept { return myUid; }
 
  static RefUID from_bytes(const std::array<std::uint8_t, OCCTL_REF_UID_WIRE_SIZE>& theBytes)
  {
    ::occtl_ref_uid_t aUid = OCCTL_REF_UID_INVALID;
    check(::occtl_ref_uid_from_bytes(theBytes.data(), &aUid));
    return RefUID(aUid);
  }
 
  std::array<std::uint8_t, OCCTL_REF_UID_WIRE_SIZE> to_bytes() const
  {
    std::array<std::uint8_t, OCCTL_REF_UID_WIRE_SIZE> aBytes{};
    check(::occtl_ref_uid_to_bytes(myUid, aBytes.data()));
    return aBytes;
  }
 
  bool is_valid() const noexcept
  {
    return myUid.bits != 0;
  } 
 
  bool operator==(const RefUID& theOther) const noexcept
  {
    return myUid.bits == theOther.myUid.bits;
  } 
 
  bool operator!=(const RefUID& theOther) const noexcept
  {
    return myUid.bits != theOther.myUid.bits;
  } 
 
private:
  ::occtl_ref_uid_t myUid;
};
 
class RepUID
{
public:
  explicit RepUID(const ::occtl_rep_uid_t theUid) noexcept
      : myUid(theUid)
  {
  }
 
  static RepUID invalid() noexcept { return RepUID(OCCTL_REP_UID_INVALID); }
 
  ::occtl_rep_uid_t get() const noexcept { return myUid; }
 
  static RepUID from_bytes(const std::array<std::uint8_t, OCCTL_REP_UID_WIRE_SIZE>& theBytes)
  {
    ::occtl_rep_uid_t aUid = OCCTL_REP_UID_INVALID;
    check(::occtl_rep_uid_from_bytes(theBytes.data(), &aUid));
    return RepUID(aUid);
  }
 
  std::array<std::uint8_t, OCCTL_REP_UID_WIRE_SIZE> to_bytes() const
  {
    std::array<std::uint8_t, OCCTL_REP_UID_WIRE_SIZE> aBytes{};
    check(::occtl_rep_uid_to_bytes(myUid, aBytes.data()));
    return aBytes;
  }
 
  bool is_valid() const noexcept
  {
    return myUid.bits != 0;
  } 
 
  bool operator==(const RepUID& theOther) const noexcept
  {
    return myUid.bits == theOther.myUid.bits;
  } 
 
  bool operator!=(const RepUID& theOther) const noexcept
  {
    return myUid.bits != theOther.myUid.bits;
  } 
 
private:
  ::occtl_rep_uid_t myUid;
};
 
} // namespace occtl
 
#endif // OCCTL_HPP_UID_HPP