开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网格计算 > 查看源码
Types.pm
资源名称：hadoop-0.20.0.tar.gz　[点击查看]
上传用户：quxuerui
上传日期：2018-01-08
资源大小：41811k
文件大小：15k
源码类别：

网格计算

开发平台：

Java

Types.pm：源码内容
  1. #
  2. # Autogenerated by Thrift
  3. #
  4. # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  5. #
  6. require 5.6.0;
  7. use strict;
  8. use warnings;
  9. use Thrift;
  11. package ThriftHandle;
  12. use base('Class::Accessor');
  13. ThriftHandle->mk_accessors( qw( id ) );
  14. sub new {
  15. my $classname = shift;
  16. my $self      = {};
  17. my $vals      = shift || {};
  18. $self->{id} = undef;
  19.   if (UNIVERSAL::isa($vals,'HASH')) {
  20.     if (defined $vals->{id}) {
  21.       $self->{id} = $vals->{id};
  22.     }
  23.   }
  24. return bless($self,$classname);
  25. }
  27. sub getName {
  28.   return 'ThriftHandle';
  29. }
  31. sub read {
  32.   my $self  = shift;
  33.   my $input = shift;
  34.   my $xfer  = 0;
  35.   my $fname;
  36.   my $ftype = 0;
  37.   my $fid   = 0;
  38.   $xfer += $input->readStructBegin($fname);
  39.   while (1) 
  40.   {
  41.     $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  42.     if ($ftype == TType::STOP) {
  43.       last;
  44.     }
  45.     SWITCH: for($fid)
  46.     {
  47.       /^-1$/ && do{      if ($ftype == TType::I64) {
  48.         $xfer += $input->readI64($self->{id});
  49.       } else {
  50.         $xfer += $input->skip($ftype);
  51.       }
  52.       last; };
  53.         $xfer += $input->skip($ftype);
  54.     }
  55.     $xfer += $input->readFieldEnd();
  56.   }
  57.   $xfer += $input->readStructEnd();
  58.   return $xfer;
  59. }
  61. sub write {
  62.   my $self   = shift;
  63.   my $output = shift;
  64.   my $xfer   = 0;
  65.   $xfer += $output->writeStructBegin('ThriftHandle');
  66.   if (defined $self->{id}) {
  67.     $xfer += $output->writeFieldBegin('id', TType::I64, -1);
  68.     $xfer += $output->writeI64($self->{id});
  69.     $xfer += $output->writeFieldEnd();
  70.   }
  71.   $xfer += $output->writeFieldStop();
  72.   $xfer += $output->writeStructEnd();
  73.   return $xfer;
  74. }
  76. package Pathname;
  77. use base('Class::Accessor');
  78. Pathname->mk_accessors( qw( pathname ) );
  79. sub new {
  80. my $classname = shift;
  81. my $self      = {};
  82. my $vals      = shift || {};
  83. $self->{pathname} = undef;
  84.   if (UNIVERSAL::isa($vals,'HASH')) {
  85.     if (defined $vals->{pathname}) {
  86.       $self->{pathname} = $vals->{pathname};
  87.     }
  88.   }
  89. return bless($self,$classname);
  90. }
  92. sub getName {
  93.   return 'Pathname';
  94. }
  96. sub read {
  97.   my $self  = shift;
  98.   my $input = shift;
  99.   my $xfer  = 0;
  100.   my $fname;
  101.   my $ftype = 0;
  102.   my $fid   = 0;
  103.   $xfer += $input->readStructBegin($fname);
  104.   while (1) 
  105.   {
  106.     $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  107.     if ($ftype == TType::STOP) {
  108.       last;
  109.     }
  110.     SWITCH: for($fid)
  111.     {
  112.       /^-1$/ && do{      if ($ftype == TType::STRING) {
  113.         $xfer += $input->readString($self->{pathname});
  114.       } else {
  115.         $xfer += $input->skip($ftype);
  116.       }
  117.       last; };
  118.         $xfer += $input->skip($ftype);
  119.     }
  120.     $xfer += $input->readFieldEnd();
  121.   }
  122.   $xfer += $input->readStructEnd();
  123.   return $xfer;
  124. }
  126. sub write {
  127.   my $self   = shift;
  128.   my $output = shift;
  129.   my $xfer   = 0;
  130.   $xfer += $output->writeStructBegin('Pathname');
  131.   if (defined $self->{pathname}) {
  132.     $xfer += $output->writeFieldBegin('pathname', TType::STRING, -1);
  133.     $xfer += $output->writeString($self->{pathname});
  134.     $xfer += $output->writeFieldEnd();
  135.   }
  136.   $xfer += $output->writeFieldStop();
  137.   $xfer += $output->writeStructEnd();
  138.   return $xfer;
  139. }
  141. package FileStatus;
  142. use base('Class::Accessor');
  143. FileStatus->mk_accessors( qw( path length isdir block_replication blocksize modification_time permission owner group ) );
  144. sub new {
  145. my $classname = shift;
  146. my $self      = {};
  147. my $vals      = shift || {};
  148. $self->{path} = undef;
  149. $self->{length} = undef;
  150. $self->{isdir} = undef;
  151. $self->{block_replication} = undef;
  152. $self->{blocksize} = undef;
  153. $self->{modification_time} = undef;
  154. $self->{permission} = undef;
  155. $self->{owner} = undef;
  156. $self->{group} = undef;
  157.   if (UNIVERSAL::isa($vals,'HASH')) {
  158.     if (defined $vals->{path}) {
  159.       $self->{path} = $vals->{path};
  160.     }
  161.     if (defined $vals->{length}) {
  162.       $self->{length} = $vals->{length};
  163.     }
  164.     if (defined $vals->{isdir}) {
  165.       $self->{isdir} = $vals->{isdir};
  166.     }
  167.     if (defined $vals->{block_replication}) {
  168.       $self->{block_replication} = $vals->{block_replication};
  169.     }
  170.     if (defined $vals->{blocksize}) {
  171.       $self->{blocksize} = $vals->{blocksize};
  172.     }
  173.     if (defined $vals->{modification_time}) {
  174.       $self->{modification_time} = $vals->{modification_time};
  175.     }
  176.     if (defined $vals->{permission}) {
  177.       $self->{permission} = $vals->{permission};
  178.     }
  179.     if (defined $vals->{owner}) {
  180.       $self->{owner} = $vals->{owner};
  181.     }
  182.     if (defined $vals->{group}) {
  183.       $self->{group} = $vals->{group};
  184.     }
  185.   }
  186. return bless($self,$classname);
  187. }
  189. sub getName {
  190.   return 'FileStatus';
  191. }
  193. sub read {
  194.   my $self  = shift;
  195.   my $input = shift;
  196.   my $xfer  = 0;
  197.   my $fname;
  198.   my $ftype = 0;
  199.   my $fid   = 0;
  200.   $xfer += $input->readStructBegin($fname);
  201.   while (1) 
  202.   {
  203.     $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  204.     if ($ftype == TType::STOP) {
  205.       last;
  206.     }
  207.     SWITCH: for($fid)
  208.     {
  209.       /^1$/ && do{      if ($ftype == TType::STRING) {
  210.         $xfer += $input->readString($self->{path});
  211.       } else {
  212.         $xfer += $input->skip($ftype);
  213.       }
  214.       last; };
  215.       /^2$/ && do{      if ($ftype == TType::I64) {
  216.         $xfer += $input->readI64($self->{length});
  217.       } else {
  218.         $xfer += $input->skip($ftype);
  219.       }
  220.       last; };
  221.       /^3$/ && do{      if ($ftype == TType::BOOL) {
  222.         $xfer += $input->readBool($self->{isdir});
  223.       } else {
  224.         $xfer += $input->skip($ftype);
  225.       }
  226.       last; };
  227.       /^4$/ && do{      if ($ftype == TType::I16) {
  228.         $xfer += $input->readI16($self->{block_replication});
  229.       } else {
  230.         $xfer += $input->skip($ftype);
  231.       }
  232.       last; };
  233.       /^5$/ && do{      if ($ftype == TType::I64) {
  234.         $xfer += $input->readI64($self->{blocksize});
  235.       } else {
  236.         $xfer += $input->skip($ftype);
  237.       }
  238.       last; };
  239.       /^6$/ && do{      if ($ftype == TType::I64) {
  240.         $xfer += $input->readI64($self->{modification_time});
  241.       } else {
  242.         $xfer += $input->skip($ftype);
  243.       }
  244.       last; };
  245.       /^7$/ && do{      if ($ftype == TType::STRING) {
  246.         $xfer += $input->readString($self->{permission});
  247.       } else {
  248.         $xfer += $input->skip($ftype);
  249.       }
  250.       last; };
  251.       /^8$/ && do{      if ($ftype == TType::STRING) {
  252.         $xfer += $input->readString($self->{owner});
  253.       } else {
  254.         $xfer += $input->skip($ftype);
  255.       }
  256.       last; };
  257.       /^9$/ && do{      if ($ftype == TType::STRING) {
  258.         $xfer += $input->readString($self->{group});
  259.       } else {
  260.         $xfer += $input->skip($ftype);
  261.       }
  262.       last; };
  263.         $xfer += $input->skip($ftype);
  264.     }
  265.     $xfer += $input->readFieldEnd();
  266.   }
  267.   $xfer += $input->readStructEnd();
  268.   return $xfer;
  269. }
  271. sub write {
  272.   my $self   = shift;
  273.   my $output = shift;
  274.   my $xfer   = 0;
  275.   $xfer += $output->writeStructBegin('FileStatus');
  276.   if (defined $self->{path}) {
  277.     $xfer += $output->writeFieldBegin('path', TType::STRING, 1);
  278.     $xfer += $output->writeString($self->{path});
  279.     $xfer += $output->writeFieldEnd();
  280.   }
  281.   if (defined $self->{length}) {
  282.     $xfer += $output->writeFieldBegin('length', TType::I64, 2);
  283.     $xfer += $output->writeI64($self->{length});
  284.     $xfer += $output->writeFieldEnd();
  285.   }
  286.   if (defined $self->{isdir}) {
  287.     $xfer += $output->writeFieldBegin('isdir', TType::BOOL, 3);
  288.     $xfer += $output->writeBool($self->{isdir});
  289.     $xfer += $output->writeFieldEnd();
  290.   }
  291.   if (defined $self->{block_replication}) {
  292.     $xfer += $output->writeFieldBegin('block_replication', TType::I16, 4);
  293.     $xfer += $output->writeI16($self->{block_replication});
  294.     $xfer += $output->writeFieldEnd();
  295.   }
  296.   if (defined $self->{blocksize}) {
  297.     $xfer += $output->writeFieldBegin('blocksize', TType::I64, 5);
  298.     $xfer += $output->writeI64($self->{blocksize});
  299.     $xfer += $output->writeFieldEnd();
  300.   }
  301.   if (defined $self->{modification_time}) {
  302.     $xfer += $output->writeFieldBegin('modification_time', TType::I64, 6);
  303.     $xfer += $output->writeI64($self->{modification_time});
  304.     $xfer += $output->writeFieldEnd();
  305.   }
  306.   if (defined $self->{permission}) {
  307.     $xfer += $output->writeFieldBegin('permission', TType::STRING, 7);
  308.     $xfer += $output->writeString($self->{permission});
  309.     $xfer += $output->writeFieldEnd();
  310.   }
  311.   if (defined $self->{owner}) {
  312.     $xfer += $output->writeFieldBegin('owner', TType::STRING, 8);
  313.     $xfer += $output->writeString($self->{owner});
  314.     $xfer += $output->writeFieldEnd();
  315.   }
  316.   if (defined $self->{group}) {
  317.     $xfer += $output->writeFieldBegin('group', TType::STRING, 9);
  318.     $xfer += $output->writeString($self->{group});
  319.     $xfer += $output->writeFieldEnd();
  320.   }
  321.   $xfer += $output->writeFieldStop();
  322.   $xfer += $output->writeStructEnd();
  323.   return $xfer;
  324. }
  326. package BlockLocation;
  327. use base('Class::Accessor');
  328. BlockLocation->mk_accessors( qw( hosts names offset length ) );
  329. sub new {
  330. my $classname = shift;
  331. my $self      = {};
  332. my $vals      = shift || {};
  333. $self->{hosts} = undef;
  334. $self->{names} = undef;
  335. $self->{offset} = undef;
  336. $self->{length} = undef;
  337.   if (UNIVERSAL::isa($vals,'HASH')) {
  338.     if (defined $vals->{hosts}) {
  339.       $self->{hosts} = $vals->{hosts};
  340.     }
  341.     if (defined $vals->{names}) {
  342.       $self->{names} = $vals->{names};
  343.     }
  344.     if (defined $vals->{offset}) {
  345.       $self->{offset} = $vals->{offset};
  346.     }
  347.     if (defined $vals->{length}) {
  348.       $self->{length} = $vals->{length};
  349.     }
  350.   }
  351. return bless($self,$classname);
  352. }
  354. sub getName {
  355.   return 'BlockLocation';
  356. }
  358. sub read {
  359.   my $self  = shift;
  360.   my $input = shift;
  361.   my $xfer  = 0;
  362.   my $fname;
  363.   my $ftype = 0;
  364.   my $fid   = 0;
  365.   $xfer += $input->readStructBegin($fname);
  366.   while (1) 
  367.   {
  368.     $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  369.     if ($ftype == TType::STOP) {
  370.       last;
  371.     }
  372.     SWITCH: for($fid)
  373.     {
  374.       /^1$/ && do{      if ($ftype == TType::LIST) {
  375.         {
  376.           my $_size0 = 0;
  377.           $self->{hosts} = [];
  378.           my $_etype3 = 0;
  379.           $xfer += $input->readListBegin($_etype3, $_size0);
  380.           for (my $_i4 = 0; $_i4 < $_size0; ++$_i4)
  381.           {
  382.             my $elem5 = undef;
  383.             $xfer += $input->readString($elem5);
  384.             push(@{$self->{hosts}},$elem5);
  385.           }
  386.           $xfer += $input->readListEnd();
  387.         }
  388.       } else {
  389.         $xfer += $input->skip($ftype);
  390.       }
  391.       last; };
  392.       /^2$/ && do{      if ($ftype == TType::LIST) {
  393.         {
  394.           my $_size6 = 0;
  395.           $self->{names} = [];
  396.           my $_etype9 = 0;
  397.           $xfer += $input->readListBegin($_etype9, $_size6);
  398.           for (my $_i10 = 0; $_i10 < $_size6; ++$_i10)
  399.           {
  400.             my $elem11 = undef;
  401.             $xfer += $input->readString($elem11);
  402.             push(@{$self->{names}},$elem11);
  403.           }
  404.           $xfer += $input->readListEnd();
  405.         }
  406.       } else {
  407.         $xfer += $input->skip($ftype);
  408.       }
  409.       last; };
  410.       /^3$/ && do{      if ($ftype == TType::I64) {
  411.         $xfer += $input->readI64($self->{offset});
  412.       } else {
  413.         $xfer += $input->skip($ftype);
  414.       }
  415.       last; };
  416.       /^4$/ && do{      if ($ftype == TType::I64) {
  417.         $xfer += $input->readI64($self->{length});
  418.       } else {
  419.         $xfer += $input->skip($ftype);
  420.       }
  421.       last; };
  422.         $xfer += $input->skip($ftype);
  423.     }
  424.     $xfer += $input->readFieldEnd();
  425.   }
  426.   $xfer += $input->readStructEnd();
  427.   return $xfer;
  428. }
  430. sub write {
  431.   my $self   = shift;
  432.   my $output = shift;
  433.   my $xfer   = 0;
  434.   $xfer += $output->writeStructBegin('BlockLocation');
  435.   if (defined $self->{hosts}) {
  436.     $xfer += $output->writeFieldBegin('hosts', TType::LIST, 1);
  437.     {
  438.       $output->writeListBegin(TType::STRING, scalar(@{$self->{hosts}}));
  439.       {
  440.         foreach my $iter12 (@{$self->{hosts}}) 
  441.         {
  442.           $xfer += $output->writeString($iter12);
  443.         }
  444.       }
  445.       $output->writeListEnd();
  446.     }
  447.     $xfer += $output->writeFieldEnd();
  448.   }
  449.   if (defined $self->{names}) {
  450.     $xfer += $output->writeFieldBegin('names', TType::LIST, 2);
  451.     {
  452.       $output->writeListBegin(TType::STRING, scalar(@{$self->{names}}));
  453.       {
  454.         foreach my $iter13 (@{$self->{names}}) 
  455.         {
  456.           $xfer += $output->writeString($iter13);
  457.         }
  458.       }
  459.       $output->writeListEnd();
  460.     }
  461.     $xfer += $output->writeFieldEnd();
  462.   }
  463.   if (defined $self->{offset}) {
  464.     $xfer += $output->writeFieldBegin('offset', TType::I64, 3);
  465.     $xfer += $output->writeI64($self->{offset});
  466.     $xfer += $output->writeFieldEnd();
  467.   }
  468.   if (defined $self->{length}) {
  469.     $xfer += $output->writeFieldBegin('length', TType::I64, 4);
  470.     $xfer += $output->writeI64($self->{length});
  471.     $xfer += $output->writeFieldEnd();
  472.   }
  473.   $xfer += $output->writeFieldStop();
  474.   $xfer += $output->writeStructEnd();
  475.   return $xfer;
  476. }
  478. package MalformedInputException;
  479. use base('Thrift::TException');
  480. use base('Class::Accessor');
  481. MalformedInputException->mk_accessors( qw( message ) );
  482. sub new {
  483. my $classname = shift;
  484. my $self      = {};
  485. my $vals      = shift || {};
  486. $self->{message} = undef;
  487.   if (UNIVERSAL::isa($vals,'HASH')) {
  488.     if (defined $vals->{message}) {
  489.       $self->{message} = $vals->{message};
  490.     }
  491.   }
  492. return bless($self,$classname);
  493. }
  495. sub getName {
  496.   return 'MalformedInputException';
  497. }
  499. sub read {
  500.   my $self  = shift;
  501.   my $input = shift;
  502.   my $xfer  = 0;
  503.   my $fname;
  504.   my $ftype = 0;
  505.   my $fid   = 0;
  506.   $xfer += $input->readStructBegin($fname);
  507.   while (1) 
  508.   {
  509.     $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  510.     if ($ftype == TType::STOP) {
  511.       last;
  512.     }
  513.     SWITCH: for($fid)
  514.     {
  515.       /^-1$/ && do{      if ($ftype == TType::STRING) {
  516.         $xfer += $input->readString($self->{message});
  517.       } else {
  518.         $xfer += $input->skip($ftype);
  519.       }
  520.       last; };
  521.         $xfer += $input->skip($ftype);
  522.     }
  523.     $xfer += $input->readFieldEnd();
  524.   }
  525.   $xfer += $input->readStructEnd();
  526.   return $xfer;
  527. }
  529. sub write {
  530.   my $self   = shift;
  531.   my $output = shift;
  532.   my $xfer   = 0;
  533.   $xfer += $output->writeStructBegin('MalformedInputException');
  534.   if (defined $self->{message}) {
  535.     $xfer += $output->writeFieldBegin('message', TType::STRING, -1);
  536.     $xfer += $output->writeString($self->{message});
  537.     $xfer += $output->writeFieldEnd();
  538.   }
  539.   $xfer += $output->writeFieldStop();
  540.   $xfer += $output->writeStructEnd();
  541.   return $xfer;
  542. }
  544. package ThriftIOException;
  545. use base('Thrift::TException');
  546. use base('Class::Accessor');
  547. ThriftIOException->mk_accessors( qw( message ) );
  548. sub new {
  549. my $classname = shift;
  550. my $self      = {};
  551. my $vals      = shift || {};
  552. $self->{message} = undef;
  553.   if (UNIVERSAL::isa($vals,'HASH')) {
  554.     if (defined $vals->{message}) {
  555.       $self->{message} = $vals->{message};
  556.     }
  557.   }
  558. return bless($self,$classname);
  559. }
  561. sub getName {
  562.   return 'ThriftIOException';
  563. }
  565. sub read {
  566.   my $self  = shift;
  567.   my $input = shift;
  568.   my $xfer  = 0;
  569.   my $fname;
  570.   my $ftype = 0;
  571.   my $fid   = 0;
  572.   $xfer += $input->readStructBegin($fname);
  573.   while (1) 
  574.   {
  575.     $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  576.     if ($ftype == TType::STOP) {
  577.       last;
  578.     }
  579.     SWITCH: for($fid)
  580.     {
  581.       /^-1$/ && do{      if ($ftype == TType::STRING) {
  582.         $xfer += $input->readString($self->{message});
  583.       } else {
  584.         $xfer += $input->skip($ftype);
  585.       }
  586.       last; };
  587.         $xfer += $input->skip($ftype);
  588.     }
  589.     $xfer += $input->readFieldEnd();
  590.   }
  591.   $xfer += $input->readStructEnd();
  592.   return $xfer;
  593. }
  595. sub write {
  596.   my $self   = shift;
  597.   my $output = shift;
  598.   my $xfer   = 0;
  599.   $xfer += $output->writeStructBegin('ThriftIOException');
  600.   if (defined $self->{message}) {
  601.     $xfer += $output->writeFieldBegin('message', TType::STRING, -1);
  602.     $xfer += $output->writeString($self->{message});
  603.     $xfer += $output->writeFieldEnd();
  604.   }
  605.   $xfer += $output->writeFieldStop();
  606.   $xfer += $output->writeStructEnd();
  607.   return $xfer;
  608. }
  610. 1;