react-native-executorch 0.5.1 → 0.5.3

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

@@ -1,111 +0,0 @@
-// Copyright 2009 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_FILTERED_RE2_H_
-#define RE2_FILTERED_RE2_H_
-
-// The class FilteredRE2 is used as a wrapper to multiple RE2 regexps.
-// It provides a prefilter mechanism that helps in cutting down the
-// number of regexps that need to be actually searched.
-//
-// By design, it does not include a string matching engine. This is to
-// allow the user of the class to use their favorite string matching
-// engine. The overall flow is: Add all the regexps using Add, then
-// Compile the FilteredRE2. Compile returns strings that need to be
-// matched. Note that the returned strings are lowercased and distinct.
-// For applying regexps to a search text, the caller does the string
-// matching using the returned strings. When doing the string match,
-// note that the caller has to do that in a case-insensitive way or
-// on a lowercased version of the search text. Then call FirstMatch
-// or AllMatches with a vector of indices of strings that were found
-// in the text to get the actual regexp matches.
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "re2/re2.h"
-
-namespace re2 {
-
-class PrefilterTree;
-
-class FilteredRE2 {
-public:
-  FilteredRE2();
-  explicit FilteredRE2(int min_atom_len);
-  ~FilteredRE2();
-
-  // Not copyable.
-  FilteredRE2(const FilteredRE2 &) = delete;
-  FilteredRE2 &operator=(const FilteredRE2 &) = delete;
-  // Movable.
-  FilteredRE2(FilteredRE2 &&other);
-  FilteredRE2 &operator=(FilteredRE2 &&other);
-
-  // Uses RE2 constructor to create a RE2 object (re). Returns
-  // re->error_code(). If error_code is other than NoError, then re is
-  // deleted and not added to re2_vec_.
-  RE2::ErrorCode Add(const StringPiece &pattern, const RE2::Options &options,
-                     int *id);
-
-  // Prepares the regexps added by Add for filtering.  Returns a set
-  // of strings that the caller should check for in candidate texts.
-  // The returned strings are lowercased and distinct. When doing
-  // string matching, it should be performed in a case-insensitive
-  // way or the search text should be lowercased first.  Call after
-  // all Add calls are done.
-  void Compile(std::vector<std::string> *strings_to_match);
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Can be called prior to Compile.
-  // Does not do any filtering: simply tries to Match the
-  // regexps in a loop.
-  int SlowFirstMatch(const StringPiece &text) const;
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Compile has to be called before
-  // calling this.
-  int FirstMatch(const StringPiece &text, const std::vector<int> &atoms) const;
-
-  // Returns the indices of all matching regexps, after first clearing
-  // matched_regexps.
-  bool AllMatches(const StringPiece &text, const std::vector<int> &atoms,
-                  std::vector<int> *matching_regexps) const;
-
-  // Returns the indices of all potentially matching regexps after first
-  // clearing potential_regexps.
-  // A regexp is potentially matching if it passes the filter.
-  // If a regexp passes the filter it may still not match.
-  // A regexp that does not pass the filter is guaranteed to not match.
-  void AllPotentials(const std::vector<int> &atoms,
-                     std::vector<int> *potential_regexps) const;
-
-  // The number of regexps added.
-  int NumRegexps() const { return static_cast<int>(re2_vec_.size()); }
-
-  // Get the individual RE2 objects.
-  const RE2 &GetRE2(int regexpid) const { return *re2_vec_[regexpid]; }
-
-private:
-  // Print prefilter.
-  void PrintPrefilter(int regexpid);
-
-  // Useful for testing and debugging.
-  void RegexpsGivenStrings(const std::vector<int> &matched_atoms,
-                           std::vector<int> *passed_regexps);
-
-  // All the regexps in the FilteredRE2.
-  std::vector<RE2 *> re2_vec_;
-
-  // Has the FilteredRE2 been compiled using Compile()
-  bool compiled_;
-
-  // An AND-OR tree of string atoms used for filtering regexps.
-  std::unique_ptr<PrefilterTree> prefilter_tree_;
-};
-
-} // namespace re2
-
-#endif // RE2_FILTERED_RE2_H_

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

@@ -1,43 +0,0 @@
-// Copyright 2018 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_POD_ARRAY_H_
-#define RE2_POD_ARRAY_H_
-
-#include <memory>
-#include <type_traits>
-
-namespace re2 {
-
-template <typename T> class PODArray {
-public:
-  static_assert(std::is_trivial<T>::value && std::is_standard_layout<T>::value,
-                "T must be POD");
-
-  PODArray() : ptr_() {}
-  explicit PODArray(int len)
-      : ptr_(std::allocator<T>().allocate(len), Deleter(len)) {}
-
-  T *data() const { return ptr_.get(); }
-
-  int size() const { return ptr_.get_deleter().len_; }
-
-  T &operator[](int pos) const { return ptr_[pos]; }
-
-private:
-  struct Deleter {
-    Deleter() : len_(0) {}
-    explicit Deleter(int len) : len_(len) {}
-
-    void operator()(T *ptr) const { std::allocator<T>().deallocate(ptr, len_); }
-
-    int len_;
-  };
-
-  std::unique_ptr<T[], Deleter> ptr_;
-};
-
-} // namespace re2
-
-#endif // RE2_POD_ARRAY_H_

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

@@ -1,130 +0,0 @@
-// Copyright 2009 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_PREFILTER_H_
-#define RE2_PREFILTER_H_
-
-// Prefilter is the class used to extract string guards from regexps.
-// Rather than using Prefilter class directly, use FilteredRE2.
-// See filtered_re2.h
-
-#include <set>
-#include <string>
-#include <vector>
-
-#include "util/logging.h"
-#include "util/util.h"
-
-namespace re2 {
-
-class RE2;
-
-class Regexp;
-
-class Prefilter {
-  // Instead of using Prefilter directly, use FilteredRE2; see filtered_re2.h
-public:
-  enum Op {
-    ALL = 0, // Everything matches
-    NONE,    // Nothing matches
-    ATOM,    // The string atom() must match
-    AND,     // All in subs() must match
-    OR,      // One of subs() must match
-  };
-
-  explicit Prefilter(Op op);
-  ~Prefilter();
-
-  Op op() { return op_; }
-  const std::string &atom() const { return atom_; }
-  void set_unique_id(int id) { unique_id_ = id; }
-  int unique_id() const { return unique_id_; }
-
-  // The children of the Prefilter node.
-  std::vector<Prefilter *> *subs() {
-    DCHECK(op_ == AND || op_ == OR);
-    return subs_;
-  }
-
-  // Set the children vector. Prefilter takes ownership of subs and
-  // subs_ will be deleted when Prefilter is deleted.
-  void set_subs(std::vector<Prefilter *> *subs) { subs_ = subs; }
-
-  // Given a RE2, return a Prefilter. The caller takes ownership of
-  // the Prefilter and should deallocate it. Returns NULL if Prefilter
-  // cannot be formed.
-  static Prefilter *FromRE2(const RE2 *re2);
-
-  // Returns a readable debug string of the prefilter.
-  std::string DebugString() const;
-
-private:
-  // A comparator used to store exact strings. We compare by length,
-  // then lexicographically. This ordering makes it easier to reduce the
-  // set of strings in SimplifyStringSet.
-  struct LengthThenLex {
-    bool operator()(const std::string &a, const std::string &b) const {
-      return (a.size() < b.size()) || (a.size() == b.size() && a < b);
-    }
-  };
-
-  class Info;
-
-  using SSet = std::set<std::string, LengthThenLex>;
-  using SSIter = SSet::iterator;
-  using ConstSSIter = SSet::const_iterator;
-
-  // Combines two prefilters together to create an AND. The passed
-  // Prefilters will be part of the returned Prefilter or deleted.
-  static Prefilter *And(Prefilter *a, Prefilter *b);
-
-  // Combines two prefilters together to create an OR. The passed
-  // Prefilters will be part of the returned Prefilter or deleted.
-  static Prefilter *Or(Prefilter *a, Prefilter *b);
-
-  // Generalized And/Or
-  static Prefilter *AndOr(Op op, Prefilter *a, Prefilter *b);
-
-  static Prefilter *FromRegexp(Regexp *a);
-
-  static Prefilter *FromString(const std::string &str);
-
-  static Prefilter *OrStrings(SSet *ss);
-
-  static Info *BuildInfo(Regexp *re);
-
-  Prefilter *Simplify();
-
-  // Removes redundant strings from the set. A string is redundant if
-  // any of the other strings appear as a substring. The empty string
-  // is a special case, which is ignored.
-  static void SimplifyStringSet(SSet *ss);
-
-  // Adds the cross-product of a and b to dst.
-  // (For each string i in a and j in b, add i+j.)
-  static void CrossProduct(const SSet &a, const SSet &b, SSet *dst);
-
-  // Kind of Prefilter.
-  Op op_;
-
-  // Sub-matches for AND or OR Prefilter.
-  std::vector<Prefilter *> *subs_;
-
-  // Actual string to match in leaf node.
-  std::string atom_;
-
-  // If different prefilters have the same string atom, or if they are
-  // structurally the same (e.g., OR of same atom strings) they are
-  // considered the same unique nodes. This is the id for each unique
-  // node. This field is populated with a unique id for every node,
-  // and -1 for duplicate nodes.
-  int unique_id_;
-
-  Prefilter(const Prefilter &) = delete;
-  Prefilter &operator=(const Prefilter &) = delete;
-};
-
-} // namespace re2
-
-#endif // RE2_PREFILTER_H_

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

@@ -1,139 +0,0 @@
-// Copyright 2009 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_PREFILTER_TREE_H_
-#define RE2_PREFILTER_TREE_H_
-
-// The PrefilterTree class is used to form an AND-OR tree of strings
-// that would trigger each regexp. The 'prefilter' of each regexp is
-// added to PrefilterTree, and then PrefilterTree is used to find all
-// the unique strings across the prefilters. During search, by using
-// matches from a string matching engine, PrefilterTree deduces the
-// set of regexps that are to be triggered. The 'string matching
-// engine' itself is outside of this class, and the caller can use any
-// favorite engine. PrefilterTree provides a set of strings (called
-// atoms) that the user of this class should use to do the string
-// matching.
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "re2/prefilter.h"
-#include "re2/sparse_array.h"
-#include "util/util.h"
-
-namespace re2 {
-
-class PrefilterTree {
-public:
-  PrefilterTree();
-  explicit PrefilterTree(int min_atom_len);
-  ~PrefilterTree();
-
-  // Adds the prefilter for the next regexp. Note that we assume that
-  // Add called sequentially for all regexps. All Add calls
-  // must precede Compile.
-  void Add(Prefilter *prefilter);
-
-  // The Compile returns a vector of string in atom_vec.
-  // Call this after all the prefilters are added through Add.
-  // No calls to Add after Compile are allowed.
-  // The caller should use the returned set of strings to do string matching.
-  // Each time a string matches, the corresponding index then has to be
-  // and passed to RegexpsGivenStrings below.
-  void Compile(std::vector<std::string> *atom_vec);
-
-  // Given the indices of the atoms that matched, returns the indexes
-  // of regexps that should be searched.  The matched_atoms should
-  // contain all the ids of string atoms that were found to match the
-  // content. The caller can use any string match engine to perform
-  // this function. This function is thread safe.
-  void RegexpsGivenStrings(const std::vector<int> &matched_atoms,
-                           std::vector<int> *regexps) const;
-
-  // Print debug prefilter. Also prints unique ids associated with
-  // nodes of the prefilter of the regexp.
-  void PrintPrefilter(int regexpid);
-
-private:
-  typedef SparseArray<int> IntMap;
-  // TODO(junyer): Use std::unordered_set<Prefilter*> instead?
-  // It should be trivial to get rid of the stringification...
-  typedef std::map<std::string, Prefilter *> NodeMap;
-
-  // Each unique node has a corresponding Entry that helps in
-  // passing the matching trigger information along the tree.
-  struct Entry {
-  public:
-    // How many children should match before this node triggers the
-    // parent. For an atom and an OR node, this is 1 and for an AND
-    // node, it is the number of unique children.
-    int propagate_up_at_count;
-
-    // When this node is ready to trigger the parent, what are the indices
-    // of the parent nodes to trigger. The reason there may be more than
-    // one is because of sharing. For example (abc | def) and (xyz | def)
-    // are two different nodes, but they share the atom 'def'. So when
-    // 'def' matches, it triggers two parents, corresponding to the two
-    // different OR nodes.
-    std::vector<int> parents;
-
-    // When this node is ready to trigger the parent, what are the
-    // regexps that are triggered.
-    std::vector<int> regexps;
-  };
-
-  // Returns true if the prefilter node should be kept.
-  bool KeepNode(Prefilter *node) const;
-
-  // This function assigns unique ids to various parts of the
-  // prefilter, by looking at if these nodes are already in the
-  // PrefilterTree.
-  void AssignUniqueIds(NodeMap *nodes, std::vector<std::string> *atom_vec);
-
-  // Given the matching atoms, find the regexps to be triggered.
-  void PropagateMatch(const std::vector<int> &atom_ids, IntMap *regexps) const;
-
-  // Returns the prefilter node that has the same NodeString as this
-  // node. For the canonical node, returns node.
-  Prefilter *CanonicalNode(NodeMap *nodes, Prefilter *node);
-
-  // A string that uniquely identifies the node. Assumes that the
-  // children of node has already been assigned unique ids.
-  std::string NodeString(Prefilter *node) const;
-
-  // Recursively constructs a readable prefilter string.
-  std::string DebugNodeString(Prefilter *node) const;
-
-  // Used for debugging.
-  void PrintDebugInfo(NodeMap *nodes);
-
-  // These are all the nodes formed by Compile. Essentially, there is
-  // one node for each unique atom and each unique AND/OR node.
-  std::vector<Entry> entries_;
-
-  // indices of regexps that always pass through the filter (since we
-  // found no required literals in these regexps).
-  std::vector<int> unfiltered_;
-
-  // vector of Prefilter for all regexps.
-  std::vector<Prefilter *> prefilter_vec_;
-
-  // Atom index in returned strings to entry id mapping.
-  std::vector<int> atom_index_to_id_;
-
-  // Has the prefilter tree been compiled.
-  bool compiled_;
-
-  // Strings less than this length are not stored as atoms.
-  const int min_atom_len_;
-
-  PrefilterTree(const PrefilterTree &) = delete;
-  PrefilterTree &operator=(const PrefilterTree &) = delete;
-};
-
-} // namespace re2
-
-#endif // RE2_PREFILTER_TREE_H_