GRPC C++  1.46.2
proto_buffer_reader.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2015 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_PROTO_BUFFER_READER_H
20 #define GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H
21 
22 // IWYU pragma: private, include <grpcpp/support/proto_buffer_reader.h>
23 
24 #include <type_traits>
25 
34 
37 
38 namespace grpc {
39 
40 extern CoreCodegenInterface* g_core_codegen_interface;
41 
49  public:
52  explicit ProtoBufferReader(ByteBuffer* buffer)
53  : byte_count_(0), backup_count_(0), status_() {
56  if (!buffer->Valid() ||
58  &reader_, buffer->c_buffer())) {
59  status_ = Status(StatusCode::INTERNAL,
60  "Couldn't initialize byte buffer reader");
61  }
62  }
63 
64  ~ProtoBufferReader() override {
65  if (status_.ok()) {
67  }
68  }
69 
72  bool Next(const void** data, int* size) override {
73  if (!status_.ok()) {
74  return false;
75  }
77  if (backup_count_ > 0) {
78  *data = GRPC_SLICE_START_PTR(*slice_) + GRPC_SLICE_LENGTH(*slice_) -
79  backup_count_;
80  GPR_CODEGEN_ASSERT(backup_count_ <= INT_MAX);
81  *size = static_cast<int>(backup_count_);
82  backup_count_ = 0;
83  return true;
84  }
87  &slice_)) {
88  return false;
89  }
90  *data = GRPC_SLICE_START_PTR(*slice_);
91  // On win x64, int is only 32bit
92  GPR_CODEGEN_ASSERT(GRPC_SLICE_LENGTH(*slice_) <= INT_MAX);
93  byte_count_ += * size = static_cast<int>(GRPC_SLICE_LENGTH(*slice_));
94  return true;
95  }
96 
98  Status status() const { return status_; }
99 
103  void BackUp(int count) override {
104  GPR_CODEGEN_ASSERT(count <= static_cast<int>(GRPC_SLICE_LENGTH(*slice_)));
105  backup_count_ = count;
106  }
107 
110  bool Skip(int count) override {
111  const void* data;
112  int size;
113  while (Next(&data, &size)) {
114  if (size >= count) {
115  BackUp(size - count);
116  return true;
117  }
118  // size < count;
119  count -= size;
120  }
121  // error or we have too large count;
122  return false;
123  }
124 
126  int64_t ByteCount() const override { return byte_count_ - backup_count_; }
127 
128  // These protected members are needed to support internal optimizations.
129  // they expose internal bits of grpc core that are NOT stable. If you have
130  // a use case needs to use one of these functions, please send an email to
131  // https://groups.google.com/forum/#!forum/grpc-io.
132  protected:
133  void set_byte_count(int64_t byte_count) { byte_count_ = byte_count; }
134  int64_t backup_count() { return backup_count_; }
135  void set_backup_count(int64_t backup_count) { backup_count_ = backup_count; }
136  grpc_byte_buffer_reader* reader() { return &reader_; }
137  grpc_slice* slice() { return slice_; }
138  grpc_slice** mutable_slice_ptr() { return &slice_; }
139 
140  private:
141  int64_t byte_count_;
142  int64_t backup_count_;
143  grpc_byte_buffer_reader reader_;
144  grpc_slice* slice_;
146  Status status_;
147 };
148 
149 } // namespace grpc
150 
151 #endif // GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H
GRPC_SLICE_LENGTH
#define GRPC_SLICE_LENGTH(slice)
Definition: slice.h:104
grpc::CoreCodegenInterface::grpc_byte_buffer_reader_peek
virtual int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader *reader, grpc_slice **slice)=0
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::ProtoBufferReader::~ProtoBufferReader
~ProtoBufferReader() override
Definition: proto_buffer_reader.h:64
byte_buffer_reader.h
grpc::ProtoBufferReader::ProtoBufferReader
ProtoBufferReader(ByteBuffer *buffer)
Constructs buffer reader from buffer.
Definition: proto_buffer_reader.h:52
serialization_traits.h
grpc::protobuf::io::ZeroCopyInputStream
::google::protobuf::io::ZeroCopyInputStream ZeroCopyInputStream
Definition: config_protobuf.h:101
core_codegen_interface.h
grpc::ProtoBufferReader::backup_count
int64_t backup_count()
Definition: proto_buffer_reader.h:134
grpc::Status::ok
bool ok() const
Is the status OK?
Definition: status.h:120
byte_buffer.h
grpc::ProtoBufferReader::BackUp
void BackUp(int count) override
The proto library calls this to indicate that we should back up count bytes that have already been re...
Definition: proto_buffer_reader.h:103
grpc_types.h
grpc::Status
Did it work? If it didn't, why?
Definition: status.h:33
grpc::ProtoBufferReader::reader
grpc_byte_buffer_reader * reader()
Definition: proto_buffer_reader.h:136
grpc::ProtoBufferReader::ByteCount
int64_t ByteCount() const override
Returns the total number of bytes read since this object was created.
Definition: proto_buffer_reader.h:126
grpc::ProtoBufferReader::Skip
bool Skip(int count) override
The proto library calls this to skip over count bytes.
Definition: proto_buffer_reader.h:110
grpc::ByteBuffer
A sequence of bytes.
Definition: byte_buffer.h:61
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_slice
A grpc_slice s, if initialized, represents the byte range s.bytes[0..s.length-1].
Definition: slice.h:65
grpc::ProtoBufferReader::set_byte_count
void set_byte_count(int64_t byte_count)
Definition: proto_buffer_reader.h:133
grpc::ProtoBufferReader::mutable_slice_ptr
grpc_slice ** mutable_slice_ptr()
Definition: proto_buffer_reader.h:138
grpc::protobuf::util::Status
::google::protobuf::util::Status Status
Definition: config_protobuf.h:93
grpc::CoreCodegenInterface::grpc_byte_buffer_reader_init
virtual int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader, grpc_byte_buffer *buffer) GRPC_MUST_USE_RESULT=0
grpc::ProtoBufferReader::status
Status status() const
Returns the status of the buffer reader.
Definition: proto_buffer_reader.h:98
config_protobuf.h
GRPC_SLICE_START_PTR
#define GRPC_SLICE_START_PTR(slice)
Definition: slice.h:101
grpc::ByteBuffer::Valid
bool Valid() const
Is this ByteBuffer valid?
Definition: byte_buffer.h:164
grpc::g_core_codegen_interface
CoreCodegenInterface * g_core_codegen_interface
Definition: completion_queue.h:98
GPR_CODEGEN_ASSERT
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:149
grpc::ProtoBufferReader::slice
grpc_slice * slice()
Definition: proto_buffer_reader.h:137
grpc_byte_buffer_reader
Definition: byte_buffer_reader.h:30
grpc::ProtoBufferReader::Next
bool Next(const void **data, int *size) override
Give the proto library a chunk of data from the stream.
Definition: proto_buffer_reader.h:72
grpc::ProtoBufferReader::set_backup_count
void set_backup_count(int64_t backup_count)
Definition: proto_buffer_reader.h:135
slice.h
grpc::CoreCodegenInterface::grpc_byte_buffer_reader_destroy
virtual void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader *reader)=0
grpc::INTERNAL
@ INTERNAL
Internal errors.
Definition: status_code_enum.h:121