react-native-windows 0.84.0-preview.9 → 0.84.1

package/external/folly/folly/lang/Ordering.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+
+#include <folly/lang/Exception.h>
+
+namespace folly {
+
+enum class ordering : std::int8_t { lt = -1, eq = 0, gt = 1 };
+
+template <typename T>
+constexpr ordering to_ordering(T c) {
+  return ordering(int(c < T(0)) * -1 + int(c > T(0)));
+}
+
+namespace detail {
+
+template <typename C, ordering o, bool ne>
+struct cmp_pred : private C {
+  using C::C;
+
+  template <typename A, typename B>
+  constexpr bool operator()(A&& a, B&& b) const {
+    return ne ^ (C::operator()(static_cast<A&&>(a), static_cast<B&&>(b)) == o);
+  }
+};
+
+} // namespace detail
+
+template <typename C>
+struct compare_equal_to : detail::cmp_pred<C, ordering::eq, 0> {
+  using detail::cmp_pred<C, ordering::eq, 0>::cmp_pred;
+};
+
+template <typename C>
+struct compare_not_equal_to : detail::cmp_pred<C, ordering::eq, 1> {
+  using detail::cmp_pred<C, ordering::eq, 1>::cmp_pred;
+};
+
+template <typename C>
+struct compare_less : detail::cmp_pred<C, ordering::lt, 0> {
+  using detail::cmp_pred<C, ordering::lt, 0>::cmp_pred;
+};
+
+template <typename C>
+struct compare_less_equal : detail::cmp_pred<C, ordering::gt, 1> {
+  using detail::cmp_pred<C, ordering::gt, 1>::cmp_pred;
+};
+
+template <typename C>
+struct compare_greater : detail::cmp_pred<C, ordering::gt, 0> {
+  using detail::cmp_pred<C, ordering::gt, 0>::cmp_pred;
+};
+
+template <typename C>
+struct compare_greater_equal : detail::cmp_pred<C, ordering::lt, 1> {
+  using detail::cmp_pred<C, ordering::lt, 1>::cmp_pred;
+};
+
+namespace detail {
+
+// extracted to a template so initialization can be inline and visible in c++14
+template <typename D>
+struct partial_ordering_ {
+  static D const less;
+  static D const greater;
+  static D const equivalent;
+  static D const unordered;
+};
+
+template <typename D>
+FOLLY_STORAGE_CONSTEXPR D const partial_ordering_<D>::less{ordering::lt};
+template <typename D>
+FOLLY_STORAGE_CONSTEXPR D const partial_ordering_<D>::greater{ordering::gt};
+template <typename D>
+FOLLY_STORAGE_CONSTEXPR D const partial_ordering_<D>::equivalent{ordering::eq};
+template <typename D>
+FOLLY_STORAGE_CONSTEXPR D const //
+    partial_ordering_<D>::unordered{typename D::unordered_tag{}};
+
+} // namespace detail
+
+/// @def partial_ordering
+///
+/// mimic: std::partial_ordering, c++20 (partial)
+class partial_ordering : private detail::partial_ordering_<partial_ordering> {
+ private:
+  using constants = detail::partial_ordering_<partial_ordering>;
+  friend constants;
+  class unordered_tag {};
+
+ public:
+  using constants::equivalent;
+  using constants::greater;
+  using constants::less;
+  using constants::unordered;
+
+  explicit constexpr partial_ordering(unordered_tag) noexcept : value_{undef} {}
+  /* implicit */ constexpr partial_ordering(ordering o) noexcept
+      : value_{int8_t(o)} {}
+
+  explicit operator ordering() const noexcept(false) {
+    switch (value_) {
+      case undef:
+        throw_exception<std::out_of_range>("unordered");
+      default:
+        return ordering(value_);
+    }
+  }
+
+  friend bool operator==(partial_ordering a, partial_ordering b) noexcept {
+    return a.value_ == b.value_;
+  }
+  friend bool operator!=(partial_ordering a, partial_ordering b) noexcept {
+    return a.value_ != b.value_;
+  }
+
+ private:
+  static constexpr int8_t undef = 2;
+  int8_t value_ = undef;
+};
+
+} // namespace folly

package/external/folly/folly/lang/Pretty.h

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+
+#include <folly/Portability.h>
+#include <folly/lang/CArray.h>
+
+namespace folly {
+
+namespace detail {
+
+template <std::size_t S>
+using pretty_carray = c_array<char, S>;
+
+static constexpr char* pretty_carray_copy(
+    char* dest, const char* src, std::size_t n) {
+  for (std::size_t i = 0; i < n; ++i) {
+    dest[i] = src[i];
+  }
+  return dest + n;
+}
+
+template <std::size_t S>
+static constexpr pretty_carray<S> pretty_carray_from(char const (&in)[S]) {
+  pretty_carray<S> out{};
+  pretty_carray_copy(out.data, in, S);
+  return out;
+}
+
+struct pretty_info {
+  std::size_t b;
+  std::size_t e;
+};
+
+template <typename To, std::size_t S>
+static constexpr To pretty_info_to(pretty_info info, char const (&name)[S]) {
+  return To(name + info.b, info.e - info.b);
+}
+
+template <std::size_t S>
+static constexpr std::size_t pretty_lfind(
+    char const (&haystack)[S], char const needle) {
+  for (std::size_t i = 0; i < S - 1; ++i) {
+    if (haystack[i] == needle) {
+      return i;
+    }
+  }
+  return ~std::size_t(0);
+}
+
+template <std::size_t S>
+static constexpr std::size_t pretty_rfind(
+    char const (&haystack)[S], char const needle) {
+  for (std::size_t i = S; i != 0; --i) {
+    if (haystack[i - 1] == needle) {
+      return i - 1;
+    }
+  }
+  return ~std::size_t(0);
+}
+
+struct pretty_tag_msc {};
+struct pretty_tag_gcc {};
+
+using pretty_default_tag = std::conditional_t< //
+    kMscVer && !kIsClang,
+    pretty_tag_msc,
+    pretty_tag_gcc>;
+
+template <typename T>
+static constexpr auto pretty_raw(pretty_tag_msc) {
+#if defined(_MSC_VER) && !defined(__clang__)
+  return pretty_carray_from(__FUNCSIG__);
+#endif
+}
+
+template <typename T>
+static constexpr auto pretty_raw(pretty_tag_gcc) {
+#if defined(__GNUC__) || defined(__clang__)
+  return pretty_carray_from(__PRETTY_FUNCTION__);
+#endif
+}
+
+template <std::size_t S>
+static constexpr pretty_info pretty_parse(
+    pretty_tag_msc, char const (&name)[S]) {
+  //  void __cdecl folly::detail::pretty_raw<{...}>(
+  //      folly::detail::pretty_tag_msc)
+  auto const la = pretty_lfind(name, '<');
+  auto const rp = pretty_rfind(name, '>');
+  return pretty_info{la + 1, rp};
+}
+
+template <std::size_t S>
+static constexpr pretty_info pretty_parse(
+    pretty_tag_gcc, char const (&name)[S]) {
+  //  void folly::detail::pretty_raw(
+  //      folly::detail::pretty_tag_gcc) [T = {...}]
+  auto const eq = pretty_lfind(name, '=');
+  auto const br = pretty_rfind(name, ']');
+  return pretty_info{eq + 2, br};
+}
+
+template <typename T, typename Tag>
+struct pretty_name_zarray {
+  static constexpr auto raw_() {
+    constexpr auto const raw_ = pretty_raw<T>(Tag{});
+    return raw_;
+  }
+  static constexpr auto raw = raw_(); // indirection b/c of gcc-5.3 ice, gh#1105
+  static constexpr auto info = pretty_parse(Tag{}, raw.data);
+  static constexpr auto size = info.e - info.b;
+  static constexpr auto zarray_() {
+    pretty_carray<size + 1> data{};
+    pretty_carray_copy(data.data, raw.data + info.b, size);
+    data.data[size] = 0;
+    return data;
+  }
+  static constexpr pretty_carray<size + 1> zarray = zarray_();
+};
+
+template <typename T>
+constexpr const auto& pretty_name_carray() {
+  return detail::pretty_name_zarray<T, detail::pretty_default_tag>::zarray;
+}
+
+} // namespace detail
+
+//  pretty_name
+//
+//  Returns a statically-allocated C string containing the pretty name of T.
+//
+//  The pretty name of a type varies by compiler, may include tokens which
+//  would not be present in the type name as it is spelled in the source code
+//  or as it would be symbolized, and may not include tokens which would be
+//  present in the type name as it would be symbolized.
+template <typename T>
+constexpr char const* pretty_name() {
+  return detail::pretty_name_carray<T>().data;
+}
+
+} // namespace folly

package/external/folly/folly/lang/PropagateConst.h

@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include <folly/Traits.h>
+#include <folly/Utility.h>
+
+namespace folly {
+
+template <typename Pointer>
+class propagate_const;
+
+template <typename Pointer>
+constexpr Pointer& get_underlying(propagate_const<Pointer>& obj) {
+  return obj.pointer_;
+}
+
+template <typename Pointer>
+constexpr Pointer const& get_underlying(propagate_const<Pointer> const& obj) {
+  return obj.pointer_;
+}
+
+namespace detail {
+template <class Pointer>
+using is_propagate_const = is_instantiation_of<propagate_const, Pointer>;
+template <typename T>
+using is_decay_propagate_const = is_propagate_const<std::decay_t<T>>;
+
+namespace propagate_const_adl {
+using std::swap;
+template <typename T>
+auto adl_swap(T& a, T& b) noexcept(noexcept(swap(a, b)))
+    -> decltype(swap(a, b)) {
+  swap(a, b);
+}
+} // namespace propagate_const_adl
+} // namespace detail
+
+//  mimic: std::experimental::propagate_const, C++ Library Fundamentals TS v2
+template <typename Pointer>
+class propagate_const {
+ public:
+  using element_type =
+      std::remove_reference_t<decltype(*std::declval<Pointer&>())>;
+
+  constexpr propagate_const() = default;
+  constexpr propagate_const(propagate_const&&) = default;
+  propagate_const(propagate_const const&) = delete;
+
+  template <
+      typename OtherPointer,
+      std::enable_if_t<
+          std::is_constructible<Pointer, OtherPointer&&>::value &&
+              !std::is_convertible<OtherPointer&&, Pointer>::value,
+          int> = 0>
+  constexpr explicit propagate_const(propagate_const<OtherPointer>&& other)
+      : pointer_(static_cast<OtherPointer&&>(other.pointer_)) {}
+
+  template <
+      typename OtherPointer,
+      std::enable_if_t<
+          std::is_constructible<Pointer, OtherPointer&&>::value &&
+              std::is_convertible<OtherPointer&&, Pointer>::value,
+          int> = 0>
+  constexpr propagate_const(propagate_const<OtherPointer>&& other)
+      : pointer_(static_cast<OtherPointer&&>(other.pointer_)) {}
+
+  template <
+      typename OtherPointer,
+      std::enable_if_t<
+          !detail::is_decay_propagate_const<OtherPointer>::value &&
+              std::is_constructible<Pointer, OtherPointer&&>::value &&
+              !std::is_convertible<OtherPointer&&, Pointer>::value,
+          int> = 0>
+  constexpr explicit propagate_const(OtherPointer&& other)
+      : pointer_(static_cast<OtherPointer&&>(other)) {}
+
+  template <
+      typename OtherPointer,
+      std::enable_if_t<
+          !detail::is_decay_propagate_const<OtherPointer>::value &&
+              std::is_constructible<Pointer, OtherPointer&&>::value &&
+              std::is_convertible<OtherPointer&&, Pointer>::value,
+          int> = 0>
+  constexpr propagate_const(OtherPointer&& other)
+      : pointer_(static_cast<OtherPointer&&>(other)) {}
+
+  constexpr propagate_const& operator=(propagate_const&&) = default;
+  propagate_const& operator=(propagate_const const&) = delete;
+
+  template <
+      typename OtherPointer,
+      typename =
+          std::enable_if_t<std::is_convertible<OtherPointer&&, Pointer>::value>>
+  constexpr propagate_const& operator=(propagate_const<OtherPointer>&& other) {
+    pointer_ = static_cast<OtherPointer&&>(other.pointer_);
+  }
+
+  template <
+      typename OtherPointer,
+      typename = std::enable_if_t<
+          !detail::is_decay_propagate_const<OtherPointer>::value &&
+          std::is_convertible<OtherPointer&&, Pointer>::value>>
+  constexpr propagate_const& operator=(OtherPointer&& other) {
+    pointer_ = static_cast<OtherPointer&&>(other);
+    return *this;
+  }
+
+  constexpr void swap(propagate_const& other) noexcept(
+      noexcept(detail::propagate_const_adl::adl_swap(
+          std::declval<Pointer&>(), other.pointer_))) {
+    detail::propagate_const_adl::adl_swap(pointer_, other.pointer_);
+  }
+
+  constexpr element_type* get() { return get_(pointer_); }
+
+  constexpr element_type const* get() const { return get_(pointer_); }
+
+  constexpr explicit operator bool() const {
+    return static_cast<bool>(pointer_);
+  }
+
+  constexpr element_type& operator*() { return *get(); }
+
+  constexpr element_type const& operator*() const { return *get(); }
+
+  constexpr element_type* operator->() { return get(); }
+
+  constexpr element_type const* operator->() const { return get(); }
+
+  template <
+      typename OtherPointer = Pointer,
+      typename = std::enable_if_t<
+          std::is_pointer<OtherPointer>::value ||
+          std::is_convertible<OtherPointer, element_type*>::value>>
+  constexpr operator element_type*() {
+    return get();
+  }
+
+  template <
+      typename OtherPointer = Pointer,
+      typename = std::enable_if_t<
+          std::is_pointer<OtherPointer>::value ||
+          std::is_convertible<OtherPointer, element_type const*>::value>>
+  constexpr operator element_type const*() const {
+    return get();
+  }
+
+ private:
+  friend constexpr Pointer& get_underlying<>(propagate_const&);
+  friend constexpr Pointer const& get_underlying<>(propagate_const const&);
+  template <typename OtherPointer>
+  friend class propagate_const;
+
+  template <typename T>
+  constexpr static T* get_(T* t) {
+    return t;
+  }
+  template <typename T>
+  constexpr static auto get_(T& t) -> decltype(t.get()) {
+    return t.get();
+  }
+
+  Pointer pointer_;
+};
+
+template <typename Pointer>
+constexpr void swap(
+    propagate_const<Pointer>& a,
+    propagate_const<Pointer>& b) noexcept(noexcept(a.swap(b))) {
+  a.swap(b);
+}
+
+template <typename Pointer>
+constexpr bool operator==(propagate_const<Pointer> const& a, std::nullptr_t) {
+  return get_underlying(a) == nullptr;
+}
+
+template <typename Pointer>
+constexpr bool operator==(std::nullptr_t, propagate_const<Pointer> const& a) {
+  return nullptr == get_underlying(a);
+}
+
+template <typename Pointer>
+constexpr bool operator!=(propagate_const<Pointer> const& a, std::nullptr_t) {
+  return get_underlying(a) != nullptr;
+}
+
+template <typename Pointer>
+constexpr bool operator!=(std::nullptr_t, propagate_const<Pointer> const& a) {
+  return nullptr != get_underlying(a);
+}
+
+template <typename Pointer>
+constexpr bool operator==(
+    propagate_const<Pointer> const& a, propagate_const<Pointer> const& b) {
+  return get_underlying(a) == get_underlying(b);
+}
+
+template <typename Pointer>
+constexpr bool operator!=(
+    propagate_const<Pointer> const& a, propagate_const<Pointer> const& b) {
+  return get_underlying(a) != get_underlying(b);
+}
+
+template <typename Pointer>
+constexpr bool operator<(
+    propagate_const<Pointer> const& a, propagate_const<Pointer> const& b) {
+  return get_underlying(a) < get_underlying(b);
+}
+
+template <typename Pointer>
+constexpr bool operator<=(
+    propagate_const<Pointer> const& a, propagate_const<Pointer> const& b) {
+  return get_underlying(a) <= get_underlying(b);
+}
+
+template <typename Pointer>
+constexpr bool operator>(
+    propagate_const<Pointer> const& a, propagate_const<Pointer> const& b) {
+  return get_underlying(a) > get_underlying(b);
+}
+
+template <typename Pointer>
+constexpr bool operator>=(
+    propagate_const<Pointer> const& a, propagate_const<Pointer> const& b) {
+  return get_underlying(a) >= get_underlying(b);
+}
+
+//  Note: contrary to the specification, the heterogeneous comparison operators
+//  only participate in overload resolution when the equivalent heterogeneous
+//  comparison operators on the underlying pointers, as returned by invocation
+//  of get_underlying, would also participate in overload resolution.
+
+template <typename Pointer, typename Other>
+constexpr auto operator==(propagate_const<Pointer> const& a, Other const& b)
+    -> decltype(get_underlying(a) == b, false) {
+  return get_underlying(a) == b;
+}
+
+template <typename Pointer, typename Other>
+constexpr auto operator!=(propagate_const<Pointer> const& a, Other const& b)
+    -> decltype(get_underlying(a) != b, false) {
+  return get_underlying(a) != b;
+}
+
+template <typename Pointer, typename Other>
+constexpr auto operator<(propagate_const<Pointer> const& a, Other const& b)
+    -> decltype(get_underlying(a) < b, false) {
+  return get_underlying(a) < b;
+}
+
+template <typename Pointer, typename Other>
+constexpr auto operator<=(propagate_const<Pointer> const& a, Other const& b)
+    -> decltype(get_underlying(a) <= b, false) {
+  return get_underlying(a) <= b;
+}
+
+template <typename Pointer, typename Other>
+constexpr auto operator>(propagate_const<Pointer> const& a, Other const& b)
+    -> decltype(get_underlying(a) > b, false) {
+  return get_underlying(a) > b;
+}
+
+template <typename Pointer, typename Other>
+constexpr auto operator>=(propagate_const<Pointer> const& a, Other const& b)
+    -> decltype(get_underlying(a) >= b, false) {
+  return get_underlying(a) >= b;
+}
+
+template <typename Other, typename Pointer>
+constexpr auto operator==(Other const& a, propagate_const<Pointer> const& b)
+    -> decltype(a == get_underlying(b), false) {
+  return a == get_underlying(b);
+}
+
+template <typename Other, typename Pointer>
+constexpr auto operator!=(Other const& a, propagate_const<Pointer> const& b)
+    -> decltype(a != get_underlying(b), false) {
+  return a != get_underlying(b);
+}
+
+template <typename Other, typename Pointer>
+constexpr auto operator<(Other const& a, propagate_const<Pointer> const& b)
+    -> decltype(a < get_underlying(b), false) {
+  return a < get_underlying(b);
+}
+
+template <typename Other, typename Pointer>
+constexpr auto operator<=(Other const& a, propagate_const<Pointer> const& b)
+    -> decltype(a <= get_underlying(b), false) {
+  return a <= get_underlying(b);
+}
+
+template <typename Other, typename Pointer>
+constexpr auto operator>(Other const& a, propagate_const<Pointer> const& b)
+    -> decltype(a > get_underlying(b), false) {
+  return a > get_underlying(b);
+}
+
+template <typename Other, typename Pointer>
+constexpr auto operator>=(Other const& a, propagate_const<Pointer> const& b)
+    -> decltype(a >= get_underlying(b), false) {
+  return a >= get_underlying(b);
+}
+
+} // namespace folly
+
+namespace std {
+
+template <typename Pointer>
+struct hash<folly::propagate_const<Pointer>> : private hash<Pointer> {
+  using hash<Pointer>::hash;
+
+  size_t operator()(folly::propagate_const<Pointer> const& obj) const {
+    return hash<Pointer>::operator()(folly::get_underlying(obj));
+  }
+};
+
+template <typename Pointer>
+struct equal_to<folly::propagate_const<Pointer>> : private equal_to<Pointer> {
+  using equal_to<Pointer>::equal_to;
+
+  constexpr bool operator()(
+      folly::propagate_const<Pointer> const& a,
+      folly::propagate_const<Pointer> const& b) {
+    return equal_to<Pointer>::operator()(
+        folly::get_underlying(a), folly::get_underlying(b));
+  }
+};
+
+template <typename Pointer>
+struct not_equal_to<folly::propagate_const<Pointer>>
+    : private not_equal_to<Pointer> {
+  using not_equal_to<Pointer>::not_equal_to;
+
+  constexpr bool operator()(
+      folly::propagate_const<Pointer> const& a,
+      folly::propagate_const<Pointer> const& b) {
+    return not_equal_to<Pointer>::operator()(
+        folly::get_underlying(a), folly::get_underlying(b));
+  }
+};
+
+template <typename Pointer>
+struct less<folly::propagate_const<Pointer>> : private less<Pointer> {
+  using less<Pointer>::less;
+
+  constexpr bool operator()(
+      folly::propagate_const<Pointer> const& a,
+      folly::propagate_const<Pointer> const& b) {
+    return less<Pointer>::operator()(
+        folly::get_underlying(a), folly::get_underlying(b));
+  }
+};
+
+template <typename Pointer>
+struct greater<folly::propagate_const<Pointer>> : private greater<Pointer> {
+  using greater<Pointer>::greater;
+
+  constexpr bool operator()(
+      folly::propagate_const<Pointer> const& a,
+      folly::propagate_const<Pointer> const& b) {
+    return greater<Pointer>::operator()(
+        folly::get_underlying(a), folly::get_underlying(b));
+  }
+};
+
+template <typename Pointer>
+struct less_equal<folly::propagate_const<Pointer>>
+    : private less_equal<Pointer> {
+  using less_equal<Pointer>::less_equal;
+
+  constexpr bool operator()(
+      folly::propagate_const<Pointer> const& a,
+      folly::propagate_const<Pointer> const& b) {
+    return less_equal<Pointer>::operator()(
+        folly::get_underlying(a), folly::get_underlying(b));
+  }
+};
+
+template <typename Pointer>
+struct greater_equal<folly::propagate_const<Pointer>>
+    : private greater_equal<Pointer> {
+  using greater_equal<Pointer>::greater_equal;
+
+  constexpr bool operator()(
+      folly::propagate_const<Pointer> const& a,
+      folly::propagate_const<Pointer> const& b) {
+    return greater_equal<Pointer>::operator()(
+        folly::get_underlying(a), folly::get_underlying(b));
+  }
+};
+
+} // namespace std