GRPC Core  9.0.0
Data Structures | Namespaces | Functions | Variables
slice.cc File Reference
#include <grpc/support/port_platform.h>
#include "src/core/lib/slice/slice_internal.h"
#include <grpc/slice.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <string.h>
#include "src/core/lib/gprpp/memory.h"
#include "src/core/lib/gprpp/ref_counted.h"
#include "src/core/lib/iomgr/exec_ctx.h"

Data Structures

class  grpc_core::NewSliceRefcount
 
class  grpc_core::NewWithLenSliceRefcount
 
class  grpc_core::MovedStringSliceRefCount
 grpc_slice_from_moved_(string|buffer) ref count . More...
 

Namespaces

 grpc_core
 Round Robin Policy.
 

Functions

char * grpc_slice_to_c_string (grpc_slice slice)
 Return a copy of slice as a C string. More...
 
grpc_slice grpc_empty_slice (void)
 
grpc_slice grpc_slice_copy (grpc_slice s)
 Copy slice - create a new slice that contains the same data as s. More...
 
grpc_slice grpc_slice_ref (grpc_slice slice)
 Increment the refcount of s. More...
 
void grpc_slice_unref (grpc_slice slice)
 Decrement the ref count of s. More...
 
size_t grpc_slice_memory_usage (grpc_slice s)
 
grpc_slice grpc_slice_from_static_buffer (const void *s, size_t len)
 Create a slice pointing to constant memory. More...
 
grpc_slice grpc_slice_from_static_string (const char *s)
 Create a slice pointing to constant memory. More...
 
grpc_slice grpc_slice_new_with_user_data (void *p, size_t len, void(*destroy)(void *), void *user_data)
 Equivalent to grpc_slice_new, but with a separate pointer that is passed to the destroy function. More...
 
grpc_slice grpc_slice_new (void *p, size_t len, void(*destroy)(void *))
 Create a slice pointing at some data. More...
 
grpc_slice grpc_slice_new_with_len (void *p, size_t len, void(*destroy)(void *, size_t))
 Equivalent to grpc_slice_new, but with a two argument destroy function that also takes the slice length. More...
 
grpc_slice grpc_slice_from_copied_buffer (const char *source, size_t length)
 Create a slice by copying a buffer. More...
 
grpc_slice grpc_slice_from_copied_string (const char *source)
 Create a slice by copying a string. More...
 
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_malloc_large (size_t length)
 
grpc_slice grpc_slice_malloc (size_t length)
 Equivalent to grpc_slice_new(malloc(len), len, free), but saves one malloc() call. More...
 
grpc_slice grpc_slice_sub_no_ref (grpc_slice source, size_t begin, size_t end)
 The same as grpc_slice_sub, but without altering the ref count. More...
 
grpc_core::UnmanagedMemorySlice grpc_slice_sub_no_ref (const grpc_core::UnmanagedMemorySlice &source, size_t begin, size_t end)
 
grpc_slice grpc_slice_sub (grpc_slice source, size_t begin, size_t end)
 Return a result slice derived from s, which shares a ref count with s, where result.data==s.data+begin, and result.length==end-begin. More...
 
grpc_slice grpc_slice_split_tail_maybe_ref (grpc_slice *source, size_t split, grpc_slice_ref_whom ref_whom)
 The same as grpc_slice_split_tail, but with an option to skip altering refcounts (grpc_slice_split_tail_maybe_ref(..., true) is equivalent to grpc_slice_split_tail(...)) More...
 
grpc_slice grpc_slice_split_tail (grpc_slice *source, size_t split)
 Splits s into two: modifies s to be s[0:split], and returns a new slice, sharing a refcount with s, that contains s[split:s.length]. More...
 
grpc_slice grpc_slice_split_head (grpc_slice *source, size_t split)
 Splits s into two: modifies s to be s[split:s.length], and returns a new slice, sharing a refcount with s, that contains s[0:split]. More...
 
int grpc_slice_default_eq_impl (grpc_slice a, grpc_slice b)
 
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)
 Returns <0 if a < b, ==0 if a == b, >0 if a > b The order is arbitrary, and is not guaranteed to be stable across different versions of the API. More...
 
int grpc_slice_str_cmp (grpc_slice a, const char *b)
 
int grpc_slice_is_equivalent (grpc_slice a, grpc_slice b)
 Do two slices point at the same memory, with the same length If a or b is inlined, actually compares data. More...
 
int grpc_slice_buf_start_eq (grpc_slice a, const void *b, size_t len)
 return non-zero if the first blen bytes of a are equal to b More...
 
int grpc_slice_rchr (grpc_slice s, char c)
 return the index of the last instance of c in s, or -1 if not found More...
 
int grpc_slice_chr (grpc_slice s, char c)
 
int grpc_slice_slice (grpc_slice haystack, grpc_slice needle)
 return the index of the first occurrence of needle in haystack, or -1 if it's not found More...
 
grpc_slice grpc_slice_dup (grpc_slice a)
 Return a slice pointing to newly allocated memory that has the same contents as s. More...
 

Variables

grpc_slice_refcount grpc_core::kNoopRefcount (grpc_slice_refcount::Type::NOP)
 

Function Documentation

◆ grpc_empty_slice()

grpc_slice grpc_empty_slice ( void  )

◆ grpc_slice_buf_start_eq()

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

return non-zero if the first blen bytes of a are equal to b

◆ grpc_slice_chr()

int grpc_slice_chr ( grpc_slice  s,
char  c 
)

◆ grpc_slice_cmp()

int grpc_slice_cmp ( grpc_slice  a,
grpc_slice  b 
)

Returns <0 if a < b, ==0 if a == b, >0 if a > b The order is arbitrary, and is not guaranteed to be stable across different versions of the API.

◆ grpc_slice_copy()

grpc_slice grpc_slice_copy ( grpc_slice  s)

Copy slice - create a new slice that contains the same data as s.

◆ grpc_slice_default_eq_impl()

int grpc_slice_default_eq_impl ( grpc_slice  a,
grpc_slice  b 
)

◆ grpc_slice_differs_refcounted()

int grpc_slice_differs_refcounted ( const grpc_slice a,
const grpc_slice b_not_inline 
)

◆ grpc_slice_dup()

grpc_slice grpc_slice_dup ( grpc_slice  a)

Return a slice pointing to newly allocated memory that has the same contents as s.

◆ grpc_slice_eq()

int grpc_slice_eq ( grpc_slice  a,
grpc_slice  b 
)

◆ grpc_slice_from_copied_buffer()

grpc_slice grpc_slice_from_copied_buffer ( const char *  source,
size_t  len 
)

Create a slice by copying a buffer.

Equivalent to: grpc_slice slice = grpc_slice_malloc(len); memcpy(slice->data, source, len);

◆ grpc_slice_from_copied_string()

grpc_slice grpc_slice_from_copied_string ( const char *  source)

Create a slice by copying a string.

Does not preserve null terminators. Equivalent to: size_t len = strlen(source); grpc_slice slice = grpc_slice_malloc(len); memcpy(slice->data, source, len);

◆ grpc_slice_from_moved_buffer()

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

◆ grpc_slice_from_moved_string()

grpc_slice grpc_slice_from_moved_string ( grpc_core::UniquePtr< char >  p)

◆ grpc_slice_from_static_buffer()

grpc_slice grpc_slice_from_static_buffer ( const void *  s,
size_t  len 
)

Create a slice pointing to constant memory.

◆ grpc_slice_from_static_string()

grpc_slice grpc_slice_from_static_string ( const char *  s)

Create a slice pointing to constant memory.

◆ grpc_slice_is_equivalent()

int grpc_slice_is_equivalent ( grpc_slice  a,
grpc_slice  b 
)

Do two slices point at the same memory, with the same length If a or b is inlined, actually compares data.

◆ grpc_slice_malloc()

grpc_slice grpc_slice_malloc ( size_t  length)

Equivalent to grpc_slice_new(malloc(len), len, free), but saves one malloc() call.

Aborts if malloc() fails.

◆ grpc_slice_malloc_large()

grpc_slice grpc_slice_malloc_large ( size_t  length)

◆ grpc_slice_memory_usage()

size_t grpc_slice_memory_usage ( grpc_slice  s)

◆ grpc_slice_new()

grpc_slice grpc_slice_new ( void *  p,
size_t  len,
void(*)(void *)  destroy 
)

Create a slice pointing at some data.

Calls malloc to allocate a refcount for the object, and arranges that destroy will be called with the pointer passed in at destruction.

◆ grpc_slice_new_with_len()

grpc_slice grpc_slice_new_with_len ( void *  p,
size_t  len,
void(*)(void *, size_t)  destroy 
)

Equivalent to grpc_slice_new, but with a two argument destroy function that also takes the slice length.

◆ grpc_slice_new_with_user_data()

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

Equivalent to grpc_slice_new, but with a separate pointer that is passed to the destroy function.

This function can be useful when the data is part of a larger structure that must be destroyed when the data is no longer needed.

◆ grpc_slice_rchr()

int grpc_slice_rchr ( grpc_slice  s,
char  c 
)

return the index of the last instance of c in s, or -1 if not found

◆ grpc_slice_ref()

grpc_slice grpc_slice_ref ( grpc_slice  s)

Increment the refcount of s.

Requires slice is initialized. Returns s.

◆ grpc_slice_slice()

int grpc_slice_slice ( grpc_slice  haystack,
grpc_slice  needle 
)

return the index of the first occurrence of needle in haystack, or -1 if it's not found

◆ grpc_slice_split_head()

grpc_slice grpc_slice_split_head ( grpc_slice s,
size_t  split 
)

Splits s into two: modifies s to be s[split:s.length], and returns a new slice, sharing a refcount with s, that contains s[0:split].

Requires s initialized, split <= s.length

◆ grpc_slice_split_tail()

grpc_slice grpc_slice_split_tail ( grpc_slice s,
size_t  split 
)

Splits s into two: modifies s to be s[0:split], and returns a new slice, sharing a refcount with s, that contains s[split:s.length].

Requires s initialized, split <= s.length

◆ grpc_slice_split_tail_maybe_ref()

grpc_slice grpc_slice_split_tail_maybe_ref ( grpc_slice source,
size_t  split,
grpc_slice_ref_whom  ref_whom 
)

The same as grpc_slice_split_tail, but with an option to skip altering refcounts (grpc_slice_split_tail_maybe_ref(..., true) is equivalent to grpc_slice_split_tail(...))

◆ grpc_slice_str_cmp()

int grpc_slice_str_cmp ( grpc_slice  a,
const char *  b 
)

◆ grpc_slice_sub()

grpc_slice grpc_slice_sub ( grpc_slice  s,
size_t  begin,
size_t  end 
)

Return a result slice derived from s, which shares a ref count with s, where result.data==s.data+begin, and result.length==end-begin.

The ref count of s is increased by one. Do not assign result back to s. Requires s initialized, begin <= end, begin <= s.length, and end <= source->length.

◆ grpc_slice_sub_no_ref() [1/2]

grpc_core::UnmanagedMemorySlice grpc_slice_sub_no_ref ( const grpc_core::UnmanagedMemorySlice source,
size_t  begin,
size_t  end 
)

◆ grpc_slice_sub_no_ref() [2/2]

grpc_slice grpc_slice_sub_no_ref ( grpc_slice  source,
size_t  begin,
size_t  end 
)

The same as grpc_slice_sub, but without altering the ref count.

◆ grpc_slice_to_c_string()

char* grpc_slice_to_c_string ( grpc_slice  s)

Return a copy of slice as a C string.

Offers no protection against embedded NULL's. Returned string must be freed with gpr_free.

◆ grpc_slice_unref()

void grpc_slice_unref ( grpc_slice  s)

Decrement the ref count of s.

If the ref count of s reaches zero, all slices sharing the ref count are destroyed, and considered no longer initialized. If s is ultimately derived from a call to grpc_slice_new(start, len, dest) where dest!=NULL , then (*dest)(start) is called, else if s is ultimately derived from a call to grpc_slice_new_with_len(start, len, dest) where dest!=NULL , then (*dest)(start, len). Requires s initialized.