@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/encoded_string_vector.h

@@ -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)
+
+#ifndef S2_ENCODED_STRING_VECTOR_H_
+#define S2_ENCODED_STRING_VECTOR_H_
+
+#include <memory>
+#include <string>
+#include "s2/third_party/absl/strings/string_view.h"
+#include "s2/third_party/absl/types/span.h"
+#include "s2/encoded_uint_vector.h"
+
+namespace s2coding {
+
+// This class allows an EncodedStringVector to be created by adding strings
+// incrementally.  It also supports adding strings that are the output of
+// another Encoder.  For example, to create a vector of encoded S2Polygons,
+// you can do this:
+//
+// void EncodePolygons(const vector<S2Polygon*>& polygons, Encoder* encoder) {
+//   StringVectorEncoder encoded_polygons;
+//   for (auto polygon : polygons) {
+//     polygon->Encode(encoded_polygons.AddViaEncoder());
+//   }
+//   encoded_polygons.Encode(encoder);
+// }
+class StringVectorEncoder {
+ public:
+  StringVectorEncoder();
+
+  // Adds a string to the encoded vector.
+  void Add(const string& str);
+
+  // Adds a string to the encoded vector by means of the given Encoder.  The
+  // string consists of all output added to the encoder before the next call
+  // to any method of this class (after which the encoder is no longer valid).
+  Encoder* AddViaEncoder();
+
+  // Appends the EncodedStringVector representation to the given Encoder.
+  //
+  // REQUIRES: "encoder" uses the default constructor, so that its buffer
+  //           can be enlarged as necessary by calling Ensure(int).
+  void Encode(Encoder* encoder);
+
+  // Encodes a vector of strings in a format that can later be decoded as an
+  // EncodedStringVector.
+  //
+  // REQUIRES: "encoder" uses the default constructor, so that its buffer
+  //           can be enlarged as necessary by calling Ensure(int).
+  static void Encode(absl::Span<const string> v, Encoder* encoder);
+
+ private:
+  // A vector consisting of the starting offset of each string in the
+  // encoder's data buffer, plus a final entry pointing just past the end of
+  // the last string.
+  std::vector<uint64> offsets_;
+  Encoder data_;
+};
+
+// This class represents an encoded vector of strings.  Values are decoded
+// only when they are accessed.  This allows for very fast initialization and
+// no additional memory use beyond the encoded data.  The encoded data is not
+// owned by this class; typically it points into a large contiguous buffer
+// that contains other encoded data as well.
+//
+// This is one of several helper classes that allow complex data structures to
+// be initialized from an encoded format in constant time and then decoded on
+// demand.  This can be a big performance advantage when only a small part of
+// the data structure is actually used.
+class EncodedStringVector {
+ public:
+  // Constructs an uninitialized object; requires Init() to be called.
+  EncodedStringVector() {}
+
+  // Initializes the EncodedStringVector.  Returns false on errors, leaving
+  // the vector in an unspecified state.
+  //
+  // REQUIRES: The Decoder data buffer must outlive this object.
+  bool Init(Decoder* decoder);
+
+  // Resets the vector to be empty.
+  void Clear();
+
+  // Returns the size of the original vector.
+  size_t size() const;
+
+  // Returns the string at the given index.
+  absl::string_view operator[](int i) const;
+
+  // Returns a Decoder initialized with the string at the given index.
+  Decoder GetDecoder(int i) const;
+
+  // Returns a pointer to the start of the string at the given index.  This is
+  // faster than operator[] but returns an unbounded string.
+  const char* GetStart(int i) const;
+
+  // Returns the entire vector of original strings.  Requires that the
+  // data buffer passed to the constructor persists until the result vector is
+  // no longer needed.
+  std::vector<absl::string_view> Decode() const;
+
+ private:
+  EncodedUintVector<uint64> offsets_;
+  const char* data_;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline void StringVectorEncoder::Add(const string& str) {
+  offsets_.push_back(data_.length());
+  data_.Ensure(str.size());
+  data_.putn(str.data(), str.size());
+}
+
+inline Encoder* StringVectorEncoder::AddViaEncoder() {
+  offsets_.push_back(data_.length());
+  return &data_;
+}
+
+inline void EncodedStringVector::Clear() {
+  offsets_.Clear();
+  data_ = nullptr;
+}
+
+inline size_t EncodedStringVector::size() const {
+  return offsets_.size();
+}
+
+inline absl::string_view EncodedStringVector::operator[](int i) const {
+  uint64 start = (i == 0) ? 0 : offsets_[i - 1];
+  uint64 limit = offsets_[i];
+  return absl::string_view(data_ + start, limit - start);
+}
+
+inline Decoder EncodedStringVector::GetDecoder(int i) const {
+  uint64 start = (i == 0) ? 0 : offsets_[i - 1];
+  uint64 limit = offsets_[i];
+  return Decoder(data_ + start, limit - start);
+}
+
+inline const char* EncodedStringVector::GetStart(int i) const {
+  uint64 start = (i == 0) ? 0 : offsets_[i - 1];
+  return data_ + start;
+}
+
+}  // namespace s2coding
+
+#endif  // S2_ENCODED_STRING_VECTOR_H_

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

@@ -0,0 +1,69 @@
+// 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_string_vector.h"
+
+#include <vector>
+#include <gtest/gtest.h>
+#include "s2/third_party/absl/strings/string_view.h"
+
+using absl::string_view;
+using std::vector;
+
+namespace s2coding {
+
+void TestEncodedStringVector(const vector<string>& input,
+                             size_t expected_bytes) {
+  Encoder encoder;
+  StringVectorEncoder::Encode(input, &encoder);
+  EXPECT_EQ(expected_bytes, encoder.length());
+  Decoder decoder(encoder.base(), encoder.length());
+  EncodedStringVector actual;
+  ASSERT_TRUE(actual.Init(&decoder));
+  vector<string_view> expected;
+  for (const auto& str : input) {
+    expected.push_back(string_view(str));
+  }
+  EXPECT_EQ(actual.Decode(), expected);
+}
+
+TEST(EncodedStringVectorTest, Empty) {
+  TestEncodedStringVector({}, 1);
+}
+
+TEST(EncodedStringVectorTest, EmptyString) {
+  TestEncodedStringVector({""}, 2);
+}
+
+TEST(EncodedStringVectorTest, RepeatedEmptyStrings) {
+  TestEncodedStringVector({"", "", ""}, 4);
+}
+
+TEST(EncodedStringVectorTest, OneString) {
+  TestEncodedStringVector({"apples"}, 8);
+}
+
+TEST(EncodedStringVectorTest, TwoStrings) {
+  TestEncodedStringVector({"fuji", "mutsu"}, 12);
+}
+
+TEST(EncodedStringVectorTest, TwoBigStrings) {
+  TestEncodedStringVector({string(10000, 'x'), string(100000, 'y')},
+                          110007);
+}
+
+}  // namespace s2coding

package/third_party/s2geometry/src/s2/encoded_uint_vector.h

@@ -0,0 +1,299 @@
+// 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)
+
+#ifndef S2_ENCODED_UINT_VECTOR_H_
+#define S2_ENCODED_UINT_VECTOR_H_
+
+#include <type_traits>
+#include <vector>
+#include "s2/third_party/absl/base/internal/unaligned_access.h"
+#include "s2/third_party/absl/types/span.h"
+#include "s2/util/coding/coder.h"
+
+namespace s2coding {
+
+// Encodes a vector of unsigned integers in a format that can later be
+// decoded as an EncodedUintVector.
+//
+// REQUIRES: T is an unsigned integer type.
+// REQUIRES: 2 <= sizeof(T) <= 8
+// REQUIRES: "encoder" uses the default constructor, so that its buffer
+//           can be enlarged as necessary by calling Ensure(int).
+template <class T>
+void EncodeUintVector(absl::Span<const T> v, Encoder* encoder);
+
+// This class represents an encoded vector of unsigned integers of type T.
+// Values are decoded only when they are accessed.  This allows for very fast
+// initialization and no additional memory use beyond the encoded data.
+// The encoded data is not owned by this class; typically it points into a
+// large contiguous buffer that contains other encoded data as well.
+//
+// This is one of several helper classes that allow complex data structures to
+// be initialized from an encoded format in constant time and then decoded on
+// demand.  This can be a big performance advantage when only a small part of
+// the data structure is actually used.
+//
+// Values are encoded using a fixed number of bytes per value, where the
+// number of bytes depends on the largest value present.
+//
+// REQUIRES: T is an unsigned integer type.
+// REQUIRES: 2 <= sizeof(T) <= 8
+template <class T>
+class EncodedUintVector {
+ public:
+  static_assert(std::is_unsigned<T>::value, "Unsupported signed integer");
+  static_assert(sizeof(T) & 0xe, "Unsupported integer length");
+
+  // Constructs an uninitialized object; requires Init() to be called.
+  EncodedUintVector() {}
+
+  // Initializes the EncodedUintVector.  Returns false on errors, leaving the
+  // vector in an unspecified state.
+  //
+  // REQUIRES: The Decoder data buffer must outlive this object.
+  bool Init(Decoder* decoder);
+
+  // Resets the vector to be empty.
+  void Clear();
+
+  // Returns the size of the original vector.
+  size_t size() const;
+
+  // Returns the element at the given index.
+  T operator[](int i) const;
+
+  // Returns the index of the first element x such that (x >= target), or
+  // size() if no such element exists.
+  //
+  // REQUIRES: The vector elements are sorted in non-decreasing order.
+  size_t lower_bound(T target) const;
+
+  // Decodes and returns the entire original vector.
+  std::vector<T> Decode() const;
+
+ private:
+  template <int length> size_t lower_bound(T target) const;
+
+  const char* data_;
+  uint32 size_;
+  uint8 len_;
+};
+
+// Encodes an unsigned integer in little-endian format using "length" bytes.
+// (The client must ensure that the encoder's buffer is large enough.)
+//
+// REQUIRES: T is an unsigned integer type.
+// REQUIRES: 2 <= sizeof(T) <= 8
+// REQUIRES: 0 <= length <= sizeof(T)
+// REQUIRES: value < 256 ** length
+// REQUIRES: encoder->avail() >= length
+template <class T>
+void EncodeUintWithLength(T value, int length, Encoder* encoder);
+
+// Decodes a variable-length integer consisting of "length" bytes starting at
+// "ptr" in little-endian format.
+//
+// REQUIRES: T is an unsigned integer type.
+// REQUIRES: 2 <= sizeof(T) <= 8
+// REQUIRES: 0 <= length <= sizeof(T)
+template <class T>
+T GetUintWithLength(const void* ptr, int length);
+
+// Decodes and consumes a variable-length integer consisting of "length" bytes
+// in little-endian format.  Returns false if not enough bytes are available.
+//
+// REQUIRES: T is an unsigned integer type.
+// REQUIRES: 2 <= sizeof(T) <= 8
+// REQUIRES: 0 <= length <= sizeof(T)
+template <class T>
+bool DecodeUintWithLength(int length, Decoder* decoder, T* result);
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+template <class T>
+inline void EncodeUintWithLength(T value, int length, Encoder* encoder) {
+  static_assert(std::is_unsigned<T>::value, "Unsupported signed integer");
+  static_assert(sizeof(T) & 0xe, "Unsupported integer length");
+  S2_DCHECK(length >= 0 && length <= sizeof(T));
+  S2_DCHECK_GE(encoder->avail(), length);
+
+  while (--length >= 0) {
+    encoder->put8(value);
+    value >>= 8;
+  }
+  S2_DCHECK_EQ(value, 0);
+}
+
+template <class T>
+inline T GetUintWithLength(const char* ptr, int length) {
+  static_assert(std::is_unsigned<T>::value, "Unsupported signed integer");
+  static_assert(sizeof(T) & 0xe, "Unsupported integer length");
+  S2_DCHECK(length >= 0 && length <= sizeof(T));
+
+  // Note that the following code is faster than any of the following:
+  //
+  //  - A loop that repeatedly loads and shifts one byte.
+  //  - memcpying "length" bytes to a local variable of type T.
+  //  - A switch statement that handles each length optimally.
+  //
+  // The following code is slightly faster:
+  //
+  //   T mask = (length == 0) ? 0 : ~T{0} >> 8 * (sizeof(T) - length);
+  //   return *reinterpret_cast<const T*>(ptr) & mask;
+  //
+  // However this technique is unsafe because in extremely rare cases it might
+  // access out-of-bounds heap memory.  (This can only happen if "ptr" is
+  // within (sizeof(T) - length) bytes of the end of a memory page and the
+  // following page in the address space is unmapped.)
+
+  if (length & sizeof(T)) {
+    if (sizeof(T) == 8) return ABSL_INTERNAL_UNALIGNED_LOAD64(ptr);
+    if (sizeof(T) == 4) return ABSL_INTERNAL_UNALIGNED_LOAD32(ptr);
+    if (sizeof(T) == 2) return ABSL_INTERNAL_UNALIGNED_LOAD16(ptr);
+    S2_DCHECK_EQ(sizeof(T), 1);
+    return *ptr;
+  }
+  T x = 0;
+  ptr += length;
+  if (sizeof(T) > 4 && (length & 4)) {
+    x = ABSL_INTERNAL_UNALIGNED_LOAD32(ptr -= sizeof(uint32));
+  }
+  if (sizeof(T) > 2 && (length & 2)) {
+    x = (x << 16) + ABSL_INTERNAL_UNALIGNED_LOAD16(ptr -= sizeof(uint16));
+  }
+  if (sizeof(T) > 1 && (length & 1)) {
+    x = (x << 8) + static_cast<uint8>(*--ptr);
+  }
+  return x;
+}
+
+template <class T>
+bool DecodeUintWithLength(int length, Decoder* decoder, T* result) {
+  if (decoder->avail() < length) return false;
+  const char* ptr = reinterpret_cast<const char*>(decoder->ptr());
+  *result = GetUintWithLength<T>(ptr, length);
+  decoder->skip(length);
+  return true;
+}
+
+template <class T>
+void EncodeUintVector(absl::Span<const T> v, Encoder* encoder) {
+  // The encoding is as follows:
+  //
+  //   varint64: (v.size() * sizeof(T)) | (len - 1)
+  //   array of v.size() elements ["len" bytes each]
+  //
+  // Note that we don't allow (len == 0) since this would require an extra bit
+  // to encode the length.
+
+  T one_bits = 1;  // Ensures len >= 1.
+  for (auto x : v) one_bits |= x;
+  int len = (Bits::FindMSBSetNonZero64(one_bits) >> 3) + 1;
+  S2_DCHECK(len >= 1 && len <= 8);
+
+  // Note that the multiplication is optimized into a bit shift.
+  encoder->Ensure(Varint::kMax64 + v.size() * len);
+  uint64 size_len = (uint64{v.size()} * sizeof(T)) | (len - 1);
+  encoder->put_varint64(size_len);
+  for (auto x : v) {
+    EncodeUintWithLength(x, len, encoder);
+  }
+}
+
+template <class T>
+bool EncodedUintVector<T>::Init(Decoder* decoder) {
+  uint64 size_len;
+  if (!decoder->get_varint64(&size_len)) return false;
+  size_ = size_len / sizeof(T);  // Optimized into bit shift.
+  len_ = (size_len & (sizeof(T) - 1)) + 1;
+  if (size_ > std::numeric_limits<size_t>::max() / sizeof(T)) return false;
+  size_t bytes = size_ * len_;
+  if (decoder->avail() < bytes) return false;
+  data_ = reinterpret_cast<const char*>(decoder->ptr());
+  decoder->skip(bytes);
+  return true;
+}
+
+template <class T>
+void EncodedUintVector<T>::Clear() {
+  size_ = 0;
+  data_ = nullptr;
+}
+
+template <class T>
+inline size_t EncodedUintVector<T>::size() const {
+  return size_;
+}
+
+template <class T>
+inline T EncodedUintVector<T>::operator[](int i) const {
+  S2_DCHECK(i >= 0 && i < size_);
+  return GetUintWithLength<T>(data_ + i * len_, len_);
+}
+
+template <class T>
+size_t EncodedUintVector<T>::lower_bound(T target) const {
+  static_assert(sizeof(T) & 0xe, "Unsupported integer length");
+  S2_DCHECK(len_ >= 1 && len_ <= sizeof(T));
+
+  // TODO(ericv): Consider using the unused 28 bits of "len_" to store the
+  // last result of lower_bound() to be used as a hint.  This should help in
+  // common situation where the same element is looked up repeatedly.  This
+  // would require declaring the new field (length_lower_bound_hint_) as
+  // mutable std::atomic<uint32> (accessed using std::memory_order_relaxed)
+  // with a custom copy constructor that resets the hint component to zero.
+  switch (len_) {
+    case 1: return lower_bound<1>(target);
+    case 2: return lower_bound<2>(target);
+    case 3: return lower_bound<3>(target);
+    case 4: return lower_bound<4>(target);
+    case 5: return lower_bound<5>(target);
+    case 6: return lower_bound<6>(target);
+    case 7: return lower_bound<7>(target);
+    default: return lower_bound<8>(target);
+  }
+}
+
+template <class T> template <int length>
+inline size_t EncodedUintVector<T>::lower_bound(T target) const {
+  size_t lo = 0, hi = size_;
+  while (lo < hi) {
+    size_t mid = (lo + hi) >> 1;
+    T value = GetUintWithLength<T>(data_ + mid * length, length);
+    if (value < target) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return lo;
+}
+
+template <class T>
+std::vector<T> EncodedUintVector<T>::Decode() const {
+  std::vector<T> result(size_);
+  for (int i = 0; i < size_; ++i) {
+    result[i] = (*this)[i];
+  }
+  return result;
+}
+
+}  // namespace s2coding
+
+#endif  // S2_ENCODED_UINT_VECTOR_H_

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

@@ -0,0 +1,124 @@
+// 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_uint_vector.h"
+
+#include <vector>
+#include <gtest/gtest.h>
+
+using std::vector;
+
+namespace s2coding {
+
+static_assert(sizeof(EncodedUintVector<uint64>) == 16, "too big");
+
+template <class T>
+void TestEncodedUintVector(const vector<T>& expected, size_t expected_bytes) {
+  Encoder encoder;
+  EncodeUintVector<T>(expected, &encoder);
+  EXPECT_EQ(expected_bytes, encoder.length());
+  Decoder decoder(encoder.base(), encoder.length());
+  EncodedUintVector<T> actual;
+  ASSERT_TRUE(actual.Init(&decoder));
+  EXPECT_EQ(actual.Decode(), expected);
+}
+
+TEST(EncodedUintVectorTest, Empty) {
+  TestEncodedUintVector(vector<uint32>{}, 1);
+}
+
+TEST(EncodedUintVectorTest, Zero) {
+  TestEncodedUintVector(vector<uint64>{0}, 2);
+}
+
+TEST(EncodedUintVectorTest, RepeatedZeros) {
+  TestEncodedUintVector(vector<uint16>{0, 0, 0}, 4);
+}
+
+TEST(EncodedUintVectorTest, MaxInt) {
+  TestEncodedUintVector(vector<uint64>{~0ULL}, 9);
+}
+
+TEST(EncodedUintVectorTest, OneByte) {
+  TestEncodedUintVector(vector<uint64>{0, 255, 1, 254}, 5);
+}
+
+TEST(EncodedUintVectorTest, TwoBytes) {
+  TestEncodedUintVector(vector<uint64>{0, 255, 256, 254}, 9);
+}
+
+TEST(EncodedUintVectorTest, ThreeBytes) {
+  TestEncodedUintVector(vector<uint64>{0xffffff, 0x0102, 0, 0x050403}, 13);
+}
+
+TEST(EncodedUintVectorTest, EightBytes) {
+  TestEncodedUintVector(vector<uint64>{~0ULL, 0, 0x0102030405060708}, 25);
+}
+
+template <class T>
+vector<T> MakeSortedTestVector(int bytes_per_value, int num_values) {
+  S2_DCHECK_LE(bytes_per_value, sizeof(T));
+  T limit_value = ~T{0} >> (8 * (sizeof(T) - bytes_per_value));
+  vector<T> values;
+  for (int i = 0; i + 1 < num_values; ++i) {
+    values.push_back(limit_value * (static_cast<double>(i) / (num_values - 1)));
+  }
+  // The last value needs special handling since casting it to "double" loses
+  // precision when T == uint64.
+  values.push_back(limit_value);
+  S2_CHECK(std::is_sorted(values.begin(), values.end()));
+  return values;
+}
+
+template <class T>
+EncodedUintVector<T> MakeEncodedVector(const vector<T>& values,
+                                       Encoder* encoder) {
+  EncodeUintVector<T>(values, encoder);
+  Decoder decoder(encoder->base(), encoder->length());
+  EncodedUintVector<T> actual;
+  S2_CHECK(actual.Init(&decoder));
+  return actual;
+}
+
+template <class T>
+void TestLowerBound(int bytes_per_value, int num_values) {
+  auto v = MakeSortedTestVector<T>(bytes_per_value, num_values);
+  Encoder encoder;
+  auto actual = MakeEncodedVector(v, &encoder);
+  for (T x : v) {
+    EXPECT_EQ(std::lower_bound(v.begin(), v.end(), x) - v.begin(),
+              actual.lower_bound(x));
+    if (x > 0) {
+      EXPECT_EQ(std::lower_bound(v.begin(), v.end(), x - 1) - v.begin(),
+                actual.lower_bound(x - 1));
+    }
+  }
+}
+
+TEST(EncodedUintVector, LowerBound) {
+  for (int bytes_per_value = 8; bytes_per_value <= 8; ++bytes_per_value) {
+    TestLowerBound<uint64>(bytes_per_value, 10);
+    if (bytes_per_value <= 4) {
+      TestLowerBound<uint32>(bytes_per_value, 500);
+      if (bytes_per_value <= 2) {
+        TestLowerBound<uint16>(bytes_per_value, 100);
+      }
+    }
+  }
+}
+
+}  // namespace s2coding