pymomentum-cpu 0.1.93.post0__cp312-cp312-macosx_14_0_arm64.whl

include/rerun/datatypes/uuid.hpp

@@ -0,0 +1,60 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/uuid.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A 16-byte UUID.
+    struct Uuid {
+        /// The raw bytes representing the UUID.
+        std::array<uint8_t, 16> bytes;
+
+      public:
+        Uuid() = default;
+
+        Uuid(std::array<uint8_t, 16> bytes_) : bytes(bytes_) {}
+
+        Uuid& operator=(std::array<uint8_t, 16> bytes_) {
+            bytes = bytes_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Uuid> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Uuid";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Uuid` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Uuid* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::Uuid* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/uvec2d.hpp

@@ -0,0 +1,76 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/uvec2d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A uint32 vector in 2D space.
+    struct UVec2D {
+        std::array<uint32_t, 2> xy;
+
+      public: // START of extensions from uvec2d_ext.cpp:
+        /// Construct UVec2D from x/y values.
+        UVec2D(uint32_t x, uint32_t y) : xy{x, y} {}
+
+        /// Construct UVec2D from x/y uint32_t pointer.
+        explicit UVec2D(const uint32_t* xy_) : xy{xy_[0], xy_[1]} {}
+
+        uint32_t x() const {
+            return xy[0];
+        }
+
+        uint32_t y() const {
+            return xy[1];
+        }
+
+        // END of extensions from uvec2d_ext.cpp, start of generated code:
+
+      public:
+        UVec2D() = default;
+
+        UVec2D(std::array<uint32_t, 2> xy_) : xy(xy_) {}
+
+        UVec2D& operator=(std::array<uint32_t, 2> xy_) {
+            xy = xy_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::UVec2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.UVec2D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::UVec2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::UVec2D* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::UVec2D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/uvec3d.hpp

@@ -0,0 +1,80 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/uvec3d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A uint32 vector in 3D space.
+    struct UVec3D {
+        std::array<uint32_t, 3> xyz;
+
+      public: // START of extensions from uvec3d_ext.cpp:
+        /// Construct UVec3D from x/y/z values.
+        UVec3D(uint32_t x, uint32_t y, uint32_t z) : xyz{x, y, z} {}
+
+        /// Construct UVec3D from x/y/z uint32_t pointer.
+        explicit UVec3D(const uint32_t* xyz_) : xyz{xyz_[0], xyz_[1], xyz_[2]} {}
+
+        uint32_t x() const {
+            return xyz[0];
+        }
+
+        uint32_t y() const {
+            return xyz[1];
+        }
+
+        uint32_t z() const {
+            return xyz[2];
+        }
+
+        // END of extensions from uvec3d_ext.cpp, start of generated code:
+
+      public:
+        UVec3D() = default;
+
+        UVec3D(std::array<uint32_t, 3> xyz_) : xyz(xyz_) {}
+
+        UVec3D& operator=(std::array<uint32_t, 3> xyz_) {
+            xyz = xyz_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::UVec3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.UVec3D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::UVec3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::UVec3D* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::UVec3D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/uvec4d.hpp

@@ -0,0 +1,59 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/uvec4d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A uint vector in 4D space.
+    struct UVec4D {
+        std::array<uint32_t, 4> xyzw;
+
+      public:
+        UVec4D() = default;
+
+        UVec4D(std::array<uint32_t, 4> xyzw_) : xyzw(xyzw_) {}
+
+        UVec4D& operator=(std::array<uint32_t, 4> xyzw_) {
+            xyzw = xyzw_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::UVec4D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.UVec4D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::UVec4D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::UVec4D* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::UVec4D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/vec2d.hpp

@@ -0,0 +1,76 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/vec2d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A vector in 2D space.
+    struct Vec2D {
+        std::array<float, 2> xy;
+
+      public: // START of extensions from vec2d_ext.cpp:
+        /// Construct Vec2D from x/y values.
+        Vec2D(float x, float y) : xy{x, y} {}
+
+        /// Construct Vec2D from x/y float pointer.
+        explicit Vec2D(const float* xy_) : xy{xy_[0], xy_[1]} {}
+
+        float x() const {
+            return xy[0];
+        }
+
+        float y() const {
+            return xy[1];
+        }
+
+        // END of extensions from vec2d_ext.cpp, start of generated code:
+
+      public:
+        Vec2D() = default;
+
+        Vec2D(std::array<float, 2> xy_) : xy(xy_) {}
+
+        Vec2D& operator=(std::array<float, 2> xy_) {
+            xy = xy_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Vec2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Vec2D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Vec2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Vec2D* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::Vec2D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/vec3d.hpp

@@ -0,0 +1,80 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/vec3d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A vector in 3D space.
+    struct Vec3D {
+        std::array<float, 3> xyz;
+
+      public: // START of extensions from vec3d_ext.cpp:
+        /// Construct Vec3D from x/y/z values.
+        Vec3D(float x, float y, float z) : xyz{x, y, z} {}
+
+        /// Construct Vec3D from x/y/z float pointer.
+        explicit Vec3D(const float* xyz_) : xyz{xyz_[0], xyz_[1], xyz_[2]} {}
+
+        float x() const {
+            return xyz[0];
+        }
+
+        float y() const {
+            return xyz[1];
+        }
+
+        float z() const {
+            return xyz[2];
+        }
+
+        // END of extensions from vec3d_ext.cpp, start of generated code:
+
+      public:
+        Vec3D() = default;
+
+        Vec3D(std::array<float, 3> xyz_) : xyz(xyz_) {}
+
+        Vec3D& operator=(std::array<float, 3> xyz_) {
+            xyz = xyz_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Vec3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Vec3D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Vec3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Vec3D* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::Vec3D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/vec4d.hpp

@@ -0,0 +1,84 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/vec4d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A vector in 4D space.
+    struct Vec4D {
+        std::array<float, 4> xyzw;
+
+      public: // START of extensions from vec4d_ext.cpp:
+        /// Construct Vec4D from x/y/z/w values.
+        Vec4D(float x, float y, float z, float w) : xyzw{x, y, z, w} {}
+
+        /// Construct Vec4D from x/y/z/w float pointer.
+        explicit Vec4D(const float* xyzw_) : xyzw{xyzw_[0], xyzw_[1], xyzw_[2], xyzw_[3]} {}
+
+        float x() const {
+            return xyzw[0];
+        }
+
+        float y() const {
+            return xyzw[1];
+        }
+
+        float z() const {
+            return xyzw[2];
+        }
+
+        float w() const {
+            return xyzw[3];
+        }
+
+        // END of extensions from vec4d_ext.cpp, start of generated code:
+
+      public:
+        Vec4D() = default;
+
+        Vec4D(std::array<float, 4> xyzw_) : xyzw(xyzw_) {}
+
+        Vec4D& operator=(std::array<float, 4> xyzw_) {
+            xyzw = xyzw_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Vec4D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Vec4D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Vec4D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Vec4D* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::Vec4D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/video_timestamp.hpp

@@ -0,0 +1,67 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/video_timestamp.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    /// \private
+    template <typename T>
+    class NumericBuilder;
+
+    class Array;
+    class DataType;
+    class Int64Type;
+    using Int64Builder = NumericBuilder<Int64Type>;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: Presentation timestamp within a `archetypes::AssetVideo`.
+    ///
+    /// Specified in nanoseconds.
+    /// Presentation timestamps are typically measured as time since video start.
+    struct VideoTimestamp {
+        /// Presentation timestamp value in nanoseconds.
+        int64_t timestamp_ns;
+
+      public:
+        VideoTimestamp() = default;
+
+        VideoTimestamp(int64_t timestamp_ns_) : timestamp_ns(timestamp_ns_) {}
+
+        VideoTimestamp& operator=(int64_t timestamp_ns_) {
+            timestamp_ns = timestamp_ns_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::VideoTimestamp> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.VideoTimestamp";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::VideoTimestamp` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::VideoTimestamp* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::Int64Builder* builder, const datatypes::VideoTimestamp* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/view_coordinates.hpp

@@ -0,0 +1,87 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/view_coordinates.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: How we interpret the coordinate system of an entity/space.
+    ///
+    /// For instance: What is "up"? What does the Z axis mean?
+    ///
+    /// The three coordinates are always ordered as [x, y, z].
+    ///
+    /// For example [Right, Down, Forward] means that the X axis points to the right, the Y axis points
+    /// down, and the Z axis points forward.
+    ///
+    /// ⚠ [Rerun does not yet support left-handed coordinate systems](https://github.com/rerun-io/rerun/issues/5032).
+    ///
+    /// The following constants are used to represent the different directions:
+    ///  * Up = 1
+    ///  * Down = 2
+    ///  * Right = 3
+    ///  * Left = 4
+    ///  * Forward = 5
+    ///  * Back = 6
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewCoordinates {
+        /// The directions of the [x, y, z] axes.
+        std::array<uint8_t, 3> coordinates;
+
+      public: // START of extensions from view_coordinates_ext.cpp:
+        /// Construct Vec3D from x/y/z values.
+        explicit constexpr ViewCoordinates(uint8_t axis0, uint8_t axis1, uint8_t axis2)
+            : coordinates{axis0, axis1, axis2} {}
+
+        // END of extensions from view_coordinates_ext.cpp, start of generated code:
+
+      public:
+        ViewCoordinates() = default;
+
+        ViewCoordinates(std::array<uint8_t, 3> coordinates_) : coordinates(coordinates_) {}
+
+        ViewCoordinates& operator=(std::array<uint8_t, 3> coordinates_) {
+            coordinates = coordinates_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::ViewCoordinates> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.ViewCoordinates";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::ViewCoordinates` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::ViewCoordinates* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::ViewCoordinates* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun