3 * Copyright 2015 gRPC authors.
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
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #ifndef GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H
20 #define GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H
22 // IWYU pragma: private, include <grpcpp/support/proto_buffer_reader.h>
24 #include <type_traits>
26 #include <grpc/impl/codegen/byte_buffer_reader.h>
27 #include <grpc/impl/codegen/grpc_types.h>
28 #include <grpc/impl/codegen/slice.h>
29 #include <grpcpp/impl/codegen/byte_buffer.h>
30 #include <grpcpp/impl/codegen/config_protobuf.h>
31 #include <grpcpp/impl/codegen/core_codegen_interface.h>
32 #include <grpcpp/impl/codegen/serialization_traits.h>
33 #include <grpcpp/impl/codegen/status.h>
35 /// This header provides an object that reads bytes directly from a
36 /// grpc::ByteBuffer, via the ZeroCopyInputStream interface
40 extern CoreCodegenInterface* g_core_codegen_interface;
42 /// This is a specialization of the protobuf class ZeroCopyInputStream
43 /// The principle is to get one chunk of data at a time from the proto layer,
44 /// with options to backup (re-see some bytes) or skip (forward past some bytes)
46 /// Read more about ZeroCopyInputStream interface here:
47 /// https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.io.zero_copy_stream#ZeroCopyInputStream
48 class ProtoBufferReader : public ::grpc::protobuf::io::ZeroCopyInputStream {
50 /// Constructs buffer reader from \a buffer. Will set \a status() to non ok
51 /// if \a buffer is invalid (the internal buffer has not been initialized).
52 explicit ProtoBufferReader(ByteBuffer* buffer)
53 : byte_count_(0), backup_count_(0), status_() {
54 /// Implemented through a grpc_byte_buffer_reader which iterates
55 /// over the slices that make up a byte buffer
56 if (!buffer->Valid() ||
57 !g_core_codegen_interface->grpc_byte_buffer_reader_init(
58 &reader_, buffer->c_buffer())) {
59 status_ = Status(StatusCode::INTERNAL,
60 "Couldn't initialize byte buffer reader");
64 ~ProtoBufferReader() override {
66 g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_);
70 /// Give the proto library a chunk of data from the stream. The caller
71 /// may safely read from data[0, size - 1].
72 bool Next(const void** data, int* size) override {
76 /// If we have backed up previously, we need to return the backed-up slice
77 if (backup_count_ > 0) {
78 *data = GRPC_SLICE_START_PTR(*slice_) + GRPC_SLICE_LENGTH(*slice_) -
80 GPR_CODEGEN_ASSERT(backup_count_ <= INT_MAX);
81 *size = static_cast<int>(backup_count_);
85 /// Otherwise get the next slice from the byte buffer reader
86 if (!g_core_codegen_interface->grpc_byte_buffer_reader_peek(&reader_,
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_));
97 /// Returns the status of the buffer reader.
98 Status status() const { return status_; }
100 /// The proto library calls this to indicate that we should back up \a count
101 /// bytes that have already been returned by the last call of Next.
102 /// So do the backup and have that ready for a later Next.
103 void BackUp(int count) override {
104 GPR_CODEGEN_ASSERT(count <= static_cast<int>(GRPC_SLICE_LENGTH(*slice_)));
105 backup_count_ = count;
108 /// The proto library calls this to skip over \a count bytes. Implement this
109 /// using Next and BackUp combined.
110 bool Skip(int count) override {
113 while (Next(&data, &size)) {
115 BackUp(size - count);
121 // error or we have too large count;
125 /// Returns the total number of bytes read since this object was created.
126 int64_t ByteCount() const override { return byte_count_ - backup_count_; }
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.
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_; }
141 int64_t byte_count_; ///< total bytes read since object creation
142 int64_t backup_count_; ///< how far backed up in the stream we are
143 grpc_byte_buffer_reader reader_; ///< internal object to read \a grpc_slice
144 ///< from the \a grpc_byte_buffer
145 grpc_slice* slice_; ///< current slice passed back to the caller
146 Status status_; ///< status of the entire object
151 #endif // GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H