topo.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_TOPO_HPP
#define OCCTL_HPP_TOPO_HPP
 
#include <occtl/occtl_topo.h>
 
#include <occtl-hpp/core.hpp>
#include <occtl-hpp/geom.hpp>
#include <occtl-hpp/uid.hpp>
 
#include <occtl/occtl_topo_algo.h>
 
#include <cstdint>
#include <exception>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace occtl
{
 
class NodeId
{
public:
  explicit NodeId(const ::occtl_node_id_t theId) noexcept
      : myId(theId)
  {
  }
 
  static NodeId invalid() noexcept { return NodeId(OCCTL_NODE_ID_INVALID); }
 
  ::occtl_node_id_t get() const noexcept { return myId; }
 
  bool is_valid() const noexcept
  {
    return myId.bits != 0;
  } 
 
  bool operator==(const NodeId& theOther) const noexcept
  {
    return myId.bits == theOther.myId.bits;
  } 
 
  bool operator!=(const NodeId& theOther) const noexcept
  {
    return myId.bits != theOther.myId.bits;
  } 
 
private:
  ::occtl_node_id_t myId;
};
 
class RefId
{
public:
  explicit RefId(const ::occtl_ref_id_t theId) noexcept
      : myId(theId)
  {
  }
 
  static RefId invalid() noexcept { return RefId(OCCTL_REF_ID_INVALID); }
 
  ::occtl_ref_id_t get() const noexcept { return myId; }
 
  bool is_valid() const noexcept
  {
    return myId.bits != 0;
  } 
 
  bool operator==(const RefId& theOther) const noexcept
  {
    return myId.bits == theOther.myId.bits;
  } 
 
  bool operator!=(const RefId& theOther) const noexcept
  {
    return myId.bits != theOther.myId.bits;
  } 
 
private:
  ::occtl_ref_id_t myId;
};
 
class RepId
{
public:
  explicit RepId(const ::occtl_rep_id_t theId) noexcept
      : myId(theId)
  {
  }
 
  static RepId invalid() noexcept { return RepId(OCCTL_REP_ID_INVALID); }
 
  ::occtl_rep_id_t get() const noexcept { return myId; }
 
  bool is_valid() const noexcept
  {
    return myId.bits != 0;
  } 
 
  bool operator==(const RepId& theOther) const noexcept
  {
    return myId.bits == theOther.myId.bits;
  } 
 
  bool operator!=(const RepId& theOther) const noexcept
  {
    return myId.bits != theOther.myId.bits;
  } 
 
private:
  ::occtl_rep_id_t myId;
};
 
class JointId
{
public:
  explicit JointId(const ::occtl_joint_id_t theId) noexcept
      : myId(theId)
  {
  }
 
  static JointId invalid() noexcept { return JointId(OCCTL_JOINT_ID_INVALID); }
 
  ::occtl_joint_id_t get() const noexcept { return myId; }
 
  bool is_valid() const noexcept
  {
    return myId.bits != 0;
  } 
 
  bool operator==(const JointId& theOther) const noexcept
  {
    return myId.bits == theOther.myId.bits;
  } 
 
  bool operator!=(const JointId& theOther) const noexcept
  {
    return myId.bits != theOther.myId.bits;
  } 
 
private:
  ::occtl_joint_id_t myId;
};
 
using Orientation = ::occtl_orientation_t;
 
using OrientedNode = ::occtl_oriented_node_t;
 
using RelationKind = ::occtl_relation_kind_t;
 
using PointClass = ::occtl_topo_point_class_t;
 
using DistancePair = ::occtl_topo_distance_pair_t;
 
using RelationOptions = ::occtl_topo_relation_options_t;
 
using TouchHit = ::occtl_topo_touch_hit_t;
 
using AxisHit = ::occtl_topo_axis_hit_t;
 
using CurveKind = ::occtl_curve_kind_t;
 
using SurfaceKind = ::occtl_surface_kind_t;
 
using SelectOptions = ::occtl_select_options_t;
 
using SelectMetadataFilter = ::occtl_select_metadata_filter_t;
 
using TagView = ::occtl_tag_view_t;
 
using SelectDistanceToNodeSort = ::occtl_select_distance_to_node_sort_t;
 
using SelectBBoxMode = ::occtl_select_bbox_mode_t;
 
using SelectAxis = ::occtl_select_axis_t;
 
using SelectAxisPosition = ::occtl_select_axis_position_t;
 
using SelectNormalMode = ::occtl_select_normal_mode_t;
 
using SelectMeasureKind = ::occtl_select_measure_kind_t;
 
using SelectSortKey = ::occtl_select_sort_key_t;
 
using SelectSortDirection = ::occtl_select_sort_direction_t;
 
using SelectGroupOptions = ::occtl_select_group_options_t;
 
using SelectGroupKey = ::occtl_select_group_key_t;
 
using SelectGroupView = ::occtl_select_group_view_t;
 
struct HlrCategoryRoots
{
  NodeId visible_sharp   = NodeId::invalid();
  NodeId visible_smooth  = NodeId::invalid();
  NodeId visible_seam    = NodeId::invalid();
  NodeId visible_outline = NodeId::invalid();
  NodeId hidden_sharp    = NodeId::invalid();
  NodeId hidden_smooth   = NodeId::invalid();
  NodeId hidden_seam     = NodeId::invalid();
  NodeId hidden_outline  = NodeId::invalid();
};
 
struct GraphUnits
{
  double      length_unit_to_meter = 1.0;
  std::string name                 = "m";
};
 
struct GraphMaterial
{
  std::string          name;
  int32_t              has_density       = 0;
  double               density           = 0.0;
  int32_t              has_diffuse_color = 0;
  ::occtl_color_rgba_t diffuse_color     = {1.0f, 1.0f, 1.0f, 1.0f};
  ::occtl_uid_t        metadata_uid      = OCCTL_UID_INVALID;
};
 
using MaterialInfo = ::occtl_material_info_t;
 
using JointKind = ::occtl_joint_kind_t;
 
using JointInfo = ::occtl_joint_info_t;
 
using NodeKind = ::occtl_node_kind_t;
 
using TopoSplitKeep = ::occtl_topo_split_keep_t;
 
using TopoSplitByPlaneOptions = ::occtl_topo_split_by_plane_options_t;
 
using TopoSectionPlane = ::occtl_topo_section_plane_t;
 
using TopoSectionByPlanesOptions = ::occtl_topo_section_by_planes_options_t;
 
using TopoExtrudeFacesOptions = ::occtl_topo_extrude_faces_options_t;
 
using TopoMaxFilletRadiusOptions = ::occtl_topo_max_fillet_radius_options_t;
 
using EdgesToWiresOptions = ::occtl_topo_edges_to_wires_options_t;
 
using WireOffset2dOptions = ::occtl_topo_wire_offset_2d_options_t;
 
using WireFixDegenerateEdgesOptions = ::occtl_topo_wire_fix_degenerate_edges_options_t;
 
using FaceChamfer2dOptions = ::occtl_topo_face_chamfer_2d_options_t;
 
using WireChamfer2dOptions = ::occtl_topo_wire_chamfer_2d_options_t;
 
using MakeFaceFromWiresAutoOptions = ::occtl_topo_make_face_from_wires_auto_options_t;
 
class Graph;
 
class NodeIter
{
public:
  class iterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type        = NodeId;
    using difference_type   = std::ptrdiff_t;
    using pointer           = const NodeId*;
    using reference         = const NodeId&;
 
    iterator() noexcept
        : myIter(nullptr),
          myDone(true)
    {
    }
 
    explicit iterator(::occtl_node_iter_t* theIter)
        : myIter(theIter),
          myDone(false)
    {
      advance();
    }
 
    iterator(const iterator&)            = delete;
    iterator& operator=(const iterator&) = delete;
    iterator(iterator&&)                 = default;
    iterator& operator=(iterator&&)      = default;
 
    const NodeId& operator*() const noexcept { return myCurrent; }
 
    const NodeId* operator->() const noexcept { return &myCurrent; }
 
    iterator& operator++()
    {
      advance();
      return *this;
    }
 
    void operator++(int) { advance(); }
 
    bool operator==(const iterator& theOther) const noexcept
    {
      if (myDone && theOther.myDone)
      {
        return true;
      }
      return myIter == theOther.myIter && myDone == theOther.myDone;
    }
 
    bool operator!=(const iterator& theOther) const noexcept { return !(*this == theOther); }
 
  private:
    void advance()
    {
      if (myDone || myIter == nullptr)
      {
        myDone = true;
        return;
      }
      ::occtl_node_id_t      anId;
      const ::occtl_status_t aStatus = ::occtl_node_iter_next(myIter, &anId);
      if (aStatus == OCCTL_OK)
      {
        myCurrent = NodeId(anId);
      }
      else
      {
        if (aStatus != OCCTL_NOT_FOUND)
        {
          ::occtl::check(aStatus);
        }
        myDone = true;
      }
    }
 
    ::occtl_node_iter_t* myIter;
    NodeId               myCurrent{::occtl_node_id_t{0}};
    bool                 myDone;
  };
 
  NodeIter() noexcept = default;
 
  explicit NodeIter(::occtl_node_iter_t* theIter) noexcept
      : myIter(theIter)
  {
  }
 
  NodeIter(const NodeIter&)            = delete;
  NodeIter& operator=(const NodeIter&) = delete;
 
  NodeIter(NodeIter&& theOther) noexcept
      : myIter(theOther.myIter)
  {
    theOther.myIter = nullptr;
  }
 
  NodeIter& operator=(NodeIter&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_node_iter_free(myIter);
      myIter          = theOther.myIter;
      theOther.myIter = nullptr;
    }
    return *this;
  }
 
  ~NodeIter() { ::occtl_node_iter_free(myIter); }
 
  iterator begin() noexcept { return iterator(myIter); }
 
  iterator end() noexcept { return iterator(); }
 
private:
  ::occtl_node_iter_t* myIter = nullptr;
};
 
class SelectIter
{
public:
  class iterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type        = NodeId;
    using difference_type   = std::ptrdiff_t;
    using pointer           = const NodeId*;
    using reference         = const NodeId&;
 
    iterator() noexcept
        : myIter(nullptr),
          myDone(true)
    {
    }
 
    explicit iterator(::occtl_select_iter_t* theIter)
        : myIter(theIter),
          myDone(false)
    {
      advance();
    }
 
    iterator(const iterator&)            = delete;
    iterator& operator=(const iterator&) = delete;
    iterator(iterator&&)                 = default;
    iterator& operator=(iterator&&)      = default;
 
    const NodeId& operator*() const noexcept { return myCurrent; }
 
    const NodeId* operator->() const noexcept { return &myCurrent; }
 
    iterator& operator++()
    {
      advance();
      return *this;
    }
 
    void operator++(int) { advance(); }
 
    bool operator==(const iterator& theOther) const noexcept
    {
      if (myDone && theOther.myDone)
      {
        return true;
      }
      return myIter == theOther.myIter && myDone == theOther.myDone;
    }
 
    bool operator!=(const iterator& theOther) const noexcept { return !(*this == theOther); }
 
  private:
    void advance()
    {
      if (myDone || myIter == nullptr)
      {
        myDone = true;
        return;
      }
      ::occtl_node_id_t      anId{};
      const ::occtl_status_t aStatus = ::occtl_select_iter_next(myIter, &anId);
      if (aStatus == OCCTL_OK)
      {
        myCurrent = NodeId(anId);
      }
      else
      {
        if (aStatus != OCCTL_NOT_FOUND)
        {
          ::occtl::check(aStatus);
        }
        myDone = true;
      }
    }
 
    ::occtl_select_iter_t* myIter;
    NodeId                 myCurrent{::occtl_node_id_t{0}};
    bool                   myDone;
  };
 
  SelectIter() noexcept = default;
 
  explicit SelectIter(::occtl_select_iter_t* theIter) noexcept
      : myIter(theIter)
  {
  }
 
  SelectIter(const SelectIter&)            = delete;
  SelectIter& operator=(const SelectIter&) = delete;
 
  SelectIter(SelectIter&& theOther) noexcept
      : myIter(theOther.myIter)
  {
    theOther.myIter = nullptr;
  }
 
  SelectIter& operator=(SelectIter&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_select_iter_free(myIter);
      myIter          = theOther.myIter;
      theOther.myIter = nullptr;
    }
    return *this;
  }
 
  ~SelectIter() { ::occtl_select_iter_free(myIter); }
 
  iterator begin() noexcept { return iterator(myIter); }
 
  iterator end() noexcept { return iterator(); }
 
private:
  ::occtl_select_iter_t* myIter = nullptr;
};
 
class SelectGroupIter
{
public:
  class iterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type        = SelectGroupView;
    using difference_type   = std::ptrdiff_t;
    using pointer           = const SelectGroupView*;
    using reference         = const SelectGroupView&;
 
    iterator() noexcept
        : myIter(nullptr),
          myDone(true)
    {
    }
 
    explicit iterator(::occtl_select_group_iter_t* theIter)
        : myIter(theIter),
          myDone(false)
    {
      advance();
    }
 
    iterator(const iterator&)            = delete;
    iterator& operator=(const iterator&) = delete;
    iterator(iterator&&)                 = default;
    iterator& operator=(iterator&&)      = default;
 
    const SelectGroupView& operator*() const noexcept { return myCurrent; }
 
    const SelectGroupView* operator->() const noexcept { return &myCurrent; }
 
    iterator& operator++()
    {
      advance();
      return *this;
    }
 
    void operator++(int) { advance(); }
 
    bool operator==(const iterator& theOther) const noexcept
    {
      if (myDone && theOther.myDone)
      {
        return true;
      }
      return myIter == theOther.myIter && myDone == theOther.myDone;
    }
 
    bool operator!=(const iterator& theOther) const noexcept { return !(*this == theOther); }
 
  private:
    void advance()
    {
      if (myDone || myIter == nullptr)
      {
        myDone = true;
        return;
      }
      ::occtl_select_group_view_t aView   = OCCTL_SELECT_GROUP_VIEW_INIT;
      const ::occtl_status_t      aStatus = ::occtl_select_group_iter_next(myIter, &aView);
      if (aStatus == OCCTL_OK)
      {
        myCurrent = aView;
      }
      else
      {
        if (aStatus != OCCTL_NOT_FOUND)
        {
          ::occtl::check(aStatus);
        }
        myDone = true;
      }
    }
 
    ::occtl_select_group_iter_t* myIter;
    SelectGroupView              myCurrent = OCCTL_SELECT_GROUP_VIEW_INIT;
    bool                         myDone;
  };
 
  SelectGroupIter() noexcept = default;
 
  explicit SelectGroupIter(::occtl_select_group_iter_t* theIter) noexcept
      : myIter(theIter)
  {
  }
 
  SelectGroupIter(const SelectGroupIter&)            = delete;
  SelectGroupIter& operator=(const SelectGroupIter&) = delete;
 
  SelectGroupIter(SelectGroupIter&& theOther) noexcept
      : myIter(theOther.myIter)
  {
    theOther.myIter = nullptr;
  }
 
  SelectGroupIter& operator=(SelectGroupIter&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_select_group_iter_free(myIter);
      myIter          = theOther.myIter;
      theOther.myIter = nullptr;
    }
    return *this;
  }
 
  ~SelectGroupIter() { ::occtl_select_group_iter_free(myIter); }
 
  iterator begin() noexcept { return iterator(myIter); }
 
  iterator end() noexcept { return iterator(); }
 
private:
  ::occtl_select_group_iter_t* myIter = nullptr;
};
 
class AxisHitIter
{
public:
  class iterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type        = AxisHit;
    using difference_type   = std::ptrdiff_t;
    using pointer           = const AxisHit*;
    using reference         = const AxisHit&;
 
    iterator() noexcept
        : myIter(nullptr),
          myDone(true)
    {
    }
 
    explicit iterator(::occtl_topo_axis_hit_iter_t* theIter)
        : myIter(theIter),
          myDone(false)
    {
      advance();
    }
 
    iterator(const iterator&)            = delete;
    iterator& operator=(const iterator&) = delete;
    iterator(iterator&&)                 = default;
    iterator& operator=(iterator&&)      = default;
 
    const AxisHit& operator*() const noexcept { return myCurrent; }
 
    const AxisHit* operator->() const noexcept { return &myCurrent; }
 
    iterator& operator++()
    {
      advance();
      return *this;
    }
 
    void operator++(int) { advance(); }
 
    bool operator==(const iterator& theOther) const noexcept
    {
      if (myDone && theOther.myDone)
      {
        return true;
      }
      return myIter == theOther.myIter && myDone == theOther.myDone;
    }
 
    bool operator!=(const iterator& theOther) const noexcept { return !(*this == theOther); }
 
  private:
    void advance()
    {
      if (myDone || myIter == nullptr)
      {
        myDone = true;
        return;
      }
      ::occtl_topo_axis_hit_t aHit{};
      const ::occtl_status_t  aStatus = ::occtl_topo_axis_hit_iter_next(myIter, &aHit);
      if (aStatus == OCCTL_OK)
      {
        myCurrent = aHit;
      }
      else
      {
        if (aStatus != OCCTL_NOT_FOUND)
        {
          ::occtl::check(aStatus);
        }
        myDone = true;
      }
    }
 
    ::occtl_topo_axis_hit_iter_t* myIter;
    AxisHit                       myCurrent{};
    bool                          myDone;
  };
 
  AxisHitIter() noexcept = default;
 
  explicit AxisHitIter(::occtl_topo_axis_hit_iter_t* theIter) noexcept
      : myIter(theIter)
  {
  }
 
  AxisHitIter(const AxisHitIter&)            = delete;
  AxisHitIter& operator=(const AxisHitIter&) = delete;
 
  AxisHitIter(AxisHitIter&& theOther) noexcept
      : myIter(theOther.myIter)
  {
    theOther.myIter = nullptr;
  }
 
  AxisHitIter& operator=(AxisHitIter&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_topo_axis_hit_iter_free(myIter);
      myIter          = theOther.myIter;
      theOther.myIter = nullptr;
    }
    return *this;
  }
 
  ~AxisHitIter() { ::occtl_topo_axis_hit_iter_free(myIter); }
 
  iterator begin() noexcept { return iterator(myIter); }
 
  iterator end() noexcept { return iterator(); }
 
private:
  ::occtl_topo_axis_hit_iter_t* myIter = nullptr;
};
 
class TouchIter
{
public:
  class iterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type        = TouchHit;
    using difference_type   = std::ptrdiff_t;
    using pointer           = const TouchHit*;
    using reference         = const TouchHit&;
 
    iterator() noexcept
        : myIter(nullptr),
          myDone(true)
    {
    }
 
    explicit iterator(::occtl_topo_touch_iter_t* theIter)
        : myIter(theIter),
          myDone(false)
    {
      advance();
    }
 
    iterator(const iterator&)            = delete;
    iterator& operator=(const iterator&) = delete;
    iterator(iterator&&)                 = default;
    iterator& operator=(iterator&&)      = default;
 
    const TouchHit& operator*() const noexcept { return myCurrent; }
 
    const TouchHit* operator->() const noexcept { return &myCurrent; }
 
    iterator& operator++()
    {
      advance();
      return *this;
    }
 
    void operator++(int) { advance(); }
 
    bool operator==(const iterator& theOther) const noexcept
    {
      if (myDone && theOther.myDone)
      {
        return true;
      }
      return myIter == theOther.myIter && myDone == theOther.myDone;
    }
 
    bool operator!=(const iterator& theOther) const noexcept { return !(*this == theOther); }
 
  private:
    void advance()
    {
      if (myDone || myIter == nullptr)
      {
        myDone = true;
        return;
      }
      ::occtl_topo_touch_hit_t aHit{};
      const ::occtl_status_t   aStatus = ::occtl_topo_touch_iter_next(myIter, &aHit);
      if (aStatus == OCCTL_OK)
      {
        myCurrent = aHit;
      }
      else
      {
        if (aStatus != OCCTL_NOT_FOUND)
        {
          ::occtl::check(aStatus);
        }
        myDone = true;
      }
    }
 
    ::occtl_topo_touch_iter_t* myIter;
    TouchHit                   myCurrent{};
    bool                       myDone;
  };
 
  TouchIter() noexcept = default;
 
  explicit TouchIter(::occtl_topo_touch_iter_t* theIter) noexcept
      : myIter(theIter)
  {
  }
 
  TouchIter(const TouchIter&)            = delete;
  TouchIter& operator=(const TouchIter&) = delete;
 
  TouchIter(TouchIter&& theOther) noexcept
      : myIter(theOther.myIter)
  {
    theOther.myIter = nullptr;
  }
 
  TouchIter& operator=(TouchIter&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_topo_touch_iter_free(myIter);
      myIter          = theOther.myIter;
      theOther.myIter = nullptr;
    }
    return *this;
  }
 
  ~TouchIter() { ::occtl_topo_touch_iter_free(myIter); }
 
  iterator begin() noexcept { return iterator(myIter); }
 
  iterator end() noexcept { return iterator(); }
 
private:
  ::occtl_topo_touch_iter_t* myIter = nullptr;
};
 
class IntersectionIter
{
public:
  class iterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type        = NodeId;
    using difference_type   = std::ptrdiff_t;
    using pointer           = const NodeId*;
    using reference         = const NodeId&;
 
    iterator() noexcept
        : myIter(nullptr),
          myDone(true)
    {
    }
 
    explicit iterator(::occtl_topo_intersection_iter_t* theIter)
        : myIter(theIter),
          myDone(false)
    {
      advance();
    }
 
    iterator(const iterator&)            = delete;
    iterator& operator=(const iterator&) = delete;
    iterator(iterator&&)                 = default;
    iterator& operator=(iterator&&)      = default;
 
    const NodeId& operator*() const noexcept { return myCurrent; }
 
    const NodeId* operator->() const noexcept { return &myCurrent; }
 
    iterator& operator++()
    {
      advance();
      return *this;
    }
 
    void operator++(int) { advance(); }
 
    bool operator==(const iterator& theOther) const noexcept
    {
      if (myDone && theOther.myDone)
      {
        return true;
      }
      return myIter == theOther.myIter && myDone == theOther.myDone;
    }
 
    bool operator!=(const iterator& theOther) const noexcept { return !(*this == theOther); }
 
  private:
    void advance()
    {
      if (myDone || myIter == nullptr)
      {
        myDone = true;
        return;
      }
      ::occtl_node_id_t      aNode   = OCCTL_NODE_ID_INVALID;
      const ::occtl_status_t aStatus = ::occtl_topo_intersection_iter_next(myIter, &aNode);
      if (aStatus == OCCTL_OK)
      {
        myCurrent = NodeId(aNode);
      }
      else
      {
        if (aStatus != OCCTL_NOT_FOUND)
        {
          ::occtl::check(aStatus);
        }
        myDone = true;
      }
    }
 
    ::occtl_topo_intersection_iter_t* myIter;
    NodeId                            myCurrent = NodeId::invalid();
    bool                              myDone;
  };
 
  IntersectionIter() noexcept = default;
 
  explicit IntersectionIter(::occtl_topo_intersection_iter_t* theIter) noexcept
      : myIter(theIter)
  {
  }
 
  IntersectionIter(const IntersectionIter&)            = delete;
  IntersectionIter& operator=(const IntersectionIter&) = delete;
 
  IntersectionIter(IntersectionIter&& theOther) noexcept
      : myIter(theOther.myIter)
  {
    theOther.myIter = nullptr;
  }
 
  IntersectionIter& operator=(IntersectionIter&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_topo_intersection_iter_free(myIter);
      myIter          = theOther.myIter;
      theOther.myIter = nullptr;
    }
    return *this;
  }
 
  ~IntersectionIter() { ::occtl_topo_intersection_iter_free(myIter); }
 
  iterator begin() noexcept { return iterator(myIter); }
 
  iterator end() noexcept { return iterator(); }
 
private:
  ::occtl_topo_intersection_iter_t* myIter = nullptr;
};
 
class Batch
{
public:
  Batch(const Batch&)            = delete;
  Batch& operator=(const Batch&) = delete;
 
  Batch(Batch&& theOther) noexcept
      : myBatch(theOther.myBatch),
        myGraph(theOther.myGraph)
  {
    theOther.myBatch = nullptr;
    theOther.myGraph = nullptr;
  }
 
  Batch& operator=(Batch&& theOther) noexcept
  {
    if (this != &theOther)
    {
      silentAbort();
      myBatch          = theOther.myBatch;
      theOther.myBatch = nullptr;
      myGraph          = theOther.myGraph;
      theOther.myGraph = nullptr;
    }
    return *this;
  }
 
  ~Batch() noexcept { silentAbort(); }
 
  ::occtl_graph_t* graph() noexcept { return myGraph; }
 
  void commit()
  {
    if (myBatch != nullptr)
    {
      check(::occtl_batch_commit(myBatch));
      myBatch = nullptr;
    }
  }
 
  void abort()
  {
    if (myBatch != nullptr)
    {
      check(::occtl_batch_abort(myBatch));
      myBatch = nullptr;
    }
  }
 
private:
  friend class Graph;
 
  explicit Batch(::occtl_batch_t* const theBatch, ::occtl_graph_t* const theGraph) noexcept
      : myBatch(theBatch),
        myGraph(theGraph)
  {
  }
 
  void silentAbort() noexcept
  {
    if (myBatch != nullptr)
    {
      ::occtl_batch_abort(myBatch);
      myBatch = nullptr;
    }
  }
 
  ::occtl_batch_t* myBatch = nullptr;
  ::occtl_graph_t* myGraph = nullptr;
};
 
class ExplorerIter
{
public:
  struct Item
  {
    NodeId      node{::occtl_node_id_t{0}};
    Transform   transform{::occtl_transform_t{}};
    Orientation orientation{OCCTL_ORIENTATION_FORWARD};
  };
 
  class iterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type        = Item;
    using difference_type   = std::ptrdiff_t;
    using pointer           = const Item*;
    using reference         = const Item&;
 
    iterator() noexcept
        : myIter(nullptr),
          myDone(true)
    {
    }
 
    explicit iterator(::occtl_topo_explorer_iter_t* theIter)
        : myIter(theIter),
          myDone(false)
    {
      advance();
    }
 
    iterator(const iterator&)            = delete;
    iterator& operator=(const iterator&) = delete;
    iterator(iterator&&)                 = default;
    iterator& operator=(iterator&&)      = default;
 
    const Item& operator*() const noexcept { return myCurrent; }
 
    const Item* operator->() const noexcept { return &myCurrent; }
 
    iterator& operator++()
    {
      advance();
      return *this;
    }
 
    void operator++(int) { advance(); }
 
    bool operator==(const iterator& theOther) const noexcept
    {
      if (myDone && theOther.myDone)
      {
        return true;
      }
      return myIter == theOther.myIter && myDone == theOther.myDone;
    }
 
    bool operator!=(const iterator& theOther) const noexcept { return !(*this == theOther); }
 
  private:
    void advance()
    {
      if (myDone || myIter == nullptr)
      {
        myDone = true;
        return;
      }
      ::occtl_node_id_t      anId{};
      ::occtl_transform_t    aTrsf{};
      ::occtl_orientation_t  aOri = OCCTL_ORIENTATION_FORWARD;
      const ::occtl_status_t aStatus =
        ::occtl_topo_explorer_iter_next(myIter, &anId, &aTrsf, &aOri);
      if (aStatus == OCCTL_OK)
      {
        myCurrent = Item{NodeId(anId), Transform(aTrsf), occtl::Orientation{aOri}};
      }
      else
      {
        if (aStatus != OCCTL_NOT_FOUND)
        {
          ::occtl::check(aStatus);
        }
        myDone = true;
      }
    }
 
    ::occtl_topo_explorer_iter_t* myIter;
    Item                          myCurrent{};
    bool                          myDone;
  };
 
  ExplorerIter() noexcept = default;
 
  explicit ExplorerIter(::occtl_topo_explorer_iter_t* theIter) noexcept
      : myIter(theIter)
  {
  }
 
  ExplorerIter(const ExplorerIter&)            = delete;
  ExplorerIter& operator=(const ExplorerIter&) = delete;
 
  ExplorerIter(ExplorerIter&& theOther) noexcept
      : myIter(theOther.myIter)
  {
    theOther.myIter = nullptr;
  }
 
  ExplorerIter& operator=(ExplorerIter&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_topo_explorer_iter_free(myIter);
      myIter          = theOther.myIter;
      theOther.myIter = nullptr;
    }
    return *this;
  }
 
  ~ExplorerIter() { ::occtl_topo_explorer_iter_free(myIter); }
 
  iterator begin() noexcept { return iterator(myIter); }
 
  iterator end() noexcept { return iterator(); }
 
private:
  ::occtl_topo_explorer_iter_t* myIter = nullptr;
};
 
class RelatedIter
{
public:
  struct Item
  {
    NodeId       node{::occtl_node_id_t{0}};
    RelationKind relation{OCCTL_RELATION_BOUNDARY_EDGE};
  };
 
  class iterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type        = Item;
    using difference_type   = std::ptrdiff_t;
    using pointer           = const Item*;
    using reference         = const Item&;
 
    iterator() noexcept
        : myIter(nullptr),
          myDone(true)
    {
    }
 
    explicit iterator(::occtl_topo_related_iter_t* theIter)
        : myIter(theIter),
          myDone(false)
    {
      advance();
    }
 
    iterator(const iterator&)            = delete;
    iterator& operator=(const iterator&) = delete;
    iterator(iterator&&)                 = default;
    iterator& operator=(iterator&&)      = default;
 
    const Item& operator*() const noexcept { return myCurrent; }
 
    const Item* operator->() const noexcept { return &myCurrent; }
 
    iterator& operator++()
    {
      advance();
      return *this;
    }
 
    void operator++(int) { advance(); }
 
    bool operator==(const iterator& theOther) const noexcept
    {
      if (myDone && theOther.myDone)
      {
        return true;
      }
      return myIter == theOther.myIter && myDone == theOther.myDone;
    }
 
    bool operator!=(const iterator& theOther) const noexcept { return !(*this == theOther); }
 
  private:
    void advance()
    {
      if (myDone || myIter == nullptr)
      {
        myDone = true;
        return;
      }
      ::occtl_node_id_t       anId{};
      ::occtl_relation_kind_t aKind   = OCCTL_RELATION_BOUNDARY_EDGE;
      const ::occtl_status_t  aStatus = ::occtl_topo_related_iter_next(myIter, &anId, &aKind);
      if (aStatus == OCCTL_OK)
      {
        myCurrent = Item{NodeId(anId), occtl::RelationKind{aKind}};
      }
      else
      {
        if (aStatus != OCCTL_NOT_FOUND)
        {
          ::occtl::check(aStatus);
        }
        myDone = true;
      }
    }
 
    ::occtl_topo_related_iter_t* myIter;
    Item                         myCurrent{};
    bool                         myDone;
  };
 
  RelatedIter() noexcept = default;
 
  explicit RelatedIter(::occtl_topo_related_iter_t* theIter) noexcept
      : myIter(theIter)
  {
  }
 
  RelatedIter(const RelatedIter&)            = delete;
  RelatedIter& operator=(const RelatedIter&) = delete;
 
  RelatedIter(RelatedIter&& theOther) noexcept
      : myIter(theOther.myIter)
  {
    theOther.myIter = nullptr;
  }
 
  RelatedIter& operator=(RelatedIter&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_topo_related_iter_free(myIter);
      myIter          = theOther.myIter;
      theOther.myIter = nullptr;
    }
    return *this;
  }
 
  ~RelatedIter() { ::occtl_topo_related_iter_free(myIter); }
 
  iterator begin() noexcept { return iterator(myIter); }
 
  iterator end() noexcept { return iterator(); }
 
private:
  ::occtl_topo_related_iter_t* myIter = nullptr;
};
 
class Graph
{
public:
  Graph() { check(::occtl_graph_create(&myPtr)); }
 
  static Graph create() { return Graph(); }
 
  explicit Graph(::occtl_graph_t* const thePtr) noexcept
      : myPtr(thePtr)
  {
  }
 
  static Graph from_pointer_unsafe(::occtl_graph_t* const thePtr)
  {
    if (thePtr == nullptr)
    {
      throw Error(OCCTL_INVALID_HANDLE, "Graph::from_pointer_unsafe received a null pointer", 0, 0);
    }
    return Graph(thePtr);
  }
 
  ~Graph() { ::occtl_graph_free(myPtr); }
 
  Graph(Graph&& theOther) noexcept
      : myPtr(theOther.myPtr)
  {
    theOther.myPtr = nullptr;
  }
 
  Graph& operator=(Graph&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_graph_free(myPtr);
      myPtr          = theOther.myPtr;
      theOther.myPtr = nullptr;
    }
    return *this;
  }
 
  Graph(const Graph&)            = delete;
  Graph& operator=(const Graph&) = delete;
 
  ::occtl_graph_t* get() const noexcept { return myPtr; }
 
  ::occtl_node_kind_t node_id_kind(const NodeId theId) const
  {
    ::occtl_node_kind_t aKind;
    check(::occtl_graph_node_kind(myPtr, theId.get(), &aKind));
    return aKind;
  }
 
  ::occtl_node_kind_t uid_kind(const UID theUid) const
  {
    ::occtl_node_kind_t aKind;
    check(::occtl_graph_uid_kind(myPtr, theUid.get(), &aKind));
    return aKind;
  }
 
  ::occtl_ref_kind_t ref_id_kind(const RefId theId) const
  {
    ::occtl_ref_kind_t aKind;
    check(::occtl_graph_ref_kind(myPtr, theId.get(), &aKind));
    return aKind;
  }
 
  ::occtl_ref_kind_t ref_uid_kind(const RefUID theUid) const
  {
    ::occtl_ref_kind_t aKind;
    check(::occtl_graph_ref_uid_kind(myPtr, theUid.get(), &aKind));
    return aKind;
  }
 
  ::occtl_rep_kind_t rep_id_kind(const RepId theId) const
  {
    ::occtl_rep_kind_t aKind;
    check(::occtl_graph_rep_kind(myPtr, theId.get(), &aKind));
    return aKind;
  }
 
  NodeId node_id_from_uid(const UID theUid) const
  {
    ::occtl_node_id_t aId;
    check(::occtl_graph_node_id_from_uid(myPtr, theUid.get(), &aId));
    return NodeId(aId);
  }
 
  UID uid_from_node_id(const NodeId theId) const
  {
    ::occtl_uid_t aUid;
    check(::occtl_graph_uid_from_node_id(myPtr, theId.get(), &aUid));
    return UID(aUid);
  }
 
  std::vector<UID> history_modified(const UID theInputUid) const
  {
    return fetch_history(&::occtl_graph_history_modified, theInputUid);
  }
 
  std::vector<UID> history_generated(const UID theInputUid) const
  {
    return fetch_history(&::occtl_graph_history_generated, theInputUid);
  }
 
  std::vector<UID> history_deleted_all() const
  {
    size_t aCount = 0;
    check(::occtl_graph_history_deleted_all(myPtr, nullptr, 0, &aCount));
    std::vector<::occtl_uid_t> aRaw(aCount);
    if (aCount != 0)
    {
      check(::occtl_graph_history_deleted_all(myPtr, aRaw.data(), aCount, &aCount));
    }
    std::vector<UID> aOut;
    aOut.reserve(aRaw.size());
    for (const ::occtl_uid_t& aUid : aRaw)
    {
      aOut.emplace_back(aUid);
    }
    return aOut;
  }
 
  RefId ref_id_from_ref_uid(const RefUID theUid) const
  {
    ::occtl_ref_id_t aId;
    check(::occtl_graph_ref_id_from_ref_uid(myPtr, theUid.get(), &aId));
    return RefId(aId);
  }
 
  RefUID ref_uid_from_ref_id(const RefId theId) const
  {
    ::occtl_ref_uid_t aUid;
    check(::occtl_graph_ref_uid_from_ref_id(myPtr, theId.get(), &aUid));
    return RefUID(aUid);
  }
 
  RepId rep_id_from_rep_uid(const RepUID theUid) const
  {
    ::occtl_rep_id_t aId;
    check(::occtl_graph_rep_id_from_rep_uid(myPtr, theUid.get(), &aId));
    return RepId(aId);
  }
 
  RepUID rep_uid_from_rep_id(const RepId theId) const
  {
    ::occtl_rep_uid_t aUid;
    check(::occtl_graph_rep_uid_from_rep_id(myPtr, theId.get(), &aUid));
    return RepUID(aUid);
  }
 
  std::vector<std::pair<RefUID, RefId>> ref_uid_table() const
  {
    size_t aCount = 0;
    check(::occtl_graph_ref_uid_table(myPtr, nullptr, nullptr, 0, &aCount));
    std::vector<::occtl_ref_uid_t> aUids(aCount);
    std::vector<::occtl_ref_id_t>  aRefs(aCount);
    if (aCount != 0)
    {
      check(::occtl_graph_ref_uid_table(myPtr, aUids.data(), aRefs.data(), aCount, &aCount));
    }
 
    std::vector<std::pair<RefUID, RefId>> aResult;
    aResult.reserve(aCount);
    for (size_t anIndex = 0; anIndex < aCount; ++anIndex)
    {
      aResult.emplace_back(RefUID(aUids[anIndex]), RefId(aRefs[anIndex]));
    }
    return aResult;
  }
 
  size_t solid_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_solid_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t shell_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_shell_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t face_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_face_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t wire_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_wire_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t edge_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_edge_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t vertex_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_vertex_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t compound_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_compound_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t compsolid_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_compsolid_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t coedge_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_coedge_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t product_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_product_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t occurrence_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_occurrence_count(myPtr, &aCount));
    return aCount;
  } 
 
  size_t node_count() const
  {
    size_t aCount = 0;
    check(::occtl_graph_node_count(myPtr, &aCount));
    return aCount;
  } 
 
  std::vector<::occtl_topo_check_issue_t> check_issues() const
  {
    size_t aCount = 0;
    check(::occtl_topo_check(myPtr, nullptr, 0, &aCount));
    std::vector<::occtl_topo_check_issue_t> anIssues(aCount);
    if (aCount != 0)
    {
      check(::occtl_topo_check(myPtr, anIssues.data(), anIssues.size(), &aCount));
      anIssues.resize(aCount);
    }
    return anIssues;
  }
 
  bool is_valid() const { return check_issues().empty(); }
 
  Point3 vertex_point(const NodeId theVertex) const
  {
    ::occtl_point3_t aPoint;
    check(::occtl_topo_vertex_point(myPtr, theVertex.get(), &aPoint));
    return Point3(aPoint);
  }
 
  double vertex_tolerance(const NodeId theVertex) const
  {
    double aTol = 0.0;
    check(::occtl_topo_vertex_tolerance(myPtr, theVertex.get(), &aTol));
    return aTol;
  }
 
  std::pair<double, double> edge_range(const NodeId theEdge) const
  {
    double aFirst = 0.0, aLast = 0.0;
    check(::occtl_topo_edge_range(myPtr, theEdge.get(), &aFirst, &aLast));
    return {aFirst, aLast};
  }
 
  double edge_tolerance(const NodeId theEdge) const
  {
    double aTol = 0.0;
    check(::occtl_topo_edge_tolerance(myPtr, theEdge.get(), &aTol));
    return aTol;
  }
 
  bool edge_is_degenerated(const NodeId theEdge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_edge_is_degenerated(myPtr, theEdge.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool edge_has_curve(const NodeId theEdge) const
  {
    int32_t aHas = 0;
    check(::occtl_topo_edge_has_curve(myPtr, theEdge.get(), &aHas));
    return aHas != 0;
  }
 
  CurveKind edge_curve_kind(const NodeId theEdge) const
  {
    ::occtl_curve_kind_t aKind = OCCTL_CURVE_KIND_UNDEFINED;
    check(::occtl_topo_edge_curve_kind(myPtr, theEdge.get(), &aKind));
    return aKind;
  }
 
  NodeId edge_start_vertex(const NodeId theEdge) const
  {
    ::occtl_node_id_t aId;
    check(::occtl_topo_edge_start_vertex(myPtr, theEdge.get(), &aId));
    return NodeId(aId);
  }
 
  NodeId edge_end_vertex(const NodeId theEdge) const
  {
    ::occtl_node_id_t aId;
    check(::occtl_topo_edge_end_vertex(myPtr, theEdge.get(), &aId));
    return NodeId(aId);
  }
 
  bool coedge_is_seam(const NodeId theCoedge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_coedge_is_seam(myPtr, theCoedge.get(), &aFlag));
    return aFlag != 0;
  }
 
  NodeId coedge_edge_of(const NodeId theCoedge) const
  {
    ::occtl_node_id_t aId;
    check(::occtl_topo_coedge_edge_of(myPtr, theCoedge.get(), &aId));
    return NodeId(aId);
  }
 
  NodeId coedge_face_of(const NodeId theCoedge) const
  {
    ::occtl_node_id_t aId;
    check(::occtl_topo_coedge_face_of(myPtr, theCoedge.get(), &aId));
    return NodeId(aId);
  }
 
  double face_tolerance(const NodeId theFace) const
  {
    double aTol = 0.0;
    check(::occtl_topo_face_tolerance(myPtr, theFace.get(), &aTol));
    return aTol;
  }
 
  NodeId face_outer_wire(const NodeId theFace) const
  {
    ::occtl_node_id_t aId;
    check(::occtl_topo_face_outer_wire(myPtr, theFace.get(), &aId));
    return NodeId(aId);
  }
 
  void face_uv_bounds(const NodeId theFace,
                      double&      theUMin,
                      double&      theUMax,
                      double&      theVMin,
                      double&      theVMax) const
  {
    check(
      ::occtl_topo_face_uv_bounds(myPtr, theFace.get(), &theUMin, &theUMax, &theVMin, &theVMax));
  }
 
  bool face_has_surface(const NodeId theFace) const
  {
    int32_t aHas = 0;
    check(::occtl_topo_face_has_surface(myPtr, theFace.get(), &aHas));
    return aHas != 0;
  }
 
  SurfaceKind face_surface_kind(const NodeId theFace) const
  {
    ::occtl_surface_kind_t aKind = OCCTL_SURFACE_KIND_UNDEFINED;
    check(::occtl_topo_face_surface_kind(myPtr, theFace.get(), &aKind));
    return aKind;
  }
 
  bool wire_is_closed(const NodeId theWire) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_wire_is_closed(myPtr, theWire.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool shell_is_closed(const NodeId theShell) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_shell_is_closed(myPtr, theShell.get(), &aFlag));
    return aFlag != 0;
  }
 
  double vertex_parameter(const NodeId theVertex, const NodeId theEdge) const
  {
    double aParam = 0.0;
    check(::occtl_topo_vertex_parameter(myPtr, theVertex.get(), theEdge.get(), &aParam));
    return aParam;
  }
 
  Point2 vertex_parameters(const NodeId theVertex, const NodeId theFace) const
  {
    ::occtl_point2_t aUV;
    check(::occtl_topo_vertex_parameters(myPtr, theVertex.get(), theFace.get(), &aUV));
    return Point2(aUV);
  }
 
  bool edge_same_parameter(const NodeId theEdge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_edge_same_parameter(myPtr, theEdge.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool edge_same_range(const NodeId theEdge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_edge_same_range(myPtr, theEdge.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool edge_is_manifold(const NodeId theEdge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_edge_is_manifold(myPtr, theEdge.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool edge_is_boundary(const NodeId theEdge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_edge_is_boundary(myPtr, theEdge.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool edge_is_seam_on_face(const NodeId theEdge, const NodeId theFace) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_edge_is_seam_on_face(myPtr, theEdge.get(), theFace.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool coedge_is_reversed(const NodeId theCoedge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_coedge_is_reversed(myPtr, theCoedge.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool coedge_has_pcurve(const NodeId theCoedge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_coedge_has_pcurve(myPtr, theCoedge.get(), &aFlag));
    return aFlag != 0;
  }
 
  double coedge_pcurve_parameter(const NodeId theCoedge, const NodeId theVertex) const
  {
    double aParam = 0.0;
    check(::occtl_topo_coedge_pcurve_parameter(myPtr, theCoedge.get(), theVertex.get(), &aParam));
    return aParam;
  }
 
  std::pair<double, double> coedge_range(const NodeId theCoedge) const
  {
    double aFirst = 0.0, aLast = 0.0;
    check(::occtl_topo_coedge_range(myPtr, theCoedge.get(), &aFirst, &aLast));
    return {aFirst, aLast};
  }
 
  void coedge_uv_points(const NodeId      theCoedge,
                        ::occtl_point2_t& theUVStart,
                        ::occtl_point2_t& theUVEnd) const
  {
    check(::occtl_topo_coedge_uv_points(myPtr, theCoedge.get(), &theUVStart, &theUVEnd));
  }
 
  NodeId coedge_seam_pair(const NodeId theCoedge) const
  {
    ::occtl_node_id_t aPair;
    check(::occtl_topo_coedge_seam_pair(myPtr, theCoedge.get(), &aPair));
    return NodeId(aPair);
  }
 
  bool face_natural_restriction(const NodeId theFace) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_face_natural_restriction(myPtr, theFace.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool face_has_triangulation(const NodeId theFace) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_face_has_triangulation(myPtr, theFace.get(), &aFlag));
    return aFlag != 0;
  }
 
  NodeId wire_face_of(const NodeId theWire) const
  {
    ::occtl_node_id_t aFace;
    check(::occtl_topo_wire_face_of(myPtr, theWire.get(), &aFace));
    return NodeId(aFace);
  }
 
  bool wire_is_outer(const NodeId theWire) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_wire_is_outer(myPtr, theWire.get(), &aFlag));
    return aFlag != 0;
  }
 
  Point2 coedge_pcurve_eval(const NodeId theCoedge, const double theU) const
  {
    ::occtl_point2_t aUV{};
    check(::occtl_topo_coedge_pcurve_eval(myPtr, theCoedge.get(), theU, &aUV));
    return Point2(aUV);
  }
 
  std::pair<Point2, Vector2> coedge_pcurve_eval_d1(const NodeId theCoedge, const double theU) const
  {
    ::occtl_point2_t  aUV{};
    ::occtl_vector2_t aD1{};
    check(::occtl_topo_coedge_pcurve_eval_d1(myPtr, theCoedge.get(), theU, &aUV, &aD1));
    return {Point2{aUV}, Vector2{aD1}};
  }
 
  std::tuple<Point2, Vector2, Vector2> coedge_pcurve_eval_d2(const NodeId theCoedge,
                                                             const double theU) const
  {
    ::occtl_point2_t  aUV{};
    ::occtl_vector2_t aD1{}, aD2{};
    check(::occtl_topo_coedge_pcurve_eval_d2(myPtr, theCoedge.get(), theU, &aUV, &aD1, &aD2));
    return {Point2{aUV}, Vector2{aD1}, Vector2{aD2}};
  }
 
  std::tuple<Point2, Vector2, Vector2, Vector2> coedge_pcurve_eval_d3(const NodeId theCoedge,
                                                                      const double theU) const
  {
    ::occtl_point2_t  aUV{};
    ::occtl_vector2_t aD1{}, aD2{}, aD3{};
    check(::occtl_topo_coedge_pcurve_eval_d3(myPtr, theCoedge.get(), theU, &aUV, &aD1, &aD2, &aD3));
    return {Point2{aUV}, Vector2{aD1}, Vector2{aD2}, Vector2{aD3}};
  }
 
  Vector2 coedge_pcurve_eval_dn(const NodeId   theCoedge,
                                const double   theU,
                                const uint32_t theN) const
  {
    ::occtl_vector2_t aDN{};
    check(::occtl_topo_coedge_pcurve_eval_dn(myPtr, theCoedge.get(), theU, theN, &aDN));
    return Vector2{aDN};
  }
 
  Point3 edge_eval(const NodeId theEdge, const double theU) const
  {
    ::occtl_point3_t aP{};
    check(::occtl_topo_edge_eval(myPtr, theEdge.get(), theU, &aP));
    return Point3(aP);
  }
 
  std::pair<Point3, Vector3> edge_eval_d1(const NodeId theEdge, const double theU) const
  {
    ::occtl_point3_t  aP{};
    ::occtl_vector3_t aD1{};
    check(::occtl_topo_edge_eval_d1(myPtr, theEdge.get(), theU, &aP, &aD1));
    return {Point3{aP}, Vector3{aD1}};
  }
 
  std::tuple<Point3, Vector3, Vector3> edge_eval_d2(const NodeId theEdge, const double theU) const
  {
    ::occtl_point3_t  aP{};
    ::occtl_vector3_t aD1{}, aD2{};
    check(::occtl_topo_edge_eval_d2(myPtr, theEdge.get(), theU, &aP, &aD1, &aD2));
    return {Point3{aP}, Vector3{aD1}, Vector3{aD2}};
  }
 
  std::tuple<Point3, Vector3, Vector3, Vector3> edge_eval_d3(const NodeId theEdge,
                                                             const double theU) const
  {
    ::occtl_point3_t  aP{};
    ::occtl_vector3_t aD1{}, aD2{}, aD3{};
    check(::occtl_topo_edge_eval_d3(myPtr, theEdge.get(), theU, &aP, &aD1, &aD2, &aD3));
    return {Point3{aP}, Vector3{aD1}, Vector3{aD2}, Vector3{aD3}};
  }
 
  Vector3 edge_eval_dn(const NodeId theEdge, const double theU, const uint32_t theN) const
  {
    ::occtl_vector3_t aDN{};
    check(::occtl_topo_edge_eval_dn(myPtr, theEdge.get(), theU, theN, &aDN));
    return Vector3{aDN};
  }
 
  Point3 face_eval(const NodeId theFace, const double theU, const double theV) const
  {
    ::occtl_point3_t aP{};
    check(::occtl_topo_face_eval(myPtr, theFace.get(), theU, theV, &aP));
    return Point3(aP);
  }
 
  std::tuple<Point3, Vector3, Vector3> face_eval_d1(const NodeId theFace,
                                                    const double theU,
                                                    const double theV) const
  {
    ::occtl_point3_t  aP{};
    ::occtl_vector3_t aD1U{}, aD1V{};
    check(::occtl_topo_face_eval_d1(myPtr, theFace.get(), theU, theV, &aP, &aD1U, &aD1V));
    return {Point3{aP}, Vector3{aD1U}, Vector3{aD1V}};
  }
 
  std::tuple<Point3, Vector3, Vector3, Vector3, Vector3, Vector3> face_eval_d2(
    const NodeId theFace,
    const double theU,
    const double theV) const
  {
    ::occtl_point3_t  aP{};
    ::occtl_vector3_t aD1U{}, aD1V{}, aD2U{}, aD2V{}, aD2UV{};
    check(::occtl_topo_face_eval_d2(myPtr,
                                    theFace.get(),
                                    theU,
                                    theV,
                                    &aP,
                                    &aD1U,
                                    &aD1V,
                                    &aD2U,
                                    &aD2V,
                                    &aD2UV));
    return {Point3{aP}, Vector3{aD1U}, Vector3{aD1V}, Vector3{aD2U}, Vector3{aD2V}, Vector3{aD2UV}};
  }
 
  std::
    tuple<Point3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3>
    face_eval_d3(const NodeId theFace, const double theU, const double theV) const
  {
    ::occtl_point3_t  aP{};
    ::occtl_vector3_t aD1U{}, aD1V{}, aD2U{}, aD2V{}, aD2UV{};
    ::occtl_vector3_t aD3U{}, aD3V{}, aD3UUV{}, aD3UVV{};
    check(::occtl_topo_face_eval_d3(myPtr,
                                    theFace.get(),
                                    theU,
                                    theV,
                                    &aP,
                                    &aD1U,
                                    &aD1V,
                                    &aD2U,
                                    &aD2V,
                                    &aD2UV,
                                    &aD3U,
                                    &aD3V,
                                    &aD3UUV,
                                    &aD3UVV));
    return {Point3{aP},
            Vector3{aD1U},
            Vector3{aD1V},
            Vector3{aD2U},
            Vector3{aD2V},
            Vector3{aD2UV},
            Vector3{aD3U},
            Vector3{aD3V},
            Vector3{aD3UUV},
            Vector3{aD3UVV}};
  }
 
  Vector3 face_eval_dn(const NodeId   theFace,
                       const double   theU,
                       const double   theV,
                       const uint32_t theNu,
                       const uint32_t theNv) const
  {
    ::occtl_vector3_t aDN{};
    check(::occtl_topo_face_eval_dn(myPtr, theFace.get(), theU, theV, theNu, theNv, &aDN));
    return Vector3{aDN};
  }
 
  uint32_t face_wire_count(const NodeId theFace) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_face_wire_count(myPtr, theFace.get(), &aCount));
    return aCount;
  }
 
  uint32_t wire_coedge_count(const NodeId theWire) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_wire_coedge_count(myPtr, theWire.get(), &aCount));
    return aCount;
  }
 
  uint32_t edge_face_count(const NodeId theEdge) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_edge_face_count(myPtr, theEdge.get(), &aCount));
    return aCount;
  }
 
  uint32_t wire_distinct_edge_count(const NodeId theWire) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_wire_distinct_edge_count(myPtr, theWire.get(), &aCount));
    return aCount;
  }
 
  uint32_t vertex_edge_count(const NodeId theVertex) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_vertex_edge_count(myPtr, theVertex.get(), &aCount));
    return aCount;
  }
 
  uint32_t solid_shell_count(const NodeId theSolid) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_solid_shell_count(myPtr, theSolid.get(), &aCount));
    return aCount;
  }
 
  uint32_t shell_face_count(const NodeId theShell) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_shell_face_count(myPtr, theShell.get(), &aCount));
    return aCount;
  }
 
  uint32_t wire_edge_count(const NodeId theWire) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_wire_edge_count(myPtr, theWire.get(), &aCount));
    return aCount;
  }
 
  uint32_t edge_vertex_count(const NodeId theEdge) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_edge_vertex_count(myPtr, theEdge.get(), &aCount));
    return aCount;
  }
 
  uint32_t product_occurrence_count(const NodeId theProduct) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_product_occurrence_count(myPtr, theProduct.get(), &aCount));
    return aCount;
  }
 
  uint32_t compound_child_count(const NodeId theCompound) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_compound_child_count(myPtr, theCompound.get(), &aCount));
    return aCount;
  }
 
  uint32_t compsolid_solid_count(const NodeId theCompSolid) const
  {
    uint32_t aCount = 0;
    check(::occtl_topo_compsolid_solid_count(myPtr, theCompSolid.get(), &aCount));
    return aCount;
  }
 
  NodeIter wire_explorer(const NodeId theWire) const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_topo_wire_explorer_create(myPtr, theWire.get(), &anIt));
    return NodeIter(anIt);
  }
 
  std::vector<OrientedNode> wire_order_edges(const NodeId theWire) const
  {
    size_t aCount = 0;
    check(::occtl_topo_wire_order_edges(myPtr, theWire.get(), nullptr, 0, &aCount));
 
    std::vector<OrientedNode> aResult(aCount);
    if (aCount > 0)
    {
      check(::occtl_topo_wire_order_edges(myPtr,
                                          theWire.get(),
                                          aResult.data(),
                                          aResult.size(),
                                          &aCount));
      aResult.resize(aCount);
    }
    return aResult;
  }
 
  ExplorerIter child_explorer(
    const NodeId                                      theRoot,
    const ::occtl_topo_child_explorer_config_t* const theConfig = nullptr) const
  {
    ::occtl_topo_explorer_iter_t* anIt = nullptr;
    check(::occtl_topo_child_explorer_create(myPtr, theRoot.get(), theConfig, &anIt));
    return ExplorerIter(anIt);
  }
 
  ExplorerIter parent_explorer(
    const NodeId                                       theNode,
    const ::occtl_topo_parent_explorer_config_t* const theConfig = nullptr) const
  {
    ::occtl_topo_explorer_iter_t* anIt = nullptr;
    check(::occtl_topo_parent_explorer_create(myPtr, theNode.get(), theConfig, &anIt));
    return ExplorerIter(anIt);
  }
 
  RelatedIter related(const NodeId theNode) const
  {
    ::occtl_topo_related_iter_t* anIt = nullptr;
    check(::occtl_topo_related_iter_create(myPtr, theNode.get(), &anIt));
    return RelatedIter(anIt);
  }
 
  DistancePair distance_pair(const NodeId theNodeA, const NodeId theNodeB) const
  {
    DistancePair aPair{};
    check(::occtl_topo_distance_pair(myPtr, theNodeA.get(), theNodeB.get(), &aPair));
    return aPair;
  }
 
  TouchIter touches(const NodeId                 theNodeA,
                    const NodeId                 theNodeB,
                    const RelationOptions* const theOptions = nullptr) const
  {
    ::occtl_topo_touch_iter_t* anIt = nullptr;
    check(::occtl_topo_touch_iter_create(myPtr, theNodeA.get(), theNodeB.get(), theOptions, &anIt));
    return TouchIter(anIt);
  }
 
  IntersectionIter intersections(const NodeId                 theNodeA,
                                 const NodeId                 theNodeB,
                                 const RelationOptions* const theOptions = nullptr)
  {
    ::occtl_topo_intersection_iter_t* anIt = nullptr;
    check(::occtl_topo_intersection_iter_create(myPtr,
                                                theNodeA.get(),
                                                theNodeB.get(),
                                                theOptions,
                                                &anIt));
    return IntersectionIter(anIt);
  }
 
  AxisHitIter faces_intersected_by_axis(const NodeId          theRoot,
                                        const Axis1Placement& theAxis,
                                        const double          theMinParameter,
                                        const double          theMaxParameter,
                                        const double          theTolerance) const
  {
    ::occtl_topo_axis_hit_iter_t* anIt = nullptr;
    check(::occtl_topo_axis_intersect_faces(myPtr,
                                            theRoot.get(),
                                            theAxis.c_type(),
                                            theMinParameter,
                                            theMaxParameter,
                                            theTolerance,
                                            &anIt));
    return AxisHitIter(anIt);
  }
 
  bool is_same_geometry(const NodeId theNodeA,
                        const NodeId theNodeB,
                        const double theTolerance) const
  {
    int32_t aFlag = 0;
    check(
      ::occtl_topo_is_same_geometry(myPtr, theNodeA.get(), theNodeB.get(), theTolerance, &aFlag));
    return aFlag != 0;
  }
 
  std::vector<NodeId> common_vertices(const NodeId theNodeA, const NodeId theNodeB) const
  {
    size_t aCount = 0;
    check(::occtl_topo_common_vertices(myPtr, theNodeA.get(), theNodeB.get(), nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (aCount > 0)
    {
      check(::occtl_topo_common_vertices(myPtr,
                                         theNodeA.get(),
                                         theNodeB.get(),
                                         aRaw.data(),
                                         aRaw.size(),
                                         &aCount));
    }
 
    std::vector<NodeId> aResult;
    aResult.reserve(aCount);
    for (size_t anI = 0; anI < aCount; ++anI)
    {
      aResult.push_back(NodeId(aRaw[anI]));
    }
    return aResult;
  }
 
  std::vector<NodeId> adjacent_edges(const NodeId theEdge) const
  {
    size_t aCount = 0;
    check(::occtl_topo_adjacent_edges(myPtr, theEdge.get(), nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (aCount > 0)
    {
      check(::occtl_topo_adjacent_edges(myPtr, theEdge.get(), aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aResult;
    aResult.reserve(aCount);
    for (size_t anI = 0; anI < aCount; ++anI)
    {
      aResult.push_back(NodeId(aRaw[anI]));
    }
    return aResult;
  }
 
  std::vector<NodeId> adjacent_faces(const NodeId theFace) const
  {
    size_t aCount = 0;
    check(::occtl_topo_adjacent_faces(myPtr, theFace.get(), nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (aCount > 0)
    {
      check(::occtl_topo_adjacent_faces(myPtr, theFace.get(), aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aResult;
    aResult.reserve(aCount);
    for (size_t anI = 0; anI < aCount; ++anI)
    {
      aResult.push_back(NodeId(aRaw[anI]));
    }
    return aResult;
  }
 
  std::vector<NodeId> connected_edges(const NodeId theSeedEdge) const
  {
    size_t aCount = 0;
    check(::occtl_topo_connected_edges(myPtr, theSeedEdge.get(), nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (aCount > 0)
    {
      check(
        ::occtl_topo_connected_edges(myPtr, theSeedEdge.get(), aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aResult;
    aResult.reserve(aCount);
    for (size_t anI = 0; anI < aCount; ++anI)
    {
      aResult.push_back(NodeId(aRaw[anI]));
    }
    return aResult;
  }
 
  std::vector<NodeId> connected_faces(const NodeId theSeedFace) const
  {
    size_t aCount = 0;
    check(::occtl_topo_connected_faces(myPtr, theSeedFace.get(), nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (aCount > 0)
    {
      check(
        ::occtl_topo_connected_faces(myPtr, theSeedFace.get(), aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aResult;
    aResult.reserve(aCount);
    for (size_t anI = 0; anI < aCount; ++anI)
    {
      aResult.push_back(NodeId(aRaw[anI]));
    }
    return aResult;
  }
 
  int32_t graph_distance(const NodeId               theRoot,
                         const std::vector<NodeId>& theSources,
                         const NodeId               theTarget) const
  {
    std::vector<::occtl_node_id_t> aRawSources;
    aRawSources.reserve(theSources.size());
    for (const NodeId& aSource : theSources)
    {
      aRawSources.push_back(aSource.get());
    }
 
    int32_t aDistance = -1;
    check(::occtl_topo_graph_distance(myPtr,
                                      theRoot.get(),
                                      aRawSources.data(),
                                      aRawSources.size(),
                                      theTarget.get(),
                                      &aDistance));
    return aDistance;
  }
 
  int32_t graph_distance(const NodeId theRoot, const NodeId theSource, const NodeId theTarget) const
  {
    const ::occtl_node_id_t aSource   = theSource.get();
    int32_t                 aDistance = -1;
    check(
      ::occtl_topo_graph_distance(myPtr, theRoot.get(), &aSource, 1, theTarget.get(), &aDistance));
    return aDistance;
  }
 
  PointClass classify_point(const NodeId  theSolid,
                            const Point3& thePoint,
                            const double  theTolerance) const
  {
    PointClass aClass = OCCTL_TOPO_POINT_CLASS_UNKNOWN;
    check(
      ::occtl_topo_classify_point(myPtr, theSolid.get(), thePoint.c_type(), theTolerance, &aClass));
    return aClass;
  }
 
  bool is_inside(const NodeId  theSolid,
                 const Point3& thePoint,
                 const double  theTolerance,
                 const bool    theIncludeBoundary = true) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_is_inside(myPtr,
                                 theSolid.get(),
                                 thePoint.c_type(),
                                 theTolerance,
                                 theIncludeBoundary ? 1 : 0,
                                 &aFlag));
    return aFlag != 0;
  }
 
  NodeIter solids() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_solid_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter shells() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_shell_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter faces() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_face_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter wires() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_wire_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter edges() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_edge_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter vertices() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_vertex_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter compounds() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_compound_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter compsolids() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_compsolid_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter coedges() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_coedge_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter products() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_product_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter occurrences() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_occurrence_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter root_products() const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_graph_root_product_iter_create(myPtr, &anIt));
    return NodeIter(anIt);
  } 
 
  SelectIter select(const SelectOptions& theOptions)
  {
    ::occtl_select_iter_t* anIt = nullptr;
    check(::occtl_select_iter_create(myPtr, &theOptions, &anIt));
    return SelectIter(anIt);
  }
 
  SelectIter select_tagged(const SelectOptions& theOptions,
                           const char* const    theTag,
                           const size_t         theTagLen)
  {
    ::occtl_select_iter_t* anIt = nullptr;
    check(::occtl_select_tagged_iter_create(myPtr, &theOptions, theTag, theTagLen, &anIt));
    return SelectIter(anIt);
  }
 
  SelectGroupIter select_groups(const SelectOptions&      theSelectOptions,
                                const SelectGroupOptions& theGroupOptions)
  {
    ::occtl_select_group_iter_t* anIt = nullptr;
    check(::occtl_select_group_iter_create(myPtr, &theSelectOptions, &theGroupOptions, &anIt));
    return SelectGroupIter(anIt);
  }
 
  NodeIter shells_of_solid(const NodeId theSolid) const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_topo_shells_of_solid_iter_create(myPtr, theSolid.get(), &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter faces_of_shell(const NodeId theShell) const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_topo_faces_of_shell_iter_create(myPtr, theShell.get(), &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter wires_of_face(const NodeId theFace) const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_topo_wires_of_face_iter_create(myPtr, theFace.get(), &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter coedges_of_wire(const NodeId theWire) const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_topo_coedges_of_wire_iter_create(myPtr, theWire.get(), &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter edges_of_wire(const NodeId theWire) const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_topo_edges_of_wire_iter_create(myPtr, theWire.get(), &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter vertices_of_edge(const NodeId theEdge) const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_topo_vertices_of_edge_iter_create(myPtr, theEdge.get(), &anIt));
    return NodeIter(anIt);
  } 
 
  NodeIter occurrences_of_product(const NodeId theProduct) const
  {
    ::occtl_node_iter_t* anIt = nullptr;
    check(::occtl_topo_occurrences_of_product_iter_create(myPtr, theProduct.get(), &anIt));
    return NodeIter(anIt);
  } 
 
  NodeId make_vertex(const ::occtl_topo_make_vertex_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_vertex(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  NodeId make_edge(const ::occtl_topo_make_edge_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_edge(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  NodeId make_wire(const ::occtl_topo_make_wire_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_wire(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  std::vector<NodeId> edges_to_wires(const EdgesToWiresOptions& theOptions)
  {
    size_t aCount = 0;
    check(::occtl_topo_edges_to_wires(myPtr, &theOptions, nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (aCount > 0)
    {
      check(::occtl_topo_edges_to_wires(myPtr, &theOptions, aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aResult;
    aResult.reserve(aCount);
    for (size_t anI = 0; anI < aCount; ++anI)
    {
      aResult.push_back(NodeId(aRaw[anI]));
    }
    return aResult;
  }
 
  NodeId wire_offset_2d(const WireOffset2dOptions& theOptions)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_wire_offset_2d(myPtr, &theOptions, &anId));
    return NodeId(anId);
  }
 
  size_t wire_fix_degenerate_edges(const WireFixDegenerateEdgesOptions& theOptions)
  {
    size_t aRemoved = 0;
    check(::occtl_topo_wire_fix_degenerate(myPtr, &theOptions, &aRemoved));
    return aRemoved;
  }
 
  NodeId face_chamfer_2d(const FaceChamfer2dOptions& theOptions)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_face_chamfer_2d(myPtr, &theOptions, &anId));
    return NodeId(anId);
  }
 
  NodeId wire_chamfer_2d(const WireChamfer2dOptions& theOptions)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_wire_chamfer_2d(myPtr, &theOptions, &anId));
    return NodeId(anId);
  }
 
  NodeId make_face(const ::occtl_topo_make_face_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_face(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  NodeId make_face_from_wires_auto(const MakeFaceFromWiresAutoOptions& theOptions)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_face_from_wires_auto(myPtr, &theOptions, &anId));
    return NodeId(anId);
  }
 
  NodeId make_shell(const ::occtl_topo_make_shell_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_shell(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  NodeId make_solid(const ::occtl_topo_make_solid_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_solid(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  void solid_view(const NodeId theSolid, ::occtl_solid_view_t& theView) const
  {
    ::occtl_solid_view_init(&theView);
    check(::occtl_topo_solid_view(myPtr, theSolid.get(), &theView));
  }
 
  void compound_view(const NodeId theCompound, ::occtl_compound_view_t& theView) const
  {
    ::occtl_compound_view_init(&theView);
    check(::occtl_topo_compound_view(myPtr, theCompound.get(), &theView));
  }
 
  void wire_view(const NodeId theWire, ::occtl_wire_view_t& theView) const
  {
    ::occtl_wire_view_init(&theView);
    check(::occtl_topo_wire_view(myPtr, theWire.get(), &theView));
  }
 
  void shell_view(const NodeId theShell, ::occtl_shell_view_t& theView) const
  {
    ::occtl_shell_view_init(&theView);
    check(::occtl_topo_shell_view(myPtr, theShell.get(), &theView));
  }
 
  void vertex_view(const NodeId theVertex, ::occtl_vertex_view_t& theView) const
  {
    ::occtl_vertex_view_init(&theView);
    check(::occtl_topo_vertex_view(myPtr, theVertex.get(), &theView));
  }
 
  NodeId make_compsolid(const ::occtl_topo_make_compsolid_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_compsolid(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  NodeId make_compound(const ::occtl_topo_make_compound_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_compound(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  void remove(const NodeId theId) { check(::occtl_topo_remove(myPtr, theId.get())); }
 
  void remove_subgraph(const NodeId theId)
  {
    check(::occtl_topo_remove_subgraph(myPtr, theId.get()));
  }
 
  Batch begin_batch()
  {
    ::occtl_batch_t* aBatch = nullptr;
    check(::occtl_graph_begin_batch(myPtr, &aBatch));
    return Batch(aBatch, myPtr);
  }
 
  void set_vertex_point(const NodeId theVertex, const ::occtl_point3_t& thePoint)
  {
    check(::occtl_topo_set_vertex_point(myPtr, theVertex.get(), thePoint));
  }
 
  void set_vertex_tolerance(const NodeId theVertex, const double theTol)
  {
    check(::occtl_topo_set_vertex_tolerance(myPtr, theVertex.get(), theTol));
  }
 
  void set_edge_tolerance(const NodeId theEdge, const double theTol)
  {
    check(::occtl_topo_set_edge_tolerance(myPtr, theEdge.get(), theTol));
  }
 
  void set_face_tolerance(const NodeId theFace, const double theTol)
  {
    check(::occtl_topo_set_face_tolerance(myPtr, theFace.get(), theTol));
  }
 
  void set_edge_param_range(const NodeId theEdge, const double theFirst, const double theLast)
  {
    check(::occtl_topo_set_edge_param_range(myPtr, theEdge.get(), theFirst, theLast));
  }
 
  void set_edge_same_parameter(const NodeId theEdge, const bool theFlag)
  {
    check(::occtl_topo_set_edge_same_parameter(myPtr, theEdge.get(), theFlag ? 1 : 0));
  }
 
  void set_edge_same_range(const NodeId theEdge, const bool theFlag)
  {
    check(::occtl_topo_set_edge_same_range(myPtr, theEdge.get(), theFlag ? 1 : 0));
  }
 
  void set_edge_is_degenerate(const NodeId theEdge, const bool theFlag)
  {
    check(::occtl_topo_set_edge_is_degenerate(myPtr, theEdge.get(), theFlag ? 1 : 0));
  }
 
  void set_edge_is_closed(const NodeId theEdge, const bool theFlag)
  {
    check(::occtl_topo_set_edge_is_closed(myPtr, theEdge.get(), theFlag ? 1 : 0));
  }
 
  void set_wire_is_closed(const NodeId theWire, const bool theFlag)
  {
    check(::occtl_topo_set_wire_is_closed(myPtr, theWire.get(), theFlag ? 1 : 0));
  }
 
  void set_shell_is_closed(const NodeId theShell, const bool theFlag)
  {
    check(::occtl_topo_set_shell_is_closed(myPtr, theShell.get(), theFlag ? 1 : 0));
  }
 
  void set_face_natural_restriction(const NodeId theFace, const bool theFlag)
  {
    check(::occtl_topo_set_face_natural_restriction(myPtr, theFace.get(), theFlag ? 1 : 0));
  }
 
  void set_coedge_param_range(const NodeId theCoedge, const double theFirst, const double theLast)
  {
    check(::occtl_topo_set_coedge_param_range(myPtr, theCoedge.get(), theFirst, theLast));
  }
 
  void set_coedge_uv_box(const NodeId            theCoedge,
                         const ::occtl_point2_t& theUvLo,
                         const ::occtl_point2_t& theUvHi)
  {
    check(::occtl_topo_set_coedge_uv_box(myPtr, theCoedge.get(), theUvLo, theUvHi));
  }
 
  Graph clone() const
  {
    ::occtl_graph_t* aClone = nullptr;
    check(::occtl_graph_clone(myPtr, &aClone));
    return Graph(aClone);
  }
 
  void compact() { check(::occtl_graph_compact(myPtr)); }
 
  void remove_with_replacement(const NodeId theNode, const NodeId theReplacement)
  {
    check(::occtl_topo_remove_with_replacement(myPtr, theNode.get(), theReplacement.get()));
  }
 
  void remove_ref(const RefId& theRefId) { check(::occtl_topo_remove_ref(myPtr, theRefId.get())); }
 
  void remove_rep(const RepId& theRepId) { check(::occtl_topo_remove_rep(myPtr, theRepId.get())); }
 
  void cleanup_removed_refs() { check(::occtl_topo_cleanup_removed_refs(myPtr)); }
 
  void set_edge_start_vertex(const NodeId theEdge, const NodeId theVertex)
  {
    check(::occtl_topo_set_edge_start_vertex(myPtr, theEdge.get(), theVertex.get()));
  }
 
  void set_edge_end_vertex(const NodeId theEdge, const NodeId theVertex)
  {
    check(::occtl_topo_set_edge_end_vertex(myPtr, theEdge.get(), theVertex.get()));
  }
 
  void set_ref_orientation(const RefId& theRefId, const Orientation theOrientation)
  {
    check(::occtl_topo_set_ref_orientation(myPtr, theRefId.get(), theOrientation));
  }
 
  void set_ref_location(const RefId& theRefId, const ::occtl_transform_t& theTransform)
  {
    check(::occtl_topo_set_ref_location(myPtr, theRefId.get(), theTransform));
  }
 
  void set_wire_ref_is_outer(const RefId& theRefId, const bool theFlag)
  {
    check(::occtl_topo_set_wire_ref_is_outer(myPtr, theRefId.get(), theFlag ? 1 : 0));
  }
 
  void color_set(const NodeId theTarget, const ::occtl_color_rgba_t& theColor)
  {
    check(::occtl_graph_color_set(myPtr, theTarget.get(), theColor));
  }
 
  ::occtl_color_rgba_t color_get(const NodeId theTarget) const
  {
    ::occtl_color_rgba_t aColor{};
    check(::occtl_graph_color_get(myPtr, theTarget.get(), &aColor));
    return aColor;
  }
 
  void color_unset(const NodeId theTarget)
  {
    check(::occtl_graph_color_unset(myPtr, theTarget.get()));
  }
 
  std::vector<std::pair<NodeId, ::occtl_color_rgba_t>> color_entries() const
  {
    size_t aCount = 0;
    check(::occtl_graph_color_entries(myPtr, nullptr, nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t>    aNodes(aCount);
    std::vector<::occtl_color_rgba_t> aColors(aCount);
    if (aCount != 0)
    {
      check(::occtl_graph_color_entries(myPtr, aNodes.data(), aColors.data(), aCount, &aCount));
    }
 
    std::vector<std::pair<NodeId, ::occtl_color_rgba_t>> aEntries;
    aEntries.reserve(aCount);
    for (size_t anIndex = 0; anIndex < aCount; ++anIndex)
    {
      aEntries.emplace_back(NodeId(aNodes[anIndex]), aColors[anIndex]);
    }
    return aEntries;
  }
 
  void name_set(const NodeId theTarget, const char* const theName, const size_t theNameLen)
  {
    check(::occtl_graph_name_set(myPtr, theTarget.get(), theName, theNameLen));
  }
 
  std::string name_get(const NodeId theTarget) const
  {
    size_t aRequired = 0;
    check(::occtl_graph_name_get(myPtr, theTarget.get(), nullptr, 0, &aRequired));
    if (aRequired <= 1)
    {
      return {};
    }
    std::string aResult(aRequired - 1, '\0');
    check(::occtl_graph_name_get(myPtr,
                                 theTarget.get(),
                                 aResult.data(),
                                 aResult.size() + 1,
                                 &aRequired));
    return aResult;
  }
 
  std::vector<NodeId> name_nodes() const
  {
    size_t aCount = 0;
    check(::occtl_graph_name_nodes(myPtr, nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (!aRaw.empty())
    {
      check(::occtl_graph_name_nodes(myPtr, aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aNodes;
    aNodes.reserve(aCount);
    for (size_t anIndex = 0; anIndex < aCount; ++anIndex)
    {
      aNodes.emplace_back(aRaw[anIndex]);
    }
    return aNodes;
  }
 
  void material_set(const NodeId theTarget, const MaterialInfo& theInfo)
  {
    check(::occtl_graph_material_set(myPtr, theTarget.get(), &theInfo));
  }
 
  GraphMaterial material_get(const NodeId theTarget) const
  {
    MaterialInfo anInfo    = OCCTL_MATERIAL_INFO_INIT;
    size_t       aRequired = 0;
    check(::occtl_graph_material_get(myPtr, theTarget.get(), &anInfo, nullptr, 0, &aRequired));
 
    GraphMaterial aMaterial;
    if (aRequired > 1)
    {
      aMaterial.name.assign(aRequired - 1, '\0');
      check(::occtl_graph_material_get(myPtr,
                                       theTarget.get(),
                                       &anInfo,
                                       aMaterial.name.data(),
                                       aMaterial.name.size() + 1,
                                       &aRequired));
    }
    else
    {
      char aName[1] = {};
      check(::occtl_graph_material_get(myPtr,
                                       theTarget.get(),
                                       &anInfo,
                                       aName,
                                       sizeof(aName),
                                       &aRequired));
      aMaterial.name.clear();
    }
 
    aMaterial.has_density       = anInfo.has_density;
    aMaterial.density           = anInfo.density;
    aMaterial.has_diffuse_color = anInfo.has_diffuse_color;
    aMaterial.diffuse_color     = anInfo.diffuse_color;
    aMaterial.metadata_uid      = anInfo.metadata_uid;
    return aMaterial;
  }
 
  void material_unset(const NodeId theTarget)
  {
    check(::occtl_graph_material_unset(myPtr, theTarget.get()));
  }
 
  std::vector<NodeId> material_nodes() const
  {
    size_t aCount = 0;
    check(::occtl_graph_material_nodes(myPtr, nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (!aRaw.empty())
    {
      check(::occtl_graph_material_nodes(myPtr, aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aNodes;
    aNodes.reserve(aCount);
    for (size_t anIndex = 0; anIndex < aCount; ++anIndex)
    {
      aNodes.emplace_back(aRaw[anIndex]);
    }
    return aNodes;
  }
 
  void graph_units_set(const double      theLengthUnitToMeter,
                       const char* const theName,
                       const size_t      theNameLen)
  {
    check(::occtl_graph_units_set(myPtr, theLengthUnitToMeter, theName, theNameLen));
  }
 
  GraphUnits graph_units_get() const
  {
    GraphUnits aUnits;
    size_t     aRequired = 0;
    check(::occtl_graph_units_get(myPtr, &aUnits.length_unit_to_meter, nullptr, 0, &aRequired));
    if (aRequired <= 1)
    {
      aUnits.name.clear();
      return aUnits;
    }
    aUnits.name.assign(aRequired - 1, '\0');
    check(::occtl_graph_units_get(myPtr,
                                  &aUnits.length_unit_to_meter,
                                  aUnits.name.data(),
                                  aUnits.name.size() + 1,
                                  &aRequired));
    return aUnits;
  }
 
  void node_metadata_set(const NodeId      theTarget,
                         const char* const theKey,
                         const size_t      theKeyLen,
                         const char* const theValue,
                         const size_t      theValueLen)
  {
    check(::occtl_graph_node_metadata_set(myPtr,
                                          theTarget.get(),
                                          theKey,
                                          theKeyLen,
                                          theValue,
                                          theValueLen));
  }
 
  std::string node_metadata_get(const NodeId      theTarget,
                                const char* const theKey,
                                const size_t      theKeyLen) const
  {
    size_t aRequired = 0;
    check(::occtl_graph_node_metadata_get(myPtr,
                                          theTarget.get(),
                                          theKey,
                                          theKeyLen,
                                          nullptr,
                                          0,
                                          &aRequired));
    if (aRequired <= 1)
    {
      return {};
    }
    std::string aResult(aRequired - 1, '\0');
    check(::occtl_graph_node_metadata_get(myPtr,
                                          theTarget.get(),
                                          theKey,
                                          theKeyLen,
                                          aResult.data(),
                                          aResult.size() + 1,
                                          &aRequired));
    return aResult;
  }
 
  std::vector<std::string> node_metadata_keys(const NodeId theTarget) const
  {
    size_t aCount = 0;
    check(::occtl_graph_node_metadata_keys(myPtr, theTarget.get(), nullptr, 0, &aCount));
 
    std::vector<::occtl_metadata_key_view_t> aViews(aCount);
    if (!aViews.empty())
    {
      check(::occtl_graph_node_metadata_keys(myPtr,
                                             theTarget.get(),
                                             aViews.data(),
                                             aViews.size(),
                                             &aCount));
    }
 
    std::vector<std::string> aKeys;
    aKeys.reserve(aCount);
    for (const ::occtl_metadata_key_view_t& aView : aViews)
    {
      aKeys.emplace_back(aView.key, aView.key_len);
    }
    return aKeys;
  }
 
  std::vector<NodeId> node_metadata_nodes() const
  {
    size_t aCount = 0;
    check(::occtl_graph_node_metadata_nodes(myPtr, nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (!aRaw.empty())
    {
      check(::occtl_graph_node_metadata_nodes(myPtr, aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aNodes;
    aNodes.reserve(aCount);
    for (size_t anIndex = 0; anIndex < aCount; ++anIndex)
    {
      aNodes.emplace_back(aRaw[anIndex]);
    }
    return aNodes;
  }
 
  void graph_metadata_set(const char* const theKey,
                          const size_t      theKeyLen,
                          const char* const theValue,
                          const size_t      theValueLen)
  {
    check(::occtl_graph_metadata_set(myPtr, theKey, theKeyLen, theValue, theValueLen));
  }
 
  std::string graph_metadata_get(const char* const theKey, const size_t theKeyLen) const
  {
    size_t aRequired = 0;
    check(::occtl_graph_metadata_get(myPtr, theKey, theKeyLen, nullptr, 0, &aRequired));
    if (aRequired <= 1)
    {
      return {};
    }
    std::string aResult(aRequired - 1, '\0');
    check(::occtl_graph_metadata_get(myPtr,
                                     theKey,
                                     theKeyLen,
                                     aResult.data(),
                                     aResult.size() + 1,
                                     &aRequired));
    return aResult;
  }
 
  std::vector<std::string> graph_metadata_keys() const
  {
    size_t aCount = 0;
    check(::occtl_graph_metadata_keys(myPtr, nullptr, 0, &aCount));
 
    std::vector<::occtl_metadata_key_view_t> aViews(aCount);
    if (!aViews.empty())
    {
      check(::occtl_graph_metadata_keys(myPtr, aViews.data(), aViews.size(), &aCount));
    }
 
    std::vector<std::string> aKeys;
    aKeys.reserve(aCount);
    for (const ::occtl_metadata_key_view_t& aView : aViews)
    {
      aKeys.emplace_back(aView.key, aView.key_len);
    }
    return aKeys;
  }
 
  void graph_metadata_unset(const char* const theKey, const size_t theKeyLen)
  {
    check(::occtl_graph_metadata_unset(myPtr, theKey, theKeyLen));
  }
 
  void node_metadata_unset(const NodeId theTarget, const char* const theKey, const size_t theKeyLen)
  {
    check(::occtl_graph_node_metadata_unset(myPtr, theTarget.get(), theKey, theKeyLen));
  }
 
  void tag_add(const NodeId theTarget, const char* const theTag, const size_t theTagLen)
  {
    check(::occtl_graph_tag_add(myPtr, theTarget.get(), theTag, theTagLen));
  }
 
  void tag_remove(const NodeId theTarget, const char* const theTag, const size_t theTagLen)
  {
    check(::occtl_graph_tag_remove(myPtr, theTarget.get(), theTag, theTagLen));
  }
 
  bool tag_has(const NodeId theTarget, const char* const theTag, const size_t theTagLen) const
  {
    int32_t hasTag = 0;
    check(::occtl_graph_tag_has(myPtr, theTarget.get(), theTag, theTagLen, &hasTag));
    return hasTag != 0;
  }
 
  std::vector<std::string> tag_list(const NodeId theTarget) const
  {
    size_t aCount = 0;
    check(::occtl_graph_tag_list(myPtr, theTarget.get(), nullptr, 0, &aCount));
 
    std::vector<::occtl_tag_view_t> aViews(aCount);
    if (!aViews.empty())
    {
      check(::occtl_graph_tag_list(myPtr, theTarget.get(), aViews.data(), aViews.size(), &aCount));
    }
 
    std::vector<std::string> aTags;
    aTags.reserve(aCount);
    for (const ::occtl_tag_view_t& aView : aViews)
    {
      aTags.emplace_back(aView.tag, aView.tag_len);
    }
    return aTags;
  }
 
  std::vector<NodeId> tag_nodes(const char* const theTag    = nullptr,
                                const size_t      theTagLen = 0) const
  {
    size_t aCount = 0;
    check(::occtl_graph_tag_nodes(myPtr, theTag, theTagLen, nullptr, 0, &aCount));
 
    std::vector<::occtl_node_id_t> aRaw(aCount);
    if (!aRaw.empty())
    {
      check(::occtl_graph_tag_nodes(myPtr, theTag, theTagLen, aRaw.data(), aRaw.size(), &aCount));
    }
 
    std::vector<NodeId> aNodes;
    aNodes.reserve(aCount);
    for (size_t anIndex = 0; anIndex < aCount; ++anIndex)
    {
      aNodes.emplace_back(aRaw[anIndex]);
    }
    return aNodes;
  }
 
  JointId joint_create(const JointInfo& theInfo)
  {
    ::occtl_joint_id_t aJoint = OCCTL_JOINT_ID_INVALID;
    check(::occtl_joint_create(myPtr, &theInfo, &aJoint));
    return JointId(aJoint);
  }
 
  JointInfo joint_get(const JointId theJoint) const
  {
    JointInfo anInfo = OCCTL_JOINT_INFO_INIT;
    check(::occtl_joint_get(myPtr, theJoint.get(), &anInfo));
    return anInfo;
  }
 
  void joint_remove(const JointId theJoint) { check(::occtl_joint_remove(myPtr, theJoint.get())); }
 
  std::vector<JointId> joint_list(const NodeId theNode = NodeId::invalid()) const
  {
    size_t aCount = 0;
    check(::occtl_joint_list(myPtr, theNode.get(), nullptr, 0, &aCount));
    std::vector<::occtl_joint_id_t> aIds(aCount);
    if (aCount != 0)
    {
      check(::occtl_joint_list(myPtr, theNode.get(), aIds.data(), aIds.size(), &aCount));
    }
    std::vector<JointId> aResult;
    aResult.reserve(aIds.size());
    for (const ::occtl_joint_id_t& anId : aIds)
    {
      aResult.emplace_back(anId);
    }
    return aResult;
  }
 
  void clear_cached(const NodeId theNode)
  {
    check(::occtl_graph_clear_cached(myPtr, theNode.get(), OCCTL_REF_ID_INVALID));
  }
 
  void clear_cached(const RefId theRef)
  {
    check(::occtl_graph_clear_cached(myPtr, OCCTL_NODE_ID_INVALID, theRef.get()));
  }
 
  ::occtl_select_bbox_t bbox_get(const NodeId theNode)
  {
    ::occtl_select_bbox_t aBox{};
    check(::occtl_graph_bbox_get(myPtr, theNode.get(), &aBox));
    return aBox;
  }
 
  ::occtl_graph_obb_t obb_get(const NodeId theNode)
  {
    ::occtl_graph_obb_t aBox{};
    check(::occtl_graph_obb_get(myPtr, theNode.get(), &aBox));
    return aBox;
  }
 
  ::occtl_graph_uv_bounds_t face_uv_bounds_get(const NodeId theFace)
  {
    ::occtl_graph_uv_bounds_t aBounds{};
    check(::occtl_graph_face_uv_bounds_get(myPtr, theFace.get(), &aBounds));
    return aBounds;
  }
 
  double measure_get(const NodeId theNode, const SelectMeasureKind theKind)
  {
    double aValue = 0.0;
    check(::occtl_graph_measure_get(myPtr, theNode.get(), theKind, &aValue));
    return aValue;
  }
 
  ::occtl_graph_mass_properties_t mass_properties_get(const NodeId theNode)
  {
    ::occtl_graph_mass_properties_t aProperties{};
    check(::occtl_graph_mass_properties_get(myPtr, theNode.get(), &aProperties));
    return aProperties;
  }
 
  CurveKind edge_curve_kind_get(const NodeId theEdge)
  {
    CurveKind aKind = OCCTL_CURVE_KIND_UNDEFINED;
    check(::occtl_graph_edge_curve_kind_get(myPtr, theEdge.get(), &aKind));
    return aKind;
  }
 
  SurfaceKind face_surface_kind_get(const NodeId theFace)
  {
    SurfaceKind aKind = OCCTL_SURFACE_KIND_UNDEFINED;
    check(::occtl_graph_face_surface_kind_get(myPtr, theFace.get(), &aKind));
    return aKind;
  }
 
  std::vector<NodeId> descendant_vertices_get(const NodeId theNode)
  {
    size_t aCount = 0;
    check(::occtl_graph_descendant_vertices_get(myPtr, theNode.get(), nullptr, 0, &aCount));
    std::vector<::occtl_node_id_t> aIds(aCount);
    if (aCount != 0)
    {
      check(::occtl_graph_descendant_vertices_get(myPtr,
                                                  theNode.get(),
                                                  aIds.data(),
                                                  aIds.size(),
                                                  &aCount));
    }
    std::vector<NodeId> aResult;
    aResult.reserve(aIds.size());
    for (const ::occtl_node_id_t& anId : aIds)
    {
      aResult.emplace_back(anId);
    }
    return aResult;
  }
 
  std::vector<NodeId> descendant_edges_get(const NodeId theNode)
  {
    size_t aCount = 0;
    check(::occtl_graph_descendant_edges_get(myPtr, theNode.get(), nullptr, 0, &aCount));
    std::vector<::occtl_node_id_t> aIds(aCount);
    if (aCount != 0)
    {
      check(::occtl_graph_descendant_edges_get(myPtr,
                                               theNode.get(),
                                               aIds.data(),
                                               aIds.size(),
                                               &aCount));
    }
    std::vector<NodeId> aResult;
    aResult.reserve(aIds.size());
    for (const ::occtl_node_id_t& anId : aIds)
    {
      aResult.emplace_back(anId);
    }
    return aResult;
  }
 
  std::vector<NodeId> descendant_faces_get(const NodeId theNode)
  {
    size_t aCount = 0;
    check(::occtl_graph_descendant_faces_get(myPtr, theNode.get(), nullptr, 0, &aCount));
    std::vector<::occtl_node_id_t> aIds(aCount);
    if (aCount != 0)
    {
      check(::occtl_graph_descendant_faces_get(myPtr,
                                               theNode.get(),
                                               aIds.data(),
                                               aIds.size(),
                                               &aCount));
    }
    std::vector<NodeId> aResult;
    aResult.reserve(aIds.size());
    for (const ::occtl_node_id_t& anId : aIds)
    {
      aResult.emplace_back(anId);
    }
    return aResult;
  }
 
  std::vector<NodeId> descendants_get(const NodeId theNode, const NodeKind theKind)
  {
    size_t aCount = 0;
    check(::occtl_graph_descendants_get(myPtr, theNode.get(), theKind, nullptr, 0, &aCount));
    std::vector<::occtl_node_id_t> aIds(aCount);
    if (aCount != 0)
    {
      check(::occtl_graph_descendants_get(myPtr,
                                          theNode.get(),
                                          theKind,
                                          aIds.data(),
                                          aIds.size(),
                                          &aCount));
    }
    std::vector<NodeId> aResult;
    aResult.reserve(aIds.size());
    for (const ::occtl_node_id_t& anId : aIds)
    {
      aResult.emplace_back(anId);
    }
    return aResult;
  }
 
  std::vector<NodeId> adjacent_faces_get(const NodeId theFace)
  {
    size_t aCount = 0;
    check(::occtl_graph_adjacent_faces_get(myPtr, theFace.get(), nullptr, 0, &aCount));
    std::vector<::occtl_node_id_t> aIds(aCount);
    if (aCount != 0)
    {
      check(
        ::occtl_graph_adjacent_faces_get(myPtr, theFace.get(), aIds.data(), aIds.size(), &aCount));
    }
    std::vector<NodeId> aResult;
    aResult.reserve(aIds.size());
    for (const ::occtl_node_id_t& anId : aIds)
    {
      aResult.emplace_back(anId);
    }
    return aResult;
  }
 
  std::vector<NodeId> adjacent_edges_get(const NodeId theEdge)
  {
    size_t aCount = 0;
    check(::occtl_graph_adjacent_edges_get(myPtr, theEdge.get(), nullptr, 0, &aCount));
    std::vector<::occtl_node_id_t> aIds(aCount);
    if (aCount != 0)
    {
      check(
        ::occtl_graph_adjacent_edges_get(myPtr, theEdge.get(), aIds.data(), aIds.size(), &aCount));
    }
    std::vector<NodeId> aResult;
    aResult.reserve(aIds.size());
    for (const ::occtl_node_id_t& anId : aIds)
    {
      aResult.emplace_back(anId);
    }
    return aResult;
  }
 
  double pair_distance_get(const NodeId theFirst, const NodeId theSecond)
  {
    double aDistance = 0.0;
    check(::occtl_graph_pair_distance_get(myPtr, theFirst.get(), theSecond.get(), &aDistance));
    return aDistance;
  }
 
  NodeId make_product(const ::occtl_topo_make_product_info_t& theInfo)
  {
    ::occtl_node_id_t anId;
    check(::occtl_topo_make_product(myPtr, &theInfo, &anId));
    return NodeId(anId);
  }
 
  void link_product_to_topology(const NodeId               theProduct,
                                const NodeId               theRoot,
                                const ::occtl_transform_t& thePlacement)
  {
    check(::occtl_topo_link_product(myPtr, theProduct.get(), theRoot.get(), thePlacement));
  }
 
  NodeId link_product_to_topology_with_occurrence(const NodeId               theProduct,
                                                  const NodeId               theRoot,
                                                  const ::occtl_transform_t& thePlacement)
  {
    ::occtl_node_id_t anOccurrence{};
    check(::occtl_topo_link_product_occurrence(myPtr,
                                               theProduct.get(),
                                               theRoot.get(),
                                               thePlacement,
                                               &anOccurrence));
    return NodeId(anOccurrence);
  }
 
  void link_products(const NodeId               theParentProduct,
                     const NodeId               theChildProduct,
                     const ::occtl_transform_t& thePlacement,
                     const NodeId               theParentOccurrence = NodeId(OCCTL_NODE_ID_INVALID))
  {
    check(::occtl_topo_link_products(myPtr,
                                     theParentProduct.get(),
                                     theChildProduct.get(),
                                     thePlacement,
                                     theParentOccurrence.get()));
  }
 
  NodeId link_products_with_occurrence(
    const NodeId               theParentProduct,
    const NodeId               theChildProduct,
    const ::occtl_transform_t& thePlacement,
    const NodeId               theParentOccurrence = NodeId(OCCTL_NODE_ID_INVALID))
  {
    ::occtl_node_id_t anOccurrence{};
    check(::occtl_topo_link_products_occurrence(myPtr,
                                                theParentProduct.get(),
                                                theChildProduct.get(),
                                                thePlacement,
                                                theParentOccurrence.get(),
                                                &anOccurrence));
    return NodeId(anOccurrence);
  }
 
  void remove_occurrence(const RefId& theOccurrenceRef)
  {
    check(::occtl_topo_remove_occurrence(myPtr, theOccurrenceRef.get()));
  }
 
  void occurrence_transform_set(const NodeId theOccurrence, const ::occtl_transform_t& theTransform)
  {
    check(::occtl_topo_occurrence_set_transform(myPtr, theOccurrence.get(), theTransform));
  }
 
  ::occtl_transform_t occurrence_transform_get(const NodeId theOccurrence) const
  {
    ::occtl_transform_t aTransform;
    check(::occtl_topo_occurrence_transform(myPtr, theOccurrence.get(), &aTransform));
    return aTransform;
  }
 
  ::occtl_transform_t occurrence_world_transform(const NodeId theRoot,
                                                 const NodeId theOccurrence) const
  {
    ::occtl_transform_t aTransform;
    check(::occtl_topo_occurrence_world_transform(myPtr,
                                                  theRoot.get(),
                                                  theOccurrence.get(),
                                                  &aTransform));
    return aTransform;
  }
 
  void shell_add_face(const NodeId                theShell,
                      const NodeId                theFace,
                      const ::occtl_orientation_t theOrientation)
  {
    check(::occtl_topo_shell_add_face(myPtr, theShell.get(), theFace.get(), theOrientation));
  }
 
  void shell_remove_face(const NodeId theShell, const NodeId theFace)
  {
    check(::occtl_topo_shell_remove_face(myPtr, theShell.get(), theFace.get()));
  }
 
  void face_add_holes(const NodeId theFace, const std::vector<NodeId>& theHoles)
  {
    std::vector<::occtl_node_id_t> aRaw;
    aRaw.reserve(theHoles.size());
    for (const NodeId& aHole : theHoles)
    {
      aRaw.push_back(aHole.get());
    }
    check(::occtl_topo_face_add_holes(myPtr,
                                      theFace.get(),
                                      aRaw.empty() ? nullptr : aRaw.data(),
                                      aRaw.size()));
  }
 
  void face_remove_holes(const NodeId theFace)
  {
    check(::occtl_topo_face_remove_holes(myPtr, theFace.get(), nullptr, 0));
  }
 
  void face_remove_holes(const NodeId theFace, const std::vector<NodeId>& theHoles)
  {
    std::vector<::occtl_node_id_t> aRaw;
    aRaw.reserve(theHoles.size());
    for (const NodeId& aHole : theHoles)
    {
      aRaw.push_back(aHole.get());
    }
    check(::occtl_topo_face_remove_holes(myPtr,
                                         theFace.get(),
                                         aRaw.empty() ? nullptr : aRaw.data(),
                                         aRaw.size()));
  }
 
  void solid_add_shell(const NodeId                theSolid,
                       const NodeId                theShell,
                       const ::occtl_orientation_t theOrientation)
  {
    check(::occtl_topo_solid_add_shell(myPtr, theSolid.get(), theShell.get(), theOrientation));
  }
 
  void solid_remove_shell(const NodeId theSolid, const NodeId theShell)
  {
    check(::occtl_topo_solid_remove_shell(myPtr, theSolid.get(), theShell.get()));
  }
 
  void compound_add_child(const NodeId                theCompound,
                          const NodeId                theChild,
                          const ::occtl_orientation_t theOrientation)
  {
    check(
      ::occtl_topo_compound_add_child(myPtr, theCompound.get(), theChild.get(), theOrientation));
  }
 
  void compound_remove_child(const NodeId theCompound, const NodeId theChild)
  {
    check(::occtl_topo_compound_remove_child(myPtr, theCompound.get(), theChild.get()));
  }
 
  struct EdgeSplitResult
  {
    NodeId Edge1; 
    NodeId Edge2; 
  };
 
  EdgeSplitResult edge_split(const NodeId theEdge, const double theParameter)
  {
    ::occtl_node_id_t aE1{};
    ::occtl_node_id_t aE2{};
    check(::occtl_topo_edge_split(myPtr, theEdge.get(), theParameter, &aE1, &aE2));
    return {NodeId(aE1), NodeId(aE2)};
  }
 
  void edge_add_internal_vertex(const NodeId theEdge, const NodeId theVertex)
  {
    check(::occtl_topo_edge_add_internal_vertex(myPtr, theEdge.get(), theVertex.get()));
  }
 
  void edge_remove_vertex(const NodeId theEdge, const NodeId theVertex)
  {
    check(::occtl_topo_edge_remove_vertex(myPtr, theEdge.get(), theVertex.get()));
  }
 
  void replace_edge_curve(const NodeId theEdge, const ::occtl_rep_id_t theCurveId)
  {
    check(::occtl_topo_replace_edge_curve(myPtr, theEdge.get(), theCurveId));
  }
 
  void replace_face_surface(const NodeId theFace, const ::occtl_rep_id_t theSurfaceId)
  {
    check(::occtl_topo_replace_face_surface(myPtr, theFace.get(), theSurfaceId));
  }
 
  void replace_coedge_pcurve(const NodeId theCoedge, const ::occtl_rep_id_t thePcurveId)
  {
    check(::occtl_topo_replace_coedge_pcurve(myPtr, theCoedge.get(), thePcurveId));
  }
 
  void add_pcurve(const NodeId                theEdge,
                  const NodeId                theFace,
                  const ::occtl_rep_id_t      thePcurveId,
                  const double                theFirst,
                  const double                theLast,
                  const ::occtl_orientation_t theOrientation)
  {
    check(::occtl_topo_add_pcurve(myPtr,
                                  theEdge.get(),
                                  theFace.get(),
                                  thePcurveId,
                                  theFirst,
                                  theLast,
                                  theOrientation));
  }
 
  ::occtl_shape_continuity_t edge_continuity(const NodeId theEdge,
                                             const NodeId theFaceA,
                                             const NodeId theFaceB) const
  {
    ::occtl_shape_continuity_t aCont{};
    check(
      ::occtl_topo_edge_continuity(myPtr, theEdge.get(), theFaceA.get(), theFaceB.get(), &aCont));
    return aCont;
  }
 
  bool edge_has_continuity(const NodeId theEdge, const NodeId theFaceA, const NodeId theFaceB) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_edge_has_continuity(myPtr,
                                           theEdge.get(),
                                           theFaceA.get(),
                                           theFaceB.get(),
                                           &aFlag));
    return aFlag != 0;
  }
 
  ::occtl_shape_continuity_t edge_max_continuity(const NodeId theEdge) const
  {
    ::occtl_shape_continuity_t aCont{};
    check(::occtl_topo_edge_max_continuity(myPtr, theEdge.get(), &aCont));
    return aCont;
  }
 
  ::occtl_orientation_t coedge_orientation(const NodeId theCoedge) const
  {
    ::occtl_orientation_t anOri{};
    check(::occtl_topo_coedge_orientation(myPtr, theCoedge.get(), &anOri));
    return anOri;
  }
 
  NodeId edge_find_coedge_on_face(const NodeId theEdge, const NodeId theFace) const
  {
    ::occtl_node_id_t aCoedge{};
    check(::occtl_topo_edge_find_coedge_on_face(myPtr, theEdge.get(), theFace.get(), &aCoedge));
    return NodeId(aCoedge);
  }
 
  NodeId edge_find_coedge_on_face_oriented(const NodeId                theEdge,
                                           const NodeId                theFace,
                                           const ::occtl_orientation_t theOrientation) const
  {
    ::occtl_node_id_t aCoedge{};
    check(::occtl_topo_edge_find_coedge_on_face_oriented(myPtr,
                                                         theEdge.get(),
                                                         theFace.get(),
                                                         theOrientation,
                                                         &aCoedge));
    return NodeId(aCoedge);
  }
 
  ::occtl_point3_t vertex_point_in_usage(const NodeId theVertex, const NodeId theParent) const
  {
    ::occtl_point3_t aPoint{};
    check(::occtl_topo_vertex_point_in_usage(myPtr, theVertex.get(), theParent.get(), &aPoint));
    return aPoint;
  }
 
  double vertex_pcurve_parameter(const NodeId theVertex, const NodeId theCoedge) const
  {
    double aU = 0.0;
    check(::occtl_topo_vertex_pcurve_parameter(myPtr, theVertex.get(), theCoedge.get(), &aU));
    return aU;
  }
 
  bool edge_has_polygon3d(const NodeId theEdge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_edge_has_polygon3d(myPtr, theEdge.get(), &aFlag));
    return aFlag != 0;
  }
 
  bool coedge_has_polygon_on_surface(const NodeId theCoedge) const
  {
    int32_t aFlag = 0;
    check(::occtl_topo_coedge_has_polygon_on_surface(myPtr, theCoedge.get(), &aFlag));
    return aFlag != 0;
  }
 
  void face_uv_bounds_restricted(const NodeId       theFace,
                                 const double       theUMin,
                                 const double       theUMax,
                                 const double       theVMin,
                                 const double       theVMax,
                                 const double       theU,
                                 const double       theV,
                                 ::occtl_point3_t&  theOutPoint,
                                 ::occtl_vector3_t& theOutD1U,
                                 ::occtl_vector3_t& theOutD1V) const
  {
    check(::occtl_topo_face_uv_bounds_restricted(myPtr,
                                                 theFace.get(),
                                                 theUMin,
                                                 theUMax,
                                                 theVMin,
                                                 theVMax,
                                                 theU,
                                                 theV,
                                                 &theOutPoint,
                                                 &theOutD1U,
                                                 &theOutD1V));
  }
 
  std::pair<Graph, NodeId> fillet(const ::occtl_topo_fillet_options_t& theOpts)
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_fillet(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> blend_edges(const NodeId                             theRoot,
                                       const std::vector<NodeId>&               theEdges,
                                       const ::occtl_topo_edge_blend_options_t& theOpts) const
  {
    std::vector<::occtl_node_id_t> aEdges;
    aEdges.reserve(theEdges.size());
    for (const NodeId& anEdge : theEdges)
    {
      aEdges.push_back(anEdge.get());
    }
 
    ::occtl_topo_edge_blend_options_t aOpts = theOpts;
    aOpts.root                              = theRoot.get();
    aOpts.edges                             = aEdges.data();
    aOpts.edge_count                        = aEdges.size();
 
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_blend_edges(myPtr, &aOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> fillet_edges(const NodeId               theRoot,
                                        const std::vector<NodeId>& theEdges,
                                        const double               theRadius) const
  {
    ::occtl_topo_edge_blend_options_t aOpts = OCCTL_TOPO_EDGE_BLEND_OPTIONS_INIT;
    aOpts.radius                            = theRadius;
    aOpts.chamfer_mode                      = 0;
    return blend_edges(theRoot, theEdges, aOpts);
  }
 
  std::pair<Graph, NodeId> chamfer_edges(const NodeId               theRoot,
                                         const std::vector<NodeId>& theEdges,
                                         const double               theDist1,
                                         const double               theDist2) const
  {
    ::occtl_topo_edge_blend_options_t aOpts = OCCTL_TOPO_EDGE_BLEND_OPTIONS_INIT;
    aOpts.chamfer_mode                      = 1;
    aOpts.chamfer_dist1                     = theDist1;
    aOpts.chamfer_dist2                     = theDist2;
    return blend_edges(theRoot, theEdges, aOpts);
  }
 
  double max_fillet_radius(const NodeId                                    theRoot,
                           const std::vector<NodeId>&                      theEdges,
                           const ::occtl_topo_max_fillet_radius_options_t& theOpts) const
  {
    std::vector<::occtl_node_id_t> aEdges;
    aEdges.reserve(theEdges.size());
    for (const NodeId& anEdge : theEdges)
    {
      aEdges.push_back(anEdge.get());
    }
 
    ::occtl_topo_max_fillet_radius_options_t aOpts = theOpts;
    aOpts.root                                     = theRoot.get();
    aOpts.edges                                    = aEdges.data();
    aOpts.edge_count                               = aEdges.size();
 
    double aRadius = 0.0;
    check(::occtl_topo_max_fillet_radius(myPtr, &aOpts, &aRadius));
    return aRadius;
  }
 
  std::pair<Graph, NodeId> transformed(const NodeId theRoot, const Transform& theTransform) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(
      ::occtl_topo_transformed(myPtr, theRoot.get(), theTransform.c_type(), &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> project_on_face(
    const ::occtl_topo_project_on_face_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_project_on_face(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> wrap_on_face(const ::occtl_topo_wrap_on_face_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_wrap_on_face(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> project_face_along_direction(
    const ::occtl_topo_project_face_direction_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_project_face_along_direction(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> face_to_arcs(const ::occtl_topo_face_to_arcs_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_face_to_arcs(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, HlrCategoryRoots> hlr_project(const ::occtl_topo_hlr_options_t& theOpts) const
  {
    ::occtl_topo_hlr_result_t aResult = OCCTL_TOPO_HLR_RESULT_INIT;
    check(::occtl_topo_make_hlr_projection(myPtr, &theOpts, &aResult));
    HlrCategoryRoots aRoots;
    aRoots.visible_sharp   = NodeId(aResult.visible_sharp);
    aRoots.visible_smooth  = NodeId(aResult.visible_smooth);
    aRoots.visible_seam    = NodeId(aResult.visible_seam);
    aRoots.visible_outline = NodeId(aResult.visible_outline);
    aRoots.hidden_sharp    = NodeId(aResult.hidden_sharp);
    aRoots.hidden_smooth   = NodeId(aResult.hidden_smooth);
    aRoots.hidden_seam     = NodeId(aResult.hidden_seam);
    aRoots.hidden_outline  = NodeId(aResult.hidden_outline);
    return {Graph(aResult.graph), aRoots};
  }
 
  std::pair<Graph, NodeId> draft_faces(const ::occtl_topo_draft_faces_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_draft_faces(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> remove_features(const NodeId               theRoot,
                                           const std::vector<NodeId>& theSelections,
                                           const bool                 theParallel = false) const
  {
    std::vector<::occtl_node_id_t> aSelections;
    aSelections.reserve(theSelections.size());
    for (const NodeId& aSelection : theSelections)
    {
      aSelections.push_back(aSelection.get());
    }
 
    ::occtl_topo_defeature_options_t aOpts = OCCTL_TOPO_DEFEATURE_OPTIONS_INIT;
    aOpts.root                             = theRoot.get();
    aOpts.selections                       = aSelections.data();
    aOpts.selection_count                  = aSelections.size();
    aOpts.parallel                         = theParallel ? 1 : 0;
 
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_defeature(myPtr, &aOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> remove_features(const ::occtl_topo_defeature_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_defeature(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> offset_features(const NodeId               theRoot,
                                           const std::vector<NodeId>& theSelections,
                                           const double               theSelectionOffset,
                                           const double               theBaseOffset = 0.0) const
  {
    std::vector<::occtl_node_id_t> aSelections;
    aSelections.reserve(theSelections.size());
    for (const NodeId& aSelection : theSelections)
    {
      aSelections.push_back(aSelection.get());
    }
 
    ::occtl_topo_offset_features_options_t aOpts = OCCTL_TOPO_OFFSET_FEATURES_OPTIONS_INIT;
    aOpts.root                                   = theRoot.get();
    aOpts.selections                             = aSelections.data();
    aOpts.selection_count                        = aSelections.size();
    aOpts.selection_offset                       = theSelectionOffset;
    aOpts.base_offset                            = theBaseOffset;
 
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_make_offset_features(myPtr, &aOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> offset_features(
    const ::occtl_topo_offset_features_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_make_offset_features(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> make_filling(const ::occtl_topo_filling_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_make_filling(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> make_filling_patch(
    const ::occtl_topo_filling_patch_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_make_filling_patch(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> translated(const NodeId theRoot, const Vector3& theDelta) const
  {
    return transformed(theRoot, Transform::translation(theDelta));
  }
 
  std::pair<Graph, NodeId> rotated(const NodeId          theRoot,
                                   const Axis1Placement& theAxis,
                                   const double          theAngle) const
  {
    return transformed(theRoot, Transform::rotation(theAxis, theAngle));
  }
 
  std::pair<Graph, NodeId> scaled(const NodeId  theRoot,
                                  const Point3& theCenter,
                                  const double  theFactor) const
  {
    return transformed(theRoot, Transform::scale(theCenter, theFactor));
  }
 
  std::pair<Graph, NodeId> mirror(const NodeId                theRoot,
                                  const ::occtl_point3_t&     thePoint,
                                  const ::occtl_direction3_t& theNormal) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_mirrored(myPtr, theRoot.get(), thePoint, theNormal, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> split_by_plane(
    const ::occtl_topo_split_by_plane_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_make_split_by_plane(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> section_by_planes(
    const ::occtl_topo_section_by_planes_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_make_sections_by_planes(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> extrude_faces_to_solids(
    const ::occtl_topo_extrude_faces_options_t& theOpts) const
  {
    occtl_graph_t*  aOutGraph = nullptr;
    occtl_node_id_t aOutRoot  = OCCTL_NODE_ID_INVALID;
    check(::occtl_topo_make_face_extrusion(myPtr, &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> linear_pattern(
    const NodeId                                 theRoot,
    const ::occtl_topo_linear_pattern_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(::occtl_topo_make_linear_pattern(myPtr, theRoot.get(), &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  std::pair<Graph, NodeId> circular_pattern(
    const NodeId                                   theRoot,
    const ::occtl_topo_circular_pattern_options_t& theOpts) const
  {
    ::occtl_graph_t*  aOutGraph = nullptr;
    ::occtl_node_id_t aOutRoot{};
    check(
      ::occtl_topo_make_circular_pattern(myPtr, theRoot.get(), &theOpts, &aOutGraph, &aOutRoot));
    return {Graph(aOutGraph), NodeId(aOutRoot)};
  }
 
  template <typename Fn>
  void for_each(const uint64_t theKindMask, Fn theFn) const
  {
    driveVisitorMask(::occtl_graph_for_each, theKindMask, theFn);
  }
 
  template <typename Fn>
  void for_each_ref(const uint64_t theRefKindMask, Fn theFn) const
  {
    driveRefVisitor(::occtl_graph_for_each_ref, theRefKindMask, theFn);
  }
 
  template <typename Fn>
  void for_each_rep(const uint64_t theRepKindMask, Fn theFn) const
  {
    driveRepVisitor(::occtl_graph_for_each_rep, theRepKindMask, theFn);
  }
 
  template <typename Fn>
  void for_each_related(const NodeId theNode, Fn theFn) const
  {
    driveChildVisitor(::occtl_topo_for_each_related, theNode, theFn);
  }
 
private:
  template <typename Fn>
  struct VisitorBridge
  {
    Fn*                fn;
    std::exception_ptr exc;
  };
 
  template <typename Fn>
  static ::occtl_status_t OCCTL_CALL visitorTrampoline(const ::occtl_node_id_t theId,
                                                       void* const             theUser)
  {
    VisitorBridge<Fn>* const aBridge = static_cast<VisitorBridge<Fn>*>(theUser);
    try
    {
      if constexpr (std::is_invocable_r_v<bool, Fn&, NodeId>)
      {
        return (*aBridge->fn)(NodeId(theId)) ? OCCTL_OK : OCCTL_CANCELLED;
      }
      else
      {
        (*aBridge->fn)(NodeId(theId));
        return OCCTL_OK;
      }
    }
    catch (...)
    {
      aBridge->exc = std::current_exception();
      return OCCTL_INTERNAL;
    }
  }
 
  template <typename Fn>
  struct RefBridge
  {
    Fn*                fn;
    std::exception_ptr exc;
  };
 
  template <typename Fn>
  static ::occtl_status_t OCCTL_CALL refTrampoline(const ::occtl_ref_id_t theId,
                                                   void* const            theUser)
  {
    RefBridge<Fn>* const aBridge = static_cast<RefBridge<Fn>*>(theUser);
    try
    {
      if constexpr (std::is_invocable_r_v<bool, Fn&, ::occtl_ref_id_t>)
      {
        return (*aBridge->fn)(theId) ? OCCTL_OK : OCCTL_CANCELLED;
      }
      else
      {
        (*aBridge->fn)(theId);
        return OCCTL_OK;
      }
    }
    catch (...)
    {
      aBridge->exc = std::current_exception();
      return OCCTL_INTERNAL;
    }
  }
 
  template <typename Fn>
  struct RepBridge
  {
    Fn*                fn;
    std::exception_ptr exc;
  };
 
  template <typename Fn>
  static ::occtl_status_t OCCTL_CALL repTrampoline(const ::occtl_rep_id_t theId,
                                                   void* const            theUser)
  {
    RepBridge<Fn>* const aBridge = static_cast<RepBridge<Fn>*>(theUser);
    try
    {
      if constexpr (std::is_invocable_r_v<bool, Fn&, ::occtl_rep_id_t>)
      {
        return (*aBridge->fn)(theId) ? OCCTL_OK : OCCTL_CANCELLED;
      }
      else
      {
        (*aBridge->fn)(theId);
        return OCCTL_OK;
      }
    }
    catch (...)
    {
      aBridge->exc = std::current_exception();
      return OCCTL_INTERNAL;
    }
  }
 
  template <typename CFn, typename Fn>
  void driveVisitor(CFn theCFn, Fn& theFn) const
  {
    VisitorBridge<Fn>      aBridge{&theFn, nullptr};
    const ::occtl_status_t aSt = theCFn(myPtr, &visitorTrampoline<Fn>, &aBridge);
    if (aBridge.exc)
    {
      std::rethrow_exception(aBridge.exc);
    }
    check(aSt);
  }
 
  template <typename CFn, typename Fn>
  void driveChildVisitor(CFn theCFn, const NodeId theParent, Fn& theFn) const
  {
    VisitorBridge<Fn>      aBridge{&theFn, nullptr};
    const ::occtl_status_t aSt = theCFn(myPtr, theParent.get(), &visitorTrampoline<Fn>, &aBridge);
    if (aBridge.exc)
    {
      std::rethrow_exception(aBridge.exc);
    }
    check(aSt);
  }
 
  template <typename CFn, typename Fn>
  void driveVisitorMask(CFn theCFn, const uint64_t theMask, Fn& theFn) const
  {
    VisitorBridge<Fn>      aBridge{&theFn, nullptr};
    const ::occtl_status_t aSt = theCFn(myPtr, theMask, &visitorTrampoline<Fn>, &aBridge);
    if (aBridge.exc)
    {
      std::rethrow_exception(aBridge.exc);
    }
    check(aSt);
  }
 
  template <typename CFn, typename Fn>
  void driveRefVisitor(CFn theCFn, const uint64_t theMask, Fn& theFn) const
  {
    RefBridge<Fn>          aBridge{&theFn, nullptr};
    const ::occtl_status_t aSt = theCFn(myPtr, theMask, &refTrampoline<Fn>, &aBridge);
    if (aBridge.exc)
    {
      std::rethrow_exception(aBridge.exc);
    }
    check(aSt);
  }
 
  template <typename CFn, typename Fn>
  void driveRepVisitor(CFn theCFn, const uint64_t theMask, Fn& theFn) const
  {
    RepBridge<Fn>          aBridge{&theFn, nullptr};
    const ::occtl_status_t aSt = theCFn(myPtr, theMask, &repTrampoline<Fn>, &aBridge);
    if (aBridge.exc)
    {
      std::rethrow_exception(aBridge.exc);
    }
    check(aSt);
  }
 
  using HistoryAccessor = ::occtl_status_t (*)(const ::occtl_graph_t*,
                                               ::occtl_uid_t,
                                               ::occtl_uid_t*,
                                               std::size_t,
                                               std::size_t*);
 
  std::vector<UID> fetch_history(const HistoryAccessor theAccessor, const UID theInputUid) const
  {
    size_t aCount = 0;
    check(theAccessor(myPtr, theInputUid.get(), nullptr, 0, &aCount));
    std::vector<::occtl_uid_t> aRaw(aCount);
    if (aCount != 0)
    {
      check(theAccessor(myPtr, theInputUid.get(), aRaw.data(), aCount, &aCount));
    }
    std::vector<UID> aOut;
    aOut.reserve(aRaw.size());
    for (const ::occtl_uid_t& aUid : aRaw)
    {
      aOut.emplace_back(aUid);
    }
    return aOut;
  }
 
  ::occtl_graph_t* myPtr = nullptr;
};
 
} // namespace occtl
 
#endif // OCCTL_HPP_TOPO_HPP