include/grpcpp/impl/codegen/byte_buffer.h

   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 #include <grpc/impl/codegen/byte_buffer.h>
  23
  24 #include <grpcpp/impl/codegen/config.h>
  25 #include <grpcpp/impl/codegen/core_codegen_interface.h>
  26 #include <grpcpp/impl/codegen/serialization_traits.h>
  27 #include <grpcpp/impl/codegen/slice.h>
  28 #include <grpcpp/impl/codegen/status.h>
  29
  30 #include <vector>
  31
  32 namespace grpc {
  33
  34 class ServerInterface;
  35 class ByteBuffer;
  36 class ServerInterface;
  37
  38 namespace internal {
  39 class CallOpSendMessage;
  40 template <class R>
  41 class CallOpRecvMessage;
  42 class CallOpGenericRecvMessage;
  43 class MethodHandler;
  44 template <class ServiceType, class RequestType, class ResponseType>
  45 class RpcMethodHandler;
  46 template <class ServiceType, class RequestType, class ResponseType>
  47 class ServerStreamingHandler;
  48 template <class RequestType, class ResponseType>
  49 class CallbackUnaryHandler;
  50 template <class RequestType, class ResponseType>
  51 class CallbackServerStreamingHandler;
  52 template <StatusCode code>
  53 class ErrorMethodHandler;
  54 class ExternalConnectionAcceptorImpl;
  55 template <class R>
  56 class DeserializeFuncType;
  57 class GrpcByteBufferPeer;
  58 template <class ServiceType, class RequestType, class ResponseType>
  59 class RpcMethodHandler;
  60 template <class ServiceType, class RequestType, class ResponseType>
  61 class ServerStreamingHandler;
  62
  63 }  // namespace internal
  64 /// A sequence of bytes.
  65 class ByteBuffer final {
  66  public:
  67   /// Constuct an empty buffer.
  68   ByteBuffer() : buffer_(nullptr) {}
  69
  70   /// Construct buffer from \a slices, of which there are \a nslices.
  71   ByteBuffer(const Slice* slices, size_t nslices) {
  72     // The following assertions check that the representation of a grpc::Slice
  73     // is identical to that of a grpc_slice:  it has a grpc_slice field, and
  74     // nothing else.
  75     static_assert(std::is_same<decltype(slices[0].slice_), grpc_slice>::value,
  76                   "Slice must have same representation as grpc_slice");
  77     static_assert(sizeof(Slice) == sizeof(grpc_slice),
  78                   "Slice must have same representation as grpc_slice");
  79     // The following assertions check that the representation of a ByteBuffer is
  80     // identical to grpc_byte_buffer*:  it has a grpc_byte_buffer* field,
  81     // and nothing else.
  82     static_assert(std::is_same<decltype(buffer_), grpc_byte_buffer*>::value,
  83                   "ByteBuffer must have same representation as "
  84                   "grpc_byte_buffer*");
  85     static_assert(sizeof(ByteBuffer) == sizeof(grpc_byte_buffer*),
  86                   "ByteBuffer must have same representation as "
  87                   "grpc_byte_buffer*");
  88     // The const_cast is legal if grpc_raw_byte_buffer_create() does no more
  89     // than its advertised side effect of increasing the reference count of the
  90     // slices it processes, and such an increase does not affect the semantics
  91     // seen by the caller of this constructor.
  92     buffer_ = g_core_codegen_interface->grpc_raw_byte_buffer_create(
  93         reinterpret_cast<grpc_slice*>(const_cast<Slice*>(slices)), nslices);
  94   }
  95
  96   /// Constuct a byte buffer by referencing elements of existing buffer
  97   /// \a buf. Wrapper of core function grpc_byte_buffer_copy . This is not
  98   /// a deep copy; it is just a referencing. As a result, its performance is
  99   /// size-independent.
 100   ByteBuffer(const ByteBuffer& buf) : buffer_(nullptr) { operator=(buf); }
 101
 102   ~ByteBuffer() {
 103     if (buffer_) {
 104       g_core_codegen_interface->grpc_byte_buffer_destroy(buffer_);
 105     }
 106   }
 107
 108   /// Wrapper of core function grpc_byte_buffer_copy . This is not
 109   /// a deep copy; it is just a referencing. As a result, its performance is
 110   /// size-independent.
 111   ByteBuffer& operator=(const ByteBuffer& buf) {
 112     if (this != &buf) {
 113       Clear();  // first remove existing data
 114     }
 115     if (buf.buffer_) {
 116       // then copy
 117       buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buf.buffer_);
 118     }
 119     return *this;
 120   }
 121
 122   /// Dump (read) the buffer contents into \a slices.
 123   Status Dump(std::vector<Slice>* slices) const;
 124
 125   /// Remove all data.
 126   void Clear() {
 127     if (buffer_) {
 128       g_core_codegen_interface->grpc_byte_buffer_destroy(buffer_);
 129       buffer_ = nullptr;
 130     }
 131   }
 132
 133   /// Make a duplicate copy of the internals of this byte
 134   /// buffer so that we have our own owned version of it.
 135   /// bbuf.Duplicate(); is equivalent to bbuf=bbuf; but is actually readable.
 136   /// This is not a deep copy; it is a referencing and its performance
 137   /// is size-independent.
 138   void Duplicate() {
 139     buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buffer_);
 140   }
 141
 142   /// Forget underlying byte buffer without destroying
 143   /// Use this only for un-owned byte buffers
 144   void Release() { buffer_ = nullptr; }
 145
 146   /// Buffer size in bytes.
 147   size_t Length() const {
 148     return buffer_ == nullptr
 149                ? 0
 150                : g_core_codegen_interface->grpc_byte_buffer_length(buffer_);
 151   }
 152
 153   /// Swap the state of *this and *other.
 154   void Swap(ByteBuffer* other) {
 155     grpc_byte_buffer* tmp = other->buffer_;
 156     other->buffer_ = buffer_;
 157     buffer_ = tmp;
 158   }
 159
 160   /// Is this ByteBuffer valid?
 161   bool Valid() const { return (buffer_ != nullptr); }
 162
 163  private:
 164   friend class SerializationTraits<ByteBuffer, void>;
 165   friend class ServerInterface;
 166   friend class internal::CallOpSendMessage;
 167   template <class R>
 168   friend class internal::CallOpRecvMessage;
 169   friend class internal::CallOpGenericRecvMessage;
 170   template <class ServiceType, class RequestType, class ResponseType>
 171   friend class RpcMethodHandler;
 172   template <class ServiceType, class RequestType, class ResponseType>
 173   friend class ServerStreamingHandler;
 174   template <class ServiceType, class RequestType, class ResponseType>
 175   friend class internal::RpcMethodHandler;
 176   template <class ServiceType, class RequestType, class ResponseType>
 177   friend class internal::ServerStreamingHandler;
 178   template <class RequestType, class ResponseType>
 179   friend class internal::CallbackUnaryHandler;
 180   template <class RequestType, class ResponseType>
 181   friend class ::grpc::internal::CallbackServerStreamingHandler;
 182   template <StatusCode code>
 183   friend class internal::ErrorMethodHandler;
 184   template <class R>
 185   friend class internal::DeserializeFuncType;
 186   friend class ProtoBufferReader;
 187   friend class ProtoBufferWriter;
 188   friend class internal::GrpcByteBufferPeer;
 189   friend class internal::ExternalConnectionAcceptorImpl;
 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     ByteBufferPointer(const ByteBuffer* b)
 207         : bbuf_(const_cast<ByteBuffer*>(b)) {}
 208     operator ByteBuffer*() { return bbuf_; }
 209     operator grpc_byte_buffer*() { return bbuf_->buffer_; }
 210     operator grpc_byte_buffer**() { return &bbuf_->buffer_; }
 211
 212    private:
 213     ByteBuffer* bbuf_;
 214   };
 215   ByteBufferPointer bbuf_ptr() const { return ByteBufferPointer(this); }
 216 };
 217
 218 template <>
 219 class SerializationTraits<ByteBuffer, void> {
 220  public:
 221   static Status Deserialize(ByteBuffer* byte_buffer, ByteBuffer* dest) {
 222     dest->set_buffer(byte_buffer->buffer_);
 223     return Status::OK;
 224   }
 225   static Status Serialize(const ByteBuffer& source, ByteBuffer* buffer,
 226                           bool* own_buffer) {
 227     *buffer = source;
 228     *own_buffer = true;
 229     return g_core_codegen_interface->ok();
 230   }
 231 };
 232
 233 }  // namespace grpc
 234
 235 #endif  // GRPCPP_IMPL_CODEGEN_BYTE_BUFFER_H