chromium/third_party/grpc/src/src/core/lib/slice/slice.cc

//
//
// Copyright 2015 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.
//
//

#include <grpc/support/port_platform.h>

#include "src/core/lib/slice/slice.h"

#include <string.h>

#include <new>

#include <grpc/slice.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>

#include "src/core/lib/gprpp/memory.h"
#include "src/core/lib/slice/slice_internal.h"
#include "src/core/lib/slice/slice_refcount.h"

char* grpc_slice_to_c_string(grpc_slice slice) { … }

grpc_slice grpc_empty_slice(void) { … }

grpc_slice grpc_slice_copy(grpc_slice s) { … }

namespace grpc_core {

// grpc_slice_new support structures - we create a refcount object extended
// with the user provided data pointer & destroy function
class NewSliceRefcount : public grpc_slice_refcount { … };

}  // namespace grpc_core

size_t grpc_slice_memory_usage(grpc_slice s) { … }

grpc_slice grpc_slice_from_static_buffer(const void* s, size_t len) { … }

grpc_slice grpc_slice_from_static_string(const char* s) { … }

grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
                                         void (*destroy)(void*),
                                         void* user_data) { … }

grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*)) { … }

namespace grpc_core {
// grpc_slice_new_with_len support structures - we create a refcount object
// extended with the user provided data pointer & destroy function
class NewWithLenSliceRefcount : public grpc_slice_refcount { … };

/// grpc_slice_from_moved_(string|buffer) ref count .
class MovedStringSliceRefCount : public grpc_slice_refcount { … };

// grpc_slice_from_cpp_string() ref count.
class MovedCppStringSliceRefCount : public grpc_slice_refcount { … };

}  // namespace grpc_core

grpc_slice grpc_slice_new_with_len(void* p, size_t len,
                                   void (*destroy)(void*, size_t)) { … }

grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t len) { … }

grpc_slice grpc_slice_from_copied_string(const char* source) { … }

grpc_slice grpc_slice_from_moved_buffer(grpc_core::UniquePtr<char> p,
                                        size_t len) { … }

grpc_slice grpc_slice_from_moved_string(grpc_core::UniquePtr<char> p) { … }

grpc_slice grpc_slice_from_cpp_string(std::string str) { … }

grpc_slice grpc_slice_malloc_large(size_t length) { … }

grpc_slice grpc_slice_malloc(size_t length) { … }

static grpc_slice sub_no_ref(const grpc_slice& source, size_t begin,
                             size_t end) { … }

grpc_slice grpc_slice_sub_no_ref(grpc_slice source, size_t begin, size_t end) { … }

grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) { … }

grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
                                           grpc_slice_ref_whom ref_whom) { … }

grpc_slice grpc_slice_split_tail(grpc_slice* source, size_t split) { … }

grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) { … }

int grpc_slice_eq(grpc_slice a, grpc_slice b) { … }

int grpc_slice_differs_refcounted(const grpc_slice& a,
                                  const grpc_slice& b_not_inline) { … }

int grpc_slice_cmp(grpc_slice a, grpc_slice b) { … }

int grpc_slice_str_cmp(grpc_slice a, const char* b) { … }

int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b) { … }

int grpc_slice_buf_start_eq(grpc_slice a, const void* b, size_t len) { … }

int grpc_slice_rchr(grpc_slice s, char c) { … }

int grpc_slice_chr(grpc_slice s, char c) { … }

int grpc_slice_slice(grpc_slice haystack, grpc_slice needle) { … }

grpc_slice grpc_slice_dup(grpc_slice a) { … }

grpc_slice grpc_slice_ref(grpc_slice slice) { … }

void grpc_slice_unref(grpc_slice slice) { … }