MRId.h

Go to the documentation of this file.

#pragma once
 
#include <MRCMisc/common.h>
#include <MRCMisc/exports.h>
 
#include <stdbool.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct MR_NoInit MR_NoInit; // Defined in `#include <MRCMesh/MRMeshFwd.h>`.
 
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_UndirectedEdgeId
{
    int id_;
} MR_UndirectedEdgeId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_FaceId
{
    int id_;
} MR_FaceId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_VertId
{
    int id_;
} MR_VertId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_PixelId
{
    int id_;
} MR_PixelId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_RegionId
{
    int id_;
} MR_RegionId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_NodeId
{
    int id_;
} MR_NodeId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_ObjId
{
    int id_;
} MR_ObjId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_TextureId
{
    int id_;
} MR_TextureId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_GraphVertId
{
    int id_;
} MR_GraphVertId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_GraphEdgeId
{
    int id_;
} MR_GraphEdgeId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_LocaleDomainId
{
    int id_;
} MR_LocaleDomainId;
 
// stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
typedef struct MR_Id_MR_ICPElemtTag MR_Id_MR_ICPElemtTag;
 
// Variant of Id<T> with omitted initialization by default. Useful for containers.
typedef struct MR_NoInitNodeId MR_NoInitNodeId;
 
// Those are full specializations in `MRId.h`, so `MR_CANONICAL_TYPEDEFS` doesn't work on them.
// Have to add this too.
typedef struct MR_EdgeId
{
    int id_;
} MR_EdgeId;

typedef struct MR_VoxelId
{
    MR_uint64_t id_;
} MR_VoxelId;

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeId_DefaultConstruct(void);

MRC_API MR_UndirectedEdgeId *MR_UndirectedEdgeId_DefaultConstructArray(size_t num_elems);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_UndirectedEdgeId_ConvertTo_int(const MR_UndirectedEdgeId *_this);

MRC_API bool MR_UndirectedEdgeId_ConvertTo_bool(const MR_UndirectedEdgeId *_this);

MRC_API bool MR_UndirectedEdgeId_valid(const MR_UndirectedEdgeId *_this);

MRC_API int *MR_UndirectedEdgeId_get(MR_UndirectedEdgeId *_this);

MRC_API bool MR_equal_MR_UndirectedEdgeId(const MR_UndirectedEdgeId *_this, MR_UndirectedEdgeId b);

MRC_API bool MR_not_equal_MR_UndirectedEdgeId(const MR_UndirectedEdgeId *_this, MR_UndirectedEdgeId b);

MRC_API bool MR_less_MR_UndirectedEdgeId(const MR_UndirectedEdgeId *_this, MR_UndirectedEdgeId b);

MRC_API MR_UndirectedEdgeId *MR_decr_MR_UndirectedEdgeId(MR_UndirectedEdgeId *_this);

MRC_API MR_UndirectedEdgeId *MR_incr_MR_UndirectedEdgeId(MR_UndirectedEdgeId *_this);

MRC_API MR_UndirectedEdgeId MR_post_decr_MR_UndirectedEdgeId(MR_UndirectedEdgeId *_this);

MRC_API MR_UndirectedEdgeId MR_post_incr_MR_UndirectedEdgeId(MR_UndirectedEdgeId *_this);

MRC_API MR_UndirectedEdgeId *MR_UndirectedEdgeId_sub_assign(MR_UndirectedEdgeId *_this, int a);

MRC_API MR_UndirectedEdgeId *MR_UndirectedEdgeId_add_assign(MR_UndirectedEdgeId *_this, int a);

MRC_API MR_FaceId MR_FaceId_DefaultConstruct(void);

MRC_API MR_FaceId *MR_FaceId_DefaultConstructArray(size_t num_elems);

MRC_API MR_FaceId MR_FaceId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_FaceId MR_FaceId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_FaceId MR_FaceId_Construct_unsigned_int(unsigned int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_FaceId MR_FaceId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_FaceId_ConvertTo_int(const MR_FaceId *_this);

MRC_API bool MR_FaceId_ConvertTo_bool(const MR_FaceId *_this);

MRC_API bool MR_FaceId_valid(const MR_FaceId *_this);

MRC_API int *MR_FaceId_get(MR_FaceId *_this);

MRC_API bool MR_equal_MR_FaceId(const MR_FaceId *_this, MR_FaceId b);

MRC_API bool MR_not_equal_MR_FaceId(const MR_FaceId *_this, MR_FaceId b);

MRC_API bool MR_less_MR_FaceId(const MR_FaceId *_this, MR_FaceId b);

MRC_API MR_FaceId *MR_decr_MR_FaceId(MR_FaceId *_this);

MRC_API MR_FaceId *MR_incr_MR_FaceId(MR_FaceId *_this);

MRC_API MR_FaceId MR_post_decr_MR_FaceId(MR_FaceId *_this);

MRC_API MR_FaceId MR_post_incr_MR_FaceId(MR_FaceId *_this);

MRC_API MR_FaceId *MR_FaceId_sub_assign(MR_FaceId *_this, int a);

MRC_API MR_FaceId *MR_FaceId_add_assign(MR_FaceId *_this, int a);

MRC_API MR_VertId MR_VertId_DefaultConstruct(void);

MRC_API MR_VertId *MR_VertId_DefaultConstructArray(size_t num_elems);

MRC_API MR_VertId MR_VertId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_VertId MR_VertId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_VertId MR_VertId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_VertId_ConvertTo_int(const MR_VertId *_this);

MRC_API bool MR_VertId_ConvertTo_bool(const MR_VertId *_this);

MRC_API bool MR_VertId_valid(const MR_VertId *_this);

MRC_API int *MR_VertId_get(MR_VertId *_this);

MRC_API bool MR_equal_MR_VertId(const MR_VertId *_this, MR_VertId b);

MRC_API bool MR_not_equal_MR_VertId(const MR_VertId *_this, MR_VertId b);

MRC_API bool MR_less_MR_VertId(const MR_VertId *_this, MR_VertId b);

MRC_API MR_VertId *MR_decr_MR_VertId(MR_VertId *_this);

MRC_API MR_VertId *MR_incr_MR_VertId(MR_VertId *_this);

MRC_API MR_VertId MR_post_decr_MR_VertId(MR_VertId *_this);

MRC_API MR_VertId MR_post_incr_MR_VertId(MR_VertId *_this);

MRC_API MR_VertId *MR_VertId_sub_assign(MR_VertId *_this, int a);

MRC_API MR_VertId *MR_VertId_add_assign(MR_VertId *_this, int a);

MRC_API MR_PixelId MR_PixelId_DefaultConstruct(void);

MRC_API MR_PixelId *MR_PixelId_DefaultConstructArray(size_t num_elems);

MRC_API MR_PixelId MR_PixelId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_PixelId MR_PixelId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_PixelId MR_PixelId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_PixelId_ConvertTo_int(const MR_PixelId *_this);

MRC_API bool MR_PixelId_ConvertTo_bool(const MR_PixelId *_this);

MRC_API bool MR_PixelId_valid(const MR_PixelId *_this);

MRC_API int *MR_PixelId_get(MR_PixelId *_this);

MRC_API bool MR_equal_MR_PixelId(const MR_PixelId *_this, MR_PixelId b);

MRC_API bool MR_not_equal_MR_PixelId(const MR_PixelId *_this, MR_PixelId b);

MRC_API bool MR_less_MR_PixelId(const MR_PixelId *_this, MR_PixelId b);

MRC_API MR_PixelId *MR_decr_MR_PixelId(MR_PixelId *_this);

MRC_API MR_PixelId *MR_incr_MR_PixelId(MR_PixelId *_this);

MRC_API MR_PixelId MR_post_decr_MR_PixelId(MR_PixelId *_this);

MRC_API MR_PixelId MR_post_incr_MR_PixelId(MR_PixelId *_this);

MRC_API MR_PixelId *MR_PixelId_sub_assign(MR_PixelId *_this, int a);

MRC_API MR_PixelId *MR_PixelId_add_assign(MR_PixelId *_this, int a);

MRC_API MR_RegionId MR_RegionId_DefaultConstruct(void);

MRC_API MR_RegionId *MR_RegionId_DefaultConstructArray(size_t num_elems);

MRC_API MR_RegionId MR_RegionId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_RegionId MR_RegionId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_RegionId MR_RegionId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_RegionId_ConvertTo_int(const MR_RegionId *_this);

MRC_API bool MR_RegionId_ConvertTo_bool(const MR_RegionId *_this);

MRC_API bool MR_RegionId_valid(const MR_RegionId *_this);

MRC_API int *MR_RegionId_get(MR_RegionId *_this);

MRC_API bool MR_equal_MR_RegionId(const MR_RegionId *_this, MR_RegionId b);

MRC_API bool MR_not_equal_MR_RegionId(const MR_RegionId *_this, MR_RegionId b);

MRC_API bool MR_less_MR_RegionId(const MR_RegionId *_this, MR_RegionId b);

MRC_API MR_RegionId *MR_decr_MR_RegionId(MR_RegionId *_this);

MRC_API MR_RegionId *MR_incr_MR_RegionId(MR_RegionId *_this);

MRC_API MR_RegionId MR_post_decr_MR_RegionId(MR_RegionId *_this);

MRC_API MR_RegionId MR_post_incr_MR_RegionId(MR_RegionId *_this);

MRC_API MR_RegionId *MR_RegionId_sub_assign(MR_RegionId *_this, int a);

MRC_API MR_RegionId *MR_RegionId_add_assign(MR_RegionId *_this, int a);

MRC_API MR_NodeId MR_NodeId_DefaultConstruct(void);

MRC_API MR_NodeId *MR_NodeId_DefaultConstructArray(size_t num_elems);

MRC_API MR_NodeId MR_NodeId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_NodeId MR_NodeId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_NodeId MR_NodeId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_NodeId_ConvertTo_int(const MR_NodeId *_this);

MRC_API bool MR_NodeId_ConvertTo_bool(const MR_NodeId *_this);

MRC_API bool MR_NodeId_valid(const MR_NodeId *_this);

MRC_API int *MR_NodeId_get(MR_NodeId *_this);

MRC_API bool MR_equal_MR_NodeId(const MR_NodeId *_this, MR_NodeId b);

MRC_API bool MR_not_equal_MR_NodeId(const MR_NodeId *_this, MR_NodeId b);

MRC_API bool MR_less_MR_NodeId(const MR_NodeId *_this, MR_NodeId b);

MRC_API MR_NodeId *MR_decr_MR_NodeId(MR_NodeId *_this);

MRC_API MR_NodeId *MR_incr_MR_NodeId(MR_NodeId *_this);

MRC_API MR_NodeId MR_post_decr_MR_NodeId(MR_NodeId *_this);

MRC_API MR_NodeId MR_post_incr_MR_NodeId(MR_NodeId *_this);

MRC_API MR_NodeId *MR_NodeId_sub_assign(MR_NodeId *_this, int a);

MRC_API MR_NodeId *MR_NodeId_add_assign(MR_NodeId *_this, int a);

MRC_API MR_ObjId MR_ObjId_DefaultConstruct(void);

MRC_API MR_ObjId *MR_ObjId_DefaultConstructArray(size_t num_elems);

MRC_API MR_ObjId MR_ObjId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_ObjId MR_ObjId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_ObjId MR_ObjId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_ObjId_ConvertTo_int(const MR_ObjId *_this);

MRC_API bool MR_ObjId_ConvertTo_bool(const MR_ObjId *_this);

MRC_API bool MR_ObjId_valid(const MR_ObjId *_this);

MRC_API int *MR_ObjId_get(MR_ObjId *_this);

MRC_API bool MR_equal_MR_ObjId(const MR_ObjId *_this, MR_ObjId b);

MRC_API bool MR_not_equal_MR_ObjId(const MR_ObjId *_this, MR_ObjId b);

MRC_API bool MR_less_MR_ObjId(const MR_ObjId *_this, MR_ObjId b);

MRC_API MR_ObjId *MR_decr_MR_ObjId(MR_ObjId *_this);

MRC_API MR_ObjId *MR_incr_MR_ObjId(MR_ObjId *_this);

MRC_API MR_ObjId MR_post_decr_MR_ObjId(MR_ObjId *_this);

MRC_API MR_ObjId MR_post_incr_MR_ObjId(MR_ObjId *_this);

MRC_API MR_ObjId *MR_ObjId_sub_assign(MR_ObjId *_this, int a);

MRC_API MR_ObjId *MR_ObjId_add_assign(MR_ObjId *_this, int a);

MRC_API MR_TextureId MR_TextureId_DefaultConstruct(void);

MRC_API MR_TextureId *MR_TextureId_DefaultConstructArray(size_t num_elems);

MRC_API MR_TextureId MR_TextureId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_TextureId MR_TextureId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_TextureId MR_TextureId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_TextureId_ConvertTo_int(const MR_TextureId *_this);

MRC_API bool MR_TextureId_ConvertTo_bool(const MR_TextureId *_this);

MRC_API bool MR_TextureId_valid(const MR_TextureId *_this);

MRC_API int *MR_TextureId_get(MR_TextureId *_this);

MRC_API bool MR_equal_MR_TextureId(const MR_TextureId *_this, MR_TextureId b);

MRC_API bool MR_not_equal_MR_TextureId(const MR_TextureId *_this, MR_TextureId b);

MRC_API bool MR_less_MR_TextureId(const MR_TextureId *_this, MR_TextureId b);

MRC_API MR_TextureId *MR_decr_MR_TextureId(MR_TextureId *_this);

MRC_API MR_TextureId *MR_incr_MR_TextureId(MR_TextureId *_this);

MRC_API MR_TextureId MR_post_decr_MR_TextureId(MR_TextureId *_this);

MRC_API MR_TextureId MR_post_incr_MR_TextureId(MR_TextureId *_this);

MRC_API MR_TextureId *MR_TextureId_sub_assign(MR_TextureId *_this, int a);

MRC_API MR_TextureId *MR_TextureId_add_assign(MR_TextureId *_this, int a);

MRC_API MR_GraphVertId MR_GraphVertId_DefaultConstruct(void);

MRC_API MR_GraphVertId *MR_GraphVertId_DefaultConstructArray(size_t num_elems);

MRC_API MR_GraphVertId MR_GraphVertId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_GraphVertId MR_GraphVertId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_GraphVertId MR_GraphVertId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_GraphVertId_ConvertTo_int(const MR_GraphVertId *_this);

MRC_API bool MR_GraphVertId_ConvertTo_bool(const MR_GraphVertId *_this);

MRC_API bool MR_GraphVertId_valid(const MR_GraphVertId *_this);

MRC_API int *MR_GraphVertId_get(MR_GraphVertId *_this);

MRC_API bool MR_equal_MR_GraphVertId(const MR_GraphVertId *_this, MR_GraphVertId b);

MRC_API bool MR_not_equal_MR_GraphVertId(const MR_GraphVertId *_this, MR_GraphVertId b);

MRC_API bool MR_less_MR_GraphVertId(const MR_GraphVertId *_this, MR_GraphVertId b);

MRC_API MR_GraphVertId *MR_decr_MR_GraphVertId(MR_GraphVertId *_this);

MRC_API MR_GraphVertId *MR_incr_MR_GraphVertId(MR_GraphVertId *_this);

MRC_API MR_GraphVertId MR_post_decr_MR_GraphVertId(MR_GraphVertId *_this);

MRC_API MR_GraphVertId MR_post_incr_MR_GraphVertId(MR_GraphVertId *_this);

MRC_API MR_GraphVertId *MR_GraphVertId_sub_assign(MR_GraphVertId *_this, int a);

MRC_API MR_GraphVertId *MR_GraphVertId_add_assign(MR_GraphVertId *_this, int a);

MRC_API MR_GraphEdgeId MR_GraphEdgeId_DefaultConstruct(void);

MRC_API MR_GraphEdgeId *MR_GraphEdgeId_DefaultConstructArray(size_t num_elems);

MRC_API MR_GraphEdgeId MR_GraphEdgeId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_GraphEdgeId MR_GraphEdgeId_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_GraphEdgeId MR_GraphEdgeId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_GraphEdgeId_ConvertTo_int(const MR_GraphEdgeId *_this);

MRC_API bool MR_GraphEdgeId_ConvertTo_bool(const MR_GraphEdgeId *_this);

MRC_API bool MR_GraphEdgeId_valid(const MR_GraphEdgeId *_this);

MRC_API int *MR_GraphEdgeId_get(MR_GraphEdgeId *_this);

MRC_API bool MR_equal_MR_GraphEdgeId(const MR_GraphEdgeId *_this, MR_GraphEdgeId b);

MRC_API bool MR_not_equal_MR_GraphEdgeId(const MR_GraphEdgeId *_this, MR_GraphEdgeId b);

MRC_API bool MR_less_MR_GraphEdgeId(const MR_GraphEdgeId *_this, MR_GraphEdgeId b);

MRC_API MR_GraphEdgeId *MR_decr_MR_GraphEdgeId(MR_GraphEdgeId *_this);

MRC_API MR_GraphEdgeId *MR_incr_MR_GraphEdgeId(MR_GraphEdgeId *_this);

MRC_API MR_GraphEdgeId MR_post_decr_MR_GraphEdgeId(MR_GraphEdgeId *_this);

MRC_API MR_GraphEdgeId MR_post_incr_MR_GraphEdgeId(MR_GraphEdgeId *_this);

MRC_API MR_GraphEdgeId *MR_GraphEdgeId_sub_assign(MR_GraphEdgeId *_this, int a);

MRC_API MR_GraphEdgeId *MR_GraphEdgeId_add_assign(MR_GraphEdgeId *_this, int a);

MRC_API MR_LocaleDomainId MR_LocaleDomainId_DefaultConstruct(void);

MRC_API MR_LocaleDomainId *MR_LocaleDomainId_DefaultConstructArray(size_t num_elems);

MRC_API MR_LocaleDomainId MR_LocaleDomainId_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_LocaleDomainId MR_LocaleDomainId_Construct_int(int i);

MRC_API int MR_LocaleDomainId_ConvertTo_int(const MR_LocaleDomainId *_this);

MRC_API bool MR_LocaleDomainId_ConvertTo_bool(const MR_LocaleDomainId *_this);

MRC_API bool MR_LocaleDomainId_valid(const MR_LocaleDomainId *_this);

MRC_API int *MR_LocaleDomainId_get(MR_LocaleDomainId *_this);

MRC_API bool MR_equal_MR_LocaleDomainId(const MR_LocaleDomainId *_this, MR_LocaleDomainId b);

MRC_API bool MR_not_equal_MR_LocaleDomainId(const MR_LocaleDomainId *_this, MR_LocaleDomainId b);

MRC_API bool MR_less_MR_LocaleDomainId(const MR_LocaleDomainId *_this, MR_LocaleDomainId b);

MRC_API MR_LocaleDomainId *MR_decr_MR_LocaleDomainId(MR_LocaleDomainId *_this);

MRC_API MR_LocaleDomainId *MR_incr_MR_LocaleDomainId(MR_LocaleDomainId *_this);

MRC_API MR_LocaleDomainId MR_post_decr_MR_LocaleDomainId(MR_LocaleDomainId *_this);

MRC_API MR_LocaleDomainId MR_post_incr_MR_LocaleDomainId(MR_LocaleDomainId *_this);

MRC_API MR_LocaleDomainId *MR_LocaleDomainId_sub_assign(MR_LocaleDomainId *_this, int a);

MRC_API MR_LocaleDomainId *MR_LocaleDomainId_add_assign(MR_LocaleDomainId *_this, int a);

MRC_API const int *MR_Id_MR_ICPElemtTag_Get_id_(const MR_Id_MR_ICPElemtTag *_this);

MRC_API void MR_Id_MR_ICPElemtTag_Set_id_(MR_Id_MR_ICPElemtTag *_this, int value);

MRC_API int *MR_Id_MR_ICPElemtTag_GetMutable_id_(MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_DefaultConstruct(void);

MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_DefaultConstructArray(size_t num_elems);

MRC_API const MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_OffsetPtr(const MR_Id_MR_ICPElemtTag *ptr, ptrdiff_t i);

MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_OffsetMutablePtr(MR_Id_MR_ICPElemtTag *ptr, ptrdiff_t i);

MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_ConstructFromAnother(const MR_Id_MR_ICPElemtTag *_other);

MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_Construct(const MR_NoInit *_1);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_Construct_int(int i);
 
// Allow constructing from `int` and other integral types.
// This constructor is written like this instead of a plain `Id(int)`, because we also wish to disable construction
//   from other unrelated `Id<U>` specializations, which themselves have implicit conversions to `int`.
// We could also achieve that using `template <typename U> Id(Id<U>) = delete;`, but it turns out that that causes issues
//   for the `EdgeId::operator UndirectedEdgeId` below. There, while `UndirectedEdgeId x = EdgeId{};` compiles with this approach,
//   but `UndirectedEdgeId x(EdgeId{});` doesn't. So to allow both forms, this constructor must be written this way, as a template.
// The `= int` is there only to make the bindings emit this constructor, I don't think it affects anything else.
MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_Construct_uint64_t(MR_uint64_t i);

MRC_API void MR_Id_MR_ICPElemtTag_Destroy(const MR_Id_MR_ICPElemtTag *_this);

MRC_API void MR_Id_MR_ICPElemtTag_DestroyArray(const MR_Id_MR_ICPElemtTag *_this);

MRC_API int MR_Id_MR_ICPElemtTag_ConvertTo_int(const MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_Id_MR_ICPElemtTag_ConvertTo_bool(const MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_AssignFromAnother(MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *_other);

MRC_API bool MR_Id_MR_ICPElemtTag_valid(const MR_Id_MR_ICPElemtTag *_this);

MRC_API int *MR_Id_MR_ICPElemtTag_get(MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_equal_MR_Id_MR_ICPElemtTag(const MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *b);

MRC_API bool MR_not_equal_MR_Id_MR_ICPElemtTag(const MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *b);

MRC_API bool MR_less_MR_Id_MR_ICPElemtTag(const MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *b);

MRC_API MR_Id_MR_ICPElemtTag *MR_decr_MR_Id_MR_ICPElemtTag(MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_incr_MR_Id_MR_ICPElemtTag(MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_post_decr_MR_Id_MR_ICPElemtTag(MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_post_incr_MR_Id_MR_ICPElemtTag(MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_sub_assign(MR_Id_MR_ICPElemtTag *_this, int a);

MRC_API MR_Id_MR_ICPElemtTag *MR_Id_MR_ICPElemtTag_add_assign(MR_Id_MR_ICPElemtTag *_this, int a);

MRC_API const int *MR_NoInitNodeId_Get_id_(const MR_NoInitNodeId *_this);

MRC_API void MR_NoInitNodeId_Set_id_(MR_NoInitNodeId *_this, int value);

MRC_API int *MR_NoInitNodeId_GetMutable_id_(MR_NoInitNodeId *_this);

MRC_API MR_NoInitNodeId *MR_NoInitNodeId_DefaultConstruct(void);

MRC_API MR_NoInitNodeId *MR_NoInitNodeId_DefaultConstructArray(size_t num_elems);

MRC_API const MR_NoInitNodeId *MR_NoInitNodeId_OffsetPtr(const MR_NoInitNodeId *ptr, ptrdiff_t i);

MRC_API MR_NoInitNodeId *MR_NoInitNodeId_OffsetMutablePtr(MR_NoInitNodeId *ptr, ptrdiff_t i);

MRC_API const MR_NodeId *MR_NoInitNodeId_UpcastTo_MR_NodeId(const MR_NoInitNodeId *object);

MRC_API MR_NodeId *MR_NoInitNodeId_MutableUpcastTo_MR_NodeId(MR_NoInitNodeId *object);

MRC_API const MR_NoInitNodeId *MR_NoInitNodeId_StaticDowncastFrom_MR_NodeId(const MR_NodeId *object);

MRC_API MR_NoInitNodeId *MR_NoInitNodeId_MutableStaticDowncastFrom_MR_NodeId(MR_NodeId *object);

MRC_API MR_NoInitNodeId *MR_NoInitNodeId_ConstructFromAnother(const MR_NoInitNodeId *_other);

MRC_API MR_NoInitNodeId *MR_NoInitNodeId_Construct(MR_NodeId id);

MRC_API void MR_NoInitNodeId_Destroy(const MR_NoInitNodeId *_this);

MRC_API void MR_NoInitNodeId_DestroyArray(const MR_NoInitNodeId *_this);

MRC_API int MR_NoInitNodeId_ConvertTo_int(const MR_NoInitNodeId *_this);

MRC_API bool MR_NoInitNodeId_ConvertTo_bool(const MR_NoInitNodeId *_this);

MRC_API MR_NoInitNodeId *MR_NoInitNodeId_AssignFromAnother(MR_NoInitNodeId *_this, const MR_NoInitNodeId *_other);

MRC_API bool MR_NoInitNodeId_valid(const MR_NoInitNodeId *_this);

MRC_API int *MR_NoInitNodeId_get(MR_NoInitNodeId *_this);

MRC_API bool MR_equal_MR_NoInitNodeId_MR_NodeId(const MR_NoInitNodeId *_this, MR_NodeId b);

MRC_API bool MR_not_equal_MR_NoInitNodeId_MR_NodeId(const MR_NoInitNodeId *_this, MR_NodeId b);

MRC_API bool MR_less_MR_NoInitNodeId_MR_NodeId(const MR_NoInitNodeId *_this, MR_NodeId b);

MRC_API MR_NodeId *MR_NoInitNodeId_sub_assign(MR_NoInitNodeId *_this, int a);

MRC_API MR_NodeId *MR_NoInitNodeId_add_assign(MR_NoInitNodeId *_this, int a);

MRC_API MR_EdgeId MR_EdgeId_DefaultConstruct(void);

MRC_API MR_EdgeId *MR_EdgeId_DefaultConstructArray(size_t num_elems);

MRC_API MR_EdgeId MR_EdgeId_Construct_MR_NoInit(const MR_NoInit *_1);

MRC_API MR_EdgeId MR_EdgeId_Construct_MR_UndirectedEdgeId(MR_UndirectedEdgeId u);

MRC_API MR_EdgeId MR_EdgeId_Construct_int(int i);

MRC_API MR_EdgeId MR_EdgeId_Construct_unsigned_int(unsigned int i);

MRC_API MR_EdgeId MR_EdgeId_Construct_uint64_t(MR_uint64_t i);

MRC_API int MR_EdgeId_ConvertTo_int(const MR_EdgeId *_this);

MRC_API bool MR_EdgeId_ConvertTo_bool(const MR_EdgeId *_this);

MRC_API MR_UndirectedEdgeId MR_EdgeId_ConvertTo_MR_UndirectedEdgeId(const MR_EdgeId *_this);

MRC_API bool MR_EdgeId_valid(const MR_EdgeId *_this);

MRC_API int *MR_EdgeId_get(MR_EdgeId *_this);
 
// returns identifier of the edge with same ends but opposite orientation
MRC_API MR_EdgeId MR_EdgeId_sym(const MR_EdgeId *_this);
 
// among each pair of sym-edges: one is always even and the other is odd
MRC_API bool MR_EdgeId_even(const MR_EdgeId *_this);

MRC_API bool MR_EdgeId_odd(const MR_EdgeId *_this);
 
// returns unique identifier of the edge ignoring its direction
MRC_API MR_UndirectedEdgeId MR_EdgeId_undirected(const MR_EdgeId *_this);

MRC_API bool MR_equal_MR_EdgeId(const MR_EdgeId *_this, MR_EdgeId b);

MRC_API bool MR_not_equal_MR_EdgeId(const MR_EdgeId *_this, MR_EdgeId b);

MRC_API bool MR_less_MR_EdgeId(const MR_EdgeId *_this, MR_EdgeId b);

MRC_API MR_EdgeId *MR_decr_MR_EdgeId(MR_EdgeId *_this);

MRC_API MR_EdgeId *MR_incr_MR_EdgeId(MR_EdgeId *_this);

MRC_API MR_EdgeId MR_post_decr_MR_EdgeId(MR_EdgeId *_this);

MRC_API MR_EdgeId MR_post_incr_MR_EdgeId(MR_EdgeId *_this);

MRC_API MR_EdgeId *MR_EdgeId_sub_assign(MR_EdgeId *_this, int a);

MRC_API MR_EdgeId *MR_EdgeId_add_assign(MR_EdgeId *_this, int a);

MRC_API MR_VoxelId MR_VoxelId_DefaultConstruct(void);

MRC_API MR_VoxelId *MR_VoxelId_DefaultConstructArray(size_t num_elems);

MRC_API MR_VoxelId MR_VoxelId_Construct_MR_NoInit(const MR_NoInit *_1);

MRC_API MR_VoxelId MR_VoxelId_Construct_uint64_t(MR_uint64_t i);

MRC_API MR_uint64_t MR_VoxelId_ConvertTo_uint64_t(const MR_VoxelId *_this);

MRC_API bool MR_VoxelId_ConvertTo_bool(const MR_VoxelId *_this);

MRC_API bool MR_VoxelId_valid(const MR_VoxelId *_this);

MRC_API MR_uint64_t *MR_VoxelId_get(MR_VoxelId *_this);

MRC_API bool MR_equal_MR_VoxelId(const MR_VoxelId *_this, MR_VoxelId b);

MRC_API bool MR_not_equal_MR_VoxelId(const MR_VoxelId *_this, MR_VoxelId b);

MRC_API bool MR_less_MR_VoxelId(const MR_VoxelId *_this, MR_VoxelId b);

MRC_API MR_VoxelId *MR_decr_MR_VoxelId(MR_VoxelId *_this);

MRC_API MR_VoxelId *MR_incr_MR_VoxelId(MR_VoxelId *_this);

MRC_API MR_VoxelId MR_post_decr_MR_VoxelId(MR_VoxelId *_this);

MRC_API MR_VoxelId MR_post_incr_MR_VoxelId(MR_VoxelId *_this);

MRC_API MR_VoxelId *MR_VoxelId_sub_assign(MR_VoxelId *_this, MR_uint64_t a);

MRC_API MR_VoxelId *MR_VoxelId_add_assign(MR_VoxelId *_this, MR_uint64_t a);

MRC_API MR_EdgeId MR_add_MR_EdgeId_int(MR_EdgeId id, int a);

MRC_API MR_NodeId MR_add_MR_NodeId_int(MR_NodeId id, int a);

MRC_API MR_VoxelId MR_add_MR_VoxelId_int(MR_VoxelId id, int a);

MRC_API MR_EdgeId MR_add_MR_EdgeId_unsigned_int(MR_EdgeId id, unsigned int a);

MRC_API MR_NodeId MR_add_MR_NodeId_unsigned_int(MR_NodeId id, unsigned int a);

MRC_API MR_VoxelId MR_add_MR_VoxelId_unsigned_int(MR_VoxelId id, unsigned int a);

MRC_API MR_EdgeId MR_add_MR_EdgeId_uint64_t(MR_EdgeId id, MR_uint64_t a);

MRC_API MR_NodeId MR_add_MR_NodeId_uint64_t(MR_NodeId id, MR_uint64_t a);

MRC_API MR_VoxelId MR_add_MR_VoxelId_uint64_t(MR_VoxelId id, MR_uint64_t a);

MRC_API MR_VoxelId MR_sub_MR_VoxelId_int(MR_VoxelId id, int a);

MRC_API MR_VoxelId MR_sub_MR_VoxelId_unsigned_int(MR_VoxelId id, unsigned int a);

MRC_API MR_VoxelId MR_sub_MR_VoxelId_uint64_t(MR_VoxelId id, MR_uint64_t a);
 
#ifdef __cplusplus
} // extern "C"
#endif