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

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

网格计算

开发平台：

Java

ThriftHadoopFileSystem.php：源码内容
  1.   public $success = null;
  2.   public $ouch = null;
  4.   public function __construct($vals=null) {
  5.     if (!isset(self::$_TSPEC)) {
  6.       self::$_TSPEC = array(
  7.         0 => array(
  8.           'var' => 'success',
  9.           'type' => TType::STRING,
  10.           ),
  11.         1 => array(
  12.           'var' => 'ouch',
  13.           'type' => TType::STRUCT,
  14.           'class' => 'ThriftIOException',
  15.           ),
  16.         );
  17.     }
  18.     if (is_array($vals)) {
  19.       if (isset($vals['success'])) {
  20.         $this->success = $vals['success'];
  21.       }
  22.       if (isset($vals['ouch'])) {
  23.         $this->ouch = $vals['ouch'];
  24.       }
  25.     }
  26.   }
  28.   public function getName() {
  29.     return 'ThriftHadoopFileSystem_read_result';
  30.   }
  32.   public function read($input)
  33.   {
  34.     $xfer = 0;
  35.     $fname = null;
  36.     $ftype = 0;
  37.     $fid = 0;
  38.     $xfer += $input->readStructBegin($fname);
  39.     while (true)
  40.     {
  41.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  42.       if ($ftype == TType::STOP) {
  43.         break;
  44.       }
  45.       switch ($fid)
  46.       {
  47.         case 0:
  48.           if ($ftype == TType::STRING) {
  49.             $xfer += $input->readString($this->success);
  50.           } else {
  51.             $xfer += $input->skip($ftype);
  52.           }
  53.           break;
  54.         case 1:
  55.           if ($ftype == TType::STRUCT) {
  56.             $this->ouch = new ThriftIOException();
  57.             $xfer += $this->ouch->read($input);
  58.           } else {
  59.             $xfer += $input->skip($ftype);
  60.           }
  61.           break;
  62.         default:
  63.           $xfer += $input->skip($ftype);
  64.           break;
  65.       }
  66.       $xfer += $input->readFieldEnd();
  67.     }
  68.     $xfer += $input->readStructEnd();
  69.     return $xfer;
  70.   }
  72.   public function write($output) {
  73.     $xfer = 0;
  74.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_read_result');
  75.     if ($this->success !== null) {
  76.       $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
  77.       $xfer += $output->writeString($this->success);
  78.       $xfer += $output->writeFieldEnd();
  79.     }
  80.     if ($this->ouch !== null) {
  81.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  82.       $xfer += $this->ouch->write($output);
  83.       $xfer += $output->writeFieldEnd();
  84.     }
  85.     $xfer += $output->writeFieldStop();
  86.     $xfer += $output->writeStructEnd();
  87.     return $xfer;
  88.   }
  90. }
  92. class ThriftHadoopFileSystem_close_args {
  93.   static $_TSPEC;
  95.   public $out = null;
  97.   public function __construct($vals=null) {
  98.     if (!isset(self::$_TSPEC)) {
  99.       self::$_TSPEC = array(
  100.         1 => array(
  101.           'var' => 'out',
  102.           'type' => TType::STRUCT,
  103.           'class' => 'ThriftHandle',
  104.           ),
  105.         );
  106.     }
  107.     if (is_array($vals)) {
  108.       if (isset($vals['out'])) {
  109.         $this->out = $vals['out'];
  110.       }
  111.     }
  112.   }
  114.   public function getName() {
  115.     return 'ThriftHadoopFileSystem_close_args';
  116.   }
  118.   public function read($input)
  119.   {
  120.     $xfer = 0;
  121.     $fname = null;
  122.     $ftype = 0;
  123.     $fid = 0;
  124.     $xfer += $input->readStructBegin($fname);
  125.     while (true)
  126.     {
  127.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  128.       if ($ftype == TType::STOP) {
  129.         break;
  130.       }
  131.       switch ($fid)
  132.       {
  133.         case 1:
  134.           if ($ftype == TType::STRUCT) {
  135.             $this->out = new ThriftHandle();
  136.             $xfer += $this->out->read($input);
  137.           } else {
  138.             $xfer += $input->skip($ftype);
  139.           }
  140.           break;
  141.         default:
  142.           $xfer += $input->skip($ftype);
  143.           break;
  144.       }
  145.       $xfer += $input->readFieldEnd();
  146.     }
  147.     $xfer += $input->readStructEnd();
  148.     return $xfer;
  149.   }
  151.   public function write($output) {
  152.     $xfer = 0;
  153.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_close_args');
  154.     if ($this->out !== null) {
  155.       if (!is_object($this->out)) {
  156.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  157.       }
  158.       $xfer += $output->writeFieldBegin('out', TType::STRUCT, 1);
  159.       $xfer += $this->out->write($output);
  160.       $xfer += $output->writeFieldEnd();
  161.     }
  162.     $xfer += $output->writeFieldStop();
  163.     $xfer += $output->writeStructEnd();
  164.     return $xfer;
  165.   }
  167. }
  169. class ThriftHadoopFileSystem_close_result {
  170.   static $_TSPEC;
  172.   public $success = null;
  173.   public $ouch = null;
  175.   public function __construct($vals=null) {
  176.     if (!isset(self::$_TSPEC)) {
  177.       self::$_TSPEC = array(
  178.         0 => array(
  179.           'var' => 'success',
  180.           'type' => TType::BOOL,
  181.           ),
  182.         1 => array(
  183.           'var' => 'ouch',
  184.           'type' => TType::STRUCT,
  185.           'class' => 'ThriftIOException',
  186.           ),
  187.         );
  188.     }
  189.     if (is_array($vals)) {
  190.       if (isset($vals['success'])) {
  191.         $this->success = $vals['success'];
  192.       }
  193.       if (isset($vals['ouch'])) {
  194.         $this->ouch = $vals['ouch'];
  195.       }
  196.     }
  197.   }
  199.   public function getName() {
  200.     return 'ThriftHadoopFileSystem_close_result';
  201.   }
  203.   public function read($input)
  204.   {
  205.     $xfer = 0;
  206.     $fname = null;
  207.     $ftype = 0;
  208.     $fid = 0;
  209.     $xfer += $input->readStructBegin($fname);
  210.     while (true)
  211.     {
  212.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  213.       if ($ftype == TType::STOP) {
  214.         break;
  215.       }
  216.       switch ($fid)
  217.       {
  218.         case 0:
  219.           if ($ftype == TType::BOOL) {
  220.             $xfer += $input->readBool($this->success);
  221.           } else {
  222.             $xfer += $input->skip($ftype);
  223.           }
  224.           break;
  225.         case 1:
  226.           if ($ftype == TType::STRUCT) {
  227.             $this->ouch = new ThriftIOException();
  228.             $xfer += $this->ouch->read($input);
  229.           } else {
  230.             $xfer += $input->skip($ftype);
  231.           }
  232.           break;
  233.         default:
  234.           $xfer += $input->skip($ftype);
  235.           break;
  236.       }
  237.       $xfer += $input->readFieldEnd();
  238.     }
  239.     $xfer += $input->readStructEnd();
  240.     return $xfer;
  241.   }
  243.   public function write($output) {
  244.     $xfer = 0;
  245.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_close_result');
  246.     if ($this->success !== null) {
  247.       $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
  248.       $xfer += $output->writeBool($this->success);
  249.       $xfer += $output->writeFieldEnd();
  250.     }
  251.     if ($this->ouch !== null) {
  252.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  253.       $xfer += $this->ouch->write($output);
  254.       $xfer += $output->writeFieldEnd();
  255.     }
  256.     $xfer += $output->writeFieldStop();
  257.     $xfer += $output->writeStructEnd();
  258.     return $xfer;
  259.   }
  261. }
  263. class ThriftHadoopFileSystem_rm_args {
  264.   static $_TSPEC;
  266.   public $path = null;
  267.   public $recursive = null;
  269.   public function __construct($vals=null) {
  270.     if (!isset(self::$_TSPEC)) {
  271.       self::$_TSPEC = array(
  272.         1 => array(
  273.           'var' => 'path',
  274.           'type' => TType::STRUCT,
  275.           'class' => 'Pathname',
  276.           ),
  277.         2 => array(
  278.           'var' => 'recursive',
  279.           'type' => TType::BOOL,
  280.           ),
  281.         );
  282.     }
  283.     if (is_array($vals)) {
  284.       if (isset($vals['path'])) {
  285.         $this->path = $vals['path'];
  286.       }
  287.       if (isset($vals['recursive'])) {
  288.         $this->recursive = $vals['recursive'];
  289.       }
  290.     }
  291.   }
  293.   public function getName() {
  294.     return 'ThriftHadoopFileSystem_rm_args';
  295.   }
  297.   public function read($input)
  298.   {
  299.     $xfer = 0;
  300.     $fname = null;
  301.     $ftype = 0;
  302.     $fid = 0;
  303.     $xfer += $input->readStructBegin($fname);
  304.     while (true)
  305.     {
  306.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  307.       if ($ftype == TType::STOP) {
  308.         break;
  309.       }
  310.       switch ($fid)
  311.       {
  312.         case 1:
  313.           if ($ftype == TType::STRUCT) {
  314.             $this->path = new Pathname();
  315.             $xfer += $this->path->read($input);
  316.           } else {
  317.             $xfer += $input->skip($ftype);
  318.           }
  319.           break;
  320.         case 2:
  321.           if ($ftype == TType::BOOL) {
  322.             $xfer += $input->readBool($this->recursive);
  323.           } else {
  324.             $xfer += $input->skip($ftype);
  325.           }
  326.           break;
  327.         default:
  328.           $xfer += $input->skip($ftype);
  329.           break;
  330.       }
  331.       $xfer += $input->readFieldEnd();
  332.     }
  333.     $xfer += $input->readStructEnd();
  334.     return $xfer;
  335.   }
  337.   public function write($output) {
  338.     $xfer = 0;
  339.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_rm_args');
  340.     if ($this->path !== null) {
  341.       if (!is_object($this->path)) {
  342.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  343.       }
  344.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  345.       $xfer += $this->path->write($output);
  346.       $xfer += $output->writeFieldEnd();
  347.     }
  348.     if ($this->recursive !== null) {
  349.       $xfer += $output->writeFieldBegin('recursive', TType::BOOL, 2);
  350.       $xfer += $output->writeBool($this->recursive);
  351.       $xfer += $output->writeFieldEnd();
  352.     }
  353.     $xfer += $output->writeFieldStop();
  354.     $xfer += $output->writeStructEnd();
  355.     return $xfer;
  356.   }
  358. }
  360. class ThriftHadoopFileSystem_rm_result {
  361.   static $_TSPEC;
  363.   public $success = null;
  364.   public $ouch = null;
  366.   public function __construct($vals=null) {
  367.     if (!isset(self::$_TSPEC)) {
  368.       self::$_TSPEC = array(
  369.         0 => array(
  370.           'var' => 'success',
  371.           'type' => TType::BOOL,
  372.           ),
  373.         1 => array(
  374.           'var' => 'ouch',
  375.           'type' => TType::STRUCT,
  376.           'class' => 'ThriftIOException',
  377.           ),
  378.         );
  379.     }
  380.     if (is_array($vals)) {
  381.       if (isset($vals['success'])) {
  382.         $this->success = $vals['success'];
  383.       }
  384.       if (isset($vals['ouch'])) {
  385.         $this->ouch = $vals['ouch'];
  386.       }
  387.     }
  388.   }
  390.   public function getName() {
  391.     return 'ThriftHadoopFileSystem_rm_result';
  392.   }
  394.   public function read($input)
  395.   {
  396.     $xfer = 0;
  397.     $fname = null;
  398.     $ftype = 0;
  399.     $fid = 0;
  400.     $xfer += $input->readStructBegin($fname);
  401.     while (true)
  402.     {
  403.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  404.       if ($ftype == TType::STOP) {
  405.         break;
  406.       }
  407.       switch ($fid)
  408.       {
  409.         case 0:
  410.           if ($ftype == TType::BOOL) {
  411.             $xfer += $input->readBool($this->success);
  412.           } else {
  413.             $xfer += $input->skip($ftype);
  414.           }
  415.           break;
  416.         case 1:
  417.           if ($ftype == TType::STRUCT) {
  418.             $this->ouch = new ThriftIOException();
  419.             $xfer += $this->ouch->read($input);
  420.           } else {
  421.             $xfer += $input->skip($ftype);
  422.           }
  423.           break;
  424.         default:
  425.           $xfer += $input->skip($ftype);
  426.           break;
  427.       }
  428.       $xfer += $input->readFieldEnd();
  429.     }
  430.     $xfer += $input->readStructEnd();
  431.     return $xfer;
  432.   }
  434.   public function write($output) {
  435.     $xfer = 0;
  436.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_rm_result');
  437.     if ($this->success !== null) {
  438.       $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
  439.       $xfer += $output->writeBool($this->success);
  440.       $xfer += $output->writeFieldEnd();
  441.     }
  442.     if ($this->ouch !== null) {
  443.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  444.       $xfer += $this->ouch->write($output);
  445.       $xfer += $output->writeFieldEnd();
  446.     }
  447.     $xfer += $output->writeFieldStop();
  448.     $xfer += $output->writeStructEnd();
  449.     return $xfer;
  450.   }
  452. }
  454. class ThriftHadoopFileSystem_rename_args {
  455.   static $_TSPEC;
  457.   public $path = null;
  458.   public $dest = null;
  460.   public function __construct($vals=null) {
  461.     if (!isset(self::$_TSPEC)) {
  462.       self::$_TSPEC = array(
  463.         1 => array(
  464.           'var' => 'path',
  465.           'type' => TType::STRUCT,
  466.           'class' => 'Pathname',
  467.           ),
  468.         2 => array(
  469.           'var' => 'dest',
  470.           'type' => TType::STRUCT,
  471.           'class' => 'Pathname',
  472.           ),
  473.         );
  474.     }
  475.     if (is_array($vals)) {
  476.       if (isset($vals['path'])) {
  477.         $this->path = $vals['path'];
  478.       }
  479.       if (isset($vals['dest'])) {
  480.         $this->dest = $vals['dest'];
  481.       }
  482.     }
  483.   }
  485.   public function getName() {
  486.     return 'ThriftHadoopFileSystem_rename_args';
  487.   }
  489.   public function read($input)
  490.   {
  491.     $xfer = 0;
  492.     $fname = null;
  493.     $ftype = 0;
  494.     $fid = 0;
  495.     $xfer += $input->readStructBegin($fname);
  496.     while (true)
  497.     {
  498.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  499.       if ($ftype == TType::STOP) {
  500.         break;
  501.       }
  502.       switch ($fid)
  503.       {
  504.         case 1:
  505.           if ($ftype == TType::STRUCT) {
  506.             $this->path = new Pathname();
  507.             $xfer += $this->path->read($input);
  508.           } else {
  509.             $xfer += $input->skip($ftype);
  510.           }
  511.           break;
  512.         case 2:
  513.           if ($ftype == TType::STRUCT) {
  514.             $this->dest = new Pathname();
  515.             $xfer += $this->dest->read($input);
  516.           } else {
  517.             $xfer += $input->skip($ftype);
  518.           }
  519.           break;
  520.         default:
  521.           $xfer += $input->skip($ftype);
  522.           break;
  523.       }
  524.       $xfer += $input->readFieldEnd();
  525.     }
  526.     $xfer += $input->readStructEnd();
  527.     return $xfer;
  528.   }
  530.   public function write($output) {
  531.     $xfer = 0;
  532.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_rename_args');
  533.     if ($this->path !== null) {
  534.       if (!is_object($this->path)) {
  535.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  536.       }
  537.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  538.       $xfer += $this->path->write($output);
  539.       $xfer += $output->writeFieldEnd();
  540.     }
  541.     if ($this->dest !== null) {
  542.       if (!is_object($this->dest)) {
  543.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  544.       }
  545.       $xfer += $output->writeFieldBegin('dest', TType::STRUCT, 2);
  546.       $xfer += $this->dest->write($output);
  547.       $xfer += $output->writeFieldEnd();
  548.     }
  549.     $xfer += $output->writeFieldStop();
  550.     $xfer += $output->writeStructEnd();
  551.     return $xfer;
  552.   }
  554. }
  556. class ThriftHadoopFileSystem_rename_result {
  557.   static $_TSPEC;
  559.   public $success = null;
  560.   public $ouch = null;
  562.   public function __construct($vals=null) {
  563.     if (!isset(self::$_TSPEC)) {
  564.       self::$_TSPEC = array(
  565.         0 => array(
  566.           'var' => 'success',
  567.           'type' => TType::BOOL,
  568.           ),
  569.         1 => array(
  570.           'var' => 'ouch',
  571.           'type' => TType::STRUCT,
  572.           'class' => 'ThriftIOException',
  573.           ),
  574.         );
  575.     }
  576.     if (is_array($vals)) {
  577.       if (isset($vals['success'])) {
  578.         $this->success = $vals['success'];
  579.       }
  580.       if (isset($vals['ouch'])) {
  581.         $this->ouch = $vals['ouch'];
  582.       }
  583.     }
  584.   }
  586.   public function getName() {
  587.     return 'ThriftHadoopFileSystem_rename_result';
  588.   }
  590.   public function read($input)
  591.   {
  592.     $xfer = 0;
  593.     $fname = null;
  594.     $ftype = 0;
  595.     $fid = 0;
  596.     $xfer += $input->readStructBegin($fname);
  597.     while (true)
  598.     {
  599.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  600.       if ($ftype == TType::STOP) {
  601.         break;
  602.       }
  603.       switch ($fid)
  604.       {
  605.         case 0:
  606.           if ($ftype == TType::BOOL) {
  607.             $xfer += $input->readBool($this->success);
  608.           } else {
  609.             $xfer += $input->skip($ftype);
  610.           }
  611.           break;
  612.         case 1:
  613.           if ($ftype == TType::STRUCT) {
  614.             $this->ouch = new ThriftIOException();
  615.             $xfer += $this->ouch->read($input);
  616.           } else {
  617.             $xfer += $input->skip($ftype);
  618.           }
  619.           break;
  620.         default:
  621.           $xfer += $input->skip($ftype);
  622.           break;
  623.       }
  624.       $xfer += $input->readFieldEnd();
  625.     }
  626.     $xfer += $input->readStructEnd();
  627.     return $xfer;
  628.   }
  630.   public function write($output) {
  631.     $xfer = 0;
  632.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_rename_result');
  633.     if ($this->success !== null) {
  634.       $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
  635.       $xfer += $output->writeBool($this->success);
  636.       $xfer += $output->writeFieldEnd();
  637.     }
  638.     if ($this->ouch !== null) {
  639.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  640.       $xfer += $this->ouch->write($output);
  641.       $xfer += $output->writeFieldEnd();
  642.     }
  643.     $xfer += $output->writeFieldStop();
  644.     $xfer += $output->writeStructEnd();
  645.     return $xfer;
  646.   }
  648. }
  650. class ThriftHadoopFileSystem_mkdirs_args {
  651.   static $_TSPEC;
  653.   public $path = null;
  655.   public function __construct($vals=null) {
  656.     if (!isset(self::$_TSPEC)) {
  657.       self::$_TSPEC = array(
  658.         1 => array(
  659.           'var' => 'path',
  660.           'type' => TType::STRUCT,
  661.           'class' => 'Pathname',
  662.           ),
  663.         );
  664.     }
  665.     if (is_array($vals)) {
  666.       if (isset($vals['path'])) {
  667.         $this->path = $vals['path'];
  668.       }
  669.     }
  670.   }
  672.   public function getName() {
  673.     return 'ThriftHadoopFileSystem_mkdirs_args';
  674.   }
  676.   public function read($input)
  677.   {
  678.     $xfer = 0;
  679.     $fname = null;
  680.     $ftype = 0;
  681.     $fid = 0;
  682.     $xfer += $input->readStructBegin($fname);
  683.     while (true)
  684.     {
  685.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  686.       if ($ftype == TType::STOP) {
  687.         break;
  688.       }
  689.       switch ($fid)
  690.       {
  691.         case 1:
  692.           if ($ftype == TType::STRUCT) {
  693.             $this->path = new Pathname();
  694.             $xfer += $this->path->read($input);
  695.           } else {
  696.             $xfer += $input->skip($ftype);
  697.           }
  698.           break;
  699.         default:
  700.           $xfer += $input->skip($ftype);
  701.           break;
  702.       }
  703.       $xfer += $input->readFieldEnd();
  704.     }
  705.     $xfer += $input->readStructEnd();
  706.     return $xfer;
  707.   }
  709.   public function write($output) {
  710.     $xfer = 0;
  711.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_mkdirs_args');
  712.     if ($this->path !== null) {
  713.       if (!is_object($this->path)) {
  714.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  715.       }
  716.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  717.       $xfer += $this->path->write($output);
  718.       $xfer += $output->writeFieldEnd();
  719.     }
  720.     $xfer += $output->writeFieldStop();
  721.     $xfer += $output->writeStructEnd();
  722.     return $xfer;
  723.   }
  725. }
  727. class ThriftHadoopFileSystem_mkdirs_result {
  728.   static $_TSPEC;
  730.   public $success = null;
  731.   public $ouch = null;
  733.   public function __construct($vals=null) {
  734.     if (!isset(self::$_TSPEC)) {
  735.       self::$_TSPEC = array(
  736.         0 => array(
  737.           'var' => 'success',
  738.           'type' => TType::BOOL,
  739.           ),
  740.         1 => array(
  741.           'var' => 'ouch',
  742.           'type' => TType::STRUCT,
  743.           'class' => 'ThriftIOException',
  744.           ),
  745.         );
  746.     }
  747.     if (is_array($vals)) {
  748.       if (isset($vals['success'])) {
  749.         $this->success = $vals['success'];
  750.       }
  751.       if (isset($vals['ouch'])) {
  752.         $this->ouch = $vals['ouch'];
  753.       }
  754.     }
  755.   }
  757.   public function getName() {
  758.     return 'ThriftHadoopFileSystem_mkdirs_result';
  759.   }
  761.   public function read($input)
  762.   {
  763.     $xfer = 0;
  764.     $fname = null;
  765.     $ftype = 0;
  766.     $fid = 0;
  767.     $xfer += $input->readStructBegin($fname);
  768.     while (true)
  769.     {
  770.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  771.       if ($ftype == TType::STOP) {
  772.         break;
  773.       }
  774.       switch ($fid)
  775.       {
  776.         case 0:
  777.           if ($ftype == TType::BOOL) {
  778.             $xfer += $input->readBool($this->success);
  779.           } else {
  780.             $xfer += $input->skip($ftype);
  781.           }
  782.           break;
  783.         case 1:
  784.           if ($ftype == TType::STRUCT) {
  785.             $this->ouch = new ThriftIOException();
  786.             $xfer += $this->ouch->read($input);
  787.           } else {
  788.             $xfer += $input->skip($ftype);
  789.           }
  790.           break;
  791.         default:
  792.           $xfer += $input->skip($ftype);
  793.           break;
  794.       }
  795.       $xfer += $input->readFieldEnd();
  796.     }
  797.     $xfer += $input->readStructEnd();
  798.     return $xfer;
  799.   }
  801.   public function write($output) {
  802.     $xfer = 0;
  803.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_mkdirs_result');
  804.     if ($this->success !== null) {
  805.       $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
  806.       $xfer += $output->writeBool($this->success);
  807.       $xfer += $output->writeFieldEnd();
  808.     }
  809.     if ($this->ouch !== null) {
  810.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  811.       $xfer += $this->ouch->write($output);
  812.       $xfer += $output->writeFieldEnd();
  813.     }
  814.     $xfer += $output->writeFieldStop();
  815.     $xfer += $output->writeStructEnd();
  816.     return $xfer;
  817.   }
  819. }
  821. class ThriftHadoopFileSystem_exists_args {
  822.   static $_TSPEC;
  824.   public $path = null;
  826.   public function __construct($vals=null) {
  827.     if (!isset(self::$_TSPEC)) {
  828.       self::$_TSPEC = array(
  829.         1 => array(
  830.           'var' => 'path',
  831.           'type' => TType::STRUCT,
  832.           'class' => 'Pathname',
  833.           ),
  834.         );
  835.     }
  836.     if (is_array($vals)) {
  837.       if (isset($vals['path'])) {
  838.         $this->path = $vals['path'];
  839.       }
  840.     }
  841.   }
  843.   public function getName() {
  844.     return 'ThriftHadoopFileSystem_exists_args';
  845.   }
  847.   public function read($input)
  848.   {
  849.     $xfer = 0;
  850.     $fname = null;
  851.     $ftype = 0;
  852.     $fid = 0;
  853.     $xfer += $input->readStructBegin($fname);
  854.     while (true)
  855.     {
  856.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  857.       if ($ftype == TType::STOP) {
  858.         break;
  859.       }
  860.       switch ($fid)
  861.       {
  862.         case 1:
  863.           if ($ftype == TType::STRUCT) {
  864.             $this->path = new Pathname();
  865.             $xfer += $this->path->read($input);
  866.           } else {
  867.             $xfer += $input->skip($ftype);
  868.           }
  869.           break;
  870.         default:
  871.           $xfer += $input->skip($ftype);
  872.           break;
  873.       }
  874.       $xfer += $input->readFieldEnd();
  875.     }
  876.     $xfer += $input->readStructEnd();
  877.     return $xfer;
  878.   }
  880.   public function write($output) {
  881.     $xfer = 0;
  882.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_exists_args');
  883.     if ($this->path !== null) {
  884.       if (!is_object($this->path)) {
  885.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  886.       }
  887.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  888.       $xfer += $this->path->write($output);
  889.       $xfer += $output->writeFieldEnd();
  890.     }
  891.     $xfer += $output->writeFieldStop();
  892.     $xfer += $output->writeStructEnd();
  893.     return $xfer;
  894.   }
  896. }
  898. class ThriftHadoopFileSystem_exists_result {
  899.   static $_TSPEC;
  901.   public $success = null;
  902.   public $ouch = null;
  904.   public function __construct($vals=null) {
  905.     if (!isset(self::$_TSPEC)) {
  906.       self::$_TSPEC = array(
  907.         0 => array(
  908.           'var' => 'success',
  909.           'type' => TType::BOOL,
  910.           ),
  911.         1 => array(
  912.           'var' => 'ouch',
  913.           'type' => TType::STRUCT,
  914.           'class' => 'ThriftIOException',
  915.           ),
  916.         );
  917.     }
  918.     if (is_array($vals)) {
  919.       if (isset($vals['success'])) {
  920.         $this->success = $vals['success'];
  921.       }
  922.       if (isset($vals['ouch'])) {
  923.         $this->ouch = $vals['ouch'];
  924.       }
  925.     }
  926.   }
  928.   public function getName() {
  929.     return 'ThriftHadoopFileSystem_exists_result';
  930.   }
  932.   public function read($input)
  933.   {
  934.     $xfer = 0;
  935.     $fname = null;
  936.     $ftype = 0;
  937.     $fid = 0;
  938.     $xfer += $input->readStructBegin($fname);
  939.     while (true)
  940.     {
  941.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  942.       if ($ftype == TType::STOP) {
  943.         break;
  944.       }
  945.       switch ($fid)
  946.       {
  947.         case 0:
  948.           if ($ftype == TType::BOOL) {
  949.             $xfer += $input->readBool($this->success);
  950.           } else {
  951.             $xfer += $input->skip($ftype);
  952.           }
  953.           break;
  954.         case 1:
  955.           if ($ftype == TType::STRUCT) {
  956.             $this->ouch = new ThriftIOException();
  957.             $xfer += $this->ouch->read($input);
  958.           } else {
  959.             $xfer += $input->skip($ftype);
  960.           }
  961.           break;
  962.         default:
  963.           $xfer += $input->skip($ftype);
  964.           break;
  965.       }
  966.       $xfer += $input->readFieldEnd();
  967.     }
  968.     $xfer += $input->readStructEnd();
  969.     return $xfer;
  970.   }
  972.   public function write($output) {
  973.     $xfer = 0;
  974.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_exists_result');
  975.     if ($this->success !== null) {
  976.       $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
  977.       $xfer += $output->writeBool($this->success);
  978.       $xfer += $output->writeFieldEnd();
  979.     }
  980.     if ($this->ouch !== null) {
  981.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  982.       $xfer += $this->ouch->write($output);
  983.       $xfer += $output->writeFieldEnd();
  984.     }
  985.     $xfer += $output->writeFieldStop();
  986.     $xfer += $output->writeStructEnd();
  987.     return $xfer;
  988.   }
  990. }
  992. class ThriftHadoopFileSystem_stat_args {
  993.   static $_TSPEC;
  995.   public $path = null;
  997.   public function __construct($vals=null) {
  998.     if (!isset(self::$_TSPEC)) {
  999.       self::$_TSPEC = array(
  1000.         1 => array(
  1001.           'var' => 'path',
  1002.           'type' => TType::STRUCT,
  1003.           'class' => 'Pathname',
  1004.           ),
  1005.         );
  1006.     }
  1007.     if (is_array($vals)) {
  1008.       if (isset($vals['path'])) {
  1009.         $this->path = $vals['path'];
  1010.       }
  1011.     }
  1012.   }
  1014.   public function getName() {
  1015.     return 'ThriftHadoopFileSystem_stat_args';
  1016.   }
  1018.   public function read($input)
  1019.   {
  1020.     $xfer = 0;
  1021.     $fname = null;
  1022.     $ftype = 0;
  1023.     $fid = 0;
  1024.     $xfer += $input->readStructBegin($fname);
  1025.     while (true)
  1026.     {
  1027.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1028.       if ($ftype == TType::STOP) {
  1029.         break;
  1030.       }
  1031.       switch ($fid)
  1032.       {
  1033.         case 1:
  1034.           if ($ftype == TType::STRUCT) {
  1035.             $this->path = new Pathname();
  1036.             $xfer += $this->path->read($input);
  1037.           } else {
  1038.             $xfer += $input->skip($ftype);
  1039.           }
  1040.           break;
  1041.         default:
  1042.           $xfer += $input->skip($ftype);
  1043.           break;
  1044.       }
  1045.       $xfer += $input->readFieldEnd();
  1046.     }
  1047.     $xfer += $input->readStructEnd();
  1048.     return $xfer;
  1049.   }
  1051.   public function write($output) {
  1052.     $xfer = 0;
  1053.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_stat_args');
  1054.     if ($this->path !== null) {
  1055.       if (!is_object($this->path)) {
  1056.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  1057.       }
  1058.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  1059.       $xfer += $this->path->write($output);
  1060.       $xfer += $output->writeFieldEnd();
  1061.     }
  1062.     $xfer += $output->writeFieldStop();
  1063.     $xfer += $output->writeStructEnd();
  1064.     return $xfer;
  1065.   }
  1067. }
  1069. class ThriftHadoopFileSystem_stat_result {
  1070.   static $_TSPEC;
  1072.   public $success = null;
  1073.   public $ouch = null;
  1075.   public function __construct($vals=null) {
  1076.     if (!isset(self::$_TSPEC)) {
  1077.       self::$_TSPEC = array(
  1078.         0 => array(
  1079.           'var' => 'success',
  1080.           'type' => TType::STRUCT,
  1081.           'class' => 'FileStatus',
  1082.           ),
  1083.         1 => array(
  1084.           'var' => 'ouch',
  1085.           'type' => TType::STRUCT,
  1086.           'class' => 'ThriftIOException',
  1087.           ),
  1088.         );
  1089.     }
  1090.     if (is_array($vals)) {
  1091.       if (isset($vals['success'])) {
  1092.         $this->success = $vals['success'];
  1093.       }
  1094.       if (isset($vals['ouch'])) {
  1095.         $this->ouch = $vals['ouch'];
  1096.       }
  1097.     }
  1098.   }
  1100.   public function getName() {
  1101.     return 'ThriftHadoopFileSystem_stat_result';
  1102.   }
  1104.   public function read($input)
  1105.   {
  1106.     $xfer = 0;
  1107.     $fname = null;
  1108.     $ftype = 0;
  1109.     $fid = 0;
  1110.     $xfer += $input->readStructBegin($fname);
  1111.     while (true)
  1112.     {
  1113.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1114.       if ($ftype == TType::STOP) {
  1115.         break;
  1116.       }
  1117.       switch ($fid)
  1118.       {
  1119.         case 0:
  1120.           if ($ftype == TType::STRUCT) {
  1121.             $this->success = new FileStatus();
  1122.             $xfer += $this->success->read($input);
  1123.           } else {
  1124.             $xfer += $input->skip($ftype);
  1125.           }
  1126.           break;
  1127.         case 1:
  1128.           if ($ftype == TType::STRUCT) {
  1129.             $this->ouch = new ThriftIOException();
  1130.             $xfer += $this->ouch->read($input);
  1131.           } else {
  1132.             $xfer += $input->skip($ftype);
  1133.           }
  1134.           break;
  1135.         default:
  1136.           $xfer += $input->skip($ftype);
  1137.           break;
  1138.       }
  1139.       $xfer += $input->readFieldEnd();
  1140.     }
  1141.     $xfer += $input->readStructEnd();
  1142.     return $xfer;
  1143.   }
  1145.   public function write($output) {
  1146.     $xfer = 0;
  1147.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_stat_result');
  1148.     if ($this->success !== null) {
  1149.       if (!is_object($this->success)) {
  1150.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  1151.       }
  1152.       $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
  1153.       $xfer += $this->success->write($output);
  1154.       $xfer += $output->writeFieldEnd();
  1155.     }
  1156.     if ($this->ouch !== null) {
  1157.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  1158.       $xfer += $this->ouch->write($output);
  1159.       $xfer += $output->writeFieldEnd();
  1160.     }
  1161.     $xfer += $output->writeFieldStop();
  1162.     $xfer += $output->writeStructEnd();
  1163.     return $xfer;
  1164.   }
  1166. }
  1168. class ThriftHadoopFileSystem_listStatus_args {
  1169.   static $_TSPEC;
  1171.   public $path = null;
  1173.   public function __construct($vals=null) {
  1174.     if (!isset(self::$_TSPEC)) {
  1175.       self::$_TSPEC = array(
  1176.         1 => array(
  1177.           'var' => 'path',
  1178.           'type' => TType::STRUCT,
  1179.           'class' => 'Pathname',
  1180.           ),
  1181.         );
  1182.     }
  1183.     if (is_array($vals)) {
  1184.       if (isset($vals['path'])) {
  1185.         $this->path = $vals['path'];
  1186.       }
  1187.     }
  1188.   }
  1190.   public function getName() {
  1191.     return 'ThriftHadoopFileSystem_listStatus_args';
  1192.   }
  1194.   public function read($input)
  1195.   {
  1196.     $xfer = 0;
  1197.     $fname = null;
  1198.     $ftype = 0;
  1199.     $fid = 0;
  1200.     $xfer += $input->readStructBegin($fname);
  1201.     while (true)
  1202.     {
  1203.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1204.       if ($ftype == TType::STOP) {
  1205.         break;
  1206.       }
  1207.       switch ($fid)
  1208.       {
  1209.         case 1:
  1210.           if ($ftype == TType::STRUCT) {
  1211.             $this->path = new Pathname();
  1212.             $xfer += $this->path->read($input);
  1213.           } else {
  1214.             $xfer += $input->skip($ftype);
  1215.           }
  1216.           break;
  1217.         default:
  1218.           $xfer += $input->skip($ftype);
  1219.           break;
  1220.       }
  1221.       $xfer += $input->readFieldEnd();
  1222.     }
  1223.     $xfer += $input->readStructEnd();
  1224.     return $xfer;
  1225.   }
  1227.   public function write($output) {
  1228.     $xfer = 0;
  1229.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_listStatus_args');
  1230.     if ($this->path !== null) {
  1231.       if (!is_object($this->path)) {
  1232.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  1233.       }
  1234.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  1235.       $xfer += $this->path->write($output);
  1236.       $xfer += $output->writeFieldEnd();
  1237.     }
  1238.     $xfer += $output->writeFieldStop();
  1239.     $xfer += $output->writeStructEnd();
  1240.     return $xfer;
  1241.   }
  1243. }
  1245. class ThriftHadoopFileSystem_listStatus_result {
  1246.   static $_TSPEC;
  1248.   public $success = null;
  1249.   public $ouch = null;
  1251.   public function __construct($vals=null) {
  1252.     if (!isset(self::$_TSPEC)) {
  1253.       self::$_TSPEC = array(
  1254.         0 => array(
  1255.           'var' => 'success',
  1256.           'type' => TType::LST,
  1257.           'etype' => TType::STRUCT,
  1258.           'elem' => array(
  1259.             'type' => TType::STRUCT,
  1260.             'class' => 'FileStatus',
  1261.             ),
  1262.           ),
  1263.         1 => array(
  1264.           'var' => 'ouch',
  1265.           'type' => TType::STRUCT,
  1266.           'class' => 'ThriftIOException',
  1267.           ),
  1268.         );
  1269.     }
  1270.     if (is_array($vals)) {
  1271.       if (isset($vals['success'])) {
  1272.         $this->success = $vals['success'];
  1273.       }
  1274.       if (isset($vals['ouch'])) {
  1275.         $this->ouch = $vals['ouch'];
  1276.       }
  1277.     }
  1278.   }
  1280.   public function getName() {
  1281.     return 'ThriftHadoopFileSystem_listStatus_result';
  1282.   }
  1284.   public function read($input)
  1285.   {
  1286.     $xfer = 0;
  1287.     $fname = null;
  1288.     $ftype = 0;
  1289.     $fid = 0;
  1290.     $xfer += $input->readStructBegin($fname);
  1291.     while (true)
  1292.     {
  1293.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1294.       if ($ftype == TType::STOP) {
  1295.         break;
  1296.       }
  1297.       switch ($fid)
  1298.       {
  1299.         case 0:
  1300.           if ($ftype == TType::LST) {
  1301.             $this->success = array();
  1302.             $_size14 = 0;
  1303.             $_etype17 = 0;
  1304.             $xfer += $input->readListBegin($_etype17, $_size14);
  1305.             for ($_i18 = 0; $_i18 < $_size14; ++$_i18)
  1306.             {
  1307.               $elem19 = null;
  1308.               $elem19 = new FileStatus();
  1309.               $xfer += $elem19->read($input);
  1310.               $this->success []= $elem19;
  1311.             }
  1312.             $xfer += $input->readListEnd();
  1313.           } else {
  1314.             $xfer += $input->skip($ftype);
  1315.           }
  1316.           break;
  1317.         case 1:
  1318.           if ($ftype == TType::STRUCT) {
  1319.             $this->ouch = new ThriftIOException();
  1320.             $xfer += $this->ouch->read($input);
  1321.           } else {
  1322.             $xfer += $input->skip($ftype);
  1323.           }
  1324.           break;
  1325.         default:
  1326.           $xfer += $input->skip($ftype);
  1327.           break;
  1328.       }
  1329.       $xfer += $input->readFieldEnd();
  1330.     }
  1331.     $xfer += $input->readStructEnd();
  1332.     return $xfer;
  1333.   }
  1335.   public function write($output) {
  1336.     $xfer = 0;
  1337.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_listStatus_result');
  1338.     if ($this->success !== null) {
  1339.       if (!is_array($this->success)) {
  1340.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  1341.       }
  1342.       $xfer += $output->writeFieldBegin('success', TType::LST, 0);
  1343.       {
  1344.         $output->writeListBegin(TType::STRUCT, count($this->success));
  1345.         {
  1346.           foreach ($this->success as $iter20)
  1347.           {
  1348.             $xfer += $iter20->write($output);
  1349.           }
  1350.         }
  1351.         $output->writeListEnd();
  1352.       }
  1353.       $xfer += $output->writeFieldEnd();
  1354.     }
  1355.     if ($this->ouch !== null) {
  1356.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  1357.       $xfer += $this->ouch->write($output);
  1358.       $xfer += $output->writeFieldEnd();
  1359.     }
  1360.     $xfer += $output->writeFieldStop();
  1361.     $xfer += $output->writeStructEnd();
  1362.     return $xfer;
  1363.   }
  1365. }
  1367. class ThriftHadoopFileSystem_chmod_args {
  1368.   static $_TSPEC;
  1370.   public $path = null;
  1371.   public $mode = null;
  1373.   public function __construct($vals=null) {
  1374.     if (!isset(self::$_TSPEC)) {
  1375.       self::$_TSPEC = array(
  1376.         1 => array(
  1377.           'var' => 'path',
  1378.           'type' => TType::STRUCT,
  1379.           'class' => 'Pathname',
  1380.           ),
  1381.         2 => array(
  1382.           'var' => 'mode',
  1383.           'type' => TType::I16,
  1384.           ),
  1385.         );
  1386.     }
  1387.     if (is_array($vals)) {
  1388.       if (isset($vals['path'])) {
  1389.         $this->path = $vals['path'];
  1390.       }
  1391.       if (isset($vals['mode'])) {
  1392.         $this->mode = $vals['mode'];
  1393.       }
  1394.     }
  1395.   }
  1397.   public function getName() {
  1398.     return 'ThriftHadoopFileSystem_chmod_args';
  1399.   }
  1401.   public function read($input)
  1402.   {
  1403.     $xfer = 0;
  1404.     $fname = null;
  1405.     $ftype = 0;
  1406.     $fid = 0;
  1407.     $xfer += $input->readStructBegin($fname);
  1408.     while (true)
  1409.     {
  1410.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1411.       if ($ftype == TType::STOP) {
  1412.         break;
  1413.       }
  1414.       switch ($fid)
  1415.       {
  1416.         case 1:
  1417.           if ($ftype == TType::STRUCT) {
  1418.             $this->path = new Pathname();
  1419.             $xfer += $this->path->read($input);
  1420.           } else {
  1421.             $xfer += $input->skip($ftype);
  1422.           }
  1423.           break;
  1424.         case 2:
  1425.           if ($ftype == TType::I16) {
  1426.             $xfer += $input->readI16($this->mode);
  1427.           } else {
  1428.             $xfer += $input->skip($ftype);
  1429.           }
  1430.           break;
  1431.         default:
  1432.           $xfer += $input->skip($ftype);
  1433.           break;
  1434.       }
  1435.       $xfer += $input->readFieldEnd();
  1436.     }
  1437.     $xfer += $input->readStructEnd();
  1438.     return $xfer;
  1439.   }
  1441.   public function write($output) {
  1442.     $xfer = 0;
  1443.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_chmod_args');
  1444.     if ($this->path !== null) {
  1445.       if (!is_object($this->path)) {
  1446.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  1447.       }
  1448.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  1449.       $xfer += $this->path->write($output);
  1450.       $xfer += $output->writeFieldEnd();
  1451.     }
  1452.     if ($this->mode !== null) {
  1453.       $xfer += $output->writeFieldBegin('mode', TType::I16, 2);
  1454.       $xfer += $output->writeI16($this->mode);
  1455.       $xfer += $output->writeFieldEnd();
  1456.     }
  1457.     $xfer += $output->writeFieldStop();
  1458.     $xfer += $output->writeStructEnd();
  1459.     return $xfer;
  1460.   }
  1462. }
  1464. class ThriftHadoopFileSystem_chmod_result {
  1465.   static $_TSPEC;
  1467.   public $ouch = null;
  1469.   public function __construct($vals=null) {
  1470.     if (!isset(self::$_TSPEC)) {
  1471.       self::$_TSPEC = array(
  1472.         1 => array(
  1473.           'var' => 'ouch',
  1474.           'type' => TType::STRUCT,
  1475.           'class' => 'ThriftIOException',
  1476.           ),
  1477.         );
  1478.     }
  1479.     if (is_array($vals)) {
  1480.       if (isset($vals['ouch'])) {
  1481.         $this->ouch = $vals['ouch'];
  1482.       }
  1483.     }
  1484.   }
  1486.   public function getName() {
  1487.     return 'ThriftHadoopFileSystem_chmod_result';
  1488.   }
  1490.   public function read($input)
  1491.   {
  1492.     $xfer = 0;
  1493.     $fname = null;
  1494.     $ftype = 0;
  1495.     $fid = 0;
  1496.     $xfer += $input->readStructBegin($fname);
  1497.     while (true)
  1498.     {
  1499.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1500.       if ($ftype == TType::STOP) {
  1501.         break;
  1502.       }
  1503.       switch ($fid)
  1504.       {
  1505.         case 1:
  1506.           if ($ftype == TType::STRUCT) {
  1507.             $this->ouch = new ThriftIOException();
  1508.             $xfer += $this->ouch->read($input);
  1509.           } else {
  1510.             $xfer += $input->skip($ftype);
  1511.           }
  1512.           break;
  1513.         default:
  1514.           $xfer += $input->skip($ftype);
  1515.           break;
  1516.       }
  1517.       $xfer += $input->readFieldEnd();
  1518.     }
  1519.     $xfer += $input->readStructEnd();
  1520.     return $xfer;
  1521.   }
  1523.   public function write($output) {
  1524.     $xfer = 0;
  1525.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_chmod_result');
  1526.     if ($this->ouch !== null) {
  1527.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  1528.       $xfer += $this->ouch->write($output);
  1529.       $xfer += $output->writeFieldEnd();
  1530.     }
  1531.     $xfer += $output->writeFieldStop();
  1532.     $xfer += $output->writeStructEnd();
  1533.     return $xfer;
  1534.   }
  1536. }
  1538. class ThriftHadoopFileSystem_chown_args {
  1539.   static $_TSPEC;
  1541.   public $path = null;
  1542.   public $owner = null;
  1543.   public $group = null;
  1545.   public function __construct($vals=null) {
  1546.     if (!isset(self::$_TSPEC)) {
  1547.       self::$_TSPEC = array(
  1548.         1 => array(
  1549.           'var' => 'path',
  1550.           'type' => TType::STRUCT,
  1551.           'class' => 'Pathname',
  1552.           ),
  1553.         2 => array(
  1554.           'var' => 'owner',
  1555.           'type' => TType::STRING,
  1556.           ),
  1557.         3 => array(
  1558.           'var' => 'group',
  1559.           'type' => TType::STRING,
  1560.           ),
  1561.         );
  1562.     }
  1563.     if (is_array($vals)) {
  1564.       if (isset($vals['path'])) {
  1565.         $this->path = $vals['path'];
  1566.       }
  1567.       if (isset($vals['owner'])) {
  1568.         $this->owner = $vals['owner'];
  1569.       }
  1570.       if (isset($vals['group'])) {
  1571.         $this->group = $vals['group'];
  1572.       }
  1573.     }
  1574.   }
  1576.   public function getName() {
  1577.     return 'ThriftHadoopFileSystem_chown_args';
  1578.   }
  1580.   public function read($input)
  1581.   {
  1582.     $xfer = 0;
  1583.     $fname = null;
  1584.     $ftype = 0;
  1585.     $fid = 0;
  1586.     $xfer += $input->readStructBegin($fname);
  1587.     while (true)
  1588.     {
  1589.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1590.       if ($ftype == TType::STOP) {
  1591.         break;
  1592.       }
  1593.       switch ($fid)
  1594.       {
  1595.         case 1:
  1596.           if ($ftype == TType::STRUCT) {
  1597.             $this->path = new Pathname();
  1598.             $xfer += $this->path->read($input);
  1599.           } else {
  1600.             $xfer += $input->skip($ftype);
  1601.           }
  1602.           break;
  1603.         case 2:
  1604.           if ($ftype == TType::STRING) {
  1605.             $xfer += $input->readString($this->owner);
  1606.           } else {
  1607.             $xfer += $input->skip($ftype);
  1608.           }
  1609.           break;
  1610.         case 3:
  1611.           if ($ftype == TType::STRING) {
  1612.             $xfer += $input->readString($this->group);
  1613.           } else {
  1614.             $xfer += $input->skip($ftype);
  1615.           }
  1616.           break;
  1617.         default:
  1618.           $xfer += $input->skip($ftype);
  1619.           break;
  1620.       }
  1621.       $xfer += $input->readFieldEnd();
  1622.     }
  1623.     $xfer += $input->readStructEnd();
  1624.     return $xfer;
  1625.   }
  1627.   public function write($output) {
  1628.     $xfer = 0;
  1629.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_chown_args');
  1630.     if ($this->path !== null) {
  1631.       if (!is_object($this->path)) {
  1632.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  1633.       }
  1634.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  1635.       $xfer += $this->path->write($output);
  1636.       $xfer += $output->writeFieldEnd();
  1637.     }
  1638.     if ($this->owner !== null) {
  1639.       $xfer += $output->writeFieldBegin('owner', TType::STRING, 2);
  1640.       $xfer += $output->writeString($this->owner);
  1641.       $xfer += $output->writeFieldEnd();
  1642.     }
  1643.     if ($this->group !== null) {
  1644.       $xfer += $output->writeFieldBegin('group', TType::STRING, 3);
  1645.       $xfer += $output->writeString($this->group);
  1646.       $xfer += $output->writeFieldEnd();
  1647.     }
  1648.     $xfer += $output->writeFieldStop();
  1649.     $xfer += $output->writeStructEnd();
  1650.     return $xfer;
  1651.   }
  1653. }
  1655. class ThriftHadoopFileSystem_chown_result {
  1656.   static $_TSPEC;
  1658.   public $ouch = null;
  1660.   public function __construct($vals=null) {
  1661.     if (!isset(self::$_TSPEC)) {
  1662.       self::$_TSPEC = array(
  1663.         1 => array(
  1664.           'var' => 'ouch',
  1665.           'type' => TType::STRUCT,
  1666.           'class' => 'ThriftIOException',
  1667.           ),
  1668.         );
  1669.     }
  1670.     if (is_array($vals)) {
  1671.       if (isset($vals['ouch'])) {
  1672.         $this->ouch = $vals['ouch'];
  1673.       }
  1674.     }
  1675.   }
  1677.   public function getName() {
  1678.     return 'ThriftHadoopFileSystem_chown_result';
  1679.   }
  1681.   public function read($input)
  1682.   {
  1683.     $xfer = 0;
  1684.     $fname = null;
  1685.     $ftype = 0;
  1686.     $fid = 0;
  1687.     $xfer += $input->readStructBegin($fname);
  1688.     while (true)
  1689.     {
  1690.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1691.       if ($ftype == TType::STOP) {
  1692.         break;
  1693.       }
  1694.       switch ($fid)
  1695.       {
  1696.         case 1:
  1697.           if ($ftype == TType::STRUCT) {
  1698.             $this->ouch = new ThriftIOException();
  1699.             $xfer += $this->ouch->read($input);
  1700.           } else {
  1701.             $xfer += $input->skip($ftype);
  1702.           }
  1703.           break;
  1704.         default:
  1705.           $xfer += $input->skip($ftype);
  1706.           break;
  1707.       }
  1708.       $xfer += $input->readFieldEnd();
  1709.     }
  1710.     $xfer += $input->readStructEnd();
  1711.     return $xfer;
  1712.   }
  1714.   public function write($output) {
  1715.     $xfer = 0;
  1716.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_chown_result');
  1717.     if ($this->ouch !== null) {
  1718.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  1719.       $xfer += $this->ouch->write($output);
  1720.       $xfer += $output->writeFieldEnd();
  1721.     }
  1722.     $xfer += $output->writeFieldStop();
  1723.     $xfer += $output->writeStructEnd();
  1724.     return $xfer;
  1725.   }
  1727. }
  1729. class ThriftHadoopFileSystem_setReplication_args {
  1730.   static $_TSPEC;
  1732.   public $path = null;
  1733.   public $replication = null;
  1735.   public function __construct($vals=null) {
  1736.     if (!isset(self::$_TSPEC)) {
  1737.       self::$_TSPEC = array(
  1738.         1 => array(
  1739.           'var' => 'path',
  1740.           'type' => TType::STRUCT,
  1741.           'class' => 'Pathname',
  1742.           ),
  1743.         2 => array(
  1744.           'var' => 'replication',
  1745.           'type' => TType::I16,
  1746.           ),
  1747.         );
  1748.     }
  1749.     if (is_array($vals)) {
  1750.       if (isset($vals['path'])) {
  1751.         $this->path = $vals['path'];
  1752.       }
  1753.       if (isset($vals['replication'])) {
  1754.         $this->replication = $vals['replication'];
  1755.       }
  1756.     }
  1757.   }
  1759.   public function getName() {
  1760.     return 'ThriftHadoopFileSystem_setReplication_args';
  1761.   }
  1763.   public function read($input)
  1764.   {
  1765.     $xfer = 0;
  1766.     $fname = null;
  1767.     $ftype = 0;
  1768.     $fid = 0;
  1769.     $xfer += $input->readStructBegin($fname);
  1770.     while (true)
  1771.     {
  1772.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1773.       if ($ftype == TType::STOP) {
  1774.         break;
  1775.       }
  1776.       switch ($fid)
  1777.       {
  1778.         case 1:
  1779.           if ($ftype == TType::STRUCT) {
  1780.             $this->path = new Pathname();
  1781.             $xfer += $this->path->read($input);
  1782.           } else {
  1783.             $xfer += $input->skip($ftype);
  1784.           }
  1785.           break;
  1786.         case 2:
  1787.           if ($ftype == TType::I16) {
  1788.             $xfer += $input->readI16($this->replication);
  1789.           } else {
  1790.             $xfer += $input->skip($ftype);
  1791.           }
  1792.           break;
  1793.         default:
  1794.           $xfer += $input->skip($ftype);
  1795.           break;
  1796.       }
  1797.       $xfer += $input->readFieldEnd();
  1798.     }
  1799.     $xfer += $input->readStructEnd();
  1800.     return $xfer;
  1801.   }
  1803.   public function write($output) {
  1804.     $xfer = 0;
  1805.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_setReplication_args');
  1806.     if ($this->path !== null) {
  1807.       if (!is_object($this->path)) {
  1808.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  1809.       }
  1810.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  1811.       $xfer += $this->path->write($output);
  1812.       $xfer += $output->writeFieldEnd();
  1813.     }
  1814.     if ($this->replication !== null) {
  1815.       $xfer += $output->writeFieldBegin('replication', TType::I16, 2);
  1816.       $xfer += $output->writeI16($this->replication);
  1817.       $xfer += $output->writeFieldEnd();
  1818.     }
  1819.     $xfer += $output->writeFieldStop();
  1820.     $xfer += $output->writeStructEnd();
  1821.     return $xfer;
  1822.   }
  1824. }
  1826. class ThriftHadoopFileSystem_setReplication_result {
  1827.   static $_TSPEC;
  1829.   public $ouch = null;
  1831.   public function __construct($vals=null) {
  1832.     if (!isset(self::$_TSPEC)) {
  1833.       self::$_TSPEC = array(
  1834.         1 => array(
  1835.           'var' => 'ouch',
  1836.           'type' => TType::STRUCT,
  1837.           'class' => 'ThriftIOException',
  1838.           ),
  1839.         );
  1840.     }
  1841.     if (is_array($vals)) {
  1842.       if (isset($vals['ouch'])) {
  1843.         $this->ouch = $vals['ouch'];
  1844.       }
  1845.     }
  1846.   }
  1848.   public function getName() {
  1849.     return 'ThriftHadoopFileSystem_setReplication_result';
  1850.   }
  1852.   public function read($input)
  1853.   {
  1854.     $xfer = 0;
  1855.     $fname = null;
  1856.     $ftype = 0;
  1857.     $fid = 0;
  1858.     $xfer += $input->readStructBegin($fname);
  1859.     while (true)
  1860.     {
  1861.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1862.       if ($ftype == TType::STOP) {
  1863.         break;
  1864.       }
  1865.       switch ($fid)
  1866.       {
  1867.         case 1:
  1868.           if ($ftype == TType::STRUCT) {
  1869.             $this->ouch = new ThriftIOException();
  1870.             $xfer += $this->ouch->read($input);
  1871.           } else {
  1872.             $xfer += $input->skip($ftype);
  1873.           }
  1874.           break;
  1875.         default:
  1876.           $xfer += $input->skip($ftype);
  1877.           break;
  1878.       }
  1879.       $xfer += $input->readFieldEnd();
  1880.     }
  1881.     $xfer += $input->readStructEnd();
  1882.     return $xfer;
  1883.   }
  1885.   public function write($output) {
  1886.     $xfer = 0;
  1887.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_setReplication_result');
  1888.     if ($this->ouch !== null) {
  1889.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  1890.       $xfer += $this->ouch->write($output);
  1891.       $xfer += $output->writeFieldEnd();
  1892.     }
  1893.     $xfer += $output->writeFieldStop();
  1894.     $xfer += $output->writeStructEnd();
  1895.     return $xfer;
  1896.   }
  1898. }
  1900. class ThriftHadoopFileSystem_getFileBlockLocations_args {
  1901.   static $_TSPEC;
  1903.   public $path = null;
  1904.   public $start = null;
  1905.   public $length = null;
  1907.   public function __construct($vals=null) {
  1908.     if (!isset(self::$_TSPEC)) {
  1909.       self::$_TSPEC = array(
  1910.         1 => array(
  1911.           'var' => 'path',
  1912.           'type' => TType::STRUCT,
  1913.           'class' => 'Pathname',
  1914.           ),
  1915.         2 => array(
  1916.           'var' => 'start',
  1917.           'type' => TType::I64,
  1918.           ),
  1919.         3 => array(
  1920.           'var' => 'length',
  1921.           'type' => TType::I64,
  1922.           ),
  1923.         );
  1924.     }
  1925.     if (is_array($vals)) {
  1926.       if (isset($vals['path'])) {
  1927.         $this->path = $vals['path'];
  1928.       }
  1929.       if (isset($vals['start'])) {
  1930.         $this->start = $vals['start'];
  1931.       }
  1932.       if (isset($vals['length'])) {
  1933.         $this->length = $vals['length'];
  1934.       }
  1935.     }
  1936.   }
  1938.   public function getName() {
  1939.     return 'ThriftHadoopFileSystem_getFileBlockLocations_args';
  1940.   }
  1942.   public function read($input)
  1943.   {
  1944.     $xfer = 0;
  1945.     $fname = null;
  1946.     $ftype = 0;
  1947.     $fid = 0;
  1948.     $xfer += $input->readStructBegin($fname);
  1949.     while (true)
  1950.     {
  1951.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  1952.       if ($ftype == TType::STOP) {
  1953.         break;
  1954.       }
  1955.       switch ($fid)
  1956.       {
  1957.         case 1:
  1958.           if ($ftype == TType::STRUCT) {
  1959.             $this->path = new Pathname();
  1960.             $xfer += $this->path->read($input);
  1961.           } else {
  1962.             $xfer += $input->skip($ftype);
  1963.           }
  1964.           break;
  1965.         case 2:
  1966.           if ($ftype == TType::I64) {
  1967.             $xfer += $input->readI64($this->start);
  1968.           } else {
  1969.             $xfer += $input->skip($ftype);
  1970.           }
  1971.           break;
  1972.         case 3:
  1973.           if ($ftype == TType::I64) {
  1974.             $xfer += $input->readI64($this->length);
  1975.           } else {
  1976.             $xfer += $input->skip($ftype);
  1977.           }
  1978.           break;
  1979.         default:
  1980.           $xfer += $input->skip($ftype);
  1981.           break;
  1982.       }
  1983.       $xfer += $input->readFieldEnd();
  1984.     }
  1985.     $xfer += $input->readStructEnd();
  1986.     return $xfer;
  1987.   }
  1989.   public function write($output) {
  1990.     $xfer = 0;
  1991.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_getFileBlockLocations_args');
  1992.     if ($this->path !== null) {
  1993.       if (!is_object($this->path)) {
  1994.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  1995.       }
  1996.       $xfer += $output->writeFieldBegin('path', TType::STRUCT, 1);
  1997.       $xfer += $this->path->write($output);
  1998.       $xfer += $output->writeFieldEnd();
  1999.     }
  2000.     if ($this->start !== null) {
  2001.       $xfer += $output->writeFieldBegin('start', TType::I64, 2);
  2002.       $xfer += $output->writeI64($this->start);
  2003.       $xfer += $output->writeFieldEnd();
  2004.     }
  2005.     if ($this->length !== null) {
  2006.       $xfer += $output->writeFieldBegin('length', TType::I64, 3);
  2007.       $xfer += $output->writeI64($this->length);
  2008.       $xfer += $output->writeFieldEnd();
  2009.     }
  2010.     $xfer += $output->writeFieldStop();
  2011.     $xfer += $output->writeStructEnd();
  2012.     return $xfer;
  2013.   }
  2015. }
  2017. class ThriftHadoopFileSystem_getFileBlockLocations_result {
  2018.   static $_TSPEC;
  2020.   public $success = null;
  2021.   public $ouch = null;
  2023.   public function __construct($vals=null) {
  2024.     if (!isset(self::$_TSPEC)) {
  2025.       self::$_TSPEC = array(
  2026.         0 => array(
  2027.           'var' => 'success',
  2028.           'type' => TType::LST,
  2029.           'etype' => TType::STRUCT,
  2030.           'elem' => array(
  2031.             'type' => TType::STRUCT,
  2032.             'class' => 'BlockLocation',
  2033.             ),
  2034.           ),
  2035.         1 => array(
  2036.           'var' => 'ouch',
  2037.           'type' => TType::STRUCT,
  2038.           'class' => 'ThriftIOException',
  2039.           ),
  2040.         );
  2041.     }
  2042.     if (is_array($vals)) {
  2043.       if (isset($vals['success'])) {
  2044.         $this->success = $vals['success'];
  2045.       }
  2046.       if (isset($vals['ouch'])) {
  2047.         $this->ouch = $vals['ouch'];
  2048.       }
  2049.     }
  2050.   }
  2052.   public function getName() {
  2053.     return 'ThriftHadoopFileSystem_getFileBlockLocations_result';
  2054.   }
  2056.   public function read($input)
  2057.   {
  2058.     $xfer = 0;
  2059.     $fname = null;
  2060.     $ftype = 0;
  2061.     $fid = 0;
  2062.     $xfer += $input->readStructBegin($fname);
  2063.     while (true)
  2064.     {
  2065.       $xfer += $input->readFieldBegin($fname, $ftype, $fid);
  2066.       if ($ftype == TType::STOP) {
  2067.         break;
  2068.       }
  2069.       switch ($fid)
  2070.       {
  2071.         case 0:
  2072.           if ($ftype == TType::LST) {
  2073.             $this->success = array();
  2074.             $_size21 = 0;
  2075.             $_etype24 = 0;
  2076.             $xfer += $input->readListBegin($_etype24, $_size21);
  2077.             for ($_i25 = 0; $_i25 < $_size21; ++$_i25)
  2078.             {
  2079.               $elem26 = null;
  2080.               $elem26 = new BlockLocation();
  2081.               $xfer += $elem26->read($input);
  2082.               $this->success []= $elem26;
  2083.             }
  2084.             $xfer += $input->readListEnd();
  2085.           } else {
  2086.             $xfer += $input->skip($ftype);
  2087.           }
  2088.           break;
  2089.         case 1:
  2090.           if ($ftype == TType::STRUCT) {
  2091.             $this->ouch = new ThriftIOException();
  2092.             $xfer += $this->ouch->read($input);
  2093.           } else {
  2094.             $xfer += $input->skip($ftype);
  2095.           }
  2096.           break;
  2097.         default:
  2098.           $xfer += $input->skip($ftype);
  2099.           break;
  2100.       }
  2101.       $xfer += $input->readFieldEnd();
  2102.     }
  2103.     $xfer += $input->readStructEnd();
  2104.     return $xfer;
  2105.   }
  2107.   public function write($output) {
  2108.     $xfer = 0;
  2109.     $xfer += $output->writeStructBegin('ThriftHadoopFileSystem_getFileBlockLocations_result');
  2110.     if ($this->success !== null) {
  2111.       if (!is_array($this->success)) {
  2112.         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
  2113.       }
  2114.       $xfer += $output->writeFieldBegin('success', TType::LST, 0);
  2115.       {
  2116.         $output->writeListBegin(TType::STRUCT, count($this->success));
  2117.         {
  2118.           foreach ($this->success as $iter27)
  2119.           {
  2120.             $xfer += $iter27->write($output);
  2121.           }
  2122.         }
  2123.         $output->writeListEnd();
  2124.       }
  2125.       $xfer += $output->writeFieldEnd();
  2126.     }
  2127.     if ($this->ouch !== null) {
  2128.       $xfer += $output->writeFieldBegin('ouch', TType::STRUCT, 1);
  2129.       $xfer += $this->ouch->write($output);
  2130.       $xfer += $output->writeFieldEnd();
  2131.     }
  2132.     $xfer += $output->writeFieldStop();
  2133.     $xfer += $output->writeStructEnd();
  2134.     return $xfer;
  2135.   }
  2137. }
  2139. class ThriftHadoopFileSystemProcessor {
  2140.   protected $handler_ = null;
  2141.   public function __construct($handler) {
  2142.     $this->handler_ = $handler;
  2143.   }
  2145.   public function process($input, $output) {
  2146.     $rseqid = 0;
  2147.     $fname = null;
  2148.     $mtype = 0;
  2150.     $input->readMessageBegin($fname, $mtype, $rseqid);
  2151.     $methodname = 'process_'.$fname;
  2152.     if (!method_exists($this, $methodname)) {
  2153.       $input->skip(TType::STRUCT);
  2154.       $input->readMessageEnd();
  2155.       $x = new TApplicationException('Function '.$fname.' not implemented.', TApplicationException::UNKNOWN_METHOD);
  2156.       $output->writeMessageBegin($fname, TMessageType::EXCEPTION, $rseqid);
  2157.       $x->write($output);
  2158.       $output->writeMessageEnd();
  2159.       $output->getTransport()->flush();
  2160.       return;
  2161.     }
  2162.     $this->$methodname($rseqid, $input, $output);
  2163.     return true;
  2164.   }
  2166.   protected function process_setInactivityTimeoutPeriod($seqid, $input, $output) {
  2167.     $args = new ThriftHadoopFileSystem_setInactivityTimeoutPeriod_args();
  2168.     $args->read($input);
  2169.     $input->readMessageEnd();
  2170.     $result = new ThriftHadoopFileSystem_setInactivityTimeoutPeriod_result();
  2171.     $this->handler_->setInactivityTimeoutPeriod($args->periodInSeconds);
  2172.     $output->writeMessageBegin('setInactivityTimeoutPeriod', TMessageType::REPLY, $seqid);
  2173.     $result->write($output);
  2174.     $output->getTransport()->flush();
  2175.   }
  2176.   protected function process_shutdown($seqid, $input, $output) {
  2177.     $args = new ThriftHadoopFileSystem_shutdown_args();
  2178.     $args->read($input);
  2179.     $input->readMessageEnd();
  2180.     $result = new ThriftHadoopFileSystem_shutdown_result();
  2181.     $this->handler_->shutdown($args->status);
  2182.     $output->writeMessageBegin('shutdown', TMessageType::REPLY, $seqid);
  2183.     $result->write($output);
  2184.     $output->getTransport()->flush();
  2185.   }
  2186.   protected function process_create($seqid, $input, $output) {
  2187.     $args = new ThriftHadoopFileSystem_create_args();
  2188.     $args->read($input);
  2189.     $input->readMessageEnd();
  2190.     $result = new ThriftHadoopFileSystem_create_result();
  2191.     try {
  2192.       $result->success = $this->handler_->create($args->path);
  2193.     } catch (ThriftIOException $ouch) {
  2194.       $result->ouch = $ouch;
  2195.     }
  2196.     $output->writeMessageBegin('create', TMessageType::REPLY, $seqid);
  2197.     $result->write($output);
  2198.     $output->getTransport()->flush();
  2199.   }
  2200.   protected function process_createFile($seqid, $input, $output) {
  2201.     $args = new ThriftHadoopFileSystem_createFile_args();
  2202.     $args->read($input);
  2203.     $input->readMessageEnd();
  2204.     $result = new ThriftHadoopFileSystem_createFile_result();
  2205.     try {
  2206.       $result->success = $this->handler_->createFile($args->path, $args->mode, $args->overwrite, $args->bufferSize, $args->block_replication, $args->blocksize);
  2207.     } catch (ThriftIOException $ouch) {
  2208.       $result->ouch = $ouch;
  2209.     }
  2210.     $output->writeMessageBegin('createFile', TMessageType::REPLY, $seqid);
  2211.     $result->write($output);
  2212.     $output->getTransport()->flush();
  2213.   }
  2214.   protected function process_open($seqid, $input, $output) {
  2215.     $args = new ThriftHadoopFileSystem_open_args();
  2216.     $args->read($input);
  2217.     $input->readMessageEnd();
  2218.     $result = new ThriftHadoopFileSystem_open_result();
  2219.     try {
  2220.       $result->success = $this->handler_->open($args->path);
  2221.     } catch (ThriftIOException $ouch) {
  2222.       $result->ouch = $ouch;
  2223.     }
  2224.     $output->writeMessageBegin('open', TMessageType::REPLY, $seqid);
  2225.     $result->write($output);
  2226.     $output->getTransport()->flush();
  2227.   }
  2228.   protected function process_append($seqid, $input, $output) {
  2229.     $args = new ThriftHadoopFileSystem_append_args();
  2230.     $args->read($input);
  2231.     $input->readMessageEnd();
  2232.     $result = new ThriftHadoopFileSystem_append_result();
  2233.     try {
  2234.       $result->success = $this->handler_->append($args->path);
  2235.     } catch (ThriftIOException $ouch) {
  2236.       $result->ouch = $ouch;
  2237.     }
  2238.     $output->writeMessageBegin('append', TMessageType::REPLY, $seqid);
  2239.     $result->write($output);
  2240.     $output->getTransport()->flush();
  2241.   }
  2242.   protected function process_write($seqid, $input, $output) {
  2243.     $args = new ThriftHadoopFileSystem_write_args();
  2244.     $args->read($input);
  2245.     $input->readMessageEnd();
  2246.     $result = new ThriftHadoopFileSystem_write_result();
  2247.     try {
  2248.       $result->success = $this->handler_->write($args->handle, $args->data);
  2249.     } catch (ThriftIOException $ouch) {
  2250.       $result->ouch = $ouch;
  2251.     }
  2252.     $output->writeMessageBegin('write', TMessageType::REPLY, $seqid);
  2253.     $result->write($output);
  2254.     $output->getTransport()->flush();
  2255.   }
  2256.   protected function process_read($seqid, $input, $output) {
  2257.     $args = new ThriftHadoopFileSystem_read_args();
  2258.     $args->read($input);
  2259.     $input->readMessageEnd();
  2260.     $result = new ThriftHadoopFileSystem_read_result();
  2261.     try {
  2262.       $result->success = $this->handler_->read($args->handle, $args->offset, $args->size);
  2263.     } catch (ThriftIOException $ouch) {
  2264.       $result->ouch = $ouch;
  2265.     }
  2266.     $output->writeMessageBegin('read', TMessageType::REPLY, $seqid);
  2267.     $result->write($output);
  2268.     $output->getTransport()->flush();
  2269.   }
  2270.   protected function process_close($seqid, $input, $output) {
  2271.     $args = new ThriftHadoopFileSystem_close_args();
  2272.     $args->read($input);
  2273.     $input->readMessageEnd();
  2274.     $result = new ThriftHadoopFileSystem_close_result();
  2275.     try {
  2276.       $result->success = $this->handler_->close($args->out);
  2277.     } catch (ThriftIOException $ouch) {
  2278.       $result->ouch = $ouch;
  2279.     }
  2280.     $output->writeMessageBegin('close', TMessageType::REPLY, $seqid);
  2281.     $result->write($output);
  2282.     $output->getTransport()->flush();
  2283.   }
  2284.   protected function process_rm($seqid, $input, $output) {
  2285.     $args = new ThriftHadoopFileSystem_rm_args();
  2286.     $args->read($input);
  2287.     $input->readMessageEnd();
  2288.     $result = new ThriftHadoopFileSystem_rm_result();
  2289.     try {
  2290.       $result->success = $this->handler_->rm($args->path, $args->recursive);
  2291.     } catch (ThriftIOException $ouch) {
  2292.       $result->ouch = $ouch;
  2293.     }
  2294.     $output->writeMessageBegin('rm', TMessageType::REPLY, $seqid);
  2295.     $result->write($output);
  2296.     $output->getTransport()->flush();
  2297.   }
  2298.   protected function process_rename($seqid, $input, $output) {
  2299.     $args = new ThriftHadoopFileSystem_rename_args();
  2300.     $args->read($input);
  2301.     $input->readMessageEnd();
  2302.     $result = new ThriftHadoopFileSystem_rename_result();
  2303.     try {
  2304.       $result->success = $this->handler_->rename($args->path, $args->dest);
  2305.     } catch (ThriftIOException $ouch) {
  2306.       $result->ouch = $ouch;
  2307.     }
  2308.     $output->writeMessageBegin('rename', TMessageType::REPLY, $seqid);
  2309.     $result->write($output);
  2310.     $output->getTransport()->flush();
  2311.   }
  2312.   protected function process_mkdirs($seqid, $input, $output) {
  2313.     $args = new ThriftHadoopFileSystem_mkdirs_args();
  2314.     $args->read($input);
  2315.     $input->readMessageEnd();
  2316.     $result = new ThriftHadoopFileSystem_mkdirs_result();
  2317.     try {
  2318.       $result->success = $this->handler_->mkdirs($args->path);
  2319.     } catch (ThriftIOException $ouch) {
  2320.       $result->ouch = $ouch;
  2321.     }
  2322.     $output->writeMessageBegin('mkdirs', TMessageType::REPLY, $seqid);
  2323.     $result->write($output);
  2324.     $output->getTransport()->flush();
  2325.   }
  2326.   protected function process_exists($seqid, $input, $output) {
  2327.     $args = new ThriftHadoopFileSystem_exists_args();
  2328.     $args->read($input);
  2329.     $input->readMessageEnd();
  2330.     $result = new ThriftHadoopFileSystem_exists_result();
  2331.     try {
  2332.       $result->success = $this->handler_->exists($args->path);
  2333.     } catch (ThriftIOException $ouch) {
  2334.       $result->ouch = $ouch;
  2335.     }
  2336.     $output->writeMessageBegin('exists', TMessageType::REPLY, $seqid);
  2337.     $result->write($output);
  2338.     $output->getTransport()->flush();
  2339.   }
  2340.   protected function process_stat($seqid, $input, $output) {
  2341.     $args = new ThriftHadoopFileSystem_stat_args();
  2342.     $args->read($input);
  2343.     $input->readMessageEnd();
  2344.     $result = new ThriftHadoopFileSystem_stat_result();
  2345.     try {
  2346.       $result->success = $this->handler_->stat($args->path);
  2347.     } catch (ThriftIOException $ouch) {
  2348.       $result->ouch = $ouch;
  2349.     }
  2350.     $output->writeMessageBegin('stat', TMessageType::REPLY, $seqid);
  2351.     $result->write($output);
  2352.     $output->getTransport()->flush();
  2353.   }
  2354.   protected function process_listStatus($seqid, $input, $output) {
  2355.     $args = new ThriftHadoopFileSystem_listStatus_args();
  2356.     $args->read($input);
  2357.     $input->readMessageEnd();
  2358.     $result = new ThriftHadoopFileSystem_listStatus_result();
  2359.     try {
  2360.       $result->success = $this->handler_->listStatus($args->path);
  2361.     } catch (ThriftIOException $ouch) {
  2362.       $result->ouch = $ouch;
  2363.     }
  2364.     $output->writeMessageBegin('listStatus', TMessageType::REPLY, $seqid);
  2365.     $result->write($output);
  2366.     $output->getTransport()->flush();
  2367.   }
  2368.   protected function process_chmod($seqid, $input, $output) {
  2369.     $args = new ThriftHadoopFileSystem_chmod_args();
  2370.     $args->read($input);
  2371.     $input->readMessageEnd();
  2372.     $result = new ThriftHadoopFileSystem_chmod_result();
  2373.     try {
  2374.       $this->handler_->chmod($args->path, $args->mode);
  2375.     } catch (ThriftIOException $ouch) {
  2376.       $result->ouch = $ouch;
  2377.     }
  2378.     $output->writeMessageBegin('chmod', TMessageType::REPLY, $seqid);
  2379.     $result->write($output);
  2380.     $output->getTransport()->flush();
  2381.   }
  2382.   protected function process_chown($seqid, $input, $output) {
  2383.     $args = new ThriftHadoopFileSystem_chown_args();
  2384.     $args->read($input);
  2385.     $input->readMessageEnd();
  2386.     $result = new ThriftHadoopFileSystem_chown_result();
  2387.     try {
  2388.       $this->handler_->chown($args->path, $args->owner, $args->group);
  2389.     } catch (ThriftIOException $ouch) {
  2390.       $result->ouch = $ouch;
  2391.     }
  2392.     $output->writeMessageBegin('chown', TMessageType::REPLY, $seqid);
  2393.     $result->write($output);
  2394.     $output->getTransport()->flush();
  2395.   }
  2396.   protected function process_setReplication($seqid, $input, $output) {
  2397.     $args = new ThriftHadoopFileSystem_setReplication_args();
  2398.     $args->read($input);
  2399.     $input->readMessageEnd();
  2400.     $result = new ThriftHadoopFileSystem_setReplication_result();
  2401.     try {
  2402.       $this->handler_->setReplication($args->path, $args->replication);
  2403.     } catch (ThriftIOException $ouch) {
  2404.       $result->ouch = $ouch;
  2405.     }
  2406.     $output->writeMessageBegin('setReplication', TMessageType::REPLY, $seqid);
  2407.     $result->write($output);
  2408.     $output->getTransport()->flush();
  2409.   }
  2410.   protected function process_getFileBlockLocations($seqid, $input, $output) {
  2411.     $args = new ThriftHadoopFileSystem_getFileBlockLocations_args();
  2412.     $args->read($input);
  2413.     $input->readMessageEnd();
  2414.     $result = new ThriftHadoopFileSystem_getFileBlockLocations_result();
  2415.     try {
  2416.       $result->success = $this->handler_->getFileBlockLocations($args->path, $args->start, $args->length);
  2417.     } catch (ThriftIOException $ouch) {
  2418.       $result->ouch = $ouch;
  2419.     }
  2420.     $output->writeMessageBegin('getFileBlockLocations', TMessageType::REPLY, $seqid);
  2421.     $result->write($output);
  2422.     $output->getTransport()->flush();
  2423.   }
  2424. }
  2425. ?>