blob: b7fe929af20d0b5d98a1fba4c2aad8ce90e8f32b [file] [log] [blame]
David Reiss6806fb82010-10-06 17:09:52 +00001/*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19
20#ifndef _THRIFT_PROTOCOL_TVIRTUALPROTOCOL_H_
21#define _THRIFT_PROTOCOL_TVIRTUALPROTOCOL_H_ 1
22
Roger Meier49ff8b12012-04-13 09:12:31 +000023#include <thrift/protocol/TProtocol.h>
David Reiss6806fb82010-10-06 17:09:52 +000024
Konrad Grochowski16a23a62014-11-13 15:33:38 +010025namespace apache {
26namespace thrift {
27namespace protocol {
David Reiss6806fb82010-10-06 17:09:52 +000028
29using apache::thrift::transport::TTransport;
30
31/**
32 * Helper class that provides default implementations of TProtocol methods.
33 *
34 * This class provides default implementations of the non-virtual TProtocol
35 * methods. It exists primarily so TVirtualProtocol can derive from it. It
36 * prevents TVirtualProtocol methods from causing infinite recursion if the
37 * non-virtual methods are not overridden by the TVirtualProtocol subclass.
38 *
39 * You probably don't want to use this class directly. Use TVirtualProtocol
40 * instead.
41 */
42class TProtocolDefaults : public TProtocol {
Konrad Grochowski16a23a62014-11-13 15:33:38 +010043public:
44 uint32_t readMessageBegin(std::string& name, TMessageType& messageType, int32_t& seqid) {
45 (void)name;
46 (void)messageType;
47 (void)seqid;
David Reiss6806fb82010-10-06 17:09:52 +000048 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
49 "this protocol does not support reading (yet).");
50 }
51
52 uint32_t readMessageEnd() {
53 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
54 "this protocol does not support reading (yet).");
55 }
56
57 uint32_t readStructBegin(std::string& name) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +010058 (void)name;
David Reiss6806fb82010-10-06 17:09:52 +000059 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
60 "this protocol does not support reading (yet).");
61 }
62
63 uint32_t readStructEnd() {
64 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
65 "this protocol does not support reading (yet).");
66 }
67
Konrad Grochowski16a23a62014-11-13 15:33:38 +010068 uint32_t readFieldBegin(std::string& name, TType& fieldType, int16_t& fieldId) {
69 (void)name;
70 (void)fieldType;
71 (void)fieldId;
David Reiss6806fb82010-10-06 17:09:52 +000072 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
73 "this protocol does not support reading (yet).");
74 }
75
76 uint32_t readFieldEnd() {
77 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
78 "this protocol does not support reading (yet).");
79 }
80
81 uint32_t readMapBegin(TType& keyType, TType& valType, uint32_t& size) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +010082 (void)keyType;
83 (void)valType;
84 (void)size;
David Reiss6806fb82010-10-06 17:09:52 +000085 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
86 "this protocol does not support reading (yet).");
87 }
88
89 uint32_t readMapEnd() {
90 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
91 "this protocol does not support reading (yet).");
92 }
93
94 uint32_t readListBegin(TType& elemType, uint32_t& size) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +010095 (void)elemType;
96 (void)size;
David Reiss6806fb82010-10-06 17:09:52 +000097 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
98 "this protocol does not support reading (yet).");
99 }
100
101 uint32_t readListEnd() {
102 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
103 "this protocol does not support reading (yet).");
104 }
105
106 uint32_t readSetBegin(TType& elemType, uint32_t& size) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100107 (void)elemType;
108 (void)size;
David Reiss6806fb82010-10-06 17:09:52 +0000109 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
110 "this protocol does not support reading (yet).");
111 }
112
113 uint32_t readSetEnd() {
114 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
115 "this protocol does not support reading (yet).");
116 }
117
118 uint32_t readBool(bool& value) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100119 (void)value;
David Reiss6806fb82010-10-06 17:09:52 +0000120 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
121 "this protocol does not support reading (yet).");
122 }
123
David Reiss8dfc7322010-10-06 17:09:58 +0000124 uint32_t readBool(std::vector<bool>::reference value) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100125 (void)value;
David Reiss8dfc7322010-10-06 17:09:58 +0000126 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
127 "this protocol does not support reading (yet).");
128 }
129
David Reiss6806fb82010-10-06 17:09:52 +0000130 uint32_t readByte(int8_t& byte) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100131 (void)byte;
David Reiss6806fb82010-10-06 17:09:52 +0000132 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
133 "this protocol does not support reading (yet).");
134 }
135
136 uint32_t readI16(int16_t& i16) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100137 (void)i16;
David Reiss6806fb82010-10-06 17:09:52 +0000138 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
139 "this protocol does not support reading (yet).");
140 }
141
142 uint32_t readI32(int32_t& i32) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100143 (void)i32;
David Reiss6806fb82010-10-06 17:09:52 +0000144 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
145 "this protocol does not support reading (yet).");
146 }
147
148 uint32_t readI64(int64_t& i64) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100149 (void)i64;
David Reiss6806fb82010-10-06 17:09:52 +0000150 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
151 "this protocol does not support reading (yet).");
152 }
153
154 uint32_t readDouble(double& dub) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100155 (void)dub;
David Reiss6806fb82010-10-06 17:09:52 +0000156 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
157 "this protocol does not support reading (yet).");
158 }
159
160 uint32_t readString(std::string& str) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100161 (void)str;
David Reiss6806fb82010-10-06 17:09:52 +0000162 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
163 "this protocol does not support reading (yet).");
164 }
165
166 uint32_t readBinary(std::string& str) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100167 (void)str;
David Reiss6806fb82010-10-06 17:09:52 +0000168 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
169 "this protocol does not support reading (yet).");
170 }
171
172 uint32_t writeMessageBegin(const std::string& name,
173 const TMessageType messageType,
174 const int32_t seqid) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100175 (void)name;
176 (void)messageType;
177 (void)seqid;
David Reiss6806fb82010-10-06 17:09:52 +0000178 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
179 "this protocol does not support writing (yet).");
180 }
181
182 uint32_t writeMessageEnd() {
183 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
184 "this protocol does not support writing (yet).");
185 }
186
David Reiss6806fb82010-10-06 17:09:52 +0000187 uint32_t writeStructBegin(const char* name) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100188 (void)name;
David Reiss6806fb82010-10-06 17:09:52 +0000189 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
190 "this protocol does not support writing (yet).");
191 }
192
193 uint32_t writeStructEnd() {
194 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
195 "this protocol does not support writing (yet).");
196 }
197
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100198 uint32_t writeFieldBegin(const char* name, const TType fieldType, const int16_t fieldId) {
199 (void)name;
200 (void)fieldType;
201 (void)fieldId;
David Reiss6806fb82010-10-06 17:09:52 +0000202 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
203 "this protocol does not support writing (yet).");
204 }
205
206 uint32_t writeFieldEnd() {
207 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
208 "this protocol does not support writing (yet).");
209 }
210
211 uint32_t writeFieldStop() {
212 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
213 "this protocol does not support writing (yet).");
214 }
215
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100216 uint32_t writeMapBegin(const TType keyType, const TType valType, const uint32_t size) {
217 (void)keyType;
218 (void)valType;
219 (void)size;
David Reiss6806fb82010-10-06 17:09:52 +0000220 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
221 "this protocol does not support writing (yet).");
222 }
223
224 uint32_t writeMapEnd() {
225 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
226 "this protocol does not support writing (yet).");
227 }
228
229 uint32_t writeListBegin(const TType elemType, const uint32_t size) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100230 (void)elemType;
231 (void)size;
David Reiss6806fb82010-10-06 17:09:52 +0000232 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
233 "this protocol does not support writing (yet).");
234 }
235
236 uint32_t writeListEnd() {
237 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
238 "this protocol does not support writing (yet).");
239 }
240
241 uint32_t writeSetBegin(const TType elemType, const uint32_t size) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100242 (void)elemType;
243 (void)size;
David Reiss6806fb82010-10-06 17:09:52 +0000244 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
245 "this protocol does not support writing (yet).");
246 }
247
248 uint32_t writeSetEnd() {
249 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
250 "this protocol does not support writing (yet).");
251 }
252
253 uint32_t writeBool(const bool value) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100254 (void)value;
David Reiss6806fb82010-10-06 17:09:52 +0000255 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
256 "this protocol does not support writing (yet).");
257 }
258
259 uint32_t writeByte(const int8_t byte) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100260 (void)byte;
David Reiss6806fb82010-10-06 17:09:52 +0000261 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
262 "this protocol does not support writing (yet).");
263 }
264
265 uint32_t writeI16(const int16_t i16) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100266 (void)i16;
David Reiss6806fb82010-10-06 17:09:52 +0000267 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
268 "this protocol does not support writing (yet).");
269 }
270
271 uint32_t writeI32(const int32_t i32) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100272 (void)i32;
David Reiss6806fb82010-10-06 17:09:52 +0000273 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
274 "this protocol does not support writing (yet).");
275 }
276
277 uint32_t writeI64(const int64_t i64) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100278 (void)i64;
David Reiss6806fb82010-10-06 17:09:52 +0000279 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
280 "this protocol does not support writing (yet).");
281 }
282
283 uint32_t writeDouble(const double dub) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100284 (void)dub;
David Reiss6806fb82010-10-06 17:09:52 +0000285 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
286 "this protocol does not support writing (yet).");
287 }
288
289 uint32_t writeString(const std::string& str) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100290 (void)str;
David Reiss6806fb82010-10-06 17:09:52 +0000291 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
292 "this protocol does not support writing (yet).");
293 }
294
295 uint32_t writeBinary(const std::string& str) {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100296 (void)str;
David Reiss6806fb82010-10-06 17:09:52 +0000297 throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
298 "this protocol does not support writing (yet).");
299 }
300
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100301 uint32_t skip(TType type) { return ::apache::thrift::protocol::skip(*this, type); }
David Reiss6806fb82010-10-06 17:09:52 +0000302
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100303protected:
cyy316723a2019-01-05 16:35:14 +0800304 TProtocolDefaults(std::shared_ptr<TTransport> ptrans) : TProtocol(ptrans) {}
David Reiss6806fb82010-10-06 17:09:52 +0000305};
306
307/**
308 * Concrete TProtocol classes should inherit from TVirtualProtocol
309 * so they don't have to manually override virtual methods.
310 */
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100311template <class Protocol_, class Super_ = TProtocolDefaults>
David Reiss6806fb82010-10-06 17:09:52 +0000312class TVirtualProtocol : public Super_ {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100313public:
David Reiss6806fb82010-10-06 17:09:52 +0000314 /**
315 * Writing functions.
316 */
317
Sebastian Zenker042580f2019-01-29 15:48:12 +0100318 uint32_t writeMessageBegin_virt(const std::string& name,
David Reiss6806fb82010-10-06 17:09:52 +0000319 const TMessageType messageType,
Sebastian Zenker042580f2019-01-29 15:48:12 +0100320 const int32_t seqid) override {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100321 return static_cast<Protocol_*>(this)->writeMessageBegin(name, messageType, seqid);
David Reiss6806fb82010-10-06 17:09:52 +0000322 }
323
Sebastian Zenker042580f2019-01-29 15:48:12 +0100324 uint32_t writeMessageEnd_virt() override {
David Reiss6806fb82010-10-06 17:09:52 +0000325 return static_cast<Protocol_*>(this)->writeMessageEnd();
326 }
327
Sebastian Zenker042580f2019-01-29 15:48:12 +0100328 uint32_t writeStructBegin_virt(const char* name) override {
David Reiss6806fb82010-10-06 17:09:52 +0000329 return static_cast<Protocol_*>(this)->writeStructBegin(name);
330 }
331
Sebastian Zenker042580f2019-01-29 15:48:12 +0100332 uint32_t writeStructEnd_virt() override { return static_cast<Protocol_*>(this)->writeStructEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000333
Sebastian Zenker042580f2019-01-29 15:48:12 +0100334 uint32_t writeFieldBegin_virt(const char* name,
David Reiss6806fb82010-10-06 17:09:52 +0000335 const TType fieldType,
Sebastian Zenker042580f2019-01-29 15:48:12 +0100336 const int16_t fieldId) override {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100337 return static_cast<Protocol_*>(this)->writeFieldBegin(name, fieldType, fieldId);
David Reiss6806fb82010-10-06 17:09:52 +0000338 }
339
Sebastian Zenker042580f2019-01-29 15:48:12 +0100340 uint32_t writeFieldEnd_virt() override { return static_cast<Protocol_*>(this)->writeFieldEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000341
Sebastian Zenker042580f2019-01-29 15:48:12 +0100342 uint32_t writeFieldStop_virt() override { return static_cast<Protocol_*>(this)->writeFieldStop(); }
David Reiss6806fb82010-10-06 17:09:52 +0000343
Sebastian Zenker042580f2019-01-29 15:48:12 +0100344 uint32_t writeMapBegin_virt(const TType keyType,
David Reiss6806fb82010-10-06 17:09:52 +0000345 const TType valType,
Sebastian Zenker042580f2019-01-29 15:48:12 +0100346 const uint32_t size) override {
David Reiss6806fb82010-10-06 17:09:52 +0000347 return static_cast<Protocol_*>(this)->writeMapBegin(keyType, valType, size);
348 }
349
Sebastian Zenker042580f2019-01-29 15:48:12 +0100350 uint32_t writeMapEnd_virt() override { return static_cast<Protocol_*>(this)->writeMapEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000351
Sebastian Zenker042580f2019-01-29 15:48:12 +0100352 uint32_t writeListBegin_virt(const TType elemType, const uint32_t size) override {
David Reiss6806fb82010-10-06 17:09:52 +0000353 return static_cast<Protocol_*>(this)->writeListBegin(elemType, size);
354 }
355
Sebastian Zenker042580f2019-01-29 15:48:12 +0100356 uint32_t writeListEnd_virt() override { return static_cast<Protocol_*>(this)->writeListEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000357
Sebastian Zenker042580f2019-01-29 15:48:12 +0100358 uint32_t writeSetBegin_virt(const TType elemType, const uint32_t size) override {
David Reiss6806fb82010-10-06 17:09:52 +0000359 return static_cast<Protocol_*>(this)->writeSetBegin(elemType, size);
360 }
361
Sebastian Zenker042580f2019-01-29 15:48:12 +0100362 uint32_t writeSetEnd_virt() override { return static_cast<Protocol_*>(this)->writeSetEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000363
Sebastian Zenker042580f2019-01-29 15:48:12 +0100364 uint32_t writeBool_virt(const bool value) override {
David Reiss6806fb82010-10-06 17:09:52 +0000365 return static_cast<Protocol_*>(this)->writeBool(value);
366 }
367
Sebastian Zenker042580f2019-01-29 15:48:12 +0100368 uint32_t writeByte_virt(const int8_t byte) override {
David Reiss6806fb82010-10-06 17:09:52 +0000369 return static_cast<Protocol_*>(this)->writeByte(byte);
370 }
371
Sebastian Zenker042580f2019-01-29 15:48:12 +0100372 uint32_t writeI16_virt(const int16_t i16) override {
David Reiss6806fb82010-10-06 17:09:52 +0000373 return static_cast<Protocol_*>(this)->writeI16(i16);
374 }
375
Sebastian Zenker042580f2019-01-29 15:48:12 +0100376 uint32_t writeI32_virt(const int32_t i32) override {
David Reiss6806fb82010-10-06 17:09:52 +0000377 return static_cast<Protocol_*>(this)->writeI32(i32);
378 }
379
Sebastian Zenker042580f2019-01-29 15:48:12 +0100380 uint32_t writeI64_virt(const int64_t i64) override {
David Reiss6806fb82010-10-06 17:09:52 +0000381 return static_cast<Protocol_*>(this)->writeI64(i64);
382 }
383
Sebastian Zenker042580f2019-01-29 15:48:12 +0100384 uint32_t writeDouble_virt(const double dub) override {
David Reiss6806fb82010-10-06 17:09:52 +0000385 return static_cast<Protocol_*>(this)->writeDouble(dub);
386 }
387
Sebastian Zenker042580f2019-01-29 15:48:12 +0100388 uint32_t writeString_virt(const std::string& str) override {
David Reiss6806fb82010-10-06 17:09:52 +0000389 return static_cast<Protocol_*>(this)->writeString(str);
390 }
391
Sebastian Zenker042580f2019-01-29 15:48:12 +0100392 uint32_t writeBinary_virt(const std::string& str) override {
David Reiss6806fb82010-10-06 17:09:52 +0000393 return static_cast<Protocol_*>(this)->writeBinary(str);
394 }
395
396 /**
397 * Reading functions
398 */
399
Sebastian Zenker042580f2019-01-29 15:48:12 +0100400 uint32_t readMessageBegin_virt(std::string& name,
David Reiss6806fb82010-10-06 17:09:52 +0000401 TMessageType& messageType,
Sebastian Zenker042580f2019-01-29 15:48:12 +0100402 int32_t& seqid) override {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100403 return static_cast<Protocol_*>(this)->readMessageBegin(name, messageType, seqid);
David Reiss6806fb82010-10-06 17:09:52 +0000404 }
405
Sebastian Zenker042580f2019-01-29 15:48:12 +0100406 uint32_t readMessageEnd_virt() override { return static_cast<Protocol_*>(this)->readMessageEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000407
Sebastian Zenker042580f2019-01-29 15:48:12 +0100408 uint32_t readStructBegin_virt(std::string& name) override {
David Reiss6806fb82010-10-06 17:09:52 +0000409 return static_cast<Protocol_*>(this)->readStructBegin(name);
410 }
411
Sebastian Zenker042580f2019-01-29 15:48:12 +0100412 uint32_t readStructEnd_virt() override { return static_cast<Protocol_*>(this)->readStructEnd(); }
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100413
Sebastian Zenker042580f2019-01-29 15:48:12 +0100414 uint32_t readFieldBegin_virt(std::string& name, TType& fieldType, int16_t& fieldId) override {
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100415 return static_cast<Protocol_*>(this)->readFieldBegin(name, fieldType, fieldId);
David Reiss6806fb82010-10-06 17:09:52 +0000416 }
417
Sebastian Zenker042580f2019-01-29 15:48:12 +0100418 uint32_t readFieldEnd_virt() override { return static_cast<Protocol_*>(this)->readFieldEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000419
Sebastian Zenker042580f2019-01-29 15:48:12 +0100420 uint32_t readMapBegin_virt(TType& keyType, TType& valType, uint32_t& size) override {
David Reiss6806fb82010-10-06 17:09:52 +0000421 return static_cast<Protocol_*>(this)->readMapBegin(keyType, valType, size);
422 }
423
Sebastian Zenker042580f2019-01-29 15:48:12 +0100424 uint32_t readMapEnd_virt() override { return static_cast<Protocol_*>(this)->readMapEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000425
Sebastian Zenker042580f2019-01-29 15:48:12 +0100426 uint32_t readListBegin_virt(TType& elemType, uint32_t& size) override {
David Reiss6806fb82010-10-06 17:09:52 +0000427 return static_cast<Protocol_*>(this)->readListBegin(elemType, size);
428 }
429
Sebastian Zenker042580f2019-01-29 15:48:12 +0100430 uint32_t readListEnd_virt() override { return static_cast<Protocol_*>(this)->readListEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000431
Sebastian Zenker042580f2019-01-29 15:48:12 +0100432 uint32_t readSetBegin_virt(TType& elemType, uint32_t& size) override {
David Reiss6806fb82010-10-06 17:09:52 +0000433 return static_cast<Protocol_*>(this)->readSetBegin(elemType, size);
434 }
435
Sebastian Zenker042580f2019-01-29 15:48:12 +0100436 uint32_t readSetEnd_virt() override { return static_cast<Protocol_*>(this)->readSetEnd(); }
David Reiss6806fb82010-10-06 17:09:52 +0000437
Sebastian Zenker042580f2019-01-29 15:48:12 +0100438 uint32_t readBool_virt(bool& value) override {
David Reiss6806fb82010-10-06 17:09:52 +0000439 return static_cast<Protocol_*>(this)->readBool(value);
440 }
441
Sebastian Zenker042580f2019-01-29 15:48:12 +0100442 uint32_t readBool_virt(std::vector<bool>::reference value) override {
David Reiss8dfc7322010-10-06 17:09:58 +0000443 return static_cast<Protocol_*>(this)->readBool(value);
444 }
445
Sebastian Zenker042580f2019-01-29 15:48:12 +0100446 uint32_t readByte_virt(int8_t& byte) override {
David Reiss6806fb82010-10-06 17:09:52 +0000447 return static_cast<Protocol_*>(this)->readByte(byte);
448 }
449
Sebastian Zenker042580f2019-01-29 15:48:12 +0100450 uint32_t readI16_virt(int16_t& i16) override {
David Reiss6806fb82010-10-06 17:09:52 +0000451 return static_cast<Protocol_*>(this)->readI16(i16);
452 }
453
Sebastian Zenker042580f2019-01-29 15:48:12 +0100454 uint32_t readI32_virt(int32_t& i32) override {
David Reiss6806fb82010-10-06 17:09:52 +0000455 return static_cast<Protocol_*>(this)->readI32(i32);
456 }
457
Sebastian Zenker042580f2019-01-29 15:48:12 +0100458 uint32_t readI64_virt(int64_t& i64) override {
David Reiss6806fb82010-10-06 17:09:52 +0000459 return static_cast<Protocol_*>(this)->readI64(i64);
460 }
461
Sebastian Zenker042580f2019-01-29 15:48:12 +0100462 uint32_t readDouble_virt(double& dub) override {
David Reiss6806fb82010-10-06 17:09:52 +0000463 return static_cast<Protocol_*>(this)->readDouble(dub);
464 }
465
Sebastian Zenker042580f2019-01-29 15:48:12 +0100466 uint32_t readString_virt(std::string& str) override {
David Reiss6806fb82010-10-06 17:09:52 +0000467 return static_cast<Protocol_*>(this)->readString(str);
468 }
469
Sebastian Zenker042580f2019-01-29 15:48:12 +0100470 uint32_t readBinary_virt(std::string& str) override {
David Reiss6806fb82010-10-06 17:09:52 +0000471 return static_cast<Protocol_*>(this)->readBinary(str);
472 }
473
Sebastian Zenker042580f2019-01-29 15:48:12 +0100474 uint32_t skip_virt(TType type) override { return static_cast<Protocol_*>(this)->skip(type); }
David Reiss6806fb82010-10-06 17:09:52 +0000475
476 /*
477 * Provide a default skip() implementation that uses non-virtual read
478 * methods.
479 *
480 * Note: subclasses that use TVirtualProtocol to derive from another protocol
481 * implementation (i.e., not TProtocolDefaults) should beware that this may
482 * override any non-default skip() implementation provided by the parent
483 * transport class. They may need to explicitly redefine skip() to call the
484 * correct parent implementation, if desired.
485 */
486 uint32_t skip(TType type) {
Sebastian Zenker042580f2019-01-29 15:48:12 +0100487 auto* const prot = static_cast<Protocol_*>(this);
David Reiss6806fb82010-10-06 17:09:52 +0000488 return ::apache::thrift::protocol::skip(*prot, type);
489 }
490
David Reiss8dfc7322010-10-06 17:09:58 +0000491 /*
492 * Provide a default readBool() implementation for use with
493 * std::vector<bool>, that behaves the same as reading into a normal bool.
494 *
495 * Subclasses can override this if desired, but there normally shouldn't
496 * be a need to.
497 */
498 uint32_t readBool(std::vector<bool>::reference value) {
499 bool b = false;
500 uint32_t ret = static_cast<Protocol_*>(this)->readBool(b);
501 value = b;
502 return ret;
503 }
504 using Super_::readBool; // so we don't hide readBool(bool&)
505
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100506protected:
cyy316723a2019-01-05 16:35:14 +0800507 TVirtualProtocol(std::shared_ptr<TTransport> ptrans) : Super_(ptrans) {}
David Reiss6806fb82010-10-06 17:09:52 +0000508};
Konrad Grochowski16a23a62014-11-13 15:33:38 +0100509}
510}
511} // apache::thrift::protocol
David Reiss6806fb82010-10-06 17:09:52 +0000512
513#endif // #define _THRIFT_PROTOCOL_TVIRTUALPROTOCOL_H_ 1