1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
#ifndef THRIFT_TPROTOCOLDECORATOR_H_
#define THRIFT_TPROTOCOLDECORATOR_H_ 1
#include <thrift/protocol/TProtocol.h>
#include <boost/shared_ptr.hpp>
namespace apache
{
namespace thrift
{
namespace protocol
{
using boost::shared_ptr;
/**
* <code>TProtocolDecorator</code> forwards all requests to an enclosed
* <code>TProtocol</code> instance, providing a way to author concise
* concrete decorator subclasses.
*
* <p>See p.175 of Design Patterns (by Gamma et al.)</p>
*
* @see apache::thrift::protocol::TMultiplexedProtocol
*/
class TProtocolDecorator : public TProtocol
{
public:
virtual ~TProtocolDecorator() {}
// Desc: Initializes the protocol decorator object.
TProtocolDecorator( shared_ptr<TProtocol> proto )
: TProtocol(proto->getTransport()), protocol(proto)
{
}
virtual uint32_t writeMessageBegin_virt(
const std::string& name,
const TMessageType messageType,
const int32_t seqid)
{
return protocol->writeMessageBegin(name, messageType, seqid);
}
virtual uint32_t writeMessageEnd_virt() { return protocol->writeMessageEnd(); }
virtual uint32_t writeStructBegin_virt(const char* name) { return protocol->writeStructBegin(name); }
virtual uint32_t writeStructEnd_virt() { return protocol->writeStructEnd(); }
virtual uint32_t writeFieldBegin_virt(const char* name,
const TType fieldType,
const int16_t fieldId) { return protocol->writeFieldBegin(name,fieldType,fieldId); }
virtual uint32_t writeFieldEnd_virt() { return protocol->writeFieldEnd(); }
virtual uint32_t writeFieldStop_virt() { return protocol->writeFieldStop(); }
virtual uint32_t writeMapBegin_virt(const TType keyType,
const TType valType,
const uint32_t size) { return protocol->writeMapBegin(keyType,valType,size); }
virtual uint32_t writeMapEnd_virt() { return protocol->writeMapEnd(); }
virtual uint32_t writeListBegin_virt(const TType elemType, const uint32_t size) { return protocol->writeListBegin(elemType,size); }
virtual uint32_t writeListEnd_virt() { return protocol->writeListEnd(); }
virtual uint32_t writeSetBegin_virt(const TType elemType, const uint32_t size) { return protocol->writeSetBegin(elemType,size); }
virtual uint32_t writeSetEnd_virt() { return protocol->writeSetEnd(); }
virtual uint32_t writeBool_virt(const bool value) { return protocol->writeBool(value); }
virtual uint32_t writeByte_virt(const int8_t byte) { return protocol->writeByte(byte); }
virtual uint32_t writeI16_virt(const int16_t i16) { return protocol->writeI16(i16); }
virtual uint32_t writeI32_virt(const int32_t i32) { return protocol->writeI32(i32); }
virtual uint32_t writeI64_virt(const int64_t i64) { return protocol->writeI64(i64); }
virtual uint32_t writeDouble_virt(const double dub) { return protocol->writeDouble(dub); }
virtual uint32_t writeString_virt(const std::string& str) { return protocol->writeString(str); }
virtual uint32_t writeBinary_virt(const std::string& str) { return protocol->writeBinary(str); }
virtual uint32_t readMessageBegin_virt(std::string& name, TMessageType& messageType, int32_t& seqid) { return protocol->readMessageBegin(name,messageType,seqid); }
virtual uint32_t readMessageEnd_virt() { return protocol->readMessageEnd(); }
virtual uint32_t readStructBegin_virt(std::string& name) { return protocol->readStructBegin(name); }
virtual uint32_t readStructEnd_virt() { return protocol->readStructEnd(); }
virtual uint32_t readFieldBegin_virt(std::string& name, TType& fieldType, int16_t& fieldId) { return protocol->readFieldBegin(name, fieldType, fieldId); }
virtual uint32_t readFieldEnd_virt() { return protocol->readFieldEnd(); }
virtual uint32_t readMapBegin_virt(TType& keyType, TType& valType, uint32_t& size) { return protocol->readMapBegin(keyType,valType,size); }
virtual uint32_t readMapEnd_virt() { return protocol->readMapEnd(); }
virtual uint32_t readListBegin_virt(TType& elemType, uint32_t& size) { return protocol->readListBegin(elemType,size); }
virtual uint32_t readListEnd_virt() { return protocol->readListEnd(); }
virtual uint32_t readSetBegin_virt(TType& elemType, uint32_t& size) { return protocol->readSetBegin(elemType,size); }
virtual uint32_t readSetEnd_virt() { return protocol->readSetEnd(); }
virtual uint32_t readBool_virt(bool& value) { return protocol->readBool(value); }
virtual uint32_t readBool_virt(std::vector<bool>::reference value) { return protocol->readBool(value); }
virtual uint32_t readByte_virt(int8_t& byte) { return protocol->readByte(byte); }
virtual uint32_t readI16_virt(int16_t& i16) { return protocol->readI16(i16); }
virtual uint32_t readI32_virt(int32_t& i32) { return protocol->readI32(i32); }
virtual uint32_t readI64_virt(int64_t& i64) { return protocol->readI64(i64); }
virtual uint32_t readDouble_virt(double& dub) { return protocol->readDouble(dub); }
virtual uint32_t readString_virt(std::string& str) { return protocol->readString(str); }
virtual uint32_t readBinary_virt(std::string& str) { return protocol->readBinary(str); }
private:
shared_ptr<TProtocol> protocol;
};
}
}
}
#endif // THRIFT_TPROTOCOLDECORATOR_H_
|
