include/grpcpp/impl/codegen/proto_buffer_reader.h

   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
  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>
  34
  35 /// This header provides an object that reads bytes directly from a
  36 /// grpc::ByteBuffer, via the ZeroCopyInputStream interface
  37
  38 namespace grpc {
  39
  40 extern CoreCodegenInterface* g_core_codegen_interface;
  41
  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)
  45 ///
  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 {
  49  public:
  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");
  61     }
  62   }
  63
  64   ~ProtoBufferReader() override {
  65     if (status_.ok()) {
  66       g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_);
  67     }
  68   }
  69
  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 {
  73     if (!status_.ok()) {
  74       return false;
  75     }
  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_) -
  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     }
  85     /// Otherwise get the next slice from the byte buffer reader
  86     if (!g_core_codegen_interface->grpc_byte_buffer_reader_peek(&reader_,
  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
  97   /// Returns the status of the buffer reader.
  98   Status status() const { return status_; }
  99
 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;
 106   }
 107
 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 {
 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
 125   /// Returns the total number of bytes read since this object was created.
 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_;              ///< 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
 147 };
 148
 149 }  // namespace grpc
 150
 151 #endif  // GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H