react-native-windows 0.81.34 → 0.81.35

package/external/folly/folly/json/json_pointer.cpp

@@ -0,0 +1,114 @@
+/*
+ * 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/json/json_pointer.h>
+
+#include <folly/String.h>
+
+namespace folly {
+
+// static, public
+Expected<json_pointer, json_pointer::parse_error> json_pointer::try_parse(
+    StringPiece const str) {
+  // pointer describes complete document
+  if (str.empty()) {
+    return json_pointer{};
+  }
+
+  if (str.at(0) != '/') {
+    return makeUnexpected(parse_error::invalid_first_character);
+  }
+
+  std::vector<std::string> tokens;
+  splitTo<std::string>("/", str, std::inserter(tokens, tokens.begin()));
+  tokens.erase(tokens.begin());
+
+  for (auto& token : tokens) {
+    if (!unescape(token)) {
+      return makeUnexpected(parse_error::invalid_escape_sequence);
+    }
+  }
+
+  return json_pointer(std::move(tokens));
+}
+
+// static, public
+json_pointer json_pointer::parse(StringPiece const str) {
+  auto res = try_parse(str);
+  if (res.hasValue()) {
+    return std::move(res.value());
+  }
+  switch (res.error()) {
+    case parse_error::invalid_first_character:
+      throw json_pointer::parse_exception(
+          "non-empty JSON pointer string does not start with '/'");
+    case parse_error::invalid_escape_sequence:
+      throw json_pointer::parse_exception(
+          "Invalid escape sequence in JSON pointer string");
+    default:
+      FOLLY_ASSUME_UNREACHABLE();
+  }
+}
+
+bool json_pointer::is_prefix_of(json_pointer const& other) const noexcept {
+  auto const& other_tokens = other.tokens();
+  if (tokens_.size() > other_tokens.size()) {
+    return false;
+  }
+  auto const other_begin = other_tokens.cbegin();
+  auto const other_end = other_tokens.cbegin() + tokens_.size();
+  return std::equal(tokens_.cbegin(), tokens_.cend(), other_begin, other_end);
+}
+
+std::vector<std::string> const& json_pointer::tokens() const {
+  return tokens_;
+}
+
+// private
+json_pointer::json_pointer(std::vector<std::string> tokens) noexcept
+    : tokens_{std::move(tokens)} {}
+
+// private, static
+bool json_pointer::unescape(std::string& str) {
+  char* out = &str[0];
+  char const* begin = out;
+  char const* end = begin + str.size();
+  char const* decode = begin;
+  while (decode < end) {
+    if (*decode != '~') {
+      *out++ = *decode++;
+      continue;
+    }
+    if (decode + 1 == end) {
+      return false;
+    }
+    switch (decode[1]) {
+      case '1':
+        *out++ = '/';
+        break;
+      case '0':
+        *out++ = '~';
+        break;
+      default:
+        return false;
+    }
+    decode += 2;
+  }
+  str.resize(out - begin);
+  return true;
+}
+
+} // namespace folly

package/external/folly/folly/json/json_pointer.h

@@ -0,0 +1,87 @@
+/*
+ * 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 <string>
+#include <vector>
+
+#include <folly/Expected.h>
+#include <folly/Range.h>
+
+namespace folly {
+
+/*
+ * json_pointer
+ *
+ * As described in RFC 6901 "JSON Pointer".
+ *
+ * Implements parsing. Traversal using the pointer over data structures must be
+ * implemented separately.
+ */
+class json_pointer {
+ public:
+  enum class parse_error {
+    invalid_first_character,
+    invalid_escape_sequence,
+  };
+
+  class parse_exception : public std::runtime_error {
+    using std::runtime_error::runtime_error;
+  };
+
+  json_pointer() = default;
+  ~json_pointer() = default;
+
+  /*
+   * Parse string into vector of unescaped tokens.
+   * Non-throwing and throwing versions.
+   */
+  static Expected<json_pointer, parse_error> try_parse(StringPiece const str);
+
+  static json_pointer parse(StringPiece const str);
+
+  /*
+   * Return true if this pointer is proper to prefix to another pointer
+   */
+  bool is_prefix_of(json_pointer const& other) const noexcept;
+
+  /*
+   * Get access to the parsed tokens for applications that want to traverse
+   * the pointer.
+   */
+  std::vector<std::string> const& tokens() const;
+
+  friend bool operator==(json_pointer const& lhs, json_pointer const& rhs) {
+    return lhs.tokens_ == rhs.tokens_;
+  }
+
+  friend bool operator!=(json_pointer const& lhs, json_pointer const& rhs) {
+    return lhs.tokens_ != rhs.tokens_;
+  }
+
+ private:
+  explicit json_pointer(std::vector<std::string>) noexcept;
+
+  /*
+   * Unescape the specified escape sequences, returns false if incorrect
+   */
+  static bool unescape(std::string&);
+
+  std::vector<std::string> tokens_;
+};
+
+} // namespace folly

package/external/folly/folly/json/test/BUCK

@@ -0,0 +1,147 @@
+load("@fbcode_macros//build_defs:cpp_benchmark.bzl", "cpp_benchmark")
+load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_benchmark(
+    name = "dynamic_benchmark",
+    srcs = ["DynamicBenchmark.cpp"],
+    deps = [
+        "//folly:benchmark",
+        "//folly/init:init",
+        "//folly/json:dynamic",
+    ],
+)
+
+cpp_unittest(
+    name = "dynamic_converter_test",
+    srcs = ["DynamicConverterTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:expected",
+        "//folly:fbvector",
+        "//folly:optional",
+        "//folly/json:dynamic",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "dynamic_other_test",
+    srcs = ["DynamicOtherTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/gen:base",
+        "//folly/json:dynamic",
+        "//folly/portability:gflags",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "dynamic_test",
+    srcs = ["DynamicTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:range",
+        "//folly/hash:hash",
+        "//folly/json:dynamic",
+        "//folly/portability:gtest",
+        "//folly/test:comparison_operator_test_util",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_benchmark(
+    name = "json_benchmark",
+    srcs = ["JsonBenchmark.cpp"],
+    headers = [],
+    deps = [
+        "//folly:benchmark",
+        "//folly/json:dynamic",
+    ],
+)
+
+cpp_unittest(
+    name = "json_other_test",
+    srcs = ["JsonOtherTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/json:dynamic",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "json_patch_test",
+    srcs = ["json_patch_test.cpp"],
+    headers = [],
+    deps = [
+        "//folly:json_patch",
+        "//folly:json_pointer",
+        "//folly/json:dynamic",
+        "//folly/portability:gmock",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "json_test",
+    srcs = ["JsonTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/json:dynamic",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "json_pointer_test",
+    srcs = ["json_pointer_test.cpp"],
+    headers = [],
+    deps = [
+        "//folly:json_pointer",
+        "//folly/portability:gmock",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "json_schema_test",
+    srcs = ["JSONSchemaTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/json:dynamic",
+        "//folly/json:json_schema",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "dynamic_parser_test",
+    srcs = ["DynamicParserTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:optional",
+        "//folly/json:dynamic_parser",
+        "//folly/portability:gtest",
+        "//folly/testing:test_util",
+    ],
+)
+
+cpp_unittest(
+    name = "json_test_util_test",
+    srcs = ["JsonTestUtilTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/portability:gmock",
+        "//folly/portability:gtest",
+        "//folly/test:json_mock_util",
+        "//folly/test:json_test_util",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)

package/external/folly/folly/json/test/DynamicBenchmark.cpp

@@ -0,0 +1,146 @@
+/*
+ * 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/json/dynamic.h>
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+using folly::dynamic;
+
+BENCHMARK(moveBool, iters) {
+  for (size_t i = 0; i < iters; ++i) {
+    dynamic b = true;
+    folly::makeUnpredictable(b);
+    dynamic other = std::move(b);
+    folly::doNotOptimizeAway(other);
+  }
+}
+
+BENCHMARK(moveShortString, iters) {
+  for (size_t i = 0; i < iters; ++i) {
+    dynamic s = "short";
+    folly::makeUnpredictable(s);
+    dynamic other = std::move(s);
+    folly::doNotOptimizeAway(other);
+  }
+}
+
+BENCHMARK(moveLongString, iters) {
+  for (size_t i = 0; i < iters; ++i) {
+    folly::BenchmarkSuspender braces;
+    dynamic s =
+        "a very long string which will certainly have to go on the heap";
+    folly::makeUnpredictable(s);
+    braces.dismiss();
+    dynamic other = std::move(s);
+    folly::doNotOptimizeAway(other);
+  }
+}
+
+BENCHMARK(copyBool, iters) {
+  dynamic b = true;
+  folly::makeUnpredictable(b);
+  for (size_t i = 0; i < iters; ++i) {
+    dynamic other = b;
+    folly::doNotOptimizeAway(other);
+  }
+}
+
+BENCHMARK(assignRawBool, iters) {
+  bool b = true;
+  dynamic other = false;
+  folly::makeUnpredictable(b);
+  for (size_t i = 0; i < iters; ++i) {
+    other = b;
+    folly::doNotOptimizeAway(other);
+  }
+}
+
+BENCHMARK(copyShortString, iters) {
+  dynamic s = "short";
+  folly::makeUnpredictable(s);
+  for (size_t i = 0; i < iters; ++i) {
+    dynamic other = s;
+    folly::doNotOptimizeAway(other);
+  }
+}
+
+BENCHMARK(copyLongString, iters) {
+  folly::BenchmarkSuspender braces;
+  dynamic s = "a very long string which will certainly have to go on the heap";
+  folly::makeUnpredictable(s);
+  braces.dismiss();
+  for (size_t i = 0; i < iters; ++i) {
+    dynamic other = s;
+    folly::doNotOptimizeAway(other);
+  }
+}
+
+BENCHMARK(hashBool, iters) {
+  dynamic b = true;
+  folly::makeUnpredictable(b);
+  for (size_t i = 0; i < iters; ++i) {
+    auto hash = b.hash();
+    folly::doNotOptimizeAway(hash);
+  }
+}
+
+BENCHMARK(hashShortString, iters) {
+  dynamic s = "short";
+  folly::makeUnpredictable(s);
+  for (size_t i = 0; i < iters; ++i) {
+    auto hash = s.hash();
+    folly::doNotOptimizeAway(hash);
+  }
+}
+
+BENCHMARK(hashLongString, iters) {
+  folly::BenchmarkSuspender braces;
+  dynamic s = "a very long string which will certainly have to go on the heap";
+  folly::makeUnpredictable(s);
+  braces.dismiss();
+  for (size_t i = 0; i < iters; ++i) {
+    auto hash = s.hash();
+    folly::doNotOptimizeAway(hash);
+  }
+}
+
+BENCHMARK(sizeShortString, iters) {
+  dynamic s = "short";
+  folly::makeUnpredictable(s);
+  for (size_t i = 0; i < iters; ++i) {
+    auto sz = s.size();
+    folly::doNotOptimizeAway(sz);
+  }
+}
+
+BENCHMARK(sizeLongString, iters) {
+  folly::BenchmarkSuspender braces;
+  dynamic s = "a very long string which will certainly have to go on the heap";
+  folly::makeUnpredictable(s);
+  braces.dismiss();
+  for (size_t i = 0; i < iters; ++i) {
+    auto sz = s.size();
+    folly::doNotOptimizeAway(sz);
+  }
+}
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  folly::runBenchmarks();
+  return 0;
+}