grpc 1.27.0.pre1 → 1.30.1

data/src/core/lib/gprpp/inlined_vector.h

@@ -1,246 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * 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 GRPC_CORE_LIB_GPRPP_INLINED_VECTOR_H
-#define GRPC_CORE_LIB_GPRPP_INLINED_VECTOR_H
-
-#include <grpc/support/port_platform.h>
-
-#include <cassert>
-#include <cstring>
-
-#include "src/core/lib/gprpp/memory.h"
-
-#if GRPC_USE_ABSL
-#include "absl/container/inlined_vector.h"
-#endif
-
-namespace grpc_core {
-
-#if GRPC_USE_ABSL
-
-template <typename T, size_t N, typename A = std::allocator<T>>
-using InlinedVector = absl::InlinedVector<T, N, A>;
-
-#else
-
-// NOTE: We eventually want to use absl::InlinedVector here.  However,
-// there are currently build problems that prevent us from using absl.
-// In the interim, we define a custom implementation as a place-holder,
-// with the intent to eventually replace this with the absl
-// implementation.
-//
-// This place-holder implementation does not implement the full set of
-// functionality from the absl version; it has just the methods that we
-// currently happen to need in gRPC.  If additional functionality is
-// needed before this gets replaced with the absl version, it can be
-// added, with the following proviso:
-//
-// ANY METHOD ADDED HERE MUST COMPLY WITH THE INTERFACE IN THE absl
-// IMPLEMENTATION!
-//
-// TODO(nnoble, roth): Replace this with absl::InlinedVector once we
-// integrate absl into the gRPC build system in a usable way.
-template <typename T, size_t N>
-class InlinedVector {
- public:
-  InlinedVector() { init_data(); }
-  ~InlinedVector() { destroy_elements(); }
-
-  // copy constructor
-  InlinedVector(const InlinedVector& v) {
-    init_data();
-    copy_from(v);
-  }
-
-  InlinedVector& operator=(const InlinedVector& v) {
-    if (this != &v) {
-      clear();
-      copy_from(v);
-    }
-    return *this;
-  }
-
-  // move constructor
-  InlinedVector(InlinedVector&& v) {
-    init_data();
-    move_from(v);
-  }
-
-  InlinedVector& operator=(InlinedVector&& v) {
-    if (this != &v) {
-      clear();
-      move_from(v);
-    }
-    return *this;
-  }
-
-  T* data() {
-    return dynamic_ != nullptr ? dynamic_ : reinterpret_cast<T*>(inline_);
-  }
-
-  const T* data() const {
-    return dynamic_ != nullptr ? dynamic_ : reinterpret_cast<const T*>(inline_);
-  }
-
-  T& operator[](size_t offset) {
-    assert(offset < size_);
-    return data()[offset];
-  }
-
-  const T& operator[](size_t offset) const {
-    assert(offset < size_);
-    return data()[offset];
-  }
-
-  bool operator==(const InlinedVector& other) const {
-    if (size_ != other.size_) return false;
-    for (size_t i = 0; i < size_; ++i) {
-      // Note that this uses == instead of != so that the data class doesn't
-      // have to implement !=.
-      if (!(data()[i] == other.data()[i])) return false;
-    }
-    return true;
-  }
-
-  bool operator!=(const InlinedVector& other) const {
-    return !(*this == other);
-  }
-
-  void reserve(size_t capacity) {
-    if (capacity > capacity_) {
-      T* new_dynamic =
-          std::alignment_of<T>::value == 0
-              ? static_cast<T*>(gpr_malloc(sizeof(T) * capacity))
-              : static_cast<T*>(gpr_malloc_aligned(
-                    sizeof(T) * capacity, std::alignment_of<T>::value));
-      move_elements(data(), new_dynamic, size_);
-      free_dynamic();
-      dynamic_ = new_dynamic;
-      capacity_ = capacity;
-    }
-  }
-
-  void resize(size_t new_size) {
-    while (new_size > size_) emplace_back();
-    while (new_size < size_) pop_back();
-  }
-
-  template <typename... Args>
-  void emplace_back(Args&&... args) {
-    if (size_ == capacity_) {
-      reserve(capacity_ * 2);
-    }
-    new (&(data()[size_])) T(std::forward<Args>(args)...);
-    ++size_;
-  }
-
-  void push_back(const T& value) { emplace_back(value); }
-
-  void push_back(T&& value) { emplace_back(std::move(value)); }
-
-  void pop_back() {
-    assert(!empty());
-    size_t s = size();
-    T& value = data()[s - 1];
-    value.~T();
-    size_--;
-  }
-
-  size_t size() const { return size_; }
-  bool empty() const { return size_ == 0; }
-
-  size_t capacity() const { return capacity_; }
-
-  void clear() {
-    destroy_elements();
-    init_data();
-  }
-
- private:
-  void copy_from(const InlinedVector& v) {
-    // if v is allocated, make sure we have enough capacity.
-    if (v.dynamic_ != nullptr) {
-      reserve(v.capacity_);
-    }
-    // copy over elements
-    for (size_t i = 0; i < v.size_; ++i) {
-      new (&(data()[i])) T(v[i]);
-    }
-    // copy over metadata
-    size_ = v.size_;
-    capacity_ = v.capacity_;
-  }
-
-  void move_from(InlinedVector& v) {
-    // if v is allocated, then we steal its dynamic array; otherwise, we
-    // move the elements individually.
-    if (v.dynamic_ != nullptr) {
-      dynamic_ = v.dynamic_;
-    } else {
-      move_elements(v.data(), data(), v.size_);
-    }
-    // copy over metadata
-    size_ = v.size_;
-    capacity_ = v.capacity_;
-    // null out the original
-    v.init_data();
-  }
-
-  static void move_elements(T* src, T* dst, size_t num_elements) {
-    for (size_t i = 0; i < num_elements; ++i) {
-      new (&dst[i]) T(std::move(src[i]));
-      src[i].~T();
-    }
-  }
-
-  void init_data() {
-    dynamic_ = nullptr;
-    size_ = 0;
-    capacity_ = N;
-  }
-
-  void destroy_elements() {
-    for (size_t i = 0; i < size_; ++i) {
-      T& value = data()[i];
-      value.~T();
-    }
-    free_dynamic();
-  }
-
-  void free_dynamic() {
-    if (dynamic_ != nullptr) {
-      if (std::alignment_of<T>::value == 0) {
-        gpr_free(dynamic_);
-      } else {
-        gpr_free_aligned(dynamic_);
-      }
-    }
-  }
-
-  typename std::aligned_storage<sizeof(T)>::type inline_[N];
-  T* dynamic_;
-  size_t size_;
-  size_t capacity_;
-};
-
-#endif
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_INLINED_VECTOR_H */

data/src/core/lib/gprpp/optional.h

@@ -1,74 +0,0 @@
-/*
- *
- * Copyright 2019 gRPC authors.
- *
- * 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 GRPC_CORE_LIB_GPRPP_OPTIONAL_H
-#define GRPC_CORE_LIB_GPRPP_OPTIONAL_H
-
-#include <grpc/support/port_platform.h>
-
-// TODO(yashykt): Remove false once migration to abseil is done.
-#if false && GRPC_USE_ABSL
-
-#include "absl/types/optional.h"
-
-namespace grpc_core {
-
-template <typename T>
-using Optional = absl::optional<T>;
-
-}  // namespace grpc_core
-
-#else
-
-#include <utility>
-
-namespace grpc_core {
-
-/* A make-shift alternative for absl::Optional. This can be removed in favor of
- * that once absl dependencies can be introduced. */
-template <typename T>
-class Optional {
- public:
-  Optional() : value_() {}
-
-  void set(const T& val) {
-    value_ = val;
-    set_ = true;
-  }
-
-  void set(T&& val) {
-    value_ = std::move(val);
-    set_ = true;
-  }
-
-  bool has_value() const { return set_; }
-
-  void reset() { set_ = false; }
-
-  T value() const { return value_; }
-
- private:
-  T value_;
-  bool set_ = false;
-};
-
-} /* namespace grpc_core */
-
-#endif
-
-#endif /* GRPC_CORE_LIB_GPRPP_OPTIONAL_H */

data/src/core/lib/gprpp/string_view.h

@@ -1,169 +0,0 @@
-/*
- *
- * Copyright 2019 gRPC authors.
- *
- * 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 GRPC_CORE_LIB_GPRPP_STRING_VIEW_H
-#define GRPC_CORE_LIB_GPRPP_STRING_VIEW_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/impl/codegen/slice.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <string>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
-
-#if GRPC_USE_ABSL
-#include "absl/strings/string_view.h"
-#endif
-
-namespace grpc_core {
-
-#if GRPC_USE_ABSL
-
-using StringView = absl::string_view;
-
-#else
-
-// Provides a light-weight view over a char array or a slice, similar but not
-// identical to absl::string_view.
-//
-// Any method that has the same name as absl::string_view MUST HAVE identical
-// semantics to what absl::string_view provides.
-//
-// Methods that are not part of absl::string_view API, must be clearly
-// annotated.
-//
-// StringView does not own the buffers that back the view. Callers must ensure
-// the buffer stays around while the StringView is accessible.
-//
-// Pass StringView by value in functions, since it is exactly two pointers in
-// size.
-//
-// The interface used here is not identical to absl::string_view. Notably, we
-// need to support slices while we cannot support std::string, and gpr string
-// style functions such as strdup() and cmp(). Once we switch to
-// absl::string_view this class will inherit from absl::string_view and add the
-// gRPC-specific APIs.
-class StringView final {
- public:
-  static constexpr size_t npos = std::numeric_limits<size_t>::max();
-
-  constexpr StringView(const char* ptr, size_t size) : ptr_(ptr), size_(size) {}
-  constexpr StringView(const char* ptr)
-      : StringView(ptr, ptr == nullptr ? 0 : strlen(ptr)) {}
-  constexpr StringView() : StringView(nullptr, 0) {}
-
-  constexpr const char* data() const { return ptr_; }
-  constexpr size_t size() const { return size_; }
-  constexpr bool empty() const { return size_ == 0; }
-
-  StringView substr(size_t start, size_t size = npos) {
-    GPR_DEBUG_ASSERT(start + size <= size_);
-    return StringView(ptr_ + start, std::min(size, size_ - start));
-  }
-
-  constexpr const char& operator[](size_t i) const { return ptr_[i]; }
-
-  const char& front() const { return ptr_[0]; }
-  const char& back() const { return ptr_[size_ - 1]; }
-
-  void remove_prefix(size_t n) {
-    GPR_DEBUG_ASSERT(n <= size_);
-    ptr_ += n;
-    size_ -= n;
-  }
-
-  void remove_suffix(size_t n) {
-    GPR_DEBUG_ASSERT(n <= size_);
-    size_ -= n;
-  }
-
-  size_t find(char c, size_t pos = 0) const {
-    if (empty() || pos >= size_) return npos;
-    const char* result =
-        static_cast<const char*>(memchr(ptr_ + pos, c, size_ - pos));
-    return result != nullptr ? result - ptr_ : npos;
-  }
-
-  void clear() {
-    ptr_ = nullptr;
-    size_ = 0;
-  }
-
-  // Converts to `std::basic_string`.
-  template <typename Allocator>
-  explicit operator std::basic_string<char, std::char_traits<char>, Allocator>()
-      const {
-    if (data() == nullptr) return {};
-    return std::basic_string<char, std::char_traits<char>, Allocator>(data(),
-                                                                      size());
-  }
-
-  // Compares with other.
-  inline int compare(StringView other) {
-    const size_t len = GPR_MIN(size(), other.size());
-    const int ret = strncmp(data(), other.data(), len);
-    if (ret != 0) return ret;
-    if (size() == other.size()) return 0;
-    if (size() < other.size()) return -1;
-    return 1;
-  }
-
- private:
-  const char* ptr_;
-  size_t size_;
-};
-
-inline bool operator==(StringView lhs, StringView rhs) {
-  return lhs.size() == rhs.size() &&
-         strncmp(lhs.data(), rhs.data(), lhs.size()) == 0;
-}
-
-inline bool operator!=(StringView lhs, StringView rhs) { return !(lhs == rhs); }
-
-inline bool operator<(StringView lhs, StringView rhs) {
-  return lhs.compare(rhs) < 0;
-}
-
-#endif  // GRPC_USE_ABSL
-
-// Converts grpc_slice to StringView.
-inline StringView StringViewFromSlice(const grpc_slice& slice) {
-  return StringView(reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(slice)),
-                    GRPC_SLICE_LENGTH(slice));
-}
-
-// Creates a dup of the string viewed by this class.
-// Return value is null-terminated and never nullptr.
-inline grpc_core::UniquePtr<char> StringViewToCString(const StringView sv) {
-  char* str = static_cast<char*>(gpr_malloc(sv.size() + 1));
-  if (sv.size() > 0) memcpy(str, sv.data(), sv.size());
-  str[sv.size()] = '\0';
-  return grpc_core::UniquePtr<char>(str);
-}
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_STRING_VIEW_H */