pymomentum-cpu 0.1.82.post0__cp313-cp313-macosx_14_0_arm64.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/axel/axel-config.cmake

@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+####### 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 axel-config.cmake.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+macro(check_required_components _NAME)
+  foreach(comp ${${_NAME}_FIND_COMPONENTS})
+    if(NOT ${_NAME}_${comp}_FOUND)
+      if(${_NAME}_FIND_REQUIRED_${comp})
+        set(${_NAME}_FOUND FALSE)
+      endif()
+    endif()
+  endforeach()
+endmacro()
+
+####################################################################################
+
+include(CMakeFindDependencyMacro)
+
+find_dependency(drjit CONFIG)
+find_dependency(Eigen3 3.4.0 CONFIG)
+find_dependency(Microsoft.GSL CONFIG)
+find_dependency(Dispenso CONFIG)
+
+if(OFF)
+  find_dependency(Tracy CONFIG)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/axelTargets.cmake")
+
+check_required_components("axel")

lib/cmake/axel/axelTargets-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 "axel::axel" for configuration "Release"
+set_property(TARGET axel::axel APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(axel::axel PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libaxel.a"
+  )
+
+list(APPEND _cmake_import_check_targets axel::axel )
+list(APPEND _cmake_import_check_files_for_axel::axel "${_IMPORT_PREFIX}/lib/libaxel.a" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)

lib/cmake/axel/axelTargets.cmake

@@ -0,0 +1,108 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 2.8.12 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.12")
+   message(FATAL_ERROR "CMake >= 2.8.12 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.12...3.29)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS axel::axel)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target axel::axel
+add_library(axel::axel STATIC IMPORTED)
+
+set_target_properties(axel::axel PROPERTIES
+  INTERFACE_COMPILE_FEATURES "cxx_std_17"
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+  INTERFACE_LINK_LIBRARIES "Eigen3::Eigen;Microsoft.GSL::GSL;Dispenso::dispenso;drjit"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/axelTargets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)

lib/cmake/momentum/Findre2.cmake

@@ -0,0 +1,52 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+find_package(re2 QUIET CONFIG)
+if(re2_FOUND)
+  message(STATUS "Found RE2 via CMake.")
+  return()
+endif()
+
+find_package(PkgConfig QUIET)
+if (PKG_CONFIG_FOUND)
+  pkg_check_modules(PC_RE2 QUIET re2)
+endif()
+
+if(PC_RE2_FOUND)
+  set(re2_FOUND true)
+  add_library(re2::re2 INTERFACE IMPORTED)
+  if(PC_RE2_INCLUDE_DIRS)
+    set_property(
+      TARGET re2::re2 PROPERTY
+      INTERFACE_INCLUDE_DIRECTORIES "${PC_RE2_INCLUDE_DIRS}"
+    )
+  endif()
+  if(PC_RE2_CFLAGS_OTHER)
+    # Filter out the -std flag, which is handled by CMAKE_CXX_STANDARD.
+    foreach(flag IN LISTS PC_RE2_CFLAGS_OTHER)
+      if("${flag}" MATCHES "^-std=")
+        list(REMOVE_ITEM PC_RE2_CFLAGS_OTHER "${flag}")
+      endif()
+    endforeach()
+    set_property(
+      TARGET re2::re2 PROPERTY
+      INTERFACE_COMPILE_OPTIONS "${PC_RE2_CFLAGS_OTHER}"
+    )
+  endif()
+
+  if(PC_RE2_LDFLAGS)
+    set_property(
+      TARGET re2::re2 PROPERTY
+      INTERFACE_LINK_LIBRARIES "${PC_RE2_LDFLAGS}"
+    )
+  endif()
+
+  message(STATUS "Found RE2 via pkg-config.")
+  return()
+endif()
+
+if(re2_FIND_REQUIRED)
+  message(FATAL_ERROR "Failed to find RE2.")
+endif()