File Coverage

blib/lib/Thrift/ProtocolDecorator.pm
Criterion Covered Total %
statement 74 129 57.3
branch n/a
condition n/a
subroutine 27 47 57.4
pod 0 40 0.0
total 101 216 46.7


line stmt bran cond sub pod time code
1             #
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 1     1   11 use 5.10.0;
  1         4  
21 1     1   6 use strict;
  1         2  
  1         35  
22 1     1   6 use warnings;
  1         2  
  1         24  
23              
24 1     1   4 use Thrift;
  1         2  
  1         26  
25 1     1   5 use Thrift::Protocol;
  1         2  
  1         29  
26              
27             package Thrift::ProtocolDecorator;
28 1     1   5 use base qw(Thrift::Protocol);
  1         2  
  1         117  
29 1     1   8 use version 0.77; our $VERSION = version->declare("$Thrift::VERSION");
  1         14  
  1         5  
30              
31             sub new {
32 13     13 0 22 my $classname = shift;
33 13         18 my $protocol = shift;
34 13         32 my $self = $classname->SUPER::new($protocol->getTransport());
35              
36 13         25 $self->{concreteProtocol} = $protocol;
37              
38 13         24 return bless($self,$classname);
39             }
40              
41             #
42             # Writes the message header
43             #
44             # @param string $name Function name
45             # @param int $type message type TMessageType::CALL or TMessageType::REPLY
46             # @param int $seqid The sequence id of this message
47             #
48             sub writeMessageBegin {
49 11     11 0 16 my $self = shift;
50 11         18 my ($name, $type, $seqid) = @_;
51              
52 11         23 return $self->{concreteProtocol}->writeMessageBegin($name, $type, $seqid);
53             }
54              
55             #
56             # Close the message
57             #
58             sub writeMessageEnd {
59 11     11 0 19 my $self = shift;
60              
61 11         22 return $self->{concreteProtocol}->writeMessageEnd();
62             }
63              
64             #
65             # Writes a struct header.
66             #
67             # @param string $name Struct name
68             # @throws TException on write error
69             # @return int How many bytes written
70             #
71             sub writeStructBegin {
72 11     11 0 16 my $self = shift;
73 11         19 my ($name) = @_;
74              
75 11         24 return $self->{concreteProtocol}->writeStructBegin($name);
76             }
77              
78             #
79             # Close a struct.
80             #
81             # @throws TException on write error
82             # @return int How many bytes written
83             #
84             sub writeStructEnd {
85 11     11 0 13 my $self = shift;
86              
87 11         23 return $self->{concreteProtocol}->writeStructEnd();
88             }
89              
90             #
91             # Starts a field.
92             #
93             # @param string $name Field name
94             # @param int $type Field type
95             # @param int $fid Field id
96             # @throws TException on write error
97             # @return int How many bytes written
98             #
99             sub writeFieldBegin {
100 10     10 0 18 my $self = shift;
101 10         16 my ($fieldName, $fieldType, $fieldId) = @_;
102              
103 10         22 return $self->{concreteProtocol}->writeFieldBegin($fieldName, $fieldType, $fieldId);
104             }
105              
106             sub writeFieldEnd {
107 10     10 0 14 my $self = shift;
108              
109 10         22 return $self->{concreteProtocol}->writeFieldEnd();
110             }
111              
112             sub writeFieldStop {
113 11     11 0 20 my $self = shift;
114              
115 11         18 return $self->{concreteProtocol}->writeFieldStop();
116             }
117              
118             sub writeMapBegin {
119 0     0 0 0 my $self = shift;
120 0         0 my ($keyType, $valType, $size) = @_;
121              
122 0         0 return $self->{concreteProtocol}->writeMapBegin($keyType, $valType, $size);
123             }
124              
125             sub writeMapEnd {
126 0     0 0 0 my $self = shift;
127              
128 0         0 return $self->{concreteProtocol}->writeMapEnd();
129             }
130              
131             sub writeListBegin {
132 0     0 0 0 my $self = shift;
133 0         0 my ($elemType, $size) = @_;
134              
135 0         0 return $self->{concreteProtocol}->writeListBegin($elemType, $size);
136             }
137              
138             sub writeListEnd {
139 0     0 0 0 my $self = shift;
140              
141 0         0 return $self->{concreteProtocol}->writeListEnd();
142             }
143              
144             sub writeSetBegin {
145 0     0 0 0 my $self = shift;
146 0         0 my ($elemType, $size) = @_;
147              
148 0         0 return $self->{concreteProtocol}->writeSetBegin($elemType, $size);
149             }
150              
151             sub writeSetEnd {
152 0     0 0 0 my $self = shift;
153              
154 0         0 return $self->{concreteProtocol}->writeListEnd();
155             }
156              
157             sub writeBool {
158 0     0 0 0 my $self = shift;
159 0         0 my $bool = shift;
160              
161 0         0 return $self->{concreteProtocol}->writeBool($bool);
162             }
163              
164             sub writeByte {
165 5     5 0 10 my $self = shift;
166 5         7 my $byte = shift;
167              
168 5         11 return $self->{concreteProtocol}->writeByte($byte);
169             }
170              
171             sub writeI16 {
172 0     0 0 0 my $self = shift;
173 0         0 my $i16 = shift;
174              
175 0         0 return $self->{concreteProtocol}->writeI16($i16);
176             }
177              
178             sub writeI32 {
179 5     5 0 8 my $self = shift;
180 5         9 my ($i32) = @_;
181              
182 5         12 return $self->{concreteProtocol}->writeI32($i32);
183              
184             }
185              
186             sub writeI64 {
187 0     0 0 0 my $self = shift;
188 0         0 my $i64 = shift;
189              
190 0         0 return $self->{concreteProtocol}->writeI64($i64);
191             }
192              
193             sub writeDouble {
194 0     0 0 0 my $self = shift;
195 0         0 my $dub = shift;
196              
197 0         0 return $self->{concreteProtocol}->writeDouble($dub);
198             }
199              
200             sub writeString {
201 0     0 0 0 my $self = shift;
202 0         0 my $str = shift;
203              
204 0         0 return $self->{concreteProtocol}->writeString($str);
205             }
206              
207             #
208             # Reads the message header
209             #
210             # @param string $name Function name
211             # @param int $type message type TMessageType::CALL or TMessageType::REPLY
212             # @parem int $seqid The sequence id of this message
213             #
214             sub readMessageBegin
215             {
216 11     11 0 3042 my $self = shift;
217 11         20 my ($name, $type, $seqid) = @_;
218              
219 11         33 return $self->{concreteProtocol}->readMessageBegin($name, $type, $seqid);
220             }
221              
222             #
223             # Read the close of message
224             #
225             sub readMessageEnd
226             {
227 22     22 0 47 my $self = shift;
228              
229 22         48 return $self->{concreteProtocol}->readMessageEnd();
230             }
231              
232             sub readStructBegin
233             {
234 22     22 0 36 my $self = shift;
235 22         28 my $name = shift;
236              
237 22         50 return $self->{concreteProtocol}->readStructBegin($name);
238             }
239              
240             sub readStructEnd
241             {
242 22     22 0 32 my $self = shift;
243              
244 22         48 return $self->{concreteProtocol}->readStructEnd();
245             }
246              
247             sub readFieldBegin
248             {
249 38     38 0 59 my $self = shift;
250 38         63 my ($name, $fieldType, $fieldId) = @_;
251              
252 38         81 return $self->{concreteProtocol}->readFieldBegin($name, $fieldType, $fieldId);
253             }
254              
255             sub readFieldEnd
256             {
257 16     16 0 23 my $self = shift;
258              
259 16         32 return $self->{concreteProtocol}->readFieldEnd();
260             }
261              
262             sub readMapBegin
263             {
264 0     0 0 0 my $self = shift;
265 0         0 my ($keyType, $valType, $size) = @_;
266              
267 0         0 return $self->{concreteProtocol}->readMapBegin($keyType, $valType, $size);
268             }
269              
270             sub readMapEnd
271             {
272 0     0 0 0 my $self = shift;
273              
274 0         0 return $self->{concreteProtocol}->readMapEnd();
275             }
276              
277             sub readListBegin
278             {
279 1     1 0 2 my $self = shift;
280 1         3 my ($elemType, $size) = @_;
281              
282 1         4 return $self->{concreteProtocol}->readListBegin($elemType, $size);
283             }
284              
285             sub readListEnd
286             {
287 1     1 0 3 my $self = shift;
288              
289 1         3 return $self->{concreteProtocol}->readListEnd();
290             }
291              
292             sub readSetBegin
293             {
294 0     0 0 0 my $self = shift;
295 0         0 my ($elemType, $size) = @_;
296              
297 0         0 return $self->{concreteProtocol}->readSetBegin($elemType, $size);
298             }
299              
300             sub readSetEnd
301             {
302 0     0 0 0 my $self = shift;
303              
304 0         0 return $self->{concreteProtocol}->readSetEnd();
305             }
306              
307             sub readBool
308             {
309 0     0 0 0 my $self = shift;
310 0         0 my $bool = shift;
311              
312 0         0 return $self->{concreteProtocol}->readBool($bool);
313             }
314              
315             sub readByte
316             {
317 5     5 0 9 my $self = shift;
318 5         8 my $byte = shift;
319              
320 5         19 return $self->{concreteProtocol}->readByte($byte);
321             }
322              
323             sub readI16
324             {
325 0     0 0 0 my $self = shift;
326 0         0 my $i16 = shift;
327              
328 0         0 return $self->{concreteProtocol}->readI16($i16);
329             }
330              
331             sub readI32
332             {
333 15     15 0 25 my $self = shift;
334 15         20 my $i32 = shift;
335              
336 15         33 return $self->{concreteProtocol}->readI32($i32);
337             }
338              
339             sub readI64
340             {
341 0     0 0   my $self = shift;
342 0           my $i64 = shift;
343              
344 0           return $self->{concreteProtocol}->readI64($i64);
345             }
346              
347             sub readDouble
348             {
349 0     0 0   my $self = shift;
350 0           my $dub = shift;
351              
352 0           return $self->{concreteProtocol}->readDouble($dub);
353             }
354              
355             sub readString
356             {
357 0     0 0   my $self = shift;
358 0           my $str = shift;
359              
360 0           return $self->{concreteProtocol}->readString($str);
361             }
362              
363             1;