pymomentum-cpu 0.0.0__cp312-cp312-manylinux_2_39_x86_64.whl

include/rerun/datatypes/tensor_dimension_selection.hpp

@@ -0,0 +1,56 @@
+// 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/tensor_dimension_selection.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: Selection of a single tensor dimension.
+    struct TensorDimensionSelection {
+        /// The dimension number to select.
+        uint32_t dimension;
+
+        /// Invert the direction of the dimension.
+        bool invert;
+
+      public:
+        TensorDimensionSelection() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::TensorDimensionSelection> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.datatypes.TensorDimensionSelection";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::TensorDimensionSelection` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::TensorDimensionSelection* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder, const datatypes::TensorDimensionSelection* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/time_int.hpp

@@ -0,0 +1,62 @@
+// 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/time_int.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**: A 64-bit number describing either nanoseconds OR sequence numbers.
+    struct TimeInt {
+        int64_t value;
+
+      public:
+        TimeInt() = default;
+
+        TimeInt(int64_t value_) : value(value_) {}
+
+        TimeInt& operator=(int64_t value_) {
+            value = value_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::TimeInt> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.TimeInt";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::TimeInt` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::TimeInt* 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::TimeInt* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/time_range.hpp

@@ -0,0 +1,55 @@
+// 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/visible_time_range.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "time_range_boundary.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: Visible time range bounds for a specific timeline.
+    struct TimeRange {
+        /// Low time boundary for sequence timeline.
+        rerun::datatypes::TimeRangeBoundary start;
+
+        /// High time boundary for sequence timeline.
+        rerun::datatypes::TimeRangeBoundary end;
+
+      public:
+        TimeRange() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::TimeRange> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.TimeRange";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::TimeRange` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::TimeRange* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder, const datatypes::TimeRange* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/time_range_boundary.hpp

@@ -0,0 +1,175 @@
+// 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/visible_time_range.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "time_int.hpp"
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <new>
+#include <utility>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class DenseUnionBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    namespace detail {
+        /// \private
+        enum class TimeRangeBoundaryTag : uint8_t {
+            /// Having a special empty state makes it possible to implement move-semantics. We need to be able to leave the object in a state which we can run the destructor on.
+            None = 0,
+            CursorRelative,
+            Absolute,
+            Infinite,
+        };
+
+        /// \private
+        union TimeRangeBoundaryData {
+            /// Boundary is a value relative to the time cursor.
+            rerun::datatypes::TimeInt cursor_relative;
+
+            /// Boundary is an absolute value.
+            rerun::datatypes::TimeInt absolute;
+
+            TimeRangeBoundaryData() {
+                std::memset(reinterpret_cast<void*>(this), 0, sizeof(TimeRangeBoundaryData));
+            }
+
+            ~TimeRangeBoundaryData() {}
+
+            void swap(TimeRangeBoundaryData& other) noexcept {
+                // This bitwise swap would fail for self-referential types, but we don't have any of those.
+                char temp[sizeof(TimeRangeBoundaryData)];
+                void* otherbytes = reinterpret_cast<void*>(&other);
+                void* thisbytes = reinterpret_cast<void*>(this);
+                std::memcpy(temp, thisbytes, sizeof(TimeRangeBoundaryData));
+                std::memcpy(thisbytes, otherbytes, sizeof(TimeRangeBoundaryData));
+                std::memcpy(otherbytes, temp, sizeof(TimeRangeBoundaryData));
+            }
+        };
+    } // namespace detail
+
+    /// **Datatype**: Left or right boundary of a time range.
+    struct TimeRangeBoundary {
+        TimeRangeBoundary() : _tag(detail::TimeRangeBoundaryTag::None) {}
+
+        /// Copy constructor
+        TimeRangeBoundary(const TimeRangeBoundary& other) : _tag(other._tag) {
+            const void* otherbytes = reinterpret_cast<const void*>(&other._data);
+            void* thisbytes = reinterpret_cast<void*>(&this->_data);
+            std::memcpy(thisbytes, otherbytes, sizeof(detail::TimeRangeBoundaryData));
+        }
+
+        TimeRangeBoundary& operator=(const TimeRangeBoundary& other) noexcept {
+            TimeRangeBoundary tmp(other);
+            this->swap(tmp);
+            return *this;
+        }
+
+        TimeRangeBoundary(TimeRangeBoundary&& other) noexcept : TimeRangeBoundary() {
+            this->swap(other);
+        }
+
+        TimeRangeBoundary& operator=(TimeRangeBoundary&& other) noexcept {
+            this->swap(other);
+            return *this;
+        }
+
+        void swap(TimeRangeBoundary& other) noexcept {
+            std::swap(this->_tag, other._tag);
+            this->_data.swap(other._data);
+        }
+
+        /// Boundary is a value relative to the time cursor.
+        static TimeRangeBoundary cursor_relative(rerun::datatypes::TimeInt cursor_relative) {
+            TimeRangeBoundary self;
+            self._tag = detail::TimeRangeBoundaryTag::CursorRelative;
+            new (&self._data.cursor_relative) rerun::datatypes::TimeInt(std::move(cursor_relative));
+            return self;
+        }
+
+        /// Boundary is an absolute value.
+        static TimeRangeBoundary absolute(rerun::datatypes::TimeInt absolute) {
+            TimeRangeBoundary self;
+            self._tag = detail::TimeRangeBoundaryTag::Absolute;
+            new (&self._data.absolute) rerun::datatypes::TimeInt(std::move(absolute));
+            return self;
+        }
+
+        /// The boundary extends to infinity.
+        static TimeRangeBoundary infinite() {
+            TimeRangeBoundary self;
+            self._tag = detail::TimeRangeBoundaryTag::Infinite;
+            return self;
+        }
+
+        /// Return a pointer to cursor_relative if the union is in that state, otherwise `nullptr`.
+        const rerun::datatypes::TimeInt* get_cursor_relative() const {
+            if (_tag == detail::TimeRangeBoundaryTag::CursorRelative) {
+                return &_data.cursor_relative;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to absolute if the union is in that state, otherwise `nullptr`.
+        const rerun::datatypes::TimeInt* get_absolute() const {
+            if (_tag == detail::TimeRangeBoundaryTag::Absolute) {
+                return &_data.absolute;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Returns true if the union is in the infinite state.
+        bool is_infinite() const {
+            return _tag == detail::TimeRangeBoundaryTag::Infinite;
+        }
+
+        /// \private
+        const detail::TimeRangeBoundaryData& get_union_data() const {
+            return _data;
+        }
+
+        /// \private
+        detail::TimeRangeBoundaryTag get_union_tag() const {
+            return _tag;
+        }
+
+      private:
+        detail::TimeRangeBoundaryTag _tag;
+        detail::TimeRangeBoundaryData _data;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::TimeRangeBoundary> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.TimeRangeBoundary";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::TimeRangeBoundary` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::TimeRangeBoundary* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::DenseUnionBuilder* builder, const datatypes::TimeRangeBoundary* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/uint16.hpp

@@ -0,0 +1,62 @@
+// 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/uint16.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 UInt16Type;
+    using UInt16Builder = NumericBuilder<UInt16Type>;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A 16bit unsigned integer.
+    struct UInt16 {
+        uint16_t value;
+
+      public:
+        UInt16() = default;
+
+        UInt16(uint16_t value_) : value(value_) {}
+
+        UInt16& operator=(uint16_t value_) {
+            value = value_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::UInt16> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.UInt16";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::UInt16` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::UInt16* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt16Builder* builder, const datatypes::UInt16* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/uint32.hpp

@@ -0,0 +1,62 @@
+// 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/uint32.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 UInt32Type;
+    using UInt32Builder = NumericBuilder<UInt32Type>;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A 32bit unsigned integer.
+    struct UInt32 {
+        uint32_t value;
+
+      public:
+        UInt32() = default;
+
+        UInt32(uint32_t value_) : value(value_) {}
+
+        UInt32& operator=(uint32_t value_) {
+            value = value_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::UInt32> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.UInt32";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::UInt32` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::UInt32* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt32Builder* builder, const datatypes::UInt32* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/uint64.hpp

@@ -0,0 +1,62 @@
+// 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/uint64.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 UInt64Type;
+    using UInt64Builder = NumericBuilder<UInt64Type>;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A 64bit unsigned integer.
+    struct UInt64 {
+        uint64_t value;
+
+      public:
+        UInt64() = default;
+
+        UInt64(uint64_t value_) : value(value_) {}
+
+        UInt64& operator=(uint64_t value_) {
+            value = value_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::UInt64> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.UInt64";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::UInt64` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::UInt64* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt64Builder* builder, const datatypes::UInt64* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/utf8.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/utf8.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StringBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A string of text, encoded as UTF-8.
+    struct Utf8 {
+        std::string value;
+
+      public: // START of extensions from utf8_ext.cpp:
+        /// Construct from a C string.
+        Utf8(const char* utf8_) : value(utf8_) {}
+
+        /// Explicit copy assignment from a C string to avoid ambiguity in some cases.
+        Utf8& operator=(const char* utf8_) {
+            value = utf8_;
+            return *this;
+        }
+
+        /// Returns a pointer to the underlying C string.
+        const char* c_str() const {
+            return value.c_str();
+        }
+
+        // END of extensions from utf8_ext.cpp, start of generated code:
+
+      public:
+        Utf8() = default;
+
+        Utf8(std::string value_) : value(std::move(value_)) {}
+
+        Utf8& operator=(std::string value_) {
+            value = std::move(value_);
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Utf8> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Utf8";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Utf8` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Utf8* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StringBuilder* builder, const datatypes::Utf8* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/utf8pair.hpp

@@ -0,0 +1,62 @@
+// 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/utf8_pair.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "utf8.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: Stores a tuple of UTF-8 strings.
+    struct Utf8Pair {
+        /// The first string.
+        rerun::datatypes::Utf8 first;
+
+        /// The second string.
+        rerun::datatypes::Utf8 second;
+
+      public: // START of extensions from utf8pair_ext.cpp:
+        /// Creates a string pair.
+        Utf8Pair(rerun::datatypes::Utf8 first_, rerun::datatypes::Utf8 second_)
+            : first(std::move(first_)), second(std::move(second_)) {}
+
+        // END of extensions from utf8pair_ext.cpp, start of generated code:
+
+      public:
+        Utf8Pair() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Utf8Pair> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Utf8Pair";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Utf8Pair` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Utf8Pair* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder, const datatypes::Utf8Pair* elements, size_t num_elements
+        );
+    };
+} // namespace rerun