ceph/src/jaegertracing/thrift/lib/perl/lib/Thrift/ProtocolDecorator.pm

   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 use 5.10.0;
  21 use strict;
  22 use warnings;
  23
  24 use Thrift;
  25 use Thrift::Protocol;
  26
  27 package Thrift::ProtocolDecorator;
  28 use base qw(Thrift::Protocol);
  29 use version 0.77; our $VERSION = version->declare("$Thrift::VERSION");
  30
  31 sub new {
  32     my $classname = shift;
  33     my $protocol  = shift;
  34     my $self      = $classname->SUPER::new($protocol->getTransport());
  35
  36     $self->{concreteProtocol} = $protocol;
  37
  38     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     my $self = shift;
  50     my ($name, $type, $seqid) = @_;
  51
  52       return  $self->{concreteProtocol}->writeMessageBegin($name, $type, $seqid);
  53 }
  54
  55 #
  56 # Close the message
  57 #
  58 sub writeMessageEnd {
  59      my $self = shift;
  60
  61      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     my $self = shift;
  73     my ($name) = @_;
  74
  75     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     my $self = shift;
  86
  87     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     my $self = shift;
 101     my ($fieldName, $fieldType, $fieldId) = @_;
 102
 103     return $self->{concreteProtocol}->writeFieldBegin($fieldName, $fieldType, $fieldId);
 104 }
 105
 106 sub writeFieldEnd {
 107     my $self = shift;
 108
 109     return $self->{concreteProtocol}->writeFieldEnd();
 110 }
 111
 112 sub writeFieldStop {
 113     my $self = shift;
 114
 115     return $self->{concreteProtocol}->writeFieldStop();
 116 }
 117
 118 sub writeMapBegin {
 119     my $self = shift;
 120     my ($keyType, $valType, $size) = @_;
 121
 122     return $self->{concreteProtocol}->writeMapBegin($keyType, $valType, $size);
 123 }
 124
 125 sub writeMapEnd {
 126     my $self = shift;
 127
 128     return $self->{concreteProtocol}->writeMapEnd();
 129 }
 130
 131 sub writeListBegin {
 132     my $self = shift;
 133     my ($elemType, $size) = @_;
 134
 135     return $self->{concreteProtocol}->writeListBegin($elemType, $size);
 136 }
 137
 138 sub writeListEnd {
 139     my $self = shift;
 140
 141     return $self->{concreteProtocol}->writeListEnd();
 142 }
 143
 144 sub writeSetBegin {
 145     my $self = shift;
 146     my ($elemType, $size) = @_;
 147
 148     return $self->{concreteProtocol}->writeSetBegin($elemType, $size);
 149 }
 150
 151 sub writeSetEnd {
 152     my $self = shift;
 153
 154     return $self->{concreteProtocol}->writeListEnd();
 155 }
 156
 157 sub writeBool {
 158     my $self = shift;
 159     my $bool = shift;
 160
 161     return $self->{concreteProtocol}->writeBool($bool);
 162 }
 163
 164 sub writeByte {
 165     my $self = shift;
 166     my $byte = shift;
 167
 168     return $self->{concreteProtocol}->writeByte($byte);
 169 }
 170
 171 sub writeI16 {
 172     my $self = shift;
 173     my $i16 = shift;
 174
 175     return $self->{concreteProtocol}->writeI16($i16);
 176 }
 177
 178 sub writeI32 {
 179     my $self = shift;
 180     my ($i32) = @_;
 181
 182     return $self->{concreteProtocol}->writeI32($i32);
 183
 184 }
 185
 186 sub writeI64 {
 187     my $self = shift;
 188     my $i64 = shift;
 189
 190     return $self->{concreteProtocol}->writeI64($i64);
 191 }
 192
 193 sub writeDouble {
 194     my $self = shift;
 195     my $dub = shift;
 196
 197     return $self->{concreteProtocol}->writeDouble($dub);
 198 }
 199
 200 sub writeString {
 201     my $self = shift;
 202     my $str = shift;
 203
 204     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     my $self = shift;
 217     my ($name, $type, $seqid) = @_;
 218
 219     return $self->{concreteProtocol}->readMessageBegin($name, $type, $seqid);
 220 }
 221
 222 #
 223 # Read the close of message
 224 #
 225 sub readMessageEnd
 226 {
 227     my $self = shift;
 228
 229     return $self->{concreteProtocol}->readMessageEnd();
 230 }
 231
 232 sub readStructBegin
 233 {
 234     my $self = shift;
 235     my $name = shift;
 236
 237     return $self->{concreteProtocol}->readStructBegin($name);
 238 }
 239
 240 sub readStructEnd
 241 {
 242     my $self = shift;
 243
 244     return $self->{concreteProtocol}->readStructEnd();
 245 }
 246
 247 sub readFieldBegin
 248 {
 249     my $self = shift;
 250     my ($name, $fieldType, $fieldId) = @_;
 251
 252     return $self->{concreteProtocol}->readFieldBegin($name, $fieldType, $fieldId);
 253 }
 254
 255 sub readFieldEnd
 256 {
 257     my $self = shift;
 258
 259     return $self->{concreteProtocol}->readFieldEnd();
 260 }
 261
 262 sub readMapBegin
 263 {
 264     my $self = shift;
 265     my ($keyType, $valType, $size) = @_;
 266
 267     return $self->{concreteProtocol}->readMapBegin($keyType, $valType, $size);
 268 }
 269
 270 sub readMapEnd
 271 {
 272     my $self = shift;
 273
 274     return $self->{concreteProtocol}->readMapEnd();
 275 }
 276
 277 sub readListBegin
 278 {
 279     my $self = shift;
 280     my ($elemType, $size) = @_;
 281
 282     return $self->{concreteProtocol}->readListBegin($elemType, $size);
 283 }
 284
 285 sub readListEnd
 286 {
 287     my $self = shift;
 288
 289     return $self->{concreteProtocol}->readListEnd();
 290 }
 291
 292 sub readSetBegin
 293 {
 294     my $self = shift;
 295     my ($elemType, $size) = @_;
 296
 297     return $self->{concreteProtocol}->readSetBegin($elemType, $size);
 298 }
 299
 300 sub readSetEnd
 301 {
 302     my $self = shift;
 303
 304     return $self->{concreteProtocol}->readSetEnd();
 305 }
 306
 307 sub readBool
 308 {
 309     my $self = shift;
 310     my $bool = shift;
 311
 312     return $self->{concreteProtocol}->readBool($bool);
 313 }
 314
 315 sub readByte
 316 {
 317     my $self = shift;
 318     my $byte = shift;
 319
 320     return $self->{concreteProtocol}->readByte($byte);
 321 }
 322
 323 sub readI16
 324 {
 325     my $self = shift;
 326     my $i16 = shift;
 327
 328     return $self->{concreteProtocol}->readI16($i16);
 329 }
 330
 331 sub readI32
 332 {
 333     my $self = shift;
 334     my $i32  = shift;
 335
 336     return $self->{concreteProtocol}->readI32($i32);
 337 }
 338
 339 sub readI64
 340 {
 341     my $self = shift;
 342     my $i64  = shift;
 343
 344     return $self->{concreteProtocol}->readI64($i64);
 345 }
 346
 347 sub readDouble
 348 {
 349     my $self = shift;
 350     my $dub  = shift;
 351
 352     return $self->{concreteProtocol}->readDouble($dub);
 353 }
 354
 355 sub readString
 356 {
 357     my $self = shift;
 358     my $str = shift;
 359
 360     return $self->{concreteProtocol}->readString($str);
 361 }
 362
 363 1;