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

include/rerun/blueprint/components/force_strength.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_strength.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/float64.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The strength of a given force.
+    ///
+    /// Allows to assign different weights to the individual forces, prioritizing one over the other.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ForceStrength {
+        rerun::datatypes::Float64 distance;
+
+      public:
+        ForceStrength() = default;
+
+        ForceStrength(rerun::datatypes::Float64 distance_) : distance(distance_) {}
+
+        ForceStrength& operator=(rerun::datatypes::Float64 distance_) {
+            distance = distance_;
+            return *this;
+        }
+
+        ForceStrength(double value_) : distance(value_) {}
+
+        ForceStrength& 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::ForceStrength)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ForceStrength> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.ForceStrength";
+
+        /// 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::ForceStrength` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ForceStrength* 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/grid_columns.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/grid_columns.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/uint32.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: How many columns a grid container should have.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct GridColumns {
+        /// The number of columns.
+        rerun::datatypes::UInt32 columns;
+
+      public:
+        GridColumns() = default;
+
+        GridColumns(rerun::datatypes::UInt32 columns_) : columns(columns_) {}
+
+        GridColumns& operator=(rerun::datatypes::UInt32 columns_) {
+            columns = columns_;
+            return *this;
+        }
+
+        GridColumns(uint32_t value_) : columns(value_) {}
+
+        GridColumns& operator=(uint32_t value_) {
+            columns = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying UInt32 datatype
+        operator rerun::datatypes::UInt32() const {
+            return columns;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::UInt32) == sizeof(blueprint::components::GridColumns));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::GridColumns> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.GridColumns";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::UInt32>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::GridColumns` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::GridColumns* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::UInt32>::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::UInt32>::to_arrow(
+                    &instances->columns,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/grid_spacing.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/grid_spacing.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/float32.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Space between grid lines of one line to the next in scene units.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct GridSpacing {
+        /// Space between grid lines of one line to the next in scene units.
+        rerun::datatypes::Float32 distance;
+
+      public:
+        GridSpacing() = default;
+
+        GridSpacing(rerun::datatypes::Float32 distance_) : distance(distance_) {}
+
+        GridSpacing& operator=(rerun::datatypes::Float32 distance_) {
+            distance = distance_;
+            return *this;
+        }
+
+        GridSpacing(float value_) : distance(value_) {}
+
+        GridSpacing& operator=(float value_) {
+            distance = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return distance;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(blueprint::components::GridSpacing));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::GridSpacing> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.GridSpacing";
+
+        /// 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::GridSpacing` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::GridSpacing* 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->distance,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/included_content.hpp

@@ -0,0 +1,86 @@
+// 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/included_content.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/entity_path.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: All the contents in the container.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct IncludedContent {
+        /// List of the contents by `datatypes::EntityPath`.
+        ///
+        /// This must be a path in the blueprint store.
+        /// Typically structure as `<blueprint_registry>/<uuid>`.
+        rerun::datatypes::EntityPath contents;
+
+      public:
+        IncludedContent() = default;
+
+        IncludedContent(rerun::datatypes::EntityPath contents_) : contents(std::move(contents_)) {}
+
+        IncludedContent& operator=(rerun::datatypes::EntityPath contents_) {
+            contents = std::move(contents_);
+            return *this;
+        }
+
+        IncludedContent(std::string path_) : contents(std::move(path_)) {}
+
+        IncludedContent& operator=(std::string path_) {
+            contents = std::move(path_);
+            return *this;
+        }
+
+        /// Cast to the underlying EntityPath datatype
+        operator rerun::datatypes::EntityPath() const {
+            return contents;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::EntityPath) == sizeof(blueprint::components::IncludedContent)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::IncludedContent> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.IncludedContent";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::EntityPath>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::IncludedContent` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::IncludedContent* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::EntityPath>::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::EntityPath>::to_arrow(
+                    &instances->contents,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/lock_range_during_zoom.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/lock_range_during_zoom.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/bool.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Indicate whether the range should be locked when zooming in on the data.
+    ///
+    /// Default is `false`, i.e. zoom will change the visualized range.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct LockRangeDuringZoom {
+        rerun::datatypes::Bool lock_range;
+
+      public:
+        LockRangeDuringZoom() = default;
+
+        LockRangeDuringZoom(rerun::datatypes::Bool lock_range_) : lock_range(lock_range_) {}
+
+        LockRangeDuringZoom& operator=(rerun::datatypes::Bool lock_range_) {
+            lock_range = lock_range_;
+            return *this;
+        }
+
+        LockRangeDuringZoom(bool value_) : lock_range(value_) {}
+
+        LockRangeDuringZoom& operator=(bool value_) {
+            lock_range = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return lock_range;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::Bool) == sizeof(blueprint::components::LockRangeDuringZoom)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::LockRangeDuringZoom> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.LockRangeDuringZoom";
+
+        /// 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::LockRangeDuringZoom` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::LockRangeDuringZoom* 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->lock_range,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/map_provider.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/map_provider.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**: Name of the map provider to be used in Map views.
+    enum class MapProvider : uint8_t {
+
+        /// `OpenStreetMap` is the default map provider.
+        OpenStreetMap = 1,
+
+        /// Mapbox Streets is a minimalistic map designed by Mapbox.
+        MapboxStreets = 2,
+
+        /// Mapbox Dark is a dark-themed map designed by Mapbox.
+        MapboxDark = 3,
+
+        /// Mapbox Satellite is a satellite map designed by Mapbox.
+        MapboxSatellite = 4,
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::MapProvider> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.MapProvider";
+
+        /// 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::MapProvider` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::MapProvider* 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::MapProvider* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/components/near_clip_plane.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/near_clip_plane.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/float32.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Distance to the near clip plane used for `Spatial2DView`.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct NearClipPlane {
+        /// Distance to the near clip plane in 3D scene units.
+        rerun::datatypes::Float32 near_clip_plane;
+
+      public:
+        NearClipPlane() = default;
+
+        NearClipPlane(rerun::datatypes::Float32 near_clip_plane_)
+            : near_clip_plane(near_clip_plane_) {}
+
+        NearClipPlane& operator=(rerun::datatypes::Float32 near_clip_plane_) {
+            near_clip_plane = near_clip_plane_;
+            return *this;
+        }
+
+        NearClipPlane(float value_) : near_clip_plane(value_) {}
+
+        NearClipPlane& operator=(float value_) {
+            near_clip_plane = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return near_clip_plane;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::Float32) == sizeof(blueprint::components::NearClipPlane)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::NearClipPlane> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.NearClipPlane";
+
+        /// 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::NearClipPlane` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::NearClipPlane* 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->near_clip_plane,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/panel_state.hpp

@@ -0,0 +1,61 @@
+// 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/panel_state.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**: Tri-state for panel controls.
+    enum class PanelState : uint8_t {
+
+        /// Completely hidden.
+        Hidden = 1,
+
+        /// Visible, but as small as possible on its shorter axis.
+        Collapsed = 2,
+
+        /// Fully expanded.
+        Expanded = 3,
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::PanelState> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.PanelState";
+
+        /// 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::PanelState` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::PanelState* 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::PanelState* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun