react-native-executorch 0.5.2 → 0.5.4

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64/re2.framework/Headers/set.h

@@ -1,85 +0,0 @@
-// Copyright 2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_SET_H_
-#define RE2_SET_H_
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "re2/re2.h"
-
-namespace re2 {
-class Prog;
-class Regexp;
-} // namespace re2
-
-namespace re2 {
-
-// An RE2::Set represents a collection of regexps that can
-// be searched for simultaneously.
-class RE2::Set {
-public:
-  enum ErrorKind {
-    kNoError = 0,
-    kNotCompiled,  // The set is not compiled.
-    kOutOfMemory,  // The DFA ran out of memory.
-    kInconsistent, // The result is inconsistent. This should never happen.
-  };
-
-  struct ErrorInfo {
-    ErrorKind kind;
-  };
-
-  Set(const RE2::Options &options, RE2::Anchor anchor);
-  ~Set();
-
-  // Not copyable.
-  Set(const Set &) = delete;
-  Set &operator=(const Set &) = delete;
-  // Movable.
-  Set(Set &&other);
-  Set &operator=(Set &&other);
-
-  // Adds pattern to the set using the options passed to the constructor.
-  // Returns the index that will identify the regexp in the output of Match(),
-  // or -1 if the regexp cannot be parsed.
-  // Indices are assigned in sequential order starting from 0.
-  // Errors do not increment the index; if error is not NULL, *error will hold
-  // the error message from the parser.
-  int Add(const StringPiece &pattern, std::string *error);
-
-  // Compiles the set in preparation for matching.
-  // Returns false if the compiler runs out of memory.
-  // Add() must not be called again after Compile().
-  // Compile() must be called before Match().
-  bool Compile();
-
-  // Returns true if text matches at least one of the regexps in the set.
-  // Fills v (if not NULL) with the indices of the matching regexps.
-  // Callers must not expect v to be sorted.
-  bool Match(const StringPiece &text, std::vector<int> *v) const;
-
-  // As above, but populates error_info (if not NULL) when none of the regexps
-  // in the set matched. This can inform callers when DFA execution fails, for
-  // example, because they might wish to handle that case differently.
-  bool Match(const StringPiece &text, std::vector<int> *v,
-             ErrorInfo *error_info) const;
-
-private:
-  typedef std::pair<std::string, re2::Regexp *> Elem;
-
-  RE2::Options options_;
-  RE2::Anchor anchor_;
-  std::vector<Elem> elem_;
-  bool compiled_;
-  int size_;
-  std::unique_ptr<re2::Prog> prog_;
-};
-
-} // namespace re2
-
-#endif // RE2_SET_H_

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64/re2.framework/Headers/sparse_array.h

@@ -1,367 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_SPARSE_ARRAY_H_
-#define RE2_SPARSE_ARRAY_H_
-
-// DESCRIPTION
-//
-// SparseArray<T>(m) is a map from integers in [0, m) to T values.
-// It requires (sizeof(T)+sizeof(int))*m memory, but it provides
-// fast iteration through the elements in the array and fast clearing
-// of the array.  The array has a concept of certain elements being
-// uninitialized (having no value).
-//
-// Insertion and deletion are constant time operations.
-//
-// Allocating the array is a constant time operation
-// when memory allocation is a constant time operation.
-//
-// Clearing the array is a constant time operation (unusual!).
-//
-// Iterating through the array is an O(n) operation, where n
-// is the number of items in the array (not O(m)).
-//
-// The array iterator visits entries in the order they were first
-// inserted into the array.  It is safe to add items to the array while
-// using an iterator: the iterator will visit indices added to the array
-// during the iteration, but will not re-visit indices whose values
-// change after visiting.  Thus SparseArray can be a convenient
-// implementation of a work queue.
-//
-// The SparseArray implementation is NOT thread-safe.  It is up to the
-// caller to make sure only one thread is accessing the array.  (Typically
-// these arrays are temporary values and used in situations where speed is
-// important.)
-//
-// The SparseArray interface does not present all the usual STL bells and
-// whistles.
-//
-// Implemented with reference to Briggs & Torczon, An Efficient
-// Representation for Sparse Sets, ACM Letters on Programming Languages
-// and Systems, Volume 2, Issue 1-4 (March-Dec.  1993), pp.  59-69.
-//
-// Briggs & Torczon popularized this technique, but it had been known
-// long before their paper.  They point out that Aho, Hopcroft, and
-// Ullman's 1974 Design and Analysis of Computer Algorithms and Bentley's
-// 1986 Programming Pearls both hint at the technique in exercises to the
-// reader (in Aho & Hopcroft, exercise 2.12; in Bentley, column 1
-// exercise 8).
-//
-// Briggs & Torczon describe a sparse set implementation.  I have
-// trivially generalized it to create a sparse array (actually the original
-// target of the AHU and Bentley exercises).
-
-// IMPLEMENTATION
-//
-// SparseArray is an array dense_ and an array sparse_ of identical size.
-// At any point, the number of elements in the sparse array is size_.
-//
-// The array dense_ contains the size_ elements in the sparse array (with
-// their indices),
-// in the order that the elements were first inserted.  This array is dense:
-// the size_ pairs are dense_[0] through dense_[size_-1].
-//
-// The array sparse_ maps from indices in [0,m) to indices in [0,size_).
-// For indices present in the array, dense_[sparse_[i]].index_ == i.
-// For indices not present in the array, sparse_ can contain any value at all,
-// perhaps outside the range [0, size_) but perhaps not.
-//
-// The lax requirement on sparse_ values makes clearing the array very easy:
-// set size_ to 0.  Lookups are slightly more complicated.
-// An index i has a value in the array if and only if:
-//   sparse_[i] is in [0, size_) AND
-//   dense_[sparse_[i]].index_ == i.
-// If both these properties hold, only then it is safe to refer to
-//   dense_[sparse_[i]].value_
-// as the value associated with index i.
-//
-// To insert a new entry, set sparse_[i] to size_,
-// initialize dense_[size_], and then increment size_.
-//
-// To make the sparse array as efficient as possible for non-primitive types,
-// elements may or may not be destroyed when they are deleted from the sparse
-// array through a call to resize(). They immediately become inaccessible, but
-// they are only guaranteed to be destroyed when the SparseArray destructor is
-// called.
-//
-// A moved-from SparseArray will be empty.
-
-// Doing this simplifies the logic below.
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#include <assert.h>
-#include <stdint.h>
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#endif
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-#include "re2/pod_array.h"
-
-namespace re2 {
-
-template <typename Value> class SparseArray {
-public:
-  SparseArray();
-  explicit SparseArray(int max_size);
-  ~SparseArray();
-
-  // IndexValue pairs: exposed in SparseArray::iterator.
-  class IndexValue;
-
-  typedef IndexValue *iterator;
-  typedef const IndexValue *const_iterator;
-
-  SparseArray(const SparseArray &src);
-  SparseArray(SparseArray &&src);
-
-  SparseArray &operator=(const SparseArray &src);
-  SparseArray &operator=(SparseArray &&src);
-
-  // Return the number of entries in the array.
-  int size() const { return size_; }
-
-  // Indicate whether the array is empty.
-  int empty() const { return size_ == 0; }
-
-  // Iterate over the array.
-  iterator begin() { return dense_.data(); }
-  iterator end() { return dense_.data() + size_; }
-
-  const_iterator begin() const { return dense_.data(); }
-  const_iterator end() const { return dense_.data() + size_; }
-
-  // Change the maximum size of the array.
-  // Invalidates all iterators.
-  void resize(int new_max_size);
-
-  // Return the maximum size of the array.
-  // Indices can be in the range [0, max_size).
-  int max_size() const {
-    if (dense_.data() != NULL)
-      return dense_.size();
-    else
-      return 0;
-  }
-
-  // Clear the array.
-  void clear() { size_ = 0; }
-
-  // Check whether index i is in the array.
-  bool has_index(int i) const;
-
-  // Comparison function for sorting.
-  // Can sort the sparse array so that future iterations
-  // will visit indices in increasing order using
-  // std::sort(arr.begin(), arr.end(), arr.less);
-  static bool less(const IndexValue &a, const IndexValue &b);
-
-public:
-  // Set the value at index i to v.
-  iterator set(int i, const Value &v) { return SetInternal(true, i, v); }
-
-  // Set the value at new index i to v.
-  // Fast but unsafe: only use if has_index(i) is false.
-  iterator set_new(int i, const Value &v) { return SetInternal(false, i, v); }
-
-  // Set the value at index i to v.
-  // Fast but unsafe: only use if has_index(i) is true.
-  iterator set_existing(int i, const Value &v) {
-    return SetExistingInternal(i, v);
-  }
-
-  // Get the value at index i.
-  // Fast but unsafe: only use if has_index(i) is true.
-  Value &get_existing(int i) {
-    assert(has_index(i));
-    return dense_[sparse_[i]].value_;
-  }
-  const Value &get_existing(int i) const {
-    assert(has_index(i));
-    return dense_[sparse_[i]].value_;
-  }
-
-private:
-  iterator SetInternal(bool allow_existing, int i, const Value &v) {
-    DebugCheckInvariants();
-    if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-      assert(false && "illegal index");
-      // Semantically, end() would be better here, but we already know
-      // the user did something stupid, so begin() insulates them from
-      // dereferencing an invalid pointer.
-      return begin();
-    }
-    if (!allow_existing) {
-      assert(!has_index(i));
-      create_index(i);
-    } else {
-      if (!has_index(i))
-        create_index(i);
-    }
-    return SetExistingInternal(i, v);
-  }
-
-  iterator SetExistingInternal(int i, const Value &v) {
-    DebugCheckInvariants();
-    assert(has_index(i));
-    dense_[sparse_[i]].value_ = v;
-    DebugCheckInvariants();
-    return dense_.data() + sparse_[i];
-  }
-
-  // Add the index i to the array.
-  // Only use if has_index(i) is known to be false.
-  // Since it doesn't set the value associated with i,
-  // this function is private, only intended as a helper
-  // for other methods.
-  void create_index(int i);
-
-  // In debug mode, verify that some invariant properties of the class
-  // are being maintained. This is called at the end of the constructor
-  // and at the beginning and end of all public non-const member functions.
-  void DebugCheckInvariants() const;
-
-  // Initializes memory for elements [min, max).
-  void MaybeInitializeMemory(int min, int max) {
-#if __has_feature(memory_sanitizer)
-    __msan_unpoison(sparse_.data() + min, (max - min) * sizeof sparse_[0]);
-#elif defined(RE2_ON_VALGRIND)
-    for (int i = min; i < max; i++) {
-      sparse_[i] = 0xababababU;
-    }
-#endif
-  }
-
-  int size_ = 0;
-  PODArray<int> sparse_;
-  PODArray<IndexValue> dense_;
-};
-
-template <typename Value> SparseArray<Value>::SparseArray() = default;
-
-template <typename Value>
-SparseArray<Value>::SparseArray(const SparseArray &src)
-    : size_(src.size_), sparse_(src.max_size()), dense_(src.max_size()) {
-  std::copy_n(src.sparse_.data(), src.max_size(), sparse_.data());
-  std::copy_n(src.dense_.data(), src.max_size(), dense_.data());
-}
-
-template <typename Value>
-SparseArray<Value>::SparseArray(SparseArray &&src)
-    : size_(src.size_), sparse_(std::move(src.sparse_)),
-      dense_(std::move(src.dense_)) {
-  src.size_ = 0;
-}
-
-template <typename Value>
-SparseArray<Value> &SparseArray<Value>::operator=(const SparseArray &src) {
-  // Construct these first for exception safety.
-  PODArray<int> a(src.max_size());
-  PODArray<IndexValue> b(src.max_size());
-
-  size_ = src.size_;
-  sparse_ = std::move(a);
-  dense_ = std::move(b);
-  std::copy_n(src.sparse_.data(), src.max_size(), sparse_.data());
-  std::copy_n(src.dense_.data(), src.max_size(), dense_.data());
-  return *this;
-}
-
-template <typename Value>
-SparseArray<Value> &SparseArray<Value>::operator=(SparseArray &&src) {
-  size_ = src.size_;
-  sparse_ = std::move(src.sparse_);
-  dense_ = std::move(src.dense_);
-  src.size_ = 0;
-  return *this;
-}
-
-// IndexValue pairs: exposed in SparseArray::iterator.
-template <typename Value> class SparseArray<Value>::IndexValue {
-public:
-  int index() const { return index_; }
-  Value &value() { return value_; }
-  const Value &value() const { return value_; }
-
-private:
-  friend class SparseArray;
-  int index_;
-  Value value_;
-};
-
-// Change the maximum size of the array.
-// Invalidates all iterators.
-template <typename Value> void SparseArray<Value>::resize(int new_max_size) {
-  DebugCheckInvariants();
-  if (new_max_size > max_size()) {
-    const int old_max_size = max_size();
-
-    // Construct these first for exception safety.
-    PODArray<int> a(new_max_size);
-    PODArray<IndexValue> b(new_max_size);
-
-    std::copy_n(sparse_.data(), old_max_size, a.data());
-    std::copy_n(dense_.data(), old_max_size, b.data());
-
-    sparse_ = std::move(a);
-    dense_ = std::move(b);
-
-    MaybeInitializeMemory(old_max_size, new_max_size);
-  }
-  if (size_ > new_max_size)
-    size_ = new_max_size;
-  DebugCheckInvariants();
-}
-
-// Check whether index i is in the array.
-template <typename Value> bool SparseArray<Value>::has_index(int i) const {
-  assert(i >= 0);
-  assert(i < max_size());
-  if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-    return false;
-  }
-  // Unsigned comparison avoids checking sparse_[i] < 0.
-  return (uint32_t)sparse_[i] < (uint32_t)size_ &&
-         dense_[sparse_[i]].index_ == i;
-}
-
-template <typename Value> void SparseArray<Value>::create_index(int i) {
-  assert(!has_index(i));
-  assert(size_ < max_size());
-  sparse_[i] = size_;
-  dense_[size_].index_ = i;
-  size_++;
-}
-
-template <typename Value>
-SparseArray<Value>::SparseArray(int max_size)
-    : sparse_(max_size), dense_(max_size) {
-  MaybeInitializeMemory(size_, max_size);
-  DebugCheckInvariants();
-}
-
-template <typename Value> SparseArray<Value>::~SparseArray() {
-  DebugCheckInvariants();
-}
-
-template <typename Value>
-void SparseArray<Value>::DebugCheckInvariants() const {
-  assert(0 <= size_);
-  assert(size_ <= max_size());
-}
-
-// Comparison function for sorting.
-template <typename Value>
-bool SparseArray<Value>::less(const IndexValue &a, const IndexValue &b) {
-  return a.index_ < b.index_;
-}
-
-} // namespace re2
-
-#endif // RE2_SPARSE_ARRAY_H_

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64/re2.framework/Headers/sparse_set.h

@@ -1,241 +0,0 @@
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_SPARSE_SET_H_
-#define RE2_SPARSE_SET_H_
-
-// DESCRIPTION
-//
-// SparseSet(m) is a set of integers in [0, m).
-// It requires sizeof(int)*m memory, but it provides
-// fast iteration through the elements in the set and fast clearing
-// of the set.
-//
-// Insertion and deletion are constant time operations.
-//
-// Allocating the set is a constant time operation
-// when memory allocation is a constant time operation.
-//
-// Clearing the set is a constant time operation (unusual!).
-//
-// Iterating through the set is an O(n) operation, where n
-// is the number of items in the set (not O(m)).
-//
-// The set iterator visits entries in the order they were first
-// inserted into the set.  It is safe to add items to the set while
-// using an iterator: the iterator will visit indices added to the set
-// during the iteration, but will not re-visit indices whose values
-// change after visiting.  Thus SparseSet can be a convenient
-// implementation of a work queue.
-//
-// The SparseSet implementation is NOT thread-safe.  It is up to the
-// caller to make sure only one thread is accessing the set.  (Typically
-// these sets are temporary values and used in situations where speed is
-// important.)
-//
-// The SparseSet interface does not present all the usual STL bells and
-// whistles.
-//
-// Implemented with reference to Briggs & Torczon, An Efficient
-// Representation for Sparse Sets, ACM Letters on Programming Languages
-// and Systems, Volume 2, Issue 1-4 (March-Dec.  1993), pp.  59-69.
-//
-// This is a specialization of sparse array; see sparse_array.h.
-
-// IMPLEMENTATION
-//
-// See sparse_array.h for implementation details.
-
-// Doing this simplifies the logic below.
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#include <assert.h>
-#include <stdint.h>
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#endif
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-#include "re2/pod_array.h"
-
-namespace re2 {
-
-template <typename Value> class SparseSetT {
-public:
-  SparseSetT();
-  explicit SparseSetT(int max_size);
-  ~SparseSetT();
-
-  typedef int *iterator;
-  typedef const int *const_iterator;
-
-  // Return the number of entries in the set.
-  int size() const { return size_; }
-
-  // Indicate whether the set is empty.
-  int empty() const { return size_ == 0; }
-
-  // Iterate over the set.
-  iterator begin() { return dense_.data(); }
-  iterator end() { return dense_.data() + size_; }
-
-  const_iterator begin() const { return dense_.data(); }
-  const_iterator end() const { return dense_.data() + size_; }
-
-  // Change the maximum size of the set.
-  // Invalidates all iterators.
-  void resize(int new_max_size);
-
-  // Return the maximum size of the set.
-  // Indices can be in the range [0, max_size).
-  int max_size() const {
-    if (dense_.data() != NULL)
-      return dense_.size();
-    else
-      return 0;
-  }
-
-  // Clear the set.
-  void clear() { size_ = 0; }
-
-  // Check whether index i is in the set.
-  bool contains(int i) const;
-
-  // Comparison function for sorting.
-  // Can sort the sparse set so that future iterations
-  // will visit indices in increasing order using
-  // std::sort(arr.begin(), arr.end(), arr.less);
-  static bool less(int a, int b);
-
-public:
-  // Insert index i into the set.
-  iterator insert(int i) { return InsertInternal(true, i); }
-
-  // Insert index i into the set.
-  // Fast but unsafe: only use if contains(i) is false.
-  iterator insert_new(int i) { return InsertInternal(false, i); }
-
-private:
-  iterator InsertInternal(bool allow_existing, int i) {
-    DebugCheckInvariants();
-    if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-      assert(false && "illegal index");
-      // Semantically, end() would be better here, but we already know
-      // the user did something stupid, so begin() insulates them from
-      // dereferencing an invalid pointer.
-      return begin();
-    }
-    if (!allow_existing) {
-      assert(!contains(i));
-      create_index(i);
-    } else {
-      if (!contains(i))
-        create_index(i);
-    }
-    DebugCheckInvariants();
-    return dense_.data() + sparse_[i];
-  }
-
-  // Add the index i to the set.
-  // Only use if contains(i) is known to be false.
-  // This function is private, only intended as a helper
-  // for other methods.
-  void create_index(int i);
-
-  // In debug mode, verify that some invariant properties of the class
-  // are being maintained. This is called at the end of the constructor
-  // and at the beginning and end of all public non-const member functions.
-  void DebugCheckInvariants() const;
-
-  // Initializes memory for elements [min, max).
-  void MaybeInitializeMemory(int min, int max) {
-#if __has_feature(memory_sanitizer)
-    __msan_unpoison(sparse_.data() + min, (max - min) * sizeof sparse_[0]);
-#elif defined(RE2_ON_VALGRIND)
-    for (int i = min; i < max; i++) {
-      sparse_[i] = 0xababababU;
-    }
-#endif
-  }
-
-  int size_ = 0;
-  PODArray<int> sparse_;
-  PODArray<int> dense_;
-};
-
-template <typename Value> SparseSetT<Value>::SparseSetT() = default;
-
-// Change the maximum size of the set.
-// Invalidates all iterators.
-template <typename Value> void SparseSetT<Value>::resize(int new_max_size) {
-  DebugCheckInvariants();
-  if (new_max_size > max_size()) {
-    const int old_max_size = max_size();
-
-    // Construct these first for exception safety.
-    PODArray<int> a(new_max_size);
-    PODArray<int> b(new_max_size);
-
-    std::copy_n(sparse_.data(), old_max_size, a.data());
-    std::copy_n(dense_.data(), old_max_size, b.data());
-
-    sparse_ = std::move(a);
-    dense_ = std::move(b);
-
-    MaybeInitializeMemory(old_max_size, new_max_size);
-  }
-  if (size_ > new_max_size)
-    size_ = new_max_size;
-  DebugCheckInvariants();
-}
-
-// Check whether index i is in the set.
-template <typename Value> bool SparseSetT<Value>::contains(int i) const {
-  assert(i >= 0);
-  assert(i < max_size());
-  if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-    return false;
-  }
-  // Unsigned comparison avoids checking sparse_[i] < 0.
-  return (uint32_t)sparse_[i] < (uint32_t)size_ && dense_[sparse_[i]] == i;
-}
-
-template <typename Value> void SparseSetT<Value>::create_index(int i) {
-  assert(!contains(i));
-  assert(size_ < max_size());
-  sparse_[i] = size_;
-  dense_[size_] = i;
-  size_++;
-}
-
-template <typename Value>
-SparseSetT<Value>::SparseSetT(int max_size)
-    : sparse_(max_size), dense_(max_size) {
-  MaybeInitializeMemory(size_, max_size);
-  DebugCheckInvariants();
-}
-
-template <typename Value> SparseSetT<Value>::~SparseSetT() {
-  DebugCheckInvariants();
-}
-
-template <typename Value> void SparseSetT<Value>::DebugCheckInvariants() const {
-  assert(0 <= size_);
-  assert(size_ <= max_size());
-}
-
-// Comparison function for sorting.
-template <typename Value> bool SparseSetT<Value>::less(int a, int b) {
-  return a < b;
-}
-
-typedef SparseSetT<void> SparseSet;
-
-} // namespace re2
-
-#endif // RE2_SPARSE_SET_H_