pymomentum-cpu 0.1.84.post0__cp313-cp313-macosx_14_0_arm64.whl

include/rerun/blueprint/components/column_share.hpp

@@ -0,0 +1,78 @@
+// 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/blueprint/components/column_share.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/float32.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The layout share of a column in the container.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ColumnShare {
+        /// The layout shares of a column in the container.
+        rerun::datatypes::Float32 share;
+
+      public:
+        ColumnShare() = default;
+
+        ColumnShare(rerun::datatypes::Float32 share_) : share(share_) {}
+
+        ColumnShare& operator=(rerun::datatypes::Float32 share_) {
+            share = share_;
+            return *this;
+        }
+
+        ColumnShare(float value_) : share(value_) {}
+
+        ColumnShare& operator=(float value_) {
+            share = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return share;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(blueprint::components::ColumnShare));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ColumnShare> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.ColumnShare";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Float32>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ColumnShare` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ColumnShare* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Float32>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Float32>::to_arrow(
+                    &instances->share,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/component_column_selector.hpp

@@ -0,0 +1,81 @@
+// 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/blueprint/components/component_column_selector.fbs".
+
+#pragma once
+
+#include "../../blueprint/datatypes/component_column_selector.hpp"
+#include "../../component_descriptor.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Describe a component column to be selected in the dataframe view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ComponentColumnSelector {
+        rerun::blueprint::datatypes::ComponentColumnSelector selector;
+
+      public:
+        ComponentColumnSelector() = default;
+
+        ComponentColumnSelector(rerun::blueprint::datatypes::ComponentColumnSelector selector_)
+            : selector(std::move(selector_)) {}
+
+        ComponentColumnSelector& operator=(
+            rerun::blueprint::datatypes::ComponentColumnSelector selector_
+        ) {
+            selector = std::move(selector_);
+            return *this;
+        }
+
+        /// Cast to the underlying ComponentColumnSelector datatype
+        operator rerun::blueprint::datatypes::ComponentColumnSelector() const {
+            return selector;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::blueprint::datatypes::ComponentColumnSelector) ==
+        sizeof(blueprint::components::ComponentColumnSelector)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ComponentColumnSelector> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.ComponentColumnSelector";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::blueprint::datatypes::ComponentColumnSelector>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ComponentColumnSelector` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ComponentColumnSelector* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::blueprint::datatypes::ComponentColumnSelector>::to_arrow(
+                    nullptr,
+                    0
+                );
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::blueprint::datatypes::ComponentColumnSelector>::to_arrow(
+                    &instances->selector,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/container_kind.hpp

@@ -0,0 +1,65 @@
+// 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/blueprint/components/container_kind.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 UInt8Type;
+    using UInt8Builder = NumericBuilder<UInt8Type>;
+} // namespace arrow
+
+namespace rerun::blueprint::components {
+    /// **Component**: The kind of a blueprint container (tabs, grid, …).
+    enum class ContainerKind : uint8_t {
+
+        /// Put children in separate tabs
+        Tabs = 1,
+
+        /// Order the children left to right
+        Horizontal = 2,
+
+        /// Order the children top to bottom
+        Vertical = 3,
+
+        /// Organize children in a grid layout
+        Grid = 4,
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ContainerKind> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.ContainerKind";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::blueprint:: components::ContainerKind` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ContainerKind* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt8Builder* builder, const blueprint::components::ContainerKind* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/components/corner2d.hpp

@@ -0,0 +1,64 @@
+// 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/blueprint/components/corner_2d.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 UInt8Type;
+    using UInt8Builder = NumericBuilder<UInt8Type>;
+} // namespace arrow
+
+namespace rerun::blueprint::components {
+    /// **Component**: One of four 2D corners, typically used to align objects.
+    enum class Corner2D : uint8_t {
+
+        /// Left top corner.
+        LeftTop = 1,
+
+        /// Right top corner.
+        RightTop = 2,
+
+        /// Left bottom corner.
+        LeftBottom = 3,
+
+        /// Right bottom corner.
+        RightBottom = 4,
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::Corner2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.Corner2D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::blueprint:: components::Corner2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::Corner2D* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt8Builder* builder, const blueprint::components::Corner2D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/components/enabled.hpp

@@ -0,0 +1,77 @@
+// 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/blueprint/components/enabled.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/bool.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Whether a procedure is enabled.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct Enabled {
+        rerun::datatypes::Bool visible;
+
+      public:
+        Enabled() = default;
+
+        Enabled(rerun::datatypes::Bool visible_) : visible(visible_) {}
+
+        Enabled& operator=(rerun::datatypes::Bool visible_) {
+            visible = visible_;
+            return *this;
+        }
+
+        Enabled(bool value_) : visible(value_) {}
+
+        Enabled& operator=(bool value_) {
+            visible = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return visible;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Bool) == sizeof(blueprint::components::Enabled));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::Enabled> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.Enabled";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Bool>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::Enabled` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::Enabled* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Bool>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Bool>::to_arrow(
+                    &instances->visible,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/filter_by_range.hpp

@@ -0,0 +1,74 @@
+// 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/blueprint/components/filter_by_range.fbs".
+
+#pragma once
+
+#include "../../blueprint/datatypes/filter_by_range.hpp"
+#include "../../component_descriptor.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Configuration for a filter-by-range feature of the dataframe view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct FilterByRange {
+        rerun::blueprint::datatypes::FilterByRange range;
+
+      public:
+        FilterByRange() = default;
+
+        FilterByRange(rerun::blueprint::datatypes::FilterByRange range_) : range(range_) {}
+
+        FilterByRange& operator=(rerun::blueprint::datatypes::FilterByRange range_) {
+            range = range_;
+            return *this;
+        }
+
+        /// Cast to the underlying FilterByRange datatype
+        operator rerun::blueprint::datatypes::FilterByRange() const {
+            return range;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::blueprint::datatypes::FilterByRange) ==
+        sizeof(blueprint::components::FilterByRange)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::FilterByRange> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.FilterByRange";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::blueprint::datatypes::FilterByRange>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::FilterByRange` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::FilterByRange* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::blueprint::datatypes::FilterByRange>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::blueprint::datatypes::FilterByRange>::to_arrow(
+                    &instances->range,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/filter_is_not_null.hpp

@@ -0,0 +1,77 @@
+// 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/blueprint/components/filter_is_not_null.fbs".
+
+#pragma once
+
+#include "../../blueprint/datatypes/filter_is_not_null.hpp"
+#include "../../component_descriptor.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Configuration for the filter is not null feature of the dataframe view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct FilterIsNotNull {
+        rerun::blueprint::datatypes::FilterIsNotNull filter_is_not_null;
+
+      public:
+        FilterIsNotNull() = default;
+
+        FilterIsNotNull(rerun::blueprint::datatypes::FilterIsNotNull filter_is_not_null_)
+            : filter_is_not_null(std::move(filter_is_not_null_)) {}
+
+        FilterIsNotNull& operator=(rerun::blueprint::datatypes::FilterIsNotNull filter_is_not_null_
+        ) {
+            filter_is_not_null = std::move(filter_is_not_null_);
+            return *this;
+        }
+
+        /// Cast to the underlying FilterIsNotNull datatype
+        operator rerun::blueprint::datatypes::FilterIsNotNull() const {
+            return filter_is_not_null;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::blueprint::datatypes::FilterIsNotNull) ==
+        sizeof(blueprint::components::FilterIsNotNull)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::FilterIsNotNull> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.FilterIsNotNull";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::blueprint::datatypes::FilterIsNotNull>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::FilterIsNotNull` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::FilterIsNotNull* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::blueprint::datatypes::FilterIsNotNull>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::blueprint::datatypes::FilterIsNotNull>::to_arrow(
+                    &instances->filter_is_not_null,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/force_distance.hpp

@@ -0,0 +1,82 @@
+// 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/blueprint/components/force_distance.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/float64.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The target distance between two nodes.
+    ///
+    /// This is helpful to scale the layout, for example if long labels are involved.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ForceDistance {
+        rerun::datatypes::Float64 distance;
+
+      public:
+        ForceDistance() = default;
+
+        ForceDistance(rerun::datatypes::Float64 distance_) : distance(distance_) {}
+
+        ForceDistance& operator=(rerun::datatypes::Float64 distance_) {
+            distance = distance_;
+            return *this;
+        }
+
+        ForceDistance(double value_) : distance(value_) {}
+
+        ForceDistance& operator=(double value_) {
+            distance = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float64 datatype
+        operator rerun::datatypes::Float64() const {
+            return distance;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::Float64) == sizeof(blueprint::components::ForceDistance)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ForceDistance> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.ForceDistance";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Float64>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ForceDistance` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ForceDistance* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Float64>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Float64>::to_arrow(
+                    &instances->distance,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/force_iterations.hpp

@@ -0,0 +1,82 @@
+// 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/blueprint/components/force_iterations.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/uint64.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Specifies how often this force should be applied per iteration.
+    ///
+    /// Increasing this parameter can lead to better results at the cost of longer computation time.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ForceIterations {
+        rerun::datatypes::UInt64 distance;
+
+      public:
+        ForceIterations() = default;
+
+        ForceIterations(rerun::datatypes::UInt64 distance_) : distance(distance_) {}
+
+        ForceIterations& operator=(rerun::datatypes::UInt64 distance_) {
+            distance = distance_;
+            return *this;
+        }
+
+        ForceIterations(uint64_t value_) : distance(value_) {}
+
+        ForceIterations& operator=(uint64_t value_) {
+            distance = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying UInt64 datatype
+        operator rerun::datatypes::UInt64() const {
+            return distance;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::UInt64) == sizeof(blueprint::components::ForceIterations)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ForceIterations> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.ForceIterations";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::UInt64>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ForceIterations` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ForceIterations* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::UInt64>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::UInt64>::to_arrow(
+                    &instances->distance,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun