react-native-windows 0.81.34 → 0.81.36

package/external/folly/folly/container/HeterogeneousAccess.h

@@ -0,0 +1,171 @@
+/*
+ * 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 <string>
+#include <string_view>
+
+#include <folly/Range.h>
+#include <folly/Traits.h>
+#include <folly/container/HeterogeneousAccess-fwd.h>
+#include <folly/hash/Hash.h>
+
+namespace folly {
+
+// folly::HeterogeneousAccessEqualTo<T>, and
+// folly::HeterogeneousAccessHash<T> are functors suitable as defaults
+// for containers that support heterogeneous access.  When possible, they
+// will be marked as transparent.  When no transparent implementation
+// is available then they fall back to std::equal_to and std::hash
+// respectively.  Since the fallbacks are not marked as transparent,
+// heterogeneous lookup won't be available in that case.  A corresponding
+// HeterogeneousAccessLess<T> could be easily added if desired.
+//
+// If T can be implicitly converted to a StringPiece or
+// to a Range<T::value_type const*> that is hashable, then
+// HeterogeneousAccess{EqualTo,Hash}<T> will be transparent without any
+// additional work.  In practice this is true for T that can be convered to
+// StringPiece or Range<IntegralType const*>.  This includes std::string,
+// std::string_view (when available), std::array, folly::Range,
+// std::vector, and folly::small_vector.
+//
+// Additional specializations of HeterogeneousAccess*<T> should go in
+// the header that declares T.  Don't forget to typedef is_transparent to
+// void and folly_is_avalanching to std::true_type in the specializations.
+
+template <typename T, typename Enable>
+struct HeterogeneousAccessEqualTo : std::equal_to<T> {};
+
+template <typename T, typename Enable>
+struct HeterogeneousAccessHash : std::hash<T> {
+  using folly_is_avalanching = IsAvalanchingHasher<std::hash<T>, T>;
+};
+
+//////// strings
+
+namespace detail {
+
+template <typename T, typename Enable = void>
+struct ValueTypeForTransparentConversionToRange {
+  using type = char;
+};
+
+// We assume that folly::hasher<folly::Range<T const*>> won't be enabled
+// when it would be lower quality than std::hash<U> for a U that is
+// convertible to folly::Range<T const*>.
+template <typename T>
+struct ValueTypeForTransparentConversionToRange<
+    T,
+    void_t<
+        decltype(std::declval<hasher<Range<typename T::value_type const*>>>()(
+            std::declval<Range<typename T::value_type const*>>()))>> {
+  using type = std::remove_const_t<typename T::value_type>;
+};
+
+template <typename T>
+using TransparentlyConvertibleToRange = std::is_convertible<
+    T,
+    Range<typename ValueTypeForTransparentConversionToRange<T>::type const*>>;
+
+template <typename T>
+struct TransparentRangeEqualTo {
+  using is_transparent = void;
+
+  template <typename U1, typename U2>
+  bool operator()(U1 const& lhs, U2 const& rhs) const {
+    return Range<T const*>{lhs} == Range<T const*>{rhs};
+  }
+
+  // This overload is not required for functionality, but
+  // guarantees that replacing std::equal_to<std::string> with
+  // HeterogeneousAccessEqualTo<std::string> is truly zero overhead
+  bool operator()(std::string const& lhs, std::string const& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template <typename T>
+struct TransparentRangeHash {
+  using is_transparent = void;
+  using folly_is_avalanching = std::true_type;
+
+  template <typename U>
+  std::size_t operator()(U const& stringish) const {
+    return hasher<Range<T const*>>{}(Range<T const*>{stringish});
+  }
+};
+
+template <>
+struct TransparentRangeHash<char> {
+  using is_transparent = void;
+  using folly_is_avalanching = std::true_type;
+
+  // Implementing this in terms of std::hash<std::string_view> guarantees that
+  // replacing std::hash<std::string> with HeterogeneousAccessHash<std::string>
+  // is actually zero overhead in the case that the underlying implementations
+  // make different optimality tradeoffs (short versus long string performance,
+  // for example). We use hash::stdCompatibleHash here as an alternative
+  // compatible implementation of std::hash.
+  // If folly::hasher<std::string_view> dominated the performance
+  // of std::hash<std::string> then we should consider using it all of the time.
+  template <typename U>
+  std::size_t operator()(U const& stringish) const {
+    return hash::stdCompatibleHash(StringPiece{stringish});
+  }
+};
+
+template <
+    typename TableKey,
+    typename Hasher,
+    typename KeyEqual,
+    typename ArgKey>
+struct EligibleForHeterogeneousFind
+    : Conjunction<
+          is_transparent<Hasher>,
+          is_transparent<KeyEqual>,
+          is_invocable<Hasher, ArgKey const&>,
+          is_invocable<KeyEqual, ArgKey const&, TableKey const&>> {};
+
+template <
+    typename TableKey,
+    typename Hasher,
+    typename KeyEqual,
+    typename ArgKey>
+using EligibleForHeterogeneousInsert = Conjunction<
+    EligibleForHeterogeneousFind<TableKey, Hasher, KeyEqual, ArgKey>,
+    std::is_constructible<TableKey, ArgKey>>;
+
+} // namespace detail
+
+template <typename T>
+struct HeterogeneousAccessEqualTo<
+    T,
+    std::enable_if_t<detail::TransparentlyConvertibleToRange<T>::value>>
+    : detail::TransparentRangeEqualTo<
+          typename detail::ValueTypeForTransparentConversionToRange<T>::type> {
+};
+
+template <typename T>
+struct HeterogeneousAccessHash<
+    T,
+    std::enable_if_t<detail::TransparentlyConvertibleToRange<T>::value>>
+    : detail::TransparentRangeHash<
+          typename detail::ValueTypeForTransparentConversionToRange<T>::type> {
+};
+
+} // namespace folly

package/external/folly/folly/container/IntrusiveHeap.h

@@ -0,0 +1,268 @@
+/*
+ * 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.
+ */
+
+/**
+ * Skew heap [1] implementation using top-down meld.
+ *
+ * [1] D.D. Sleator, R.E. Tarjan, Self-Adjusting Heaps,
+ * SIAM Journal of Computing, 15(1): 52-69, 1986.
+ * http://www.cs.cmu.edu/~sleator/papers/adjusting-heaps.pdf
+ */
+
+#pragma once
+
+#include <functional>
+#include <utility>
+
+#include <boost/intrusive/parent_from_member.hpp>
+#include <boost/noncopyable.hpp>
+#include <glog/logging.h>
+#include <folly/Portability.h>
+
+namespace folly {
+
+/**
+ * Base class for items to be inserted into IntrusiveHeap<..., Tag> storing
+ * pointers for internal use.
+ */
+template <class Tag = void>
+class IntrusiveHeapNode : private boost::noncopyable {
+ public:
+  bool isLinked() const { return parent_ != kUnlinked; }
+
+ private:
+  template <class, class, class, class>
+  friend class IntrusiveHeap;
+  friend class IntrusiveHeapTest;
+
+  static IntrusiveHeapNode* const kUnlinked;
+
+  /**
+   * If this is in a heap, (parent_ == nullptr) <=> (this == heap_.root_).
+   * Otherwise, parent_ is kUnlinked.
+   */
+  IntrusiveHeapNode* parent_ = kUnlinked;
+
+  /**
+   * If this is in a heap, left_ and right_ point to subheaps or nullptr.
+   * Otherwise, these are undefined.
+   */
+  IntrusiveHeapNode* left_;
+  IntrusiveHeapNode* right_;
+};
+
+template <class Tag>
+IntrusiveHeapNode<Tag>* const IntrusiveHeapNode<Tag>::kUnlinked =
+    reinterpret_cast<IntrusiveHeapNode*>(1);
+
+template <class T, class Tag>
+struct DerivedNodeTraits {
+  static IntrusiveHeapNode<Tag>* asNode(T* x) { return x; }
+  static T* asT(IntrusiveHeapNode<Tag>* n) { return static_cast<T*>(n); }
+};
+
+template <class T, class Tag, IntrusiveHeapNode<Tag> T::*PtrToMember>
+struct MemberNodeTraits {
+  static IntrusiveHeapNode<Tag>* asNode(T* x) { return &(x->*PtrToMember); }
+  static T* asT(IntrusiveHeapNode<Tag>* n) {
+    return boost::intrusive::get_parent_from_member(n, PtrToMember);
+  }
+};
+
+/**
+ * IntrusiveHeap implements a skew heap with intrusive pointers to provide
+ * O(log(n)) operations on any node in the heap with no separately allocated
+ * node type.
+ *
+ * - To be inserted into an IntrusiveHeap<T, Compare, Tag>, T must inherit from
+ *   IntrusiveHeapNode<Tag>, or have a member of type IntrusiveHeapNode<Tag> and
+ *   use MemberNodeTraits.
+ *
+ * - An instance of T may only be included in one IntrusiveHeap for each Tag
+ *   type. It may be included in more than one IntrusiveHeap by inheriting from
+ *   IntrusiveHeapNode again with a different tag type, or by using composition
+ *   with different members.
+ */
+template <
+    class T,
+    class Compare = std::less<>,
+    class Tag = void,
+    class NodeTraitsType = DerivedNodeTraits<T, Tag>>
+class IntrusiveHeap {
+ public:
+  using Node = IntrusiveHeapNode<Tag>;
+  using NodeTraits = NodeTraitsType;
+  using Value = T;
+
+  IntrusiveHeap() {}
+
+  IntrusiveHeap(const IntrusiveHeap&) = delete;
+  IntrusiveHeap& operator=(const IntrusiveHeap&) = delete;
+
+  IntrusiveHeap(IntrusiveHeap&& other) noexcept
+      : root_(std::exchange(other.root_, nullptr)) {}
+  IntrusiveHeap& operator=(IntrusiveHeap&&) = delete;
+
+  /**
+   * Returns a pointer to the maximum value in the heap, or nullptr if the heap
+   * is empty.
+   */
+  T* top() const { return root_ != nullptr ? asT(root_) : nullptr; }
+
+  bool empty() const { return root_ == nullptr; }
+
+  /**
+   * Removes the maximum value from the heap and returns it, or nullptr if the
+   * heap is empty.
+   */
+  T* pop() {
+    if (root_ == nullptr) {
+      return nullptr;
+    }
+    Node* top = root_;
+    merge(top->left_, top->right_, nullptr, &root_);
+    top->parent_ = Node::kUnlinked;
+    return asT(top);
+  }
+
+  /**
+   * Visits all items in the heap.
+   */
+  template <class Visitor>
+  void visit(const Visitor& visitor) const {
+    visit(visitor, root_);
+  }
+
+  /**
+   * Updates the heap to reflect a change in a given value.
+   */
+  void update(T* x) {
+    erase(x);
+    push(x);
+  }
+
+  void push(T* x) {
+    DCHECK(x);
+    auto n = asNode(x);
+    DCHECK(!n->isLinked());
+    n->parent_ = nullptr;
+    n->left_ = nullptr;
+    n->right_ = nullptr;
+    merge(n, root_, nullptr, &root_);
+  }
+
+  void erase(T* x) {
+    auto n = asNode(x);
+    DCHECK(n->isLinked());
+    DCHECK(contains(x));
+    auto parent = n->parent_;
+    Node** out;
+    if (parent == nullptr) {
+      out = &root_;
+    } else if (parent->left_ == n) {
+      out = &parent->left_;
+    } else {
+      DCHECK_EQ(parent->right_, n);
+      out = &parent->right_;
+    }
+
+    merge(n->left_, n->right_, parent, out);
+    n->parent_ = Node::kUnlinked;
+  }
+
+  /**
+   * Check whether this node is included in this heap. Primarily meant for
+   * assertions, as containment should be externally tracked.
+   */
+  bool contains(const T* x) const {
+    DCHECK(x);
+    auto n = asNode(x);
+    while (n->parent_) {
+      n = n->parent_;
+    }
+    return n == root_;
+  }
+
+  /**
+   * Moves the contents of other into *this.
+   */
+  void merge(IntrusiveHeap other) {
+    merge(root_, other.root_, nullptr, &root_);
+  }
+
+ private:
+  friend class IntrusiveHeapTest;
+
+  template <class Visitor>
+  static void visit(const Visitor& visitor, Node* x) {
+    for (; x != nullptr; x = x->right_) {
+      visitor(asT(x));
+      visit(visitor, x->left_);
+    }
+  }
+
+  /**
+   * Merges two subtrees, assigns a parent, populates *out with new subtree.
+   */
+  FOLLY_ALWAYS_INLINE static void merge(
+      Node* a, Node* b, Node* parent, Node** out) {
+    DCHECK(out);
+    if (a == nullptr || b == nullptr) {
+      *out = a ? a : b;
+      if (*out) {
+        (*out)->parent_ = parent;
+      }
+      return;
+    }
+    do {
+      Node* grandparent = parent;
+      if (compare(a, b)) {
+        parent = b;
+      } else {
+        parent = a;
+        a = b;
+      }
+      b = parent->right_;
+      *out = parent;
+      out = &parent->left_;
+      parent->right_ = parent->left_;
+      parent->parent_ = grandparent;
+      DCHECK(a);
+    } while (b != nullptr);
+    *out = a;
+    a->parent_ = parent;
+  }
+
+  static Node* asNode(T* x) { return NodeTraits::asNode(x); }
+
+  static const Node* asNode(const T* x) {
+    return NodeTraits::asNode(const_cast<T*>(x));
+  }
+
+  static T* asT(Node* n) { return NodeTraits::asT(n); }
+
+  static const T* asT(const Node* n) {
+    return NodeTraits::asT(const_cast<Node*>(n));
+  }
+
+  static bool compare(const Node* a, const Node* b) {
+    return Compare()(*asT(a), *asT(b));
+  }
+
+  Node* root_ = nullptr;
+};
+
+} // namespace folly

package/external/folly/folly/container/IntrusiveList.h

@@ -0,0 +1,131 @@
+/*
+ * 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
+
+/*
+ * This file contains convenience aliases that make boost::intrusive::list
+ * easier to use.
+ */
+
+#include <boost/intrusive/list.hpp>
+
+namespace folly {
+
+/**
+ * An auto-unlink intrusive list hook.
+ */
+using IntrusiveListHook = boost::intrusive::list_member_hook<
+    boost::intrusive::link_mode<boost::intrusive::auto_unlink>>;
+
+/**
+ * An intrusive list.
+ *
+ * An IntrusiveList always uses an auto-unlink hook.
+ * Beware that IntrusiveList::size() is an O(n) operation, since it has to walk
+ * the entire list.
+ *
+ * Example usage:
+ *
+ *   class Foo {
+ *     // Note that the listHook member variable needs to be visible
+ *     // to the code that defines the IntrusiveList instantiation.
+ *     // The list hook can be made public, or you can make the other class a
+ *     // friend.
+ *     IntrusiveListHook listHook;
+ *   };
+ *
+ *   using FooList = IntrusiveList<Foo, &Foo::listHook>;
+ *
+ *   Foo *foo = new Foo();
+ *   FooList myList;
+ *   myList.push_back(*foo);
+ *
+ * Note that each IntrusiveListHook can only be part of a single list at any
+ * given time.  If you need the same object to be stored in two lists at once,
+ * you need to use two different IntrusiveListHook member variables.
+ *
+ * The elements stored in the list must contain an IntrusiveListHook member
+ * variable.
+ */
+template <typename T, IntrusiveListHook T::*PtrToMember>
+using IntrusiveList = boost::intrusive::list<
+    T,
+    boost::intrusive::member_hook<T, IntrusiveListHook, PtrToMember>,
+    boost::intrusive::constant_time_size<false>>;
+
+/**
+ * A safe-link intrusive list hook.
+ */
+using SafeIntrusiveListHook = boost::intrusive::list_member_hook<
+    boost::intrusive::link_mode<boost::intrusive::safe_link>>;
+
+/**
+ * A safe intrusive list.
+ *
+ * This is like IntrusiveList but always uses the safe-link hook which ensures
+ * that the hook is initialised to an unlinked state on construction and reset
+ * an unlinked state upon removing it from a list.
+ */
+template <typename T, SafeIntrusiveListHook T::*PtrToMember>
+using SafeIntrusiveList = boost::intrusive::list<
+    T,
+    boost::intrusive::member_hook<T, SafeIntrusiveListHook, PtrToMember>,
+    boost::intrusive::constant_time_size<false>>;
+
+/**
+ * An intrusive list with const-time size() method.
+ *
+ * A CountedIntrusiveList always uses a safe-link hook.
+ * CountedIntrusiveList::size() is an O(1) operation. Users of this type
+ * of lists need to remove a member from a list by calling one of the
+ * methods on the list (e.g., erase(), pop_front(), etc.), rather than
+ * calling unlink on the member's list hook. Given references to a
+ * list and a member, a constant-time removal operation can be
+ * accomplished by list.erase(list.iterator_to(member)). Also, when a
+ * member is destroyed, it is NOT automatically removed from the list.
+ *
+ * Example usage:
+ *
+ *   class Foo {
+ *     // Note that the listHook member variable needs to be visible
+ *     // to the code that defines the CountedIntrusiveList instantiation.
+ *     // The list hook can be made public, or you can make the other class a
+ *     // friend.
+ *     SafeIntrusiveListHook listHook;
+ *   };
+ *
+ *   using FooList = CountedIntrusiveList<Foo, &Foo::listHook> FooList;
+ *
+ *   Foo *foo = new Foo();
+ *   FooList myList;
+ *   myList.push_back(*foo);
+ *   myList.pop_front();
+ *
+ * Note that each SafeIntrusiveListHook can only be part of a single list at any
+ * given time.  If you need the same object to be stored in two lists at once,
+ * you need to use two different SafeIntrusiveListHook member variables.
+ *
+ * The elements stored in the list must contain an SafeIntrusiveListHook member
+ * variable.
+ */
+template <typename T, SafeIntrusiveListHook T::*PtrToMember>
+using CountedIntrusiveList = boost::intrusive::list<
+    T,
+    boost::intrusive::member_hook<T, SafeIntrusiveListHook, PtrToMember>,
+    boost::intrusive::constant_time_size<true>>;
+
+} // namespace folly