pymomentum-cpu 0.1.77.post30__cp313-cp313-manylinux_2_39_x86_64.whl

include/rerun/time_column.hpp

@@ -0,0 +1,288 @@
+#pragma once
+
+#include <cassert>
+#include <chrono>
+#include <memory> // shared_ptr
+
+#include "collection.hpp"
+#include "error.hpp"
+#include "timeline.hpp"
+
+// X.h (of X11) has a macro called `Unsorted`
+// See <https://codebrowser.dev/kde/include/X11/X.h.html#_M/Unsorted>
+// and <https://github.com/rerun-io/rerun/issues/7846>.
+#ifdef Unsorted
+#error \
+    "Found a macro 'Unsorted' (probably from X11), conflicting with `rerun::SortingStatus::Unsorted`. Add '#undef Unsorted' before '#include <rerun.hpp>' to work around this."
+#endif
+
+struct rr_time_column;
+
+namespace arrow {
+    class Array;
+}
+
+namespace rerun {
+    /// Describes whether an array is known to be sorted or not.
+    enum class SortingStatus {
+        /// It's not known whether the array is sorted or not.
+        Unknown = 0,
+
+        /// The array is known to be sorted.
+        Sorted = 1,
+
+        /// The array is known to be unsorted.
+        Unsorted = 2,
+    };
+
+    /// Arrow-encoded data for a column of time points.
+    ///
+    /// \see `rerun::RecordingStream::send_columns`
+    struct TimeColumn {
+        /// The timeline this column belongs to.
+        Timeline timeline;
+
+        /// Time points as a primitive array of i64.
+        std::shared_ptr<arrow::Array> array;
+
+        /// The sorting order of the `times` array.
+        SortingStatus sorting_status;
+
+      public:
+        /// Creates a time column from an array of time points.
+        ///
+        /// \param timeline The timeline this column belongs to.
+        /// \param times The time values.
+        /// Depending on the `TimeType` of the timeline this may be either sequence numbers, durations, or timestamps.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the time points.
+        /// Already sorted time points may perform better.
+        TimeColumn(
+            Timeline timeline, Collection<int64_t> times,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        );
+
+        /// Creates a time column from an array of sequence points.
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param sequence_points The sequence points.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the sequence points.
+        /// Already sorted time points may perform better.
+        ///
+        /// \deprecated Use `from_sequence` instead.
+        [[deprecated("Use `from_sequence` instead.")]] static TimeColumn from_sequence_points(
+            std::string timeline_name, Collection<int64_t> sequence_points,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            return TimeColumn(
+                Timeline(std::move(timeline_name), TimeType::Sequence),
+                std::move(sequence_points),
+                sorting_status
+            );
+        }
+
+        /// Creates a column from an array of sequence points, e.g. frame numbers.
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param sequence_points The sequence points.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the sequence points.
+        /// Already sorted time points may perform better.
+        static TimeColumn from_sequence(
+            std::string timeline_name, Collection<int64_t> sequence_points,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            return TimeColumn(
+                Timeline(std::move(timeline_name), TimeType::Sequence),
+                std::move(sequence_points),
+                sorting_status
+            );
+        }
+
+        /// Creates a time column from an array of nanoseconds.
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param times_in_nanoseconds Time values in nanoseconds.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the time points.
+        /// Already sorted time points may perform better.
+        [[deprecated("Use 'from_duration_nanos' or `from_nanos_since_epoch' instead"
+        )]] static TimeColumn
+            from_nanoseconds(
+                std::string timeline_name, Collection<int64_t> times_in_nanoseconds,
+                SortingStatus sorting_status = SortingStatus::Unknown
+            ) {
+            return TimeColumn(
+                Timeline(std::move(timeline_name), TimeType::Duration),
+                std::move(times_in_nanoseconds),
+                sorting_status
+            );
+        }
+
+        /// Creates a time column from an array of seconds.
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param times_in_secs Time values in seconds.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the time points.
+        /// Already sorted time points may perform better.
+        [[deprecated("Use 'from_duration_secs' or `from_secs_since_epoch' instead"
+        )]] static TimeColumn
+            from_seconds(
+                std::string timeline_name, Collection<double> times_in_secs,
+                SortingStatus sorting_status = SortingStatus::Unknown
+            );
+
+        // -----------
+        // Durations:
+
+        /// Creates a time column from an array of arbitrary std::chrono durations.
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param durations Time values as chrono durations.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the time points.
+        /// Already sorted time points may perform better.
+        template <typename TRep, typename TPeriod>
+        static TimeColumn from_durations(
+            std::string timeline_name,
+            const Collection<std::chrono::duration<TRep, TPeriod>>& durations,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            std::vector<int64_t> times(durations.size());
+            for (size_t i = 0; i < durations.size(); i++) {
+                times[i] =
+                    std::chrono::duration_cast<std::chrono::nanoseconds>(durations[i]).count();
+            }
+            return TimeColumn(
+                Timeline(std::move(timeline_name), TimeType::Duration),
+                std::move(times),
+                sorting_status
+            );
+        }
+
+        /// \deprecated Use `from_durations` instead.
+        template <typename TRep, typename TPeriod>
+        [[deprecated("Use `from_durations` instead.")]] static TimeColumn from_times(
+            std::string timeline_name,
+            const Collection<std::chrono::duration<TRep, TPeriod>>& chrono_times,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            return from_durations<TRep, TPeriod>(timeline_name, chrono_times, sorting_status);
+        }
+
+        /// Creates a duration column from an array of nanoseconds.
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param duration_in_nanos Duration values in nanoseconds.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the time points.
+        /// Already sorted time points may perform better.
+        static TimeColumn from_duration_nanoseconds(
+            std::string timeline_name, Collection<int64_t> duration_in_nanos,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            return TimeColumn(
+                Timeline(std::move(timeline_name), TimeType::Duration),
+                std::move(duration_in_nanos),
+                sorting_status
+            );
+        }
+
+        /// Creates a duration column from an array of seconds.
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param duration_in_secs Duration values in seconds.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the time points.
+        /// Already sorted time points may perform better.
+        static TimeColumn from_duration_secs(
+            std::string timeline_name, Collection<double> duration_in_secs,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            std::vector<int64_t> duration_in_nanos;
+            duration_in_nanos.reserve(duration_in_secs.size());
+            for (auto time_in_secs : duration_in_secs) {
+                duration_in_nanos.push_back(static_cast<int64_t>(time_in_secs * 1.0e9 + 0.5));
+            }
+            return TimeColumn(
+                Timeline(std::move(timeline_name), TimeType::Duration),
+                std::move(duration_in_nanos),
+                sorting_status
+            );
+        }
+
+        // -----------
+        // Timestamps:
+
+        template <typename TClock>
+        static TimeColumn from_time_points(
+            std::string timeline_name,
+            const Collection<std::chrono::time_point<TClock>>& time_points,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            std::vector<int64_t> nanos_since_epoch;
+            nanos_since_epoch.reserve(time_points.size());
+            for (auto timepoint : time_points) {
+                auto nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                    timepoint.time_since_epoch()
+                );
+                nanos_since_epoch.push_back(nanos.count());
+            }
+            return TimeColumn::from_nanos_since_epoch(
+                std::move(timeline_name),
+                nanos_since_epoch,
+                sorting_status
+            );
+        }
+
+        /// Creates a timestamp column from an array of nanoseconds since Unix Epoch (1970-01-01 00:00:00 UTC).
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param timestamp_in_nanos Timestamp values in nanoseconds.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the time points.
+        /// Already sorted time points may perform better.
+        static TimeColumn from_nanos_since_epoch(
+            std::string timeline_name, Collection<int64_t> timestamp_in_nanos,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            return TimeColumn(
+                Timeline(std::move(timeline_name), TimeType::Timestamp),
+                std::move(timestamp_in_nanos),
+                sorting_status
+            );
+        }
+
+        /// Creates a duration column from an array of seconds since Unix Epoch (1970-01-01 00:00:00 UTC).
+        ///
+        /// \param timeline_name The name of the timeline this column belongs to.
+        /// \param timestamp_in_secs Timestamp values in seconds.
+        /// Make sure the sorting status is correctly specified.
+        /// \param sorting_status The sorting status of the time points.
+        /// Already sorted time points may perform better.
+        static TimeColumn from_secs_since_epoch(
+            std::string timeline_name, Collection<double> timestamp_in_secs,
+            SortingStatus sorting_status = SortingStatus::Unknown
+        ) {
+            std::vector<int64_t> timestamp_in_nanos;
+            timestamp_in_nanos.reserve(timestamp_in_secs.size());
+            for (auto time_in_secs : timestamp_in_secs) {
+                timestamp_in_nanos.push_back(static_cast<int64_t>(time_in_secs * 1.0e9 + 0.5));
+            }
+            return TimeColumn::from_nanos_since_epoch(
+                std::move(timeline_name),
+                std::move(timestamp_in_nanos),
+                sorting_status
+            );
+        }
+
+        // -----------------------------------------------------------------------------
+
+        /// To rerun C API component batch.
+        ///
+        /// The resulting `rr_time_column` keeps the `arrow::Array` alive until it is released.
+        Error to_c_ffi_struct(rr_time_column& out_column) const;
+    };
+} // namespace rerun

include/rerun/timeline.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "error.hpp"
+
+#include <string>
+
+struct rr_timeline;
+
+namespace rerun {
+    /// Describes the type of a timeline or time point.
+    enum class TimeType {
+        /// Used e.g. for frames in a film.
+        Sequence = 1,
+
+        /// Nanoseconds.
+        Duration = 2,
+
+        /// Nanoseconds since Unix epoch (1970-01-01 00:00:00 UTC).
+        Timestamp = 3,
+    };
+
+    /// Definition of a timeline.
+    struct Timeline {
+        /// The name of the timeline.
+        std::string name;
+
+        /// The type of the timeline.
+        TimeType type;
+
+        /// Creates a new timeline.
+        Timeline(std::string name_, TimeType type_) : name(std::move(name_)), type(type_) {}
+
+        Timeline() = delete;
+
+        /// To rerun C API timeline.
+        Error to_c_ffi_struct(rr_timeline& out_column) const;
+    };
+} // namespace rerun

include/rerun/type_traits.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <iterator> // std::begin, std::end, std::size
+#include <type_traits>
+
+/// Type trait utilities.
+///
+/// The defined traits acts as an extension to std defined type traits and are used as utilities
+/// across the SDK.
+namespace rerun::traits {
+    /// Gets the value/element type of a container.
+    ///
+    /// This works for all types that stick with the std convention of having a `value_type` member type.
+    /// Fails to compile if the type does not have a `value_type` member type - this can be used for SFINAE checks.
+    template <typename T>
+    using value_type_of_t = typename std::remove_reference_t<T>::value_type;
+
+    /// \private
+    namespace details {
+        /// False type if a given type is not iterable and has a size (has `begin` and `end`).
+        template <typename T, typename = void>
+        struct is_iterable : std::false_type {};
+
+        /// True type if a given type is iterable and has a size (has `begin` and `end` implemented).
+        ///
+        /// Makes no restrictions on the type returned by `begin`/`end`.
+        template <typename T>
+        struct is_iterable<
+            T, std::void_t<
+                   decltype(std::begin(std::declval<T&>())), //
+                   decltype(std::end(std::declval<T&>()))    //
+                   >> : std::true_type {};
+    } // namespace details
+
+    /// True if a given type is iterable, meaning there is a `begin` & `end` implementation.
+    ///
+    /// Makes no restrictions on the type returned by `begin`/`end`.
+    template <typename T>
+    constexpr bool is_iterable_v = details::is_iterable<T>::value;
+} // namespace rerun::traits

include/rerun.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+// Built-in Rerun types (largely generated from an interface definition language)
+#include "rerun/archetypes.hpp"
+#include "rerun/components.hpp"
+#include "rerun/datatypes.hpp"
+
+// Rerun API.
+#include "rerun/collection.hpp"
+#include "rerun/collection_adapter.hpp"
+#include "rerun/collection_adapter_builtins.hpp"
+#include "rerun/component_descriptor.hpp"
+#include "rerun/config.hpp"
+#include "rerun/entity_path.hpp"
+#include "rerun/error.hpp"
+#include "rerun/image_utils.hpp"
+#include "rerun/recording_stream.hpp"
+#include "rerun/result.hpp"
+#include "rerun/sdk_info.hpp"
+#include "rerun/spawn.hpp"
+
+/// All Rerun C++ types and functions are in the `rerun` namespace or one of its nested namespaces.
+namespace rerun {
+    /// When an external [`DataLoader`] is asked to load some data that it doesn't know how to load, it
+    /// should exit with this exit code.
+    // NOTE: Always keep in sync with other languages.
+    const int EXTERNAL_DATA_LOADER_INCOMPATIBLE_EXIT_CODE = 66;
+
+    // Archetypes are the quick-and-easy default way of logging data to Rerun.
+    // Make them available in the rerun namespace.
+    using namespace archetypes;
+
+    // Also import any component or datatype that has a unique name:
+    using components::AlbedoFactor;
+    using components::Color;
+    using components::FillMode;
+    using components::GeoLineString;
+    using components::HalfSize2D;
+    using components::HalfSize3D;
+    using components::LatLon;
+    using components::LineStrip2D;
+    using components::LineStrip3D;
+    using components::MediaType;
+    using components::Position2D;
+    using components::Position3D;
+    using components::Radius;
+    using components::Text;
+    using components::TextLogLevel;
+    using components::TransformRelation;
+    using components::TriangleIndices;
+    using components::Vector2D;
+    using components::Vector3D;
+
+    using datatypes::Angle;
+    using datatypes::AnnotationInfo;
+    using datatypes::ChannelDatatype;
+    using datatypes::ClassDescription;
+    using datatypes::ColorModel;
+    using datatypes::DVec2D;
+    using datatypes::Float32;
+    using datatypes::KeypointPair;
+    using datatypes::Mat3x3;
+    using datatypes::PixelFormat;
+    using datatypes::Quaternion;
+    using datatypes::Rgba32;
+    using datatypes::RotationAxisAngle;
+    using datatypes::TensorBuffer;
+    using datatypes::TensorData;
+    using datatypes::Vec2D;
+    using datatypes::Vec3D;
+    using datatypes::Vec4D;
+
+    // Document namespaces that span several files:
+
+    /// All built-in archetypes. See [Types](https://www.rerun.io/docs/reference/types) in the Rerun manual.
+    namespace archetypes {}
+
+    /// All built-in components. See [Types](https://www.rerun.io/docs/reference/types) in the Rerun manual.
+    namespace components {}
+
+    /// All built-in datatypes. See [Types](https://www.rerun.io/docs/reference/types) in the Rerun manual.
+    namespace datatypes {}
+
+    /// All blueprint types. This is still experimental and subject to change!
+    namespace blueprint {}
+} // namespace rerun

lib/cmake/rerun_sdk/rerun_sdkConfig.cmake

@@ -0,0 +1,70 @@
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was Config.cmake.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+####################################################################################
+
+include("${CMAKE_CURRENT_LIST_DIR}/rerun_sdkTargets.cmake")
+
+set(RERUN_LIB_DIR "${CMAKE_CURRENT_LIST_DIR}/../..")
+
+if(ON)
+    if(NOT TARGET rerun_c)
+        # Setup `rerun_c` (imported libraries can't be exported!)
+        add_library(rerun_c STATIC IMPORTED GLOBAL)
+        get_filename_component(RERUN_C_LIB_NAME "/home/jeongseok/dev/momentum/momentum/build/cp313-cp313-linux_x86_64/_deps/rerun_sdk-src/lib/librerun_c__linux_x64.a" NAME)
+        set_target_properties(rerun_c PROPERTIES IMPORTED_LOCATION "${RERUN_LIB_DIR}/${RERUN_C_LIB_NAME}")
+        if(APPLE)
+            target_link_libraries(rerun_c INTERFACE "-framework CoreFoundation" "-framework IOKit")
+        elseif(UNIX) # if(LINUX) # CMake 3.25
+            target_link_libraries(rerun_c INTERFACE "-lm -ldl -pthread")
+        elseif(WIN32)
+            target_link_libraries(rerun_c INTERFACE ws2_32.dll Bcrypt.dll Userenv.dll ntdll.dll)
+        endif()
+    endif()
+endif()
+
+# Setup `rerun_arrow_target` (imported libraries can't be exported and package dependencies need to be re-declared)
+# if(ON AND NOT OFF)
+if(ON AND NOT OFF)
+    message(STATUS "Rerun is using bundled arrow library.")
+
+    if(NOT TARGET rerun_arrow_target)
+        add_library(rerun_arrow_target STATIC IMPORTED GLOBAL)
+        get_filename_component(RERUN_ARROW_LIB_NAME "/home/jeongseok/dev/momentum/momentum/build/cp313-cp313-linux_x86_64/arrow/lib/libarrow.a" NAME)
+        set_target_properties(rerun_arrow_target PROPERTIES IMPORTED_LOCATION "${RERUN_LIB_DIR}/${RERUN_ARROW_LIB_NAME}")
+    endif()
+
+    # We have to explicitly opt in the arrow bundled dependencies, otherwise we're missing the symbols for mimalloc.
+    if(NOT TARGET arrow_targetBundledDeps)
+        add_library(arrow_targetBundledDeps STATIC IMPORTED)
+        get_filename_component(RERUN_ARROW_DEPS_LIB_NAME "/home/jeongseok/dev/momentum/momentum/build/cp313-cp313-linux_x86_64/arrow/lib/libarrow_bundled_dependencies.a" NAME)
+        set_target_properties(arrow_targetBundledDeps PROPERTIES IMPORTED_LOCATION "${RERUN_LIB_DIR}/${RERUN_ARROW_DEPS_LIB_NAME}")
+        target_link_libraries(rerun_arrow_target INTERFACE arrow_targetBundledDeps)
+    endif()
+else()
+    if(ON AND OFF)
+        message(WARNING
+            "Rerun got built with an automatically downloaded version of libArrow,"
+            "but it was not bundled as part of the install since export of shared libArrow is not supported yet."
+            "Set RERUN_ARROW_LINK_SHARED to OFF during install or make sure find_package succeeds for Arrow."
+        )
+    endif()
+
+    include(CMakeFindDependencyMacro)
+
+    find_dependency(Arrow)
+
+    message(STATUS "Rerun is using a system installed libArrow.")
+
+    if(NOT TARGET rerun_arrow_target)
+        if(OFF)
+            add_library(rerun_arrow_target ALIAS Arrow::arrow_shared)
+        else()
+            add_library(rerun_arrow_target ALIAS Arrow::arrow_static)
+        endif()
+    endif()
+endif()

lib/cmake/rerun_sdk/rerun_sdkConfigVersion.cmake

@@ -0,0 +1,83 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is equal to the requested version.
+# The tweak version component is ignored.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  message(AUTHOR_WARNING
+    "`find_package()` specify a version range but the version strategy "
+    "(ExactVersion) of the module `${PACKAGE_FIND_NAME}` is incompatible "
+    "with this request. Only the lower endpoint of the range will be used.")
+endif()
+
+set(PACKAGE_VERSION "0.23.3")
+
+if("0.23.3" MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)") # strip the tweak version
+  set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+  set(CVF_VERSION_MINOR "${CMAKE_MATCH_2}")
+  set(CVF_VERSION_PATCH "${CMAKE_MATCH_3}")
+
+  if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+  endif()
+  if(NOT CVF_VERSION_MINOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_MINOR "${CVF_VERSION_MINOR}")
+  endif()
+  if(NOT CVF_VERSION_PATCH VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_PATCH "${CVF_VERSION_PATCH}")
+  endif()
+
+  set(CVF_VERSION_NO_TWEAK "${CVF_VERSION_MAJOR}.${CVF_VERSION_MINOR}.${CVF_VERSION_PATCH}")
+else()
+  set(CVF_VERSION_NO_TWEAK "0.23.3")
+endif()
+
+if(PACKAGE_FIND_VERSION MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)") # strip the tweak version
+  set(REQUESTED_VERSION_MAJOR "${CMAKE_MATCH_1}")
+  set(REQUESTED_VERSION_MINOR "${CMAKE_MATCH_2}")
+  set(REQUESTED_VERSION_PATCH "${CMAKE_MATCH_3}")
+
+  if(NOT REQUESTED_VERSION_MAJOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_MAJOR "${REQUESTED_VERSION_MAJOR}")
+  endif()
+  if(NOT REQUESTED_VERSION_MINOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_MINOR "${REQUESTED_VERSION_MINOR}")
+  endif()
+  if(NOT REQUESTED_VERSION_PATCH VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_PATCH "${REQUESTED_VERSION_PATCH}")
+  endif()
+
+  set(REQUESTED_VERSION_NO_TWEAK
+      "${REQUESTED_VERSION_MAJOR}.${REQUESTED_VERSION_MINOR}.${REQUESTED_VERSION_PATCH}")
+else()
+  set(REQUESTED_VERSION_NO_TWEAK "${PACKAGE_FIND_VERSION}")
+endif()
+
+if(REQUESTED_VERSION_NO_TWEAK STREQUAL CVF_VERSION_NO_TWEAK)
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+endif()
+
+if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+  set(PACKAGE_VERSION_EXACT TRUE)
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()

lib/cmake/rerun_sdk/rerun_sdkTargets-release.cmake

@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "rerun_sdk" for configuration "Release"
+set_property(TARGET rerun_sdk APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(rerun_sdk PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/librerun_sdk.a"
+  )
+
+list(APPEND _cmake_import_check_targets rerun_sdk )
+list(APPEND _cmake_import_check_files_for_rerun_sdk "${_IMPORT_PREFIX}/lib/librerun_sdk.a" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)