GRPC C++  1.46.2
byte_buffer.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2017 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 #ifndef GRPCPP_IMPL_CODEGEN_BYTE_BUFFER_H
20 #define GRPCPP_IMPL_CODEGEN_BYTE_BUFFER_H
21 
22 // IWYU pragma: private, include <grpcpp/support/byte_buffer.h>
23 
24 #include <vector>
25 
32 
33 namespace grpc {
34 
35 class ServerInterface;
36 class ByteBuffer;
37 class ServerInterface;
38 
39 namespace internal {
40 template <class RequestType, class ResponseType>
42 template <class RequestType, class ResponseType>
44 template <class RequestType>
46 template <class ServiceType, class RequestType, class ResponseType>
48 template <grpc::StatusCode code>
50 class CallOpSendMessage;
51 template <class R>
54 class ExternalConnectionAcceptorImpl;
55 template <class R>
57 class GrpcByteBufferPeer;
58 
59 } // namespace internal
61 class ByteBuffer final {
62  public:
64  ByteBuffer() : buffer_(nullptr) {}
65 
67  ByteBuffer(const Slice* slices, size_t nslices) {
68  // The following assertions check that the representation of a grpc::Slice
69  // is identical to that of a grpc_slice: it has a grpc_slice field, and
70  // nothing else.
71  static_assert(std::is_same<decltype(slices[0].slice_), grpc_slice>::value,
72  "Slice must have same representation as grpc_slice");
73  static_assert(sizeof(Slice) == sizeof(grpc_slice),
74  "Slice must have same representation as grpc_slice");
75  // The following assertions check that the representation of a ByteBuffer is
76  // identical to grpc_byte_buffer*: it has a grpc_byte_buffer* field,
77  // and nothing else.
78  static_assert(std::is_same<decltype(buffer_), grpc_byte_buffer*>::value,
79  "ByteBuffer must have same representation as "
80  "grpc_byte_buffer*");
81  static_assert(sizeof(ByteBuffer) == sizeof(grpc_byte_buffer*),
82  "ByteBuffer must have same representation as "
83  "grpc_byte_buffer*");
84  // The const_cast is legal if grpc_raw_byte_buffer_create() does no more
85  // than its advertised side effect of increasing the reference count of the
86  // slices it processes, and such an increase does not affect the semantics
87  // seen by the caller of this constructor.
89  reinterpret_cast<grpc_slice*>(const_cast<Slice*>(slices)), nslices);
90  }
91 
96  ByteBuffer(const ByteBuffer& buf) : buffer_(nullptr) { operator=(buf); }
97 
99  if (buffer_) {
101  }
102  }
103 
108  if (this != &buf) {
109  Clear(); // first remove existing data
110  }
111  if (buf.buffer_) {
112  // then copy
113  buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buf.buffer_);
114  }
115  return *this;
116  }
117 
118  // If this ByteBuffer's representation is a single flat slice, returns a
119  // slice referencing that array.
120  Status TrySingleSlice(Slice* slice) const;
121 
123  Status DumpToSingleSlice(Slice* slice) const;
124 
126  Status Dump(std::vector<Slice>* slices) const;
127 
129  void Clear() {
130  if (buffer_) {
132  buffer_ = nullptr;
133  }
134  }
135 
141  void Duplicate() {
143  }
144 
147  void Release() { buffer_ = nullptr; }
148 
150  size_t Length() const {
151  return buffer_ == nullptr
152  ? 0
154  }
155 
157  void Swap(ByteBuffer* other) {
158  grpc_byte_buffer* tmp = other->buffer_;
159  other->buffer_ = buffer_;
160  buffer_ = tmp;
161  }
162 
164  bool Valid() const { return (buffer_ != nullptr); }
165 
166  private:
167  friend class SerializationTraits<ByteBuffer, void>;
168  friend class ServerInterface;
170  template <class R>
173  template <class RequestType>
175  grpc::Status*, RequestType*);
176  template <class ServiceType, class RequestType, class ResponseType>
178  template <class RequestType, class ResponseType>
180  template <class RequestType, class ResponseType>
182  template <StatusCode code>
184  template <class R>
186  friend class ProtoBufferReader;
187  friend class ProtoBufferWriter;
190 
191  grpc_byte_buffer* buffer_;
192 
193  // takes ownership
194  void set_buffer(grpc_byte_buffer* buf) {
195  if (buffer_) {
196  Clear();
197  }
198  buffer_ = buf;
199  }
200 
201  grpc_byte_buffer* c_buffer() { return buffer_; }
202  grpc_byte_buffer** c_buffer_ptr() { return &buffer_; }
203 
204  class ByteBufferPointer {
205  public:
206  /* NOLINTNEXTLINE(google-explicit-constructor) */
207  ByteBufferPointer(const ByteBuffer* b)
208  : bbuf_(const_cast<ByteBuffer*>(b)) {}
209  /* NOLINTNEXTLINE(google-explicit-constructor) */
210  operator ByteBuffer*() { return bbuf_; }
211  /* NOLINTNEXTLINE(google-explicit-constructor) */
212  operator grpc_byte_buffer*() { return bbuf_->buffer_; }
213  /* NOLINTNEXTLINE(google-explicit-constructor) */
214  operator grpc_byte_buffer**() { return &bbuf_->buffer_; }
215 
216  private:
217  ByteBuffer* bbuf_;
218  };
219  ByteBufferPointer bbuf_ptr() const { return ByteBufferPointer(this); }
220 };
221 
222 template <>
224  public:
225  static Status Deserialize(ByteBuffer* byte_buffer, ByteBuffer* dest) {
226  dest->set_buffer(byte_buffer->buffer_);
227  return Status::OK;
228  }
229  static Status Serialize(const ByteBuffer& source, ByteBuffer* buffer,
230  bool* own_buffer) {
231  *buffer = source;
232  *own_buffer = true;
233  return g_core_codegen_interface->ok();
234  }
235 };
236 
237 } // namespace grpc
238 
239 #endif // GRPCPP_IMPL_CODEGEN_BYTE_BUFFER_H
grpc::ProtoBufferWriter
This is a specialization of the protobuf class ZeroCopyOutputStream.
Definition: proto_buffer_writer.h:55
grpc::internal::CallOpGenericRecvMessage
Definition: call_op_set.h:533
grpc::ByteBuffer::Duplicate
void Duplicate()
Make a duplicate copy of the internals of this byte buffer so that we have our own owned version of i...
Definition: byte_buffer.h:141
grpc
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
status.h
grpc::internal::CallOpSendMessage
Definition: call_op_set.h:289
grpc::ByteBuffer::Length
size_t Length() const
Buffer size in bytes.
Definition: byte_buffer.h:150
grpc::internal::ErrorMethodHandler
General method handler class for errors that prevent real method use e.g., handle unknown method by r...
Definition: byte_buffer.h:49
serialization_traits.h
config.h
grpc::CoreCodegenInterface::ok
virtual const Status & ok()=0
grpc::ByteBuffer::ByteBuffer
ByteBuffer(const Slice *slices, size_t nslices)
Construct buffer from slices, of which there are nslices.
Definition: byte_buffer.h:67
grpc::ByteBuffer::operator=
ByteBuffer & operator=(const ByteBuffer &buf)
Wrapper of core function grpc_byte_buffer_copy .
Definition: byte_buffer.h:107
core_codegen_interface.h
grpc::ByteBuffer::DumpToSingleSlice
Status DumpToSingleSlice(Slice *slice) const
Dump (read) the buffer contents into slics.
grpc::ByteBuffer::~ByteBuffer
~ByteBuffer()
Definition: byte_buffer.h:98
grpc::CoreCodegenInterface::grpc_byte_buffer_copy
virtual grpc_byte_buffer * grpc_byte_buffer_copy(grpc_byte_buffer *bb)=0
grpc::CoreCodegenInterface::grpc_byte_buffer_destroy
virtual void grpc_byte_buffer_destroy(grpc_byte_buffer *bb)=0
grpc::ByteBuffer::ByteBuffer
ByteBuffer()
Constuct an empty buffer.
Definition: byte_buffer.h:64
grpc::Status
Did it work? If it didn't, why?
Definition: status.h:33
grpc::internal::UnaryDeserializeHelper
void * UnaryDeserializeHelper(grpc_byte_buffer *, grpc::Status *, RequestType *)
A helper function with reduced templating to do deserializing.
Definition: method_handler.h:82
grpc::ByteBuffer::Clear
void Clear()
Remove all data.
Definition: byte_buffer.h:129
grpc::SerializationTraits< ByteBuffer, void >::Deserialize
static Status Deserialize(ByteBuffer *byte_buffer, ByteBuffer *dest)
Definition: byte_buffer.h:225
grpc::internal::DeserializeFuncType
Definition: byte_buffer.h:56
grpc_byte_buffer
Definition: grpc_types.h:42
grpc::ByteBuffer
A sequence of bytes.
Definition: byte_buffer.h:61
grpc::internal::CallbackUnaryHandler
Definition: byte_buffer.h:41
grpc::SerializationTraits< ByteBuffer, void >::Serialize
static Status Serialize(const ByteBuffer &source, ByteBuffer *buffer, bool *own_buffer)
Definition: byte_buffer.h:229
grpc::ByteBuffer::Swap
void Swap(ByteBuffer *other)
Swap the state of *this and *other.
Definition: byte_buffer.h:157
grpc::ProtoBufferReader
This is a specialization of the protobuf class ZeroCopyInputStream The principle is to get one chunk ...
Definition: proto_buffer_reader.h:48
grpc::internal::CallbackServerStreamingHandler
Definition: byte_buffer.h:43
grpc_slice
A grpc_slice s, if initialized, represents the byte range s.bytes[0..s.length-1].
Definition: slice.h:65
grpc::CoreCodegenInterface::grpc_raw_byte_buffer_create
virtual grpc_byte_buffer * grpc_raw_byte_buffer_create(grpc_slice *slice, size_t nslices)=0
grpc::SerializationTraits
Defines how to serialize and deserialize some type.
Definition: serialization_traits.h:60
grpc::ByteBuffer::GrpcByteBufferPeer
friend class internal::GrpcByteBufferPeer
Definition: byte_buffer.h:188
byte_buffer.h
grpc::Slice
A wrapper around grpc_slice.
Definition: slice.h:36
grpc::internal::ServerStreamingHandler
A wrapper class of an application provided server streaming handler.
Definition: byte_buffer.h:47
grpc::Status::OK
static const Status & OK
An OK pre-defined instance.
Definition: status.h:107
grpc::ByteBuffer::Dump
Status Dump(std::vector< Slice > *slices) const
Dump (read) the buffer contents into slices.
grpc::ByteBuffer::ByteBuffer
ByteBuffer(const ByteBuffer &buf)
Constuct a byte buffer by referencing elements of existing buffer buf.
Definition: byte_buffer.h:96
grpc::ByteBuffer::ExternalConnectionAcceptorImpl
friend class internal::ExternalConnectionAcceptorImpl
Definition: byte_buffer.h:189
grpc::ByteBuffer::Valid
bool Valid() const
Is this ByteBuffer valid?
Definition: byte_buffer.h:164
grpc::CoreCodegenInterface::grpc_byte_buffer_length
virtual size_t grpc_byte_buffer_length(grpc_byte_buffer *bb) GRPC_MUST_USE_RESULT=0
grpc::g_core_codegen_interface
CoreCodegenInterface * g_core_codegen_interface
Definition: completion_queue.h:98
slice.h
grpc::internal::CallOpRecvMessage
Definition: byte_buffer.h:52
grpc::ByteBuffer::Release
void Release()
Forget underlying byte buffer without destroying Use this only for un-owned byte buffers.
Definition: byte_buffer.h:147
grpc::ServerInterface
Definition: server_interface.h:61
grpc::ByteBuffer::TrySingleSlice
Status TrySingleSlice(Slice *slice) const