@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/base/spinlock.h

@@ -0,0 +1,60 @@
+// Copyright Google Inc. All Rights Reserved.
+//
+// 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.
+//
+
+#ifndef S2_BASE_SPINLOCK_H_
+#define S2_BASE_SPINLOCK_H_
+
+#include <atomic>
+
+
+class SpinLock {
+ public:
+  SpinLock() = default;
+  ~SpinLock() = default;
+  SpinLock(SpinLock const&) = delete;
+  SpinLock& operator=(SpinLock const&) = delete;
+
+  inline void Lock() {
+    while (locked_.exchange(true, std::memory_order_acquire)) {
+      // Spin.
+      continue;
+    }
+  }
+
+  inline void Unlock() {
+    locked_.store(false, std::memory_order_release);
+  }
+
+  inline bool IsHeld() const {
+    return locked_.load(std::memory_order_relaxed);
+  }
+
+ private:
+  std::atomic_bool locked_{false};
+};
+
+class SpinLockHolder {
+ public:
+  inline explicit SpinLockHolder(SpinLock* l) : lock_(l) { lock_->Lock(); }
+  inline ~SpinLockHolder() { lock_->Unlock(); }
+
+  SpinLockHolder(const SpinLockHolder&) = delete;
+  SpinLockHolder& operator=(const SpinLockHolder&) = delete;
+
+ private:
+  SpinLock* lock_;
+};
+
+#endif  // S2_BASE_SPINLOCK_H_

package/third_party/s2geometry/src/s2/base/stringprintf.cc

@@ -0,0 +1,107 @@
+// Copyright 2002 Google Inc. All Rights Reserved.
+//
+// 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 "s2/base/stringprintf.h"
+
+#include <cerrno>
+#include <cstdarg> // For va_list and related operations
+#include <cstdio> // MSVC requires this for _vsnprintf
+#include <vector>
+
+#include "s2/base/logging.h"
+
+#ifdef _MSC_VER
+enum { IS__MSC_VER = 1 };
+#else
+enum { IS__MSC_VER = 0 };
+#endif
+
+void StringAppendV(string* dst, const char* format, va_list ap) {
+  // First try with a small fixed size buffer
+  static const int kSpaceLength = 1024;
+  char space[kSpaceLength];
+
+  // It's possible for methods that use a va_list to invalidate
+  // the data in it upon use.  The fix is to make a copy
+  // of the structure before using it and use that copy instead.
+  va_list backup_ap;
+  va_copy(backup_ap, ap);
+  int result = vsnprintf(space, kSpaceLength, format, backup_ap);
+  va_end(backup_ap);
+
+  if (result < kSpaceLength) {
+    if (result >= 0) {
+      // Normal case -- everything fit.
+      dst->append(space, result);
+      return;
+    }
+
+    if (IS__MSC_VER) {
+      // Error or MSVC running out of space.  MSVC 8.0 and higher
+      // can be asked about space needed with the special idiom below:
+      va_copy(backup_ap, ap);
+      result = vsnprintf(nullptr, 0, format, backup_ap);
+      va_end(backup_ap);
+    }
+
+    if (result < 0) {
+      // Just an error.
+      return;
+    }
+  }
+
+  // Increase the buffer size to the size requested by vsnprintf,
+  // plus one for the closing \0.
+  int length = result+1;
+  char* buf = new char[length];
+
+  // Restore the va_list before we use it again
+  va_copy(backup_ap, ap);
+  result = vsnprintf(buf, length, format, backup_ap);
+  va_end(backup_ap);
+
+  if (result >= 0 && result < length) {
+    // It fit
+    dst->append(buf, result);
+  }
+  delete[] buf;
+}
+
+
+string StringPrintf(const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  string result;
+  StringAppendV(&result, format, ap);
+  va_end(ap);
+  return result;
+}
+
+const string& SStringPrintf(string* dst, const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  dst->clear();
+  StringAppendV(dst, format, ap);
+  va_end(ap);
+  return *dst;
+}
+
+void StringAppendF(string* dst, const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  StringAppendV(dst, format, ap);
+  va_end(ap);
+}

package/third_party/s2geometry/src/s2/base/stringprintf.h

@@ -0,0 +1,53 @@
+// Copyright Google Inc. All Rights Reserved.
+//
+// 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.
+//
+
+// NOTE: See third_party/absl/strings for more options.
+//
+// As of 2017q4, most use of these routines is considered legacy: use
+// of absl::StrCat, absl::Substitute, or absl::StrFormat is preferred for
+// performance and safety reasons.
+
+#ifndef S2_BASE_STRINGPRINTF_H_
+#define S2_BASE_STRINGPRINTF_H_
+
+#include <cstdarg>
+#include <string>
+#include <vector>
+
+#include "s2/base/port.h"
+
+// Return a C++ string
+extern string StringPrintf(const char* format, ...)
+    // Tell the compiler to do printf format string checking.
+    ABSL_PRINTF_ATTRIBUTE(1, 2);
+
+// Store result into a supplied string and return it
+extern const string& SStringPrintf(string* dst, const char* format, ...)
+    // Tell the compiler to do printf format string checking.
+    ABSL_PRINTF_ATTRIBUTE(2, 3);
+
+// Append result to a supplied string
+extern void StringAppendF(string* dst, const char* format, ...)
+    // Tell the compiler to do printf format string checking.
+    ABSL_PRINTF_ATTRIBUTE(2, 3);
+
+// Lower-level routine that takes a va_list and appends to a specified
+// string.  All other routines are just convenience wrappers around it.
+//
+// Implementation note: the va_list is never modified, this implementation
+// always operates on copies.
+extern void StringAppendV(string* dst, const char* format, va_list ap);
+
+#endif  // S2_BASE_STRINGPRINTF_H_

package/third_party/s2geometry/src/s2/base/strtoint.cc

@@ -0,0 +1,65 @@
+// Copyright 2008 Google Inc. All Rights Reserved.
+//
+// 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.
+//
+
+//
+// Architecture-neutral plug compatible replacements for strtol() friends.
+// See strtoint.h for details on how to use this component.
+//
+
+#include <cerrno>
+#include <climits>
+#include <limits>
+
+#include "s2/base/integral_types.h"
+#include "s2/base/port.h"
+#include "s2/base/strtoint.h"
+
+// Replacement strto[u]l functions that have identical overflow and underflow
+// characteristics for both ILP-32 and LP-64 platforms, including errno
+// preservation for error-free calls.
+int32 strto32_adapter(const char *nptr, char **endptr, int base) {
+  const int saved_errno = errno;
+  errno = 0;
+  const long result = strtol(nptr, endptr, base);
+  if (errno == ERANGE && result == LONG_MIN) {
+    return std::numeric_limits<int32>::min();
+  } else if (errno == ERANGE && result == LONG_MAX) {
+    return std::numeric_limits<int32>::max();
+  } else if (errno == 0 && result < std::numeric_limits<int32>::min()) {
+    errno = ERANGE;
+    return std::numeric_limits<int32>::min();
+  } else if (errno == 0 && result > std::numeric_limits<int32>::max()) {
+    errno = ERANGE;
+    return std::numeric_limits<int32>::max();
+  }
+  if (errno == 0)
+    errno = saved_errno;
+  return static_cast<int32>(result);
+}
+
+uint32 strtou32_adapter(const char *nptr, char **endptr, int base) {
+  const int saved_errno = errno;
+  errno = 0;
+  const unsigned long result = strtoul(nptr, endptr, base);
+  if (errno == ERANGE && result == ULONG_MAX) {
+    return std::numeric_limits<uint32>::max();
+  } else if (errno == 0 && result > std::numeric_limits<uint32>::max()) {
+    errno = ERANGE;
+    return std::numeric_limits<uint32>::max();
+  }
+  if (errno == 0)
+    errno = saved_errno;
+  return static_cast<uint32>(result);
+}

package/third_party/s2geometry/src/s2/base/strtoint.h

@@ -0,0 +1,106 @@
+// Copyright 2008 Google Inc. All Rights Reserved.
+//
+// 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.
+//
+
+//
+// Architecture-neutral plug compatible replacements for strtol() friends.
+//
+// Long's have different lengths on ILP-32 and LP-64 platforms, and so overflow
+// behavior across the two varies when strtol() and similar are used to parse
+// 32-bit integers.  Similar problems exist with atoi(), because although it
+// has an all-integer interface, it uses strtol() internally, and so suffers
+// from the same narrowing problems on assignments to int.
+//
+// Examples:
+//   errno = 0;
+//   i = strtol("3147483647", nullptr, 10);
+//   printf("%d, errno %d\n", i, errno);
+//   //   32-bit platform: 2147483647, errno 34
+//   //   64-bit platform: -1147483649, errno 0
+//
+//   printf("%d\n", atoi("3147483647"));
+//   //   32-bit platform: 2147483647
+//   //   64-bit platform: -1147483649
+//
+// A way round this is to define local replacements for these, and use them
+// instead of the standard libc functions.
+//
+// In most 32-bit cases the replacements can be inlined away to a call to the
+// libc function.  In a couple of 64-bit cases, however, adapters are required,
+// to provide the right overflow and errno behavior.
+//
+
+#ifndef S2_BASE_STRTOINT_H_
+#define S2_BASE_STRTOINT_H_
+
+#include <cstdlib> // For strtol* functions.
+#include <string>
+#include "s2/base/integral_types.h"
+#include "s2/base/port.h"
+#include "s2/third_party/absl/base/macros.h"
+
+// Adapter functions for handling overflow and errno.
+int32 strto32_adapter(const char *nptr, char **endptr, int base);
+uint32 strtou32_adapter(const char *nptr, char **endptr, int base);
+
+// Conversions to a 32-bit integer can pass the call to strto[u]l on 32-bit
+// platforms, but need a little extra work on 64-bit platforms.
+inline int32 strto32(const char *nptr, char **endptr, int base) {
+  if (sizeof(int32) == sizeof(long))
+    return static_cast<int32>(strtol(nptr, endptr, base));
+  else
+    return strto32_adapter(nptr, endptr, base);
+}
+
+inline uint32 strtou32(const char *nptr, char **endptr, int base) {
+  if (sizeof(uint32) == sizeof(unsigned long))
+    return static_cast<uint32>(strtoul(nptr, endptr, base));
+  else
+    return strtou32_adapter(nptr, endptr, base);
+}
+
+// For now, long long is 64-bit on all the platforms we care about, so these
+// functions can simply pass the call to strto[u]ll.
+inline int64 strto64(const char *nptr, char **endptr, int base) {
+  static_assert(sizeof(int64) == sizeof(long long),
+                "sizeof int64 is not sizeof long long");
+  return strtoll(nptr, endptr, base);
+}
+
+inline uint64 strtou64(const char *nptr, char **endptr, int base) {
+  static_assert(sizeof(uint64) == sizeof(unsigned long long),
+                "sizeof uint64 is not sizeof long long");
+  return strtoull(nptr, endptr, base);
+}
+
+// Although it returns an int, atoi() is implemented in terms of strtol, and
+// so has differing overflow and underflow behavior.  atol is the same.
+inline int32 atoi32(const char *nptr) {
+  return strto32(nptr, nullptr, 10);
+}
+
+inline int64 atoi64(const char *nptr) {
+  return strto64(nptr, nullptr, 10);
+}
+
+// Convenience versions of the above that take a string argument.
+inline int32 atoi32(const string &s) {
+  return atoi32(s.c_str());
+}
+
+inline int64 atoi64(const string &s) {
+  return atoi64(s.c_str());
+}
+
+#endif  // S2_BASE_STRTOINT_H_

package/third_party/s2geometry/src/s2/base/timer.h

@@ -0,0 +1,50 @@
+// Copyright Google Inc. All Rights Reserved.
+//
+// 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.
+//
+
+#ifndef S2_BASE_TIMER_H_
+#define S2_BASE_TIMER_H_
+
+#include <chrono>
+
+#include "s2/base/integral_types.h"
+
+class CycleTimer {
+ public:
+  CycleTimer() = default;
+
+  void Start() {
+    start_ = Now();
+  }
+
+  int64 GetInMs() const {
+    using msec = std::chrono::milliseconds;
+    return std::chrono::duration_cast<msec>(GetDuration()).count();
+  }
+
+ private:
+  using Clock = std::chrono::high_resolution_clock;
+
+  static Clock::time_point Now() {
+    return Clock::now();
+  }
+
+  Clock::duration GetDuration() const {
+    return Now() - start_;
+  }
+
+  Clock::time_point start_;
+};
+
+#endif  // S2_BASE_TIMER_H_

package/third_party/s2geometry/src/s2/encoded_s2cell_id_vector.cc

@@ -0,0 +1,164 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// 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.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/encoded_s2cell_id_vector.h"
+
+using absl::Span;
+using std::max;
+using std::min;
+using std::vector;
+
+namespace s2coding {
+
+void EncodeS2CellIdVector(Span<const S2CellId> v, Encoder* encoder) {
+  // v[i] is encoded as (base + (deltas[i] << shift)).
+  //
+  // "base" consists of 0-7 bytes, and is always shifted so that its bytes are
+  // the most-significant bytes of a uint64.
+  //
+  // "deltas" is an EncodedUintVector<uint64>, which means that all deltas
+  // have a fixed-length encoding determined by the largest delta.
+  //
+  // "shift" is in the range 0..56.  The shift value is odd only if all
+  // S2CellIds are at the same level, in which case the bit at position
+  // (shift - 1) is automatically set to 1 in "base".
+  //
+  // "base" (3 bits) and "shift" (6 bits) are encoded in either one or two
+  // bytes as follows:
+  //
+  //   - if (shift <= 4 or shift is even), then 1 byte
+  //   - otherwise 2 bytes
+  //
+  // Note that (shift == 1) means that all S2CellIds are leaf cells, and
+  // (shift == 2) means that all S2CellIds are at level 29.
+  //
+  // The full encoded format is as follows:
+  //
+  //  Byte 0, bits 0-2: base length (0-7 bytes)
+  //  Byte 0, bits 3-7: encoded shift (see below)
+  //  Byte 1: extended shift code (only needed for odd shifts >= 5)
+  //  Followed by 0-7 bytes of "base"
+  //  Followed by an EncodedUintVector of deltas.
+
+  uint64 v_or = 0, v_and = ~0ULL, v_min = ~0ULL, v_max = 0;
+  for (auto cellid : v) {
+    v_or |= cellid.id();
+    v_and &= cellid.id();
+    v_min = min(v_min, cellid.id());
+    v_max = max(v_max, cellid.id());
+  }
+  // These variables represent the values that will used during encoding.
+  uint64 e_base = 0;        // Base value.
+  int e_base_len = 0;       // Number of bytes to represent "base".
+  int e_shift = 0;          // Delta shift.
+  int e_max_delta_msb = 0;  // Bit position of the MSB of the largest delta.
+  if (v_or > 0) {
+    // We only allow even shifts, unless all values have the same low bit (in
+    // which case the shift is odd and the preceding bit is implicitly on).
+    // There is no point in allowing shifts > 56 since deltas are encoded in
+    // at least 1 byte each.
+    e_shift = min(56, Bits::FindLSBSetNonZero64(v_or) & ~1);
+    if (v_and & (1ULL << e_shift)) ++e_shift;  // All S2CellIds same level.
+
+    // "base" consists of the "base_len" most significant bytes of the minimum
+    // S2CellId.  We consider all possible values of "base_len" (0..7) and
+    // choose the one that minimizes the total encoding size.
+    uint64 e_bytes = ~0ULL;  // Best encoding size so far.
+    for (int len = 0; len < 8; ++len) {
+      // "t_base" is the base value being tested (first "len" bytes of v_min).
+      // "t_max_delta_msb" is the most-significant bit position of the largest
+      // delta (or zero if there are no deltas, i.e. if v.size() == 0).
+      // "t_bytes" is the total size of the variable portion of the encoding.
+      uint64 t_base = v_min & ~(~0ULL >> (8 * len));
+      int t_max_delta_msb =
+          max(0, Bits::Log2Floor64((v_max - t_base) >> e_shift));
+      uint64 t_bytes = len + v.size() * ((t_max_delta_msb >> 3) + 1);
+      if (t_bytes < e_bytes) {
+        e_base = t_base;
+        e_base_len = len;
+        e_max_delta_msb = t_max_delta_msb;
+        e_bytes = t_bytes;
+      }
+    }
+    // It takes one extra byte to encode odd shifts (i.e., the case where all
+    // S2CellIds are at the same level), so check whether we can get the same
+    // encoding size per delta using an even shift.
+    if ((e_shift & 1) && (e_max_delta_msb & 7) != 7) --e_shift;
+  }
+  S2_DCHECK_LE(e_base_len, 7);
+  S2_DCHECK_LE(e_shift, 56);
+  encoder->Ensure(2 + e_base_len);
+
+  // As described above, "shift" and "base_len" are encoded in 1 or 2 bytes.
+  // "shift_code" is 5 bits:
+  //   values <= 28 represent even shifts in the range 0..56
+  //   values 29, 30 represent odd shifts 1 and 3
+  //   value 31 indicates that the shift is odd and encoded in the next byte
+  int shift_code = e_shift >> 1;
+  if (e_shift & 1) shift_code = min(31, shift_code + 29);
+  encoder->put8((shift_code << 3) | e_base_len);
+  if (shift_code == 31) {
+    encoder->put8(e_shift >> 1);  // Shift is always odd, so 3 bits unused.
+  }
+  // Encode the "base_len" most-significant bytes of "base".
+  uint64 base_bytes = e_base >> (64 - 8 * max(1, e_base_len));
+  EncodeUintWithLength<uint64>(base_bytes, e_base_len, encoder);
+
+  // Finally, encode the vector of deltas.
+  vector<uint64> deltas;
+  deltas.reserve(v.size());
+  for (auto cellid : v) {
+    deltas.push_back((cellid.id() - e_base) >> e_shift);
+  }
+  EncodeUintVector<uint64>(deltas, encoder);
+}
+
+bool EncodedS2CellIdVector::Init(Decoder* decoder) {
+  // All encodings have at least 2 bytes (one for our header and one for the
+  // EncodedUintVector header), so this is safe.
+  if (decoder->avail() < 2) return false;
+
+  // Invert the encoding of (shift_code, base_len) described above.
+  int code_plus_len = decoder->get8();
+  int shift_code = code_plus_len >> 3;
+  if (shift_code == 31) {
+    shift_code = 29 + decoder->get8();
+  }
+  // Decode the "base_len" most-significant bytes of "base".
+  int base_len = code_plus_len & 7;
+  if (!DecodeUintWithLength(base_len, decoder, &base_)) return false;
+  base_ <<= 64 - 8 * max(1, base_len);
+
+  // Invert the encoding of "shift_code" described above.
+  if (shift_code >= 29) {
+    shift_ = 2 * (shift_code - 29) + 1;
+    base_ |= 1ULL << (shift_ - 1);
+  } else {
+    shift_ = 2 * shift_code;
+  }
+  return deltas_.Init(decoder);
+}
+
+vector<S2CellId> EncodedS2CellIdVector::Decode() const {
+  vector<S2CellId> result(size());
+  for (int i = 0; i < size(); ++i) {
+    result[i] = (*this)[i];
+  }
+  return result;
+}
+
+}  // namespace s2coding