react-native-windows 0.84.0 → 0.84.1

package/external/folly/folly/container/detail/Util.h

@@ -0,0 +1,303 @@
+/*
+ * 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 <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <folly/Traits.h>
+#include <folly/container/Iterator.h>
+#include <folly/functional/ApplyTuple.h>
+
+// Utility functions for container implementors
+
+namespace folly {
+namespace detail {
+
+template <typename KeyType, typename Alloc>
+struct TemporaryEmplaceKey {
+  TemporaryEmplaceKey(TemporaryEmplaceKey const&) = delete;
+  TemporaryEmplaceKey(TemporaryEmplaceKey&&) = delete;
+
+  template <typename... Args>
+  TemporaryEmplaceKey(Alloc& a, std::tuple<Args...>&& args) : alloc_(a) {
+    auto p = &value();
+    apply(
+        [&, p](auto&&... inner) {
+          std::allocator_traits<Alloc>::construct(
+              alloc_, p, std::forward<decltype(inner)>(inner)...);
+        },
+        std::move(args));
+  }
+
+  ~TemporaryEmplaceKey() {
+    std::allocator_traits<Alloc>::destroy(alloc_, &value());
+  }
+
+  KeyType& value() { return *static_cast<KeyType*>(static_cast<void*>(&raw_)); }
+
+  Alloc& alloc_;
+  folly::aligned_storage_for_t<KeyType> raw_;
+};
+
+// A map's emplace(args...) function takes arguments that can be used to
+// construct a pair<key_type const, mapped_type>, but that construction
+// only needs to take place if the key is not present in the container.
+// callWithExtractedKey helps to handle this efficiently by looking for a
+// reference to the key within the args list.  If the search is successful
+// then the search can be performed without constructing any temporaries.
+// If the search is not successful then callWithExtractedKey constructs
+// a temporary key_type and a new argument list suitable for constructing
+// the entire value_type if necessary.
+//
+// callWithExtractedKey(a, f, args...) will call f(k, args'...), where
+// k is the key and args'... is an argument list that can be used to
+// construct a pair of key and mapped value.  Note that this means f gets
+// the key twice.
+//
+// In some cases a temporary key must be constructed.  This is accomplished
+// with std::allocator_traits<>::construct, and the temporary will be
+// destroyed with std::allocator_traits<>::destroy.  Using the allocator's
+// construct method reduces unnecessary copies for pmr allocators.
+//
+// callWithExtractedKey supports heterogeneous lookup with the UsableAsKey
+// template parameter.  If a single key argument of type K is found in
+// args... then it will be passed directly to f if it is either KeyType or
+// if UsableAsKey<remove_cvref_t<K>>::value is true.  If you don't care
+// about heterogeneous lookup you can just pass a single-arg template
+// that extends std::false_type.
+
+// TODO(T31574848): We can remove the std::enable_if_t once we no longer
+// target platforms without N4387 ("perfect initialization" for pairs
+// and tuples).  libstdc++ at gcc-6.1.0 is the first release that contains
+// the improved set of pair constructors.
+template <
+    typename KeyType,
+    typename MappedType,
+    typename Func,
+    typename UsableKeyType,
+    typename Arg1,
+    typename Arg2,
+    std::enable_if_t<
+        std::is_constructible<
+            std::pair<KeyType const, MappedType>,
+            Arg1&&,
+            Arg2&&>::value,
+        int> = 0>
+auto callWithKeyAndPairArgs(
+    Func&& f,
+    UsableKeyType const& key,
+    std::tuple<Arg1>&& first_args,
+    std::tuple<Arg2>&& second_args) {
+  return f(
+      key,
+      std::forward<Arg1>(std::get<0>(first_args)),
+      std::forward<Arg2>(std::get<0>(second_args)));
+}
+
+template <
+    typename KeyType,
+    typename MappedType,
+    typename Func,
+    typename UsableKeyType,
+    typename... Args1,
+    typename... Args2>
+auto callWithKeyAndPairArgs(
+    Func&& f,
+    UsableKeyType const& key,
+    std::tuple<Args1...>&& first_args,
+    std::tuple<Args2...>&& second_args) {
+  return f(
+      key,
+      std::piecewise_construct,
+      std::move(first_args),
+      std::move(second_args));
+}
+
+template <typename>
+using ExactKeyMatchOnly = std::false_type;
+
+template <
+    typename KeyType,
+    typename MappedType,
+    template <typename> class UsableAsKey = ExactKeyMatchOnly,
+    typename Alloc,
+    typename Func,
+    typename Arg1,
+    typename... Args2,
+    std::enable_if_t<
+        std::is_same<remove_cvref_t<Arg1>, KeyType>::value ||
+            UsableAsKey<remove_cvref_t<Arg1>>::value,
+        int> = 0>
+auto callWithExtractedKey(
+    Alloc&,
+    Func&& f,
+    std::piecewise_construct_t,
+    std::tuple<Arg1>&& first_args,
+    std::tuple<Args2...>&& second_args) {
+  // we found a usable key in the args :)
+  auto const& key = std::get<0>(first_args);
+  return callWithKeyAndPairArgs<KeyType, MappedType>(
+      std::forward<Func>(f),
+      key,
+      std::tuple<Arg1&&>(std::move(first_args)),
+      std::tuple<Args2&&...>(std::move(second_args)));
+}
+
+template <
+    typename KeyType,
+    typename MappedType,
+    template <typename> class UsableAsKey = ExactKeyMatchOnly,
+    typename Alloc,
+    typename Func,
+    typename... Args1,
+    typename... Args2>
+auto callWithExtractedKey(
+    Alloc& a,
+    Func&& f,
+    std::piecewise_construct_t,
+    std::tuple<Args1...>&& first_args,
+    std::tuple<Args2...>&& second_args) {
+  // we will need to materialize a temporary key :(
+  TemporaryEmplaceKey<KeyType, Alloc> key(
+      a, std::tuple<Args1&&...>(std::move(first_args)));
+  return callWithKeyAndPairArgs<KeyType, MappedType>(
+      std::forward<Func>(f),
+      const_cast<KeyType const&>(key.value()),
+      std::forward_as_tuple(std::move(key.value())),
+      std::tuple<Args2&&...>(std::move(second_args)));
+}
+
+template <
+    typename KeyType,
+    typename MappedType,
+    template <typename> class UsableAsKey = ExactKeyMatchOnly,
+    typename Alloc,
+    typename Func>
+auto callWithExtractedKey(Alloc& a, Func&& f) {
+  return callWithExtractedKey<KeyType, MappedType, UsableAsKey>(
+      a,
+      std::forward<Func>(f),
+      std::piecewise_construct,
+      std::tuple<>{},
+      std::tuple<>{});
+}
+
+template <
+    typename KeyType,
+    typename MappedType,
+    template <typename> class UsableAsKey = ExactKeyMatchOnly,
+    typename Alloc,
+    typename Func,
+    typename U1,
+    typename U2>
+auto callWithExtractedKey(Alloc& a, Func&& f, U1&& x, U2&& y) {
+  return callWithExtractedKey<KeyType, MappedType, UsableAsKey>(
+      a,
+      std::forward<Func>(f),
+      std::piecewise_construct,
+      std::forward_as_tuple(std::forward<U1>(x)),
+      std::forward_as_tuple(std::forward<U2>(y)));
+}
+
+template <
+    typename KeyType,
+    typename MappedType,
+    template <typename> class UsableAsKey = ExactKeyMatchOnly,
+    typename Alloc,
+    typename Func,
+    typename U1,
+    typename U2>
+auto callWithExtractedKey(Alloc& a, Func&& f, std::pair<U1, U2> const& p) {
+  return callWithExtractedKey<KeyType, MappedType, UsableAsKey>(
+      a,
+      std::forward<Func>(f),
+      std::piecewise_construct,
+      std::forward_as_tuple(p.first),
+      std::forward_as_tuple(p.second));
+}
+
+template <
+    typename KeyType,
+    typename MappedType,
+    template <typename> class UsableAsKey = ExactKeyMatchOnly,
+    typename Alloc,
+    typename Func,
+    typename U1,
+    typename U2>
+auto callWithExtractedKey(Alloc& a, Func&& f, std::pair<U1, U2>&& p) {
+  // std::move(p.first) is wrong because if U1 is an lvalue reference the
+  // result will incorrectly be an rvalue ref.  static_cast here allows
+  // proper ref collapsing
+  return callWithExtractedKey<KeyType, MappedType, UsableAsKey>(
+      a,
+      std::forward<Func>(f),
+      std::piecewise_construct,
+      std::forward_as_tuple(static_cast<U1&&>(p.first)),
+      std::forward_as_tuple(static_cast<U2&&>(p.second)));
+}
+
+// callWithConstructedKey is the set container analogue of
+// callWithExtractedKey
+
+template <
+    typename KeyType,
+    template <typename> class UsableAsKey = ExactKeyMatchOnly,
+    typename Alloc,
+    typename Func,
+    typename Arg,
+    std::enable_if_t<
+        std::is_same<remove_cvref_t<Arg>, KeyType>::value ||
+            UsableAsKey<remove_cvref_t<Arg>>::value,
+        int> = 0>
+auto callWithConstructedKey(Alloc&, Func&& f, Arg&& arg) {
+  // we found a usable key in the args :)
+  auto const& key = arg;
+  return f(key, std::forward<Arg>(arg));
+}
+
+template <
+    typename KeyType,
+    template <typename> class UsableAsKey = ExactKeyMatchOnly,
+    typename Alloc,
+    typename Func,
+    typename... Args>
+auto callWithConstructedKey(Alloc& a, Func&& f, Args&&... args) {
+  // we will need to materialize a temporary key :(
+  TemporaryEmplaceKey<KeyType, Alloc> key(
+      a, std::forward_as_tuple(std::forward<Args>(args)...));
+  return f(const_cast<KeyType const&>(key.value()), std::move(key.value()));
+}
+
+// Traits to simplify deduction guides implementation for containers.
+
+// SFINAE constraint to test whether a type is an allocator according to
+// is_allocator trait.
+template <typename T>
+using RequireAllocator = std::enable_if_t<is_allocator_v<T>, T>;
+
+template <typename T>
+using RequireNotAllocator = std::enable_if_t<!is_allocator_v<T>, T>;
+
+template <typename T>
+using RequireInputIterator =
+    std::enable_if_t<iterator_category_matches_v<T, std::input_iterator_tag>>;
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/container/detail/tape_detail.h

@@ -0,0 +1,135 @@
+/*
+ * 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 <folly/Portability.h>
+#include <folly/Range.h>
+#include <folly/container/Iterator.h>
+#include <folly/container/range_traits.h>
+#include <folly/lang/Hint.h>
+#include <folly/memory/UninitializedMemoryHacks.h>
+
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace folly {
+namespace detail {
+
+template <typename Container, bool = is_contiguous_range_v<Container>>
+struct tape_reference_traits {
+  using iterator = typename Container::const_iterator;
+  using reference = Range<iterator>;
+
+  static constexpr reference make(iterator f, iterator l) {
+    return reference{f, l};
+  }
+};
+
+template <typename Container>
+struct tape_reference_traits<Container, true> {
+  using iterator = typename Container::const_iterator;
+  using value_type = typename std::iterator_traits<iterator>::value_type;
+  using reference = Range<const value_type*>;
+
+  static constexpr auto* get_address(iterator it) {
+    // std::to_address is only available since C++20
+    if constexpr (std::is_pointer_v<iterator>) {
+      return it;
+    } else {
+      return it.operator->();
+    }
+  }
+
+  static constexpr reference make(iterator f, iterator l) {
+    return reference{get_address(f), get_address(l)};
+  }
+};
+
+template <typename R>
+using get_range_const_iterator_t =
+    decltype(std::cbegin(std::declval<const R&>()));
+
+struct fake_type {};
+
+template <typename R>
+using maybe_range_const_iterator_t =
+    detected_or_t<fake_type*, get_range_const_iterator_t, R>;
+
+template <typename R>
+using maybe_range_value_t =
+    iterator_value_type_t<maybe_range_const_iterator_t<R>>;
+
+// This is a big function to inline but it's used insie a big function too
+template <typename I, typename S>
+auto compute_total_tape_len_if_possible(I f, S l) {
+  using success = std::pair<std::size_t, std::size_t>;
+  using failure = fake_type;
+  if constexpr (!iterator_category_matches_v<I, std::forward_iterator_tag>) {
+    return failure{};
+  }
+  // We have to special case StringPiece to special case `const char*` and
+  // `char[]`
+  else if constexpr (std::is_convertible_v<
+                         iterator_value_type_t<I>,
+                         folly::StringPiece>) {
+    std::size_t records_size = 0U;
+    std::size_t flat_size = 0U;
+
+    for (I i = f; i != l; ++i) {
+      ++records_size;
+      flat_size += folly::StringPiece(*i).size();
+    }
+    return success{records_size, flat_size};
+  } else if constexpr (!range_has_known_distance_v<iterator_value_type_t<I>>) {
+    return failure{};
+  } else {
+    std::size_t records_size = 0U;
+    std::size_t flat_size = 0U;
+
+    for (I i = f; i != l; ++i) {
+      ++records_size;
+      flat_size +=
+          static_cast<std::size_t>(std::distance(std::begin(*i), std::end(*i)));
+    }
+    return success{records_size, flat_size};
+  }
+}
+
+template <typename Container, typename I, typename S>
+void append_range_unsafe(Container& c, I f, S l) {
+  if constexpr (
+      !iterator_category_matches_v<I, std::random_access_iterator_tag> ||
+      !std::is_trivially_copy_constructible_v<iterator_value_type_t<I>> ||
+      !(is_instantiation_of_v<std::vector, Container> ||
+        is_instantiation_of_v<std::basic_string, Container>)) {
+    c.insert(c.end(), f, l);
+  } else {
+    folly::compiler_may_unsafely_assume(l >= f);
+    auto old_size = c.size();
+    detail::unsafeVectorSetLargerSize(c, c.size() + (l - f));
+    std::copy(f, l, c.begin() + old_size);
+  }
+}
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/container/detail/test/BUCK

@@ -0,0 +1,14 @@
+load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_unittest(
+    name = "f14_detail_test",
+    srcs = [
+        "F14DetailTest.cpp",
+    ],
+    deps = [
+        "//folly/container/detail:f14_hash_detail",
+        "//folly/portability:gtest",
+    ],
+)

package/external/folly/folly/container/detail/test/F14DetailTest.cpp

@@ -0,0 +1,47 @@
+/*
+ * 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.
+ */
+
+#include <folly/container/detail/F14Table.h>
+
+#include <folly/portability/GTest.h>
+
+#include <limits>
+
+TEST(F14SizeAndChunkShift, packed) {
+  folly::f14::detail::SizeAndChunkShift sz;
+  static_assert(sizeof(sz) == sizeof(size_t));
+  EXPECT_EQ(sz.size(), 0);
+  EXPECT_EQ(sz.chunkShift(), 0);
+
+  sz.setSize(12345678);
+  EXPECT_EQ(sz.size(), 12345678);
+  EXPECT_EQ(sz.chunkShift(), 0);
+
+  sz.setChunkCount(1);
+  EXPECT_EQ(sz.size(), 12345678);
+  EXPECT_EQ(sz.chunkCount(), 1);
+  EXPECT_EQ(sz.chunkShift(), 0);
+
+  for (int shift = 0;
+       shift <= folly::f14::detail::SizeAndChunkShift::kMaxSupportedChunkShift;
+       ++shift) {
+    const auto count = (1ULL << shift);
+    sz.setChunkCount(count);
+    EXPECT_EQ(sz.size(), 12345678);
+    EXPECT_EQ(sz.chunkCount(), count);
+    EXPECT_EQ(sz.chunkShift(), shift);
+  }
+}