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

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

网格计算

开发平台：

Java

ThriftHadoopFileSystem.cpp：源码内容
  1.     xfer += iprot->readFieldEnd();
  2.   }
  4.   xfer += iprot->readStructEnd();
  6.   return xfer;
  7. }
  9. uint32_t ThriftHadoopFileSystem_listStatus_result::write(facebook::thrift::protocol::TProtocol* oprot) const {
  11.   uint32_t xfer = 0;
  13.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_listStatus_result");
  15.   if (this->__isset.success) {
  16.     xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_LIST, 0);
  17.     {
  18.       xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->success.size());
  19.       std::vector<FileStatus> ::const_iterator _iter17;
  20.       for (_iter17 = this->success.begin(); _iter17 != this->success.end(); ++_iter17)
  21.       {
  22.         xfer += (*_iter17).write(oprot);
  23.       }
  24.       xfer += oprot->writeListEnd();
  25.     }
  26.     xfer += oprot->writeFieldEnd();
  27.   } else if (this->__isset.ouch) {
  28.     xfer += oprot->writeFieldBegin("ouch", facebook::thrift::protocol::T_STRUCT, 1);
  29.     xfer += this->ouch.write(oprot);
  30.     xfer += oprot->writeFieldEnd();
  31.   }
  32.   xfer += oprot->writeFieldStop();
  33.   xfer += oprot->writeStructEnd();
  34.   return xfer;
  35. }
  37. uint32_t ThriftHadoopFileSystem_listStatus_presult::read(facebook::thrift::protocol::TProtocol* iprot) {
  39.   uint32_t xfer = 0;
  40.   std::string fname;
  41.   facebook::thrift::protocol::TType ftype;
  42.   int16_t fid;
  44.   xfer += iprot->readStructBegin(fname);
  46.   using facebook::thrift::protocol::TProtocolException;
  49.   while (true)
  50.   {
  51.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  52.     if (ftype == facebook::thrift::protocol::T_STOP) {
  53.       break;
  54.     }
  55.     switch (fid)
  56.     {
  57.       case 0:
  58.         if (ftype == facebook::thrift::protocol::T_LIST) {
  59.           {
  60.             (*(this->success)).clear();
  61.             uint32_t _size18;
  62.             facebook::thrift::protocol::TType _etype21;
  63.             iprot->readListBegin(_etype21, _size18);
  64.             (*(this->success)).resize(_size18);
  65.             uint32_t _i22;
  66.             for (_i22 = 0; _i22 < _size18; ++_i22)
  67.             {
  68.               xfer += (*(this->success))[_i22].read(iprot);
  69.             }
  70.             iprot->readListEnd();
  71.           }
  72.           this->__isset.success = true;
  73.         } else {
  74.           xfer += iprot->skip(ftype);
  75.         }
  76.         break;
  77.       case 1:
  78.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  79.           xfer += this->ouch.read(iprot);
  80.           this->__isset.ouch = true;
  81.         } else {
  82.           xfer += iprot->skip(ftype);
  83.         }
  84.         break;
  85.       default:
  86.         xfer += iprot->skip(ftype);
  87.         break;
  88.     }
  89.     xfer += iprot->readFieldEnd();
  90.   }
  92.   xfer += iprot->readStructEnd();
  94.   return xfer;
  95. }
  97. uint32_t ThriftHadoopFileSystem_chmod_args::read(facebook::thrift::protocol::TProtocol* iprot) {
  99.   uint32_t xfer = 0;
  100.   std::string fname;
  101.   facebook::thrift::protocol::TType ftype;
  102.   int16_t fid;
  104.   xfer += iprot->readStructBegin(fname);
  106.   using facebook::thrift::protocol::TProtocolException;
  109.   while (true)
  110.   {
  111.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  112.     if (ftype == facebook::thrift::protocol::T_STOP) {
  113.       break;
  114.     }
  115.     switch (fid)
  116.     {
  117.       case 1:
  118.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  119.           xfer += this->path.read(iprot);
  120.           this->__isset.path = true;
  121.         } else {
  122.           xfer += iprot->skip(ftype);
  123.         }
  124.         break;
  125.       case 2:
  126.         if (ftype == facebook::thrift::protocol::T_I16) {
  127.           xfer += iprot->readI16(this->mode);
  128.           this->__isset.mode = true;
  129.         } else {
  130.           xfer += iprot->skip(ftype);
  131.         }
  132.         break;
  133.       default:
  134.         xfer += iprot->skip(ftype);
  135.         break;
  136.     }
  137.     xfer += iprot->readFieldEnd();
  138.   }
  140.   xfer += iprot->readStructEnd();
  142.   return xfer;
  143. }
  145. uint32_t ThriftHadoopFileSystem_chmod_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  146.   uint32_t xfer = 0;
  147.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_chmod_args");
  148.   xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRUCT, 1);
  149.   xfer += this->path.write(oprot);
  150.   xfer += oprot->writeFieldEnd();
  151.   xfer += oprot->writeFieldBegin("mode", facebook::thrift::protocol::T_I16, 2);
  152.   xfer += oprot->writeI16(this->mode);
  153.   xfer += oprot->writeFieldEnd();
  154.   xfer += oprot->writeFieldStop();
  155.   xfer += oprot->writeStructEnd();
  156.   return xfer;
  157. }
  159. uint32_t ThriftHadoopFileSystem_chmod_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  160.   uint32_t xfer = 0;
  161.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_chmod_pargs");
  162.   xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRUCT, 1);
  163.   xfer += (*(this->path)).write(oprot);
  164.   xfer += oprot->writeFieldEnd();
  165.   xfer += oprot->writeFieldBegin("mode", facebook::thrift::protocol::T_I16, 2);
  166.   xfer += oprot->writeI16((*(this->mode)));
  167.   xfer += oprot->writeFieldEnd();
  168.   xfer += oprot->writeFieldStop();
  169.   xfer += oprot->writeStructEnd();
  170.   return xfer;
  171. }
  173. uint32_t ThriftHadoopFileSystem_chmod_result::read(facebook::thrift::protocol::TProtocol* iprot) {
  175.   uint32_t xfer = 0;
  176.   std::string fname;
  177.   facebook::thrift::protocol::TType ftype;
  178.   int16_t fid;
  180.   xfer += iprot->readStructBegin(fname);
  182.   using facebook::thrift::protocol::TProtocolException;
  185.   while (true)
  186.   {
  187.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  188.     if (ftype == facebook::thrift::protocol::T_STOP) {
  189.       break;
  190.     }
  191.     switch (fid)
  192.     {
  193.       case 1:
  194.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  195.           xfer += this->ouch.read(iprot);
  196.           this->__isset.ouch = true;
  197.         } else {
  198.           xfer += iprot->skip(ftype);
  199.         }
  200.         break;
  201.       default:
  202.         xfer += iprot->skip(ftype);
  203.         break;
  204.     }
  205.     xfer += iprot->readFieldEnd();
  206.   }
  208.   xfer += iprot->readStructEnd();
  210.   return xfer;
  211. }
  213. uint32_t ThriftHadoopFileSystem_chmod_result::write(facebook::thrift::protocol::TProtocol* oprot) const {
  215.   uint32_t xfer = 0;
  217.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_chmod_result");
  219.   if (this->__isset.ouch) {
  220.     xfer += oprot->writeFieldBegin("ouch", facebook::thrift::protocol::T_STRUCT, 1);
  221.     xfer += this->ouch.write(oprot);
  222.     xfer += oprot->writeFieldEnd();
  223.   }
  224.   xfer += oprot->writeFieldStop();
  225.   xfer += oprot->writeStructEnd();
  226.   return xfer;
  227. }
  229. uint32_t ThriftHadoopFileSystem_chmod_presult::read(facebook::thrift::protocol::TProtocol* iprot) {
  231.   uint32_t xfer = 0;
  232.   std::string fname;
  233.   facebook::thrift::protocol::TType ftype;
  234.   int16_t fid;
  236.   xfer += iprot->readStructBegin(fname);
  238.   using facebook::thrift::protocol::TProtocolException;
  241.   while (true)
  242.   {
  243.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  244.     if (ftype == facebook::thrift::protocol::T_STOP) {
  245.       break;
  246.     }
  247.     switch (fid)
  248.     {
  249.       case 1:
  250.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  251.           xfer += this->ouch.read(iprot);
  252.           this->__isset.ouch = true;
  253.         } else {
  254.           xfer += iprot->skip(ftype);
  255.         }
  256.         break;
  257.       default:
  258.         xfer += iprot->skip(ftype);
  259.         break;
  260.     }
  261.     xfer += iprot->readFieldEnd();
  262.   }
  264.   xfer += iprot->readStructEnd();
  266.   return xfer;
  267. }
  269. uint32_t ThriftHadoopFileSystem_chown_args::read(facebook::thrift::protocol::TProtocol* iprot) {
  271.   uint32_t xfer = 0;
  272.   std::string fname;
  273.   facebook::thrift::protocol::TType ftype;
  274.   int16_t fid;
  276.   xfer += iprot->readStructBegin(fname);
  278.   using facebook::thrift::protocol::TProtocolException;
  281.   while (true)
  282.   {
  283.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  284.     if (ftype == facebook::thrift::protocol::T_STOP) {
  285.       break;
  286.     }
  287.     switch (fid)
  288.     {
  289.       case 1:
  290.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  291.           xfer += this->path.read(iprot);
  292.           this->__isset.path = true;
  293.         } else {
  294.           xfer += iprot->skip(ftype);
  295.         }
  296.         break;
  297.       case 2:
  298.         if (ftype == facebook::thrift::protocol::T_STRING) {
  299.           xfer += iprot->readString(this->owner);
  300.           this->__isset.owner = true;
  301.         } else {
  302.           xfer += iprot->skip(ftype);
  303.         }
  304.         break;
  305.       case 3:
  306.         if (ftype == facebook::thrift::protocol::T_STRING) {
  307.           xfer += iprot->readString(this->group);
  308.           this->__isset.group = true;
  309.         } else {
  310.           xfer += iprot->skip(ftype);
  311.         }
  312.         break;
  313.       default:
  314.         xfer += iprot->skip(ftype);
  315.         break;
  316.     }
  317.     xfer += iprot->readFieldEnd();
  318.   }
  320.   xfer += iprot->readStructEnd();
  322.   return xfer;
  323. }
  325. uint32_t ThriftHadoopFileSystem_chown_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  326.   uint32_t xfer = 0;
  327.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_chown_args");
  328.   xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRUCT, 1);
  329.   xfer += this->path.write(oprot);
  330.   xfer += oprot->writeFieldEnd();
  331.   xfer += oprot->writeFieldBegin("owner", facebook::thrift::protocol::T_STRING, 2);
  332.   xfer += oprot->writeString(this->owner);
  333.   xfer += oprot->writeFieldEnd();
  334.   xfer += oprot->writeFieldBegin("group", facebook::thrift::protocol::T_STRING, 3);
  335.   xfer += oprot->writeString(this->group);
  336.   xfer += oprot->writeFieldEnd();
  337.   xfer += oprot->writeFieldStop();
  338.   xfer += oprot->writeStructEnd();
  339.   return xfer;
  340. }
  342. uint32_t ThriftHadoopFileSystem_chown_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  343.   uint32_t xfer = 0;
  344.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_chown_pargs");
  345.   xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRUCT, 1);
  346.   xfer += (*(this->path)).write(oprot);
  347.   xfer += oprot->writeFieldEnd();
  348.   xfer += oprot->writeFieldBegin("owner", facebook::thrift::protocol::T_STRING, 2);
  349.   xfer += oprot->writeString((*(this->owner)));
  350.   xfer += oprot->writeFieldEnd();
  351.   xfer += oprot->writeFieldBegin("group", facebook::thrift::protocol::T_STRING, 3);
  352.   xfer += oprot->writeString((*(this->group)));
  353.   xfer += oprot->writeFieldEnd();
  354.   xfer += oprot->writeFieldStop();
  355.   xfer += oprot->writeStructEnd();
  356.   return xfer;
  357. }
  359. uint32_t ThriftHadoopFileSystem_chown_result::read(facebook::thrift::protocol::TProtocol* iprot) {
  361.   uint32_t xfer = 0;
  362.   std::string fname;
  363.   facebook::thrift::protocol::TType ftype;
  364.   int16_t fid;
  366.   xfer += iprot->readStructBegin(fname);
  368.   using facebook::thrift::protocol::TProtocolException;
  371.   while (true)
  372.   {
  373.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  374.     if (ftype == facebook::thrift::protocol::T_STOP) {
  375.       break;
  376.     }
  377.     switch (fid)
  378.     {
  379.       case 1:
  380.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  381.           xfer += this->ouch.read(iprot);
  382.           this->__isset.ouch = true;
  383.         } else {
  384.           xfer += iprot->skip(ftype);
  385.         }
  386.         break;
  387.       default:
  388.         xfer += iprot->skip(ftype);
  389.         break;
  390.     }
  391.     xfer += iprot->readFieldEnd();
  392.   }
  394.   xfer += iprot->readStructEnd();
  396.   return xfer;
  397. }
  399. uint32_t ThriftHadoopFileSystem_chown_result::write(facebook::thrift::protocol::TProtocol* oprot) const {
  401.   uint32_t xfer = 0;
  403.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_chown_result");
  405.   if (this->__isset.ouch) {
  406.     xfer += oprot->writeFieldBegin("ouch", facebook::thrift::protocol::T_STRUCT, 1);
  407.     xfer += this->ouch.write(oprot);
  408.     xfer += oprot->writeFieldEnd();
  409.   }
  410.   xfer += oprot->writeFieldStop();
  411.   xfer += oprot->writeStructEnd();
  412.   return xfer;
  413. }
  415. uint32_t ThriftHadoopFileSystem_chown_presult::read(facebook::thrift::protocol::TProtocol* iprot) {
  417.   uint32_t xfer = 0;
  418.   std::string fname;
  419.   facebook::thrift::protocol::TType ftype;
  420.   int16_t fid;
  422.   xfer += iprot->readStructBegin(fname);
  424.   using facebook::thrift::protocol::TProtocolException;
  427.   while (true)
  428.   {
  429.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  430.     if (ftype == facebook::thrift::protocol::T_STOP) {
  431.       break;
  432.     }
  433.     switch (fid)
  434.     {
  435.       case 1:
  436.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  437.           xfer += this->ouch.read(iprot);
  438.           this->__isset.ouch = true;
  439.         } else {
  440.           xfer += iprot->skip(ftype);
  441.         }
  442.         break;
  443.       default:
  444.         xfer += iprot->skip(ftype);
  445.         break;
  446.     }
  447.     xfer += iprot->readFieldEnd();
  448.   }
  450.   xfer += iprot->readStructEnd();
  452.   return xfer;
  453. }
  455. uint32_t ThriftHadoopFileSystem_setReplication_args::read(facebook::thrift::protocol::TProtocol* iprot) {
  457.   uint32_t xfer = 0;
  458.   std::string fname;
  459.   facebook::thrift::protocol::TType ftype;
  460.   int16_t fid;
  462.   xfer += iprot->readStructBegin(fname);
  464.   using facebook::thrift::protocol::TProtocolException;
  467.   while (true)
  468.   {
  469.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  470.     if (ftype == facebook::thrift::protocol::T_STOP) {
  471.       break;
  472.     }
  473.     switch (fid)
  474.     {
  475.       case 1:
  476.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  477.           xfer += this->path.read(iprot);
  478.           this->__isset.path = true;
  479.         } else {
  480.           xfer += iprot->skip(ftype);
  481.         }
  482.         break;
  483.       case 2:
  484.         if (ftype == facebook::thrift::protocol::T_I16) {
  485.           xfer += iprot->readI16(this->replication);
  486.           this->__isset.replication = true;
  487.         } else {
  488.           xfer += iprot->skip(ftype);
  489.         }
  490.         break;
  491.       default:
  492.         xfer += iprot->skip(ftype);
  493.         break;
  494.     }
  495.     xfer += iprot->readFieldEnd();
  496.   }
  498.   xfer += iprot->readStructEnd();
  500.   return xfer;
  501. }
  503. uint32_t ThriftHadoopFileSystem_setReplication_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  504.   uint32_t xfer = 0;
  505.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_setReplication_args");
  506.   xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRUCT, 1);
  507.   xfer += this->path.write(oprot);
  508.   xfer += oprot->writeFieldEnd();
  509.   xfer += oprot->writeFieldBegin("replication", facebook::thrift::protocol::T_I16, 2);
  510.   xfer += oprot->writeI16(this->replication);
  511.   xfer += oprot->writeFieldEnd();
  512.   xfer += oprot->writeFieldStop();
  513.   xfer += oprot->writeStructEnd();
  514.   return xfer;
  515. }
  517. uint32_t ThriftHadoopFileSystem_setReplication_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  518.   uint32_t xfer = 0;
  519.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_setReplication_pargs");
  520.   xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRUCT, 1);
  521.   xfer += (*(this->path)).write(oprot);
  522.   xfer += oprot->writeFieldEnd();
  523.   xfer += oprot->writeFieldBegin("replication", facebook::thrift::protocol::T_I16, 2);
  524.   xfer += oprot->writeI16((*(this->replication)));
  525.   xfer += oprot->writeFieldEnd();
  526.   xfer += oprot->writeFieldStop();
  527.   xfer += oprot->writeStructEnd();
  528.   return xfer;
  529. }
  531. uint32_t ThriftHadoopFileSystem_setReplication_result::read(facebook::thrift::protocol::TProtocol* iprot) {
  533.   uint32_t xfer = 0;
  534.   std::string fname;
  535.   facebook::thrift::protocol::TType ftype;
  536.   int16_t fid;
  538.   xfer += iprot->readStructBegin(fname);
  540.   using facebook::thrift::protocol::TProtocolException;
  543.   while (true)
  544.   {
  545.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  546.     if (ftype == facebook::thrift::protocol::T_STOP) {
  547.       break;
  548.     }
  549.     switch (fid)
  550.     {
  551.       case 1:
  552.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  553.           xfer += this->ouch.read(iprot);
  554.           this->__isset.ouch = true;
  555.         } else {
  556.           xfer += iprot->skip(ftype);
  557.         }
  558.         break;
  559.       default:
  560.         xfer += iprot->skip(ftype);
  561.         break;
  562.     }
  563.     xfer += iprot->readFieldEnd();
  564.   }
  566.   xfer += iprot->readStructEnd();
  568.   return xfer;
  569. }
  571. uint32_t ThriftHadoopFileSystem_setReplication_result::write(facebook::thrift::protocol::TProtocol* oprot) const {
  573.   uint32_t xfer = 0;
  575.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_setReplication_result");
  577.   if (this->__isset.ouch) {
  578.     xfer += oprot->writeFieldBegin("ouch", facebook::thrift::protocol::T_STRUCT, 1);
  579.     xfer += this->ouch.write(oprot);
  580.     xfer += oprot->writeFieldEnd();
  581.   }
  582.   xfer += oprot->writeFieldStop();
  583.   xfer += oprot->writeStructEnd();
  584.   return xfer;
  585. }
  587. uint32_t ThriftHadoopFileSystem_setReplication_presult::read(facebook::thrift::protocol::TProtocol* iprot) {
  589.   uint32_t xfer = 0;
  590.   std::string fname;
  591.   facebook::thrift::protocol::TType ftype;
  592.   int16_t fid;
  594.   xfer += iprot->readStructBegin(fname);
  596.   using facebook::thrift::protocol::TProtocolException;
  599.   while (true)
  600.   {
  601.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  602.     if (ftype == facebook::thrift::protocol::T_STOP) {
  603.       break;
  604.     }
  605.     switch (fid)
  606.     {
  607.       case 1:
  608.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  609.           xfer += this->ouch.read(iprot);
  610.           this->__isset.ouch = true;
  611.         } else {
  612.           xfer += iprot->skip(ftype);
  613.         }
  614.         break;
  615.       default:
  616.         xfer += iprot->skip(ftype);
  617.         break;
  618.     }
  619.     xfer += iprot->readFieldEnd();
  620.   }
  622.   xfer += iprot->readStructEnd();
  624.   return xfer;
  625. }
  627. uint32_t ThriftHadoopFileSystem_getFileBlockLocations_args::read(facebook::thrift::protocol::TProtocol* iprot) {
  629.   uint32_t xfer = 0;
  630.   std::string fname;
  631.   facebook::thrift::protocol::TType ftype;
  632.   int16_t fid;
  634.   xfer += iprot->readStructBegin(fname);
  636.   using facebook::thrift::protocol::TProtocolException;
  639.   while (true)
  640.   {
  641.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  642.     if (ftype == facebook::thrift::protocol::T_STOP) {
  643.       break;
  644.     }
  645.     switch (fid)
  646.     {
  647.       case 1:
  648.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  649.           xfer += this->path.read(iprot);
  650.           this->__isset.path = true;
  651.         } else {
  652.           xfer += iprot->skip(ftype);
  653.         }
  654.         break;
  655.       case 2:
  656.         if (ftype == facebook::thrift::protocol::T_I64) {
  657.           xfer += iprot->readI64(this->start);
  658.           this->__isset.start = true;
  659.         } else {
  660.           xfer += iprot->skip(ftype);
  661.         }
  662.         break;
  663.       case 3:
  664.         if (ftype == facebook::thrift::protocol::T_I64) {
  665.           xfer += iprot->readI64(this->length);
  666.           this->__isset.length = true;
  667.         } else {
  668.           xfer += iprot->skip(ftype);
  669.         }
  670.         break;
  671.       default:
  672.         xfer += iprot->skip(ftype);
  673.         break;
  674.     }
  675.     xfer += iprot->readFieldEnd();
  676.   }
  678.   xfer += iprot->readStructEnd();
  680.   return xfer;
  681. }
  683. uint32_t ThriftHadoopFileSystem_getFileBlockLocations_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  684.   uint32_t xfer = 0;
  685.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_getFileBlockLocations_args");
  686.   xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRUCT, 1);
  687.   xfer += this->path.write(oprot);
  688.   xfer += oprot->writeFieldEnd();
  689.   xfer += oprot->writeFieldBegin("start", facebook::thrift::protocol::T_I64, 2);
  690.   xfer += oprot->writeI64(this->start);
  691.   xfer += oprot->writeFieldEnd();
  692.   xfer += oprot->writeFieldBegin("length", facebook::thrift::protocol::T_I64, 3);
  693.   xfer += oprot->writeI64(this->length);
  694.   xfer += oprot->writeFieldEnd();
  695.   xfer += oprot->writeFieldStop();
  696.   xfer += oprot->writeStructEnd();
  697.   return xfer;
  698. }
  700. uint32_t ThriftHadoopFileSystem_getFileBlockLocations_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  701.   uint32_t xfer = 0;
  702.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_getFileBlockLocations_pargs");
  703.   xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRUCT, 1);
  704.   xfer += (*(this->path)).write(oprot);
  705.   xfer += oprot->writeFieldEnd();
  706.   xfer += oprot->writeFieldBegin("start", facebook::thrift::protocol::T_I64, 2);
  707.   xfer += oprot->writeI64((*(this->start)));
  708.   xfer += oprot->writeFieldEnd();
  709.   xfer += oprot->writeFieldBegin("length", facebook::thrift::protocol::T_I64, 3);
  710.   xfer += oprot->writeI64((*(this->length)));
  711.   xfer += oprot->writeFieldEnd();
  712.   xfer += oprot->writeFieldStop();
  713.   xfer += oprot->writeStructEnd();
  714.   return xfer;
  715. }
  717. uint32_t ThriftHadoopFileSystem_getFileBlockLocations_result::read(facebook::thrift::protocol::TProtocol* iprot) {
  719.   uint32_t xfer = 0;
  720.   std::string fname;
  721.   facebook::thrift::protocol::TType ftype;
  722.   int16_t fid;
  724.   xfer += iprot->readStructBegin(fname);
  726.   using facebook::thrift::protocol::TProtocolException;
  729.   while (true)
  730.   {
  731.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  732.     if (ftype == facebook::thrift::protocol::T_STOP) {
  733.       break;
  734.     }
  735.     switch (fid)
  736.     {
  737.       case 0:
  738.         if (ftype == facebook::thrift::protocol::T_LIST) {
  739.           {
  740.             this->success.clear();
  741.             uint32_t _size23;
  742.             facebook::thrift::protocol::TType _etype26;
  743.             iprot->readListBegin(_etype26, _size23);
  744.             this->success.resize(_size23);
  745.             uint32_t _i27;
  746.             for (_i27 = 0; _i27 < _size23; ++_i27)
  747.             {
  748.               xfer += this->success[_i27].read(iprot);
  749.             }
  750.             iprot->readListEnd();
  751.           }
  752.           this->__isset.success = true;
  753.         } else {
  754.           xfer += iprot->skip(ftype);
  755.         }
  756.         break;
  757.       case 1:
  758.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  759.           xfer += this->ouch.read(iprot);
  760.           this->__isset.ouch = true;
  761.         } else {
  762.           xfer += iprot->skip(ftype);
  763.         }
  764.         break;
  765.       default:
  766.         xfer += iprot->skip(ftype);
  767.         break;
  768.     }
  769.     xfer += iprot->readFieldEnd();
  770.   }
  772.   xfer += iprot->readStructEnd();
  774.   return xfer;
  775. }
  777. uint32_t ThriftHadoopFileSystem_getFileBlockLocations_result::write(facebook::thrift::protocol::TProtocol* oprot) const {
  779.   uint32_t xfer = 0;
  781.   xfer += oprot->writeStructBegin("ThriftHadoopFileSystem_getFileBlockLocations_result");
  783.   if (this->__isset.success) {
  784.     xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_LIST, 0);
  785.     {
  786.       xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->success.size());
  787.       std::vector<BlockLocation> ::const_iterator _iter28;
  788.       for (_iter28 = this->success.begin(); _iter28 != this->success.end(); ++_iter28)
  789.       {
  790.         xfer += (*_iter28).write(oprot);
  791.       }
  792.       xfer += oprot->writeListEnd();
  793.     }
  794.     xfer += oprot->writeFieldEnd();
  795.   } else if (this->__isset.ouch) {
  796.     xfer += oprot->writeFieldBegin("ouch", facebook::thrift::protocol::T_STRUCT, 1);
  797.     xfer += this->ouch.write(oprot);
  798.     xfer += oprot->writeFieldEnd();
  799.   }
  800.   xfer += oprot->writeFieldStop();
  801.   xfer += oprot->writeStructEnd();
  802.   return xfer;
  803. }
  805. uint32_t ThriftHadoopFileSystem_getFileBlockLocations_presult::read(facebook::thrift::protocol::TProtocol* iprot) {
  807.   uint32_t xfer = 0;
  808.   std::string fname;
  809.   facebook::thrift::protocol::TType ftype;
  810.   int16_t fid;
  812.   xfer += iprot->readStructBegin(fname);
  814.   using facebook::thrift::protocol::TProtocolException;
  817.   while (true)
  818.   {
  819.     xfer += iprot->readFieldBegin(fname, ftype, fid);
  820.     if (ftype == facebook::thrift::protocol::T_STOP) {
  821.       break;
  822.     }
  823.     switch (fid)
  824.     {
  825.       case 0:
  826.         if (ftype == facebook::thrift::protocol::T_LIST) {
  827.           {
  828.             (*(this->success)).clear();
  829.             uint32_t _size29;
  830.             facebook::thrift::protocol::TType _etype32;
  831.             iprot->readListBegin(_etype32, _size29);
  832.             (*(this->success)).resize(_size29);
  833.             uint32_t _i33;
  834.             for (_i33 = 0; _i33 < _size29; ++_i33)
  835.             {
  836.               xfer += (*(this->success))[_i33].read(iprot);
  837.             }
  838.             iprot->readListEnd();
  839.           }
  840.           this->__isset.success = true;
  841.         } else {
  842.           xfer += iprot->skip(ftype);
  843.         }
  844.         break;
  845.       case 1:
  846.         if (ftype == facebook::thrift::protocol::T_STRUCT) {
  847.           xfer += this->ouch.read(iprot);
  848.           this->__isset.ouch = true;
  849.         } else {
  850.           xfer += iprot->skip(ftype);
  851.         }
  852.         break;
  853.       default:
  854.         xfer += iprot->skip(ftype);
  855.         break;
  856.     }
  857.     xfer += iprot->readFieldEnd();
  858.   }
  860.   xfer += iprot->readStructEnd();
  862.   return xfer;
  863. }
  865. void ThriftHadoopFileSystemClient::setInactivityTimeoutPeriod(const int64_t periodInSeconds)
  866. {
  867.   send_setInactivityTimeoutPeriod(periodInSeconds);
  868.   recv_setInactivityTimeoutPeriod();
  869. }
  871. void ThriftHadoopFileSystemClient::send_setInactivityTimeoutPeriod(const int64_t periodInSeconds)
  872. {
  873.   int32_t cseqid = 0;
  874.   oprot_->writeMessageBegin("setInactivityTimeoutPeriod", facebook::thrift::protocol::T_CALL, cseqid);
  876.   ThriftHadoopFileSystem_setInactivityTimeoutPeriod_pargs args;
  877.   args.periodInSeconds = &periodInSeconds;
  878.   args.write(oprot_);
  880.   oprot_->writeMessageEnd();
  881.   oprot_->getTransport()->flush();
  882.   oprot_->getTransport()->writeEnd();
  883. }
  885. void ThriftHadoopFileSystemClient::recv_setInactivityTimeoutPeriod()
  886. {
  888.   int32_t rseqid = 0;
  889.   std::string fname;
  890.   facebook::thrift::protocol::TMessageType mtype;
  892.   iprot_->readMessageBegin(fname, mtype, rseqid);
  893.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  894.     facebook::thrift::TApplicationException x;
  895.     x.read(iprot_);
  896.     iprot_->readMessageEnd();
  897.     iprot_->getTransport()->readEnd();
  898.     throw x;
  899.   }
  900.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  901.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  902.     iprot_->readMessageEnd();
  903.     iprot_->getTransport()->readEnd();
  904.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  905.   }
  906.   if (fname.compare("setInactivityTimeoutPeriod") != 0) {
  907.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  908.     iprot_->readMessageEnd();
  909.     iprot_->getTransport()->readEnd();
  910.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  911.   }
  912.   ThriftHadoopFileSystem_setInactivityTimeoutPeriod_presult result;
  913.   result.read(iprot_);
  914.   iprot_->readMessageEnd();
  915.   iprot_->getTransport()->readEnd();
  917.   return;
  918. }
  920. void ThriftHadoopFileSystemClient::shutdown(const int32_t status)
  921. {
  922.   send_shutdown(status);
  923.   recv_shutdown();
  924. }
  926. void ThriftHadoopFileSystemClient::send_shutdown(const int32_t status)
  927. {
  928.   int32_t cseqid = 0;
  929.   oprot_->writeMessageBegin("shutdown", facebook::thrift::protocol::T_CALL, cseqid);
  931.   ThriftHadoopFileSystem_shutdown_pargs args;
  932.   args.status = &status;
  933.   args.write(oprot_);
  935.   oprot_->writeMessageEnd();
  936.   oprot_->getTransport()->flush();
  937.   oprot_->getTransport()->writeEnd();
  938. }
  940. void ThriftHadoopFileSystemClient::recv_shutdown()
  941. {
  943.   int32_t rseqid = 0;
  944.   std::string fname;
  945.   facebook::thrift::protocol::TMessageType mtype;
  947.   iprot_->readMessageBegin(fname, mtype, rseqid);
  948.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  949.     facebook::thrift::TApplicationException x;
  950.     x.read(iprot_);
  951.     iprot_->readMessageEnd();
  952.     iprot_->getTransport()->readEnd();
  953.     throw x;
  954.   }
  955.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  956.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  957.     iprot_->readMessageEnd();
  958.     iprot_->getTransport()->readEnd();
  959.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  960.   }
  961.   if (fname.compare("shutdown") != 0) {
  962.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  963.     iprot_->readMessageEnd();
  964.     iprot_->getTransport()->readEnd();
  965.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  966.   }
  967.   ThriftHadoopFileSystem_shutdown_presult result;
  968.   result.read(iprot_);
  969.   iprot_->readMessageEnd();
  970.   iprot_->getTransport()->readEnd();
  972.   return;
  973. }
  975. void ThriftHadoopFileSystemClient::create(ThriftHandle& _return, const Pathname& path)
  976. {
  977.   send_create(path);
  978.   recv_create(_return);
  979. }
  981. void ThriftHadoopFileSystemClient::send_create(const Pathname& path)
  982. {
  983.   int32_t cseqid = 0;
  984.   oprot_->writeMessageBegin("create", facebook::thrift::protocol::T_CALL, cseqid);
  986.   ThriftHadoopFileSystem_create_pargs args;
  987.   args.path = &path;
  988.   args.write(oprot_);
  990.   oprot_->writeMessageEnd();
  991.   oprot_->getTransport()->flush();
  992.   oprot_->getTransport()->writeEnd();
  993. }
  995. void ThriftHadoopFileSystemClient::recv_create(ThriftHandle& _return)
  996. {
  998.   int32_t rseqid = 0;
  999.   std::string fname;
  1000.   facebook::thrift::protocol::TMessageType mtype;
  1002.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1003.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1004.     facebook::thrift::TApplicationException x;
  1005.     x.read(iprot_);
  1006.     iprot_->readMessageEnd();
  1007.     iprot_->getTransport()->readEnd();
  1008.     throw x;
  1009.   }
  1010.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1011.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1012.     iprot_->readMessageEnd();
  1013.     iprot_->getTransport()->readEnd();
  1014.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1015.   }
  1016.   if (fname.compare("create") != 0) {
  1017.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1018.     iprot_->readMessageEnd();
  1019.     iprot_->getTransport()->readEnd();
  1020.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1021.   }
  1022.   ThriftHadoopFileSystem_create_presult result;
  1023.   result.success = &_return;
  1024.   result.read(iprot_);
  1025.   iprot_->readMessageEnd();
  1026.   iprot_->getTransport()->readEnd();
  1028.   if (result.__isset.success) {
  1029.     // _return pointer has now been filled
  1030.     return;
  1031.   }
  1032.   if (result.__isset.ouch) {
  1033.     throw result.ouch;
  1034.   }
  1035.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "create failed: unknown result");
  1036. }
  1038. void ThriftHadoopFileSystemClient::createFile(ThriftHandle& _return, const Pathname& path, const int16_t mode, const bool overwrite, const int32_t bufferSize, const int16_t block_replication, const int64_t blocksize)
  1039. {
  1040.   send_createFile(path, mode, overwrite, bufferSize, block_replication, blocksize);
  1041.   recv_createFile(_return);
  1042. }
  1044. void ThriftHadoopFileSystemClient::send_createFile(const Pathname& path, const int16_t mode, const bool overwrite, const int32_t bufferSize, const int16_t block_replication, const int64_t blocksize)
  1045. {
  1046.   int32_t cseqid = 0;
  1047.   oprot_->writeMessageBegin("createFile", facebook::thrift::protocol::T_CALL, cseqid);
  1049.   ThriftHadoopFileSystem_createFile_pargs args;
  1050.   args.path = &path;
  1051.   args.mode = &mode;
  1052.   args.overwrite = &overwrite;
  1053.   args.bufferSize = &bufferSize;
  1054.   args.block_replication = &block_replication;
  1055.   args.blocksize = &blocksize;
  1056.   args.write(oprot_);
  1058.   oprot_->writeMessageEnd();
  1059.   oprot_->getTransport()->flush();
  1060.   oprot_->getTransport()->writeEnd();
  1061. }
  1063. void ThriftHadoopFileSystemClient::recv_createFile(ThriftHandle& _return)
  1064. {
  1066.   int32_t rseqid = 0;
  1067.   std::string fname;
  1068.   facebook::thrift::protocol::TMessageType mtype;
  1070.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1071.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1072.     facebook::thrift::TApplicationException x;
  1073.     x.read(iprot_);
  1074.     iprot_->readMessageEnd();
  1075.     iprot_->getTransport()->readEnd();
  1076.     throw x;
  1077.   }
  1078.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1079.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1080.     iprot_->readMessageEnd();
  1081.     iprot_->getTransport()->readEnd();
  1082.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1083.   }
  1084.   if (fname.compare("createFile") != 0) {
  1085.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1086.     iprot_->readMessageEnd();
  1087.     iprot_->getTransport()->readEnd();
  1088.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1089.   }
  1090.   ThriftHadoopFileSystem_createFile_presult result;
  1091.   result.success = &_return;
  1092.   result.read(iprot_);
  1093.   iprot_->readMessageEnd();
  1094.   iprot_->getTransport()->readEnd();
  1096.   if (result.__isset.success) {
  1097.     // _return pointer has now been filled
  1098.     return;
  1099.   }
  1100.   if (result.__isset.ouch) {
  1101.     throw result.ouch;
  1102.   }
  1103.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "createFile failed: unknown result");
  1104. }
  1106. void ThriftHadoopFileSystemClient::open(ThriftHandle& _return, const Pathname& path)
  1107. {
  1108.   send_open(path);
  1109.   recv_open(_return);
  1110. }
  1112. void ThriftHadoopFileSystemClient::send_open(const Pathname& path)
  1113. {
  1114.   int32_t cseqid = 0;
  1115.   oprot_->writeMessageBegin("open", facebook::thrift::protocol::T_CALL, cseqid);
  1117.   ThriftHadoopFileSystem_open_pargs args;
  1118.   args.path = &path;
  1119.   args.write(oprot_);
  1121.   oprot_->writeMessageEnd();
  1122.   oprot_->getTransport()->flush();
  1123.   oprot_->getTransport()->writeEnd();
  1124. }
  1126. void ThriftHadoopFileSystemClient::recv_open(ThriftHandle& _return)
  1127. {
  1129.   int32_t rseqid = 0;
  1130.   std::string fname;
  1131.   facebook::thrift::protocol::TMessageType mtype;
  1133.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1134.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1135.     facebook::thrift::TApplicationException x;
  1136.     x.read(iprot_);
  1137.     iprot_->readMessageEnd();
  1138.     iprot_->getTransport()->readEnd();
  1139.     throw x;
  1140.   }
  1141.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1142.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1143.     iprot_->readMessageEnd();
  1144.     iprot_->getTransport()->readEnd();
  1145.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1146.   }
  1147.   if (fname.compare("open") != 0) {
  1148.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1149.     iprot_->readMessageEnd();
  1150.     iprot_->getTransport()->readEnd();
  1151.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1152.   }
  1153.   ThriftHadoopFileSystem_open_presult result;
  1154.   result.success = &_return;
  1155.   result.read(iprot_);
  1156.   iprot_->readMessageEnd();
  1157.   iprot_->getTransport()->readEnd();
  1159.   if (result.__isset.success) {
  1160.     // _return pointer has now been filled
  1161.     return;
  1162.   }
  1163.   if (result.__isset.ouch) {
  1164.     throw result.ouch;
  1165.   }
  1166.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "open failed: unknown result");
  1167. }
  1169. void ThriftHadoopFileSystemClient::append(ThriftHandle& _return, const Pathname& path)
  1170. {
  1171.   send_append(path);
  1172.   recv_append(_return);
  1173. }
  1175. void ThriftHadoopFileSystemClient::send_append(const Pathname& path)
  1176. {
  1177.   int32_t cseqid = 0;
  1178.   oprot_->writeMessageBegin("append", facebook::thrift::protocol::T_CALL, cseqid);
  1180.   ThriftHadoopFileSystem_append_pargs args;
  1181.   args.path = &path;
  1182.   args.write(oprot_);
  1184.   oprot_->writeMessageEnd();
  1185.   oprot_->getTransport()->flush();
  1186.   oprot_->getTransport()->writeEnd();
  1187. }
  1189. void ThriftHadoopFileSystemClient::recv_append(ThriftHandle& _return)
  1190. {
  1192.   int32_t rseqid = 0;
  1193.   std::string fname;
  1194.   facebook::thrift::protocol::TMessageType mtype;
  1196.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1197.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1198.     facebook::thrift::TApplicationException x;
  1199.     x.read(iprot_);
  1200.     iprot_->readMessageEnd();
  1201.     iprot_->getTransport()->readEnd();
  1202.     throw x;
  1203.   }
  1204.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1205.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1206.     iprot_->readMessageEnd();
  1207.     iprot_->getTransport()->readEnd();
  1208.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1209.   }
  1210.   if (fname.compare("append") != 0) {
  1211.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1212.     iprot_->readMessageEnd();
  1213.     iprot_->getTransport()->readEnd();
  1214.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1215.   }
  1216.   ThriftHadoopFileSystem_append_presult result;
  1217.   result.success = &_return;
  1218.   result.read(iprot_);
  1219.   iprot_->readMessageEnd();
  1220.   iprot_->getTransport()->readEnd();
  1222.   if (result.__isset.success) {
  1223.     // _return pointer has now been filled
  1224.     return;
  1225.   }
  1226.   if (result.__isset.ouch) {
  1227.     throw result.ouch;
  1228.   }
  1229.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "append failed: unknown result");
  1230. }
  1232. bool ThriftHadoopFileSystemClient::write(const ThriftHandle& handle, const std::string& data)
  1233. {
  1234.   send_write(handle, data);
  1235.   return recv_write();
  1236. }
  1238. void ThriftHadoopFileSystemClient::send_write(const ThriftHandle& handle, const std::string& data)
  1239. {
  1240.   int32_t cseqid = 0;
  1241.   oprot_->writeMessageBegin("write", facebook::thrift::protocol::T_CALL, cseqid);
  1243.   ThriftHadoopFileSystem_write_pargs args;
  1244.   args.handle = &handle;
  1245.   args.data = &data;
  1246.   args.write(oprot_);
  1248.   oprot_->writeMessageEnd();
  1249.   oprot_->getTransport()->flush();
  1250.   oprot_->getTransport()->writeEnd();
  1251. }
  1253. bool ThriftHadoopFileSystemClient::recv_write()
  1254. {
  1256.   int32_t rseqid = 0;
  1257.   std::string fname;
  1258.   facebook::thrift::protocol::TMessageType mtype;
  1260.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1261.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1262.     facebook::thrift::TApplicationException x;
  1263.     x.read(iprot_);
  1264.     iprot_->readMessageEnd();
  1265.     iprot_->getTransport()->readEnd();
  1266.     throw x;
  1267.   }
  1268.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1269.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1270.     iprot_->readMessageEnd();
  1271.     iprot_->getTransport()->readEnd();
  1272.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1273.   }
  1274.   if (fname.compare("write") != 0) {
  1275.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1276.     iprot_->readMessageEnd();
  1277.     iprot_->getTransport()->readEnd();
  1278.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1279.   }
  1280.   bool _return;
  1281.   ThriftHadoopFileSystem_write_presult result;
  1282.   result.success = &_return;
  1283.   result.read(iprot_);
  1284.   iprot_->readMessageEnd();
  1285.   iprot_->getTransport()->readEnd();
  1287.   if (result.__isset.success) {
  1288.     return _return;
  1289.   }
  1290.   if (result.__isset.ouch) {
  1291.     throw result.ouch;
  1292.   }
  1293.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "write failed: unknown result");
  1294. }
  1296. void ThriftHadoopFileSystemClient::read(std::string& _return, const ThriftHandle& handle, const int64_t offset, const int32_t size)
  1297. {
  1298.   send_read(handle, offset, size);
  1299.   recv_read(_return);
  1300. }
  1302. void ThriftHadoopFileSystemClient::send_read(const ThriftHandle& handle, const int64_t offset, const int32_t size)
  1303. {
  1304.   int32_t cseqid = 0;
  1305.   oprot_->writeMessageBegin("read", facebook::thrift::protocol::T_CALL, cseqid);
  1307.   ThriftHadoopFileSystem_read_pargs args;
  1308.   args.handle = &handle;
  1309.   args.offset = &offset;
  1310.   args.size = &size;
  1311.   args.write(oprot_);
  1313.   oprot_->writeMessageEnd();
  1314.   oprot_->getTransport()->flush();
  1315.   oprot_->getTransport()->writeEnd();
  1316. }
  1318. void ThriftHadoopFileSystemClient::recv_read(std::string& _return)
  1319. {
  1321.   int32_t rseqid = 0;
  1322.   std::string fname;
  1323.   facebook::thrift::protocol::TMessageType mtype;
  1325.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1326.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1327.     facebook::thrift::TApplicationException x;
  1328.     x.read(iprot_);
  1329.     iprot_->readMessageEnd();
  1330.     iprot_->getTransport()->readEnd();
  1331.     throw x;
  1332.   }
  1333.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1334.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1335.     iprot_->readMessageEnd();
  1336.     iprot_->getTransport()->readEnd();
  1337.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1338.   }
  1339.   if (fname.compare("read") != 0) {
  1340.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1341.     iprot_->readMessageEnd();
  1342.     iprot_->getTransport()->readEnd();
  1343.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1344.   }
  1345.   ThriftHadoopFileSystem_read_presult result;
  1346.   result.success = &_return;
  1347.   result.read(iprot_);
  1348.   iprot_->readMessageEnd();
  1349.   iprot_->getTransport()->readEnd();
  1351.   if (result.__isset.success) {
  1352.     // _return pointer has now been filled
  1353.     return;
  1354.   }
  1355.   if (result.__isset.ouch) {
  1356.     throw result.ouch;
  1357.   }
  1358.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "read failed: unknown result");
  1359. }
  1361. bool ThriftHadoopFileSystemClient::close(const ThriftHandle& out)
  1362. {
  1363.   send_close(out);
  1364.   return recv_close();
  1365. }
  1367. void ThriftHadoopFileSystemClient::send_close(const ThriftHandle& out)
  1368. {
  1369.   int32_t cseqid = 0;
  1370.   oprot_->writeMessageBegin("close", facebook::thrift::protocol::T_CALL, cseqid);
  1372.   ThriftHadoopFileSystem_close_pargs args;
  1373.   args.out = &out;
  1374.   args.write(oprot_);
  1376.   oprot_->writeMessageEnd();
  1377.   oprot_->getTransport()->flush();
  1378.   oprot_->getTransport()->writeEnd();
  1379. }
  1381. bool ThriftHadoopFileSystemClient::recv_close()
  1382. {
  1384.   int32_t rseqid = 0;
  1385.   std::string fname;
  1386.   facebook::thrift::protocol::TMessageType mtype;
  1388.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1389.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1390.     facebook::thrift::TApplicationException x;
  1391.     x.read(iprot_);
  1392.     iprot_->readMessageEnd();
  1393.     iprot_->getTransport()->readEnd();
  1394.     throw x;
  1395.   }
  1396.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1397.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1398.     iprot_->readMessageEnd();
  1399.     iprot_->getTransport()->readEnd();
  1400.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1401.   }
  1402.   if (fname.compare("close") != 0) {
  1403.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1404.     iprot_->readMessageEnd();
  1405.     iprot_->getTransport()->readEnd();
  1406.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1407.   }
  1408.   bool _return;
  1409.   ThriftHadoopFileSystem_close_presult result;
  1410.   result.success = &_return;
  1411.   result.read(iprot_);
  1412.   iprot_->readMessageEnd();
  1413.   iprot_->getTransport()->readEnd();
  1415.   if (result.__isset.success) {
  1416.     return _return;
  1417.   }
  1418.   if (result.__isset.ouch) {
  1419.     throw result.ouch;
  1420.   }
  1421.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "close failed: unknown result");
  1422. }
  1424. bool ThriftHadoopFileSystemClient::rm(const Pathname& path, const bool recursive)
  1425. {
  1426.   send_rm(path, recursive);
  1427.   return recv_rm();
  1428. }
  1430. void ThriftHadoopFileSystemClient::send_rm(const Pathname& path, const bool recursive)
  1431. {
  1432.   int32_t cseqid = 0;
  1433.   oprot_->writeMessageBegin("rm", facebook::thrift::protocol::T_CALL, cseqid);
  1435.   ThriftHadoopFileSystem_rm_pargs args;
  1436.   args.path = &path;
  1437.   args.recursive = &recursive;
  1438.   args.write(oprot_);
  1440.   oprot_->writeMessageEnd();
  1441.   oprot_->getTransport()->flush();
  1442.   oprot_->getTransport()->writeEnd();
  1443. }
  1445. bool ThriftHadoopFileSystemClient::recv_rm()
  1446. {
  1448.   int32_t rseqid = 0;
  1449.   std::string fname;
  1450.   facebook::thrift::protocol::TMessageType mtype;
  1452.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1453.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1454.     facebook::thrift::TApplicationException x;
  1455.     x.read(iprot_);
  1456.     iprot_->readMessageEnd();
  1457.     iprot_->getTransport()->readEnd();
  1458.     throw x;
  1459.   }
  1460.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1461.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1462.     iprot_->readMessageEnd();
  1463.     iprot_->getTransport()->readEnd();
  1464.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1465.   }
  1466.   if (fname.compare("rm") != 0) {
  1467.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1468.     iprot_->readMessageEnd();
  1469.     iprot_->getTransport()->readEnd();
  1470.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1471.   }
  1472.   bool _return;
  1473.   ThriftHadoopFileSystem_rm_presult result;
  1474.   result.success = &_return;
  1475.   result.read(iprot_);
  1476.   iprot_->readMessageEnd();
  1477.   iprot_->getTransport()->readEnd();
  1479.   if (result.__isset.success) {
  1480.     return _return;
  1481.   }
  1482.   if (result.__isset.ouch) {
  1483.     throw result.ouch;
  1484.   }
  1485.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "rm failed: unknown result");
  1486. }
  1488. bool ThriftHadoopFileSystemClient::rename(const Pathname& path, const Pathname& dest)
  1489. {
  1490.   send_rename(path, dest);
  1491.   return recv_rename();
  1492. }
  1494. void ThriftHadoopFileSystemClient::send_rename(const Pathname& path, const Pathname& dest)
  1495. {
  1496.   int32_t cseqid = 0;
  1497.   oprot_->writeMessageBegin("rename", facebook::thrift::protocol::T_CALL, cseqid);
  1499.   ThriftHadoopFileSystem_rename_pargs args;
  1500.   args.path = &path;
  1501.   args.dest = &dest;
  1502.   args.write(oprot_);
  1504.   oprot_->writeMessageEnd();
  1505.   oprot_->getTransport()->flush();
  1506.   oprot_->getTransport()->writeEnd();
  1507. }
  1509. bool ThriftHadoopFileSystemClient::recv_rename()
  1510. {
  1512.   int32_t rseqid = 0;
  1513.   std::string fname;
  1514.   facebook::thrift::protocol::TMessageType mtype;
  1516.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1517.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1518.     facebook::thrift::TApplicationException x;
  1519.     x.read(iprot_);
  1520.     iprot_->readMessageEnd();
  1521.     iprot_->getTransport()->readEnd();
  1522.     throw x;
  1523.   }
  1524.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1525.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1526.     iprot_->readMessageEnd();
  1527.     iprot_->getTransport()->readEnd();
  1528.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1529.   }
  1530.   if (fname.compare("rename") != 0) {
  1531.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1532.     iprot_->readMessageEnd();
  1533.     iprot_->getTransport()->readEnd();
  1534.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1535.   }
  1536.   bool _return;
  1537.   ThriftHadoopFileSystem_rename_presult result;
  1538.   result.success = &_return;
  1539.   result.read(iprot_);
  1540.   iprot_->readMessageEnd();
  1541.   iprot_->getTransport()->readEnd();
  1543.   if (result.__isset.success) {
  1544.     return _return;
  1545.   }
  1546.   if (result.__isset.ouch) {
  1547.     throw result.ouch;
  1548.   }
  1549.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "rename failed: unknown result");
  1550. }
  1552. bool ThriftHadoopFileSystemClient::mkdirs(const Pathname& path)
  1553. {
  1554.   send_mkdirs(path);
  1555.   return recv_mkdirs();
  1556. }
  1558. void ThriftHadoopFileSystemClient::send_mkdirs(const Pathname& path)
  1559. {
  1560.   int32_t cseqid = 0;
  1561.   oprot_->writeMessageBegin("mkdirs", facebook::thrift::protocol::T_CALL, cseqid);
  1563.   ThriftHadoopFileSystem_mkdirs_pargs args;
  1564.   args.path = &path;
  1565.   args.write(oprot_);
  1567.   oprot_->writeMessageEnd();
  1568.   oprot_->getTransport()->flush();
  1569.   oprot_->getTransport()->writeEnd();
  1570. }
  1572. bool ThriftHadoopFileSystemClient::recv_mkdirs()
  1573. {
  1575.   int32_t rseqid = 0;
  1576.   std::string fname;
  1577.   facebook::thrift::protocol::TMessageType mtype;
  1579.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1580.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1581.     facebook::thrift::TApplicationException x;
  1582.     x.read(iprot_);
  1583.     iprot_->readMessageEnd();
  1584.     iprot_->getTransport()->readEnd();
  1585.     throw x;
  1586.   }
  1587.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1588.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1589.     iprot_->readMessageEnd();
  1590.     iprot_->getTransport()->readEnd();
  1591.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1592.   }
  1593.   if (fname.compare("mkdirs") != 0) {
  1594.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1595.     iprot_->readMessageEnd();
  1596.     iprot_->getTransport()->readEnd();
  1597.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1598.   }
  1599.   bool _return;
  1600.   ThriftHadoopFileSystem_mkdirs_presult result;
  1601.   result.success = &_return;
  1602.   result.read(iprot_);
  1603.   iprot_->readMessageEnd();
  1604.   iprot_->getTransport()->readEnd();
  1606.   if (result.__isset.success) {
  1607.     return _return;
  1608.   }
  1609.   if (result.__isset.ouch) {
  1610.     throw result.ouch;
  1611.   }
  1612.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "mkdirs failed: unknown result");
  1613. }
  1615. bool ThriftHadoopFileSystemClient::exists(const Pathname& path)
  1616. {
  1617.   send_exists(path);
  1618.   return recv_exists();
  1619. }
  1621. void ThriftHadoopFileSystemClient::send_exists(const Pathname& path)
  1622. {
  1623.   int32_t cseqid = 0;
  1624.   oprot_->writeMessageBegin("exists", facebook::thrift::protocol::T_CALL, cseqid);
  1626.   ThriftHadoopFileSystem_exists_pargs args;
  1627.   args.path = &path;
  1628.   args.write(oprot_);
  1630.   oprot_->writeMessageEnd();
  1631.   oprot_->getTransport()->flush();
  1632.   oprot_->getTransport()->writeEnd();
  1633. }
  1635. bool ThriftHadoopFileSystemClient::recv_exists()
  1636. {
  1638.   int32_t rseqid = 0;
  1639.   std::string fname;
  1640.   facebook::thrift::protocol::TMessageType mtype;
  1642.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1643.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1644.     facebook::thrift::TApplicationException x;
  1645.     x.read(iprot_);
  1646.     iprot_->readMessageEnd();
  1647.     iprot_->getTransport()->readEnd();
  1648.     throw x;
  1649.   }
  1650.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1651.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1652.     iprot_->readMessageEnd();
  1653.     iprot_->getTransport()->readEnd();
  1654.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1655.   }
  1656.   if (fname.compare("exists") != 0) {
  1657.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1658.     iprot_->readMessageEnd();
  1659.     iprot_->getTransport()->readEnd();
  1660.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1661.   }
  1662.   bool _return;
  1663.   ThriftHadoopFileSystem_exists_presult result;
  1664.   result.success = &_return;
  1665.   result.read(iprot_);
  1666.   iprot_->readMessageEnd();
  1667.   iprot_->getTransport()->readEnd();
  1669.   if (result.__isset.success) {
  1670.     return _return;
  1671.   }
  1672.   if (result.__isset.ouch) {
  1673.     throw result.ouch;
  1674.   }
  1675.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "exists failed: unknown result");
  1676. }
  1678. void ThriftHadoopFileSystemClient::stat(FileStatus& _return, const Pathname& path)
  1679. {
  1680.   send_stat(path);
  1681.   recv_stat(_return);
  1682. }
  1684. void ThriftHadoopFileSystemClient::send_stat(const Pathname& path)
  1685. {
  1686.   int32_t cseqid = 0;
  1687.   oprot_->writeMessageBegin("stat", facebook::thrift::protocol::T_CALL, cseqid);
  1689.   ThriftHadoopFileSystem_stat_pargs args;
  1690.   args.path = &path;
  1691.   args.write(oprot_);
  1693.   oprot_->writeMessageEnd();
  1694.   oprot_->getTransport()->flush();
  1695.   oprot_->getTransport()->writeEnd();
  1696. }
  1698. void ThriftHadoopFileSystemClient::recv_stat(FileStatus& _return)
  1699. {
  1701.   int32_t rseqid = 0;
  1702.   std::string fname;
  1703.   facebook::thrift::protocol::TMessageType mtype;
  1705.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1706.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1707.     facebook::thrift::TApplicationException x;
  1708.     x.read(iprot_);
  1709.     iprot_->readMessageEnd();
  1710.     iprot_->getTransport()->readEnd();
  1711.     throw x;
  1712.   }
  1713.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1714.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1715.     iprot_->readMessageEnd();
  1716.     iprot_->getTransport()->readEnd();
  1717.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1718.   }
  1719.   if (fname.compare("stat") != 0) {
  1720.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1721.     iprot_->readMessageEnd();
  1722.     iprot_->getTransport()->readEnd();
  1723.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1724.   }
  1725.   ThriftHadoopFileSystem_stat_presult result;
  1726.   result.success = &_return;
  1727.   result.read(iprot_);
  1728.   iprot_->readMessageEnd();
  1729.   iprot_->getTransport()->readEnd();
  1731.   if (result.__isset.success) {
  1732.     // _return pointer has now been filled
  1733.     return;
  1734.   }
  1735.   if (result.__isset.ouch) {
  1736.     throw result.ouch;
  1737.   }
  1738.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "stat failed: unknown result");
  1739. }
  1741. void ThriftHadoopFileSystemClient::listStatus(std::vector<FileStatus> & _return, const Pathname& path)
  1742. {
  1743.   send_listStatus(path);
  1744.   recv_listStatus(_return);
  1745. }
  1747. void ThriftHadoopFileSystemClient::send_listStatus(const Pathname& path)
  1748. {
  1749.   int32_t cseqid = 0;
  1750.   oprot_->writeMessageBegin("listStatus", facebook::thrift::protocol::T_CALL, cseqid);
  1752.   ThriftHadoopFileSystem_listStatus_pargs args;
  1753.   args.path = &path;
  1754.   args.write(oprot_);
  1756.   oprot_->writeMessageEnd();
  1757.   oprot_->getTransport()->flush();
  1758.   oprot_->getTransport()->writeEnd();
  1759. }
  1761. void ThriftHadoopFileSystemClient::recv_listStatus(std::vector<FileStatus> & _return)
  1762. {
  1764.   int32_t rseqid = 0;
  1765.   std::string fname;
  1766.   facebook::thrift::protocol::TMessageType mtype;
  1768.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1769.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1770.     facebook::thrift::TApplicationException x;
  1771.     x.read(iprot_);
  1772.     iprot_->readMessageEnd();
  1773.     iprot_->getTransport()->readEnd();
  1774.     throw x;
  1775.   }
  1776.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1777.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1778.     iprot_->readMessageEnd();
  1779.     iprot_->getTransport()->readEnd();
  1780.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1781.   }
  1782.   if (fname.compare("listStatus") != 0) {
  1783.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1784.     iprot_->readMessageEnd();
  1785.     iprot_->getTransport()->readEnd();
  1786.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1787.   }
  1788.   ThriftHadoopFileSystem_listStatus_presult result;
  1789.   result.success = &_return;
  1790.   result.read(iprot_);
  1791.   iprot_->readMessageEnd();
  1792.   iprot_->getTransport()->readEnd();
  1794.   if (result.__isset.success) {
  1795.     // _return pointer has now been filled
  1796.     return;
  1797.   }
  1798.   if (result.__isset.ouch) {
  1799.     throw result.ouch;
  1800.   }
  1801.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "listStatus failed: unknown result");
  1802. }
  1804. void ThriftHadoopFileSystemClient::chmod(const Pathname& path, const int16_t mode)
  1805. {
  1806.   send_chmod(path, mode);
  1807.   recv_chmod();
  1808. }
  1810. void ThriftHadoopFileSystemClient::send_chmod(const Pathname& path, const int16_t mode)
  1811. {
  1812.   int32_t cseqid = 0;
  1813.   oprot_->writeMessageBegin("chmod", facebook::thrift::protocol::T_CALL, cseqid);
  1815.   ThriftHadoopFileSystem_chmod_pargs args;
  1816.   args.path = &path;
  1817.   args.mode = &mode;
  1818.   args.write(oprot_);
  1820.   oprot_->writeMessageEnd();
  1821.   oprot_->getTransport()->flush();
  1822.   oprot_->getTransport()->writeEnd();
  1823. }
  1825. void ThriftHadoopFileSystemClient::recv_chmod()
  1826. {
  1828.   int32_t rseqid = 0;
  1829.   std::string fname;
  1830.   facebook::thrift::protocol::TMessageType mtype;
  1832.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1833.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1834.     facebook::thrift::TApplicationException x;
  1835.     x.read(iprot_);
  1836.     iprot_->readMessageEnd();
  1837.     iprot_->getTransport()->readEnd();
  1838.     throw x;
  1839.   }
  1840.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1841.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1842.     iprot_->readMessageEnd();
  1843.     iprot_->getTransport()->readEnd();
  1844.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1845.   }
  1846.   if (fname.compare("chmod") != 0) {
  1847.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1848.     iprot_->readMessageEnd();
  1849.     iprot_->getTransport()->readEnd();
  1850.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1851.   }
  1852.   ThriftHadoopFileSystem_chmod_presult result;
  1853.   result.read(iprot_);
  1854.   iprot_->readMessageEnd();
  1855.   iprot_->getTransport()->readEnd();
  1857.   if (result.__isset.ouch) {
  1858.     throw result.ouch;
  1859.   }
  1860.   return;
  1861. }
  1863. void ThriftHadoopFileSystemClient::chown(const Pathname& path, const std::string& owner, const std::string& group)
  1864. {
  1865.   send_chown(path, owner, group);
  1866.   recv_chown();
  1867. }
  1869. void ThriftHadoopFileSystemClient::send_chown(const Pathname& path, const std::string& owner, const std::string& group)
  1870. {
  1871.   int32_t cseqid = 0;
  1872.   oprot_->writeMessageBegin("chown", facebook::thrift::protocol::T_CALL, cseqid);
  1874.   ThriftHadoopFileSystem_chown_pargs args;
  1875.   args.path = &path;
  1876.   args.owner = &owner;
  1877.   args.group = &group;
  1878.   args.write(oprot_);
  1880.   oprot_->writeMessageEnd();
  1881.   oprot_->getTransport()->flush();
  1882.   oprot_->getTransport()->writeEnd();
  1883. }
  1885. void ThriftHadoopFileSystemClient::recv_chown()
  1886. {
  1888.   int32_t rseqid = 0;
  1889.   std::string fname;
  1890.   facebook::thrift::protocol::TMessageType mtype;
  1892.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1893.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1894.     facebook::thrift::TApplicationException x;
  1895.     x.read(iprot_);
  1896.     iprot_->readMessageEnd();
  1897.     iprot_->getTransport()->readEnd();
  1898.     throw x;
  1899.   }
  1900.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1901.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1902.     iprot_->readMessageEnd();
  1903.     iprot_->getTransport()->readEnd();
  1904.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1905.   }
  1906.   if (fname.compare("chown") != 0) {
  1907.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1908.     iprot_->readMessageEnd();
  1909.     iprot_->getTransport()->readEnd();
  1910.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1911.   }
  1912.   ThriftHadoopFileSystem_chown_presult result;
  1913.   result.read(iprot_);
  1914.   iprot_->readMessageEnd();
  1915.   iprot_->getTransport()->readEnd();
  1917.   if (result.__isset.ouch) {
  1918.     throw result.ouch;
  1919.   }
  1920.   return;
  1921. }
  1923. void ThriftHadoopFileSystemClient::setReplication(const Pathname& path, const int16_t replication)
  1924. {
  1925.   send_setReplication(path, replication);
  1926.   recv_setReplication();
  1927. }
  1929. void ThriftHadoopFileSystemClient::send_setReplication(const Pathname& path, const int16_t replication)
  1930. {
  1931.   int32_t cseqid = 0;
  1932.   oprot_->writeMessageBegin("setReplication", facebook::thrift::protocol::T_CALL, cseqid);
  1934.   ThriftHadoopFileSystem_setReplication_pargs args;
  1935.   args.path = &path;
  1936.   args.replication = &replication;
  1937.   args.write(oprot_);
  1939.   oprot_->writeMessageEnd();
  1940.   oprot_->getTransport()->flush();
  1941.   oprot_->getTransport()->writeEnd();
  1942. }
  1944. void ThriftHadoopFileSystemClient::recv_setReplication()
  1945. {
  1947.   int32_t rseqid = 0;
  1948.   std::string fname;
  1949.   facebook::thrift::protocol::TMessageType mtype;
  1951.   iprot_->readMessageBegin(fname, mtype, rseqid);
  1952.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  1953.     facebook::thrift::TApplicationException x;
  1954.     x.read(iprot_);
  1955.     iprot_->readMessageEnd();
  1956.     iprot_->getTransport()->readEnd();
  1957.     throw x;
  1958.   }
  1959.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  1960.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1961.     iprot_->readMessageEnd();
  1962.     iprot_->getTransport()->readEnd();
  1963.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  1964.   }
  1965.   if (fname.compare("setReplication") != 0) {
  1966.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  1967.     iprot_->readMessageEnd();
  1968.     iprot_->getTransport()->readEnd();
  1969.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  1970.   }
  1971.   ThriftHadoopFileSystem_setReplication_presult result;
  1972.   result.read(iprot_);
  1973.   iprot_->readMessageEnd();
  1974.   iprot_->getTransport()->readEnd();
  1976.   if (result.__isset.ouch) {
  1977.     throw result.ouch;
  1978.   }
  1979.   return;
  1980. }
  1982. void ThriftHadoopFileSystemClient::getFileBlockLocations(std::vector<BlockLocation> & _return, const Pathname& path, const int64_t start, const int64_t length)
  1983. {
  1984.   send_getFileBlockLocations(path, start, length);
  1985.   recv_getFileBlockLocations(_return);
  1986. }
  1988. void ThriftHadoopFileSystemClient::send_getFileBlockLocations(const Pathname& path, const int64_t start, const int64_t length)
  1989. {
  1990.   int32_t cseqid = 0;
  1991.   oprot_->writeMessageBegin("getFileBlockLocations", facebook::thrift::protocol::T_CALL, cseqid);
  1993.   ThriftHadoopFileSystem_getFileBlockLocations_pargs args;
  1994.   args.path = &path;
  1995.   args.start = &start;
  1996.   args.length = &length;
  1997.   args.write(oprot_);
  1999.   oprot_->writeMessageEnd();
  2000.   oprot_->getTransport()->flush();
  2001.   oprot_->getTransport()->writeEnd();
  2002. }
  2004. void ThriftHadoopFileSystemClient::recv_getFileBlockLocations(std::vector<BlockLocation> & _return)
  2005. {
  2007.   int32_t rseqid = 0;
  2008.   std::string fname;
  2009.   facebook::thrift::protocol::TMessageType mtype;
  2011.   iprot_->readMessageBegin(fname, mtype, rseqid);
  2012.   if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
  2013.     facebook::thrift::TApplicationException x;
  2014.     x.read(iprot_);
  2015.     iprot_->readMessageEnd();
  2016.     iprot_->getTransport()->readEnd();
  2017.     throw x;
  2018.   }
  2019.   if (mtype != facebook::thrift::protocol::T_REPLY) {
  2020.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  2021.     iprot_->readMessageEnd();
  2022.     iprot_->getTransport()->readEnd();
  2023.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  2024.   }
  2025.   if (fname.compare("getFileBlockLocations") != 0) {
  2026.     iprot_->skip(facebook::thrift::protocol::T_STRUCT);
  2027.     iprot_->readMessageEnd();
  2028.     iprot_->getTransport()->readEnd();
  2029.     throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  2030.   }
  2031.   ThriftHadoopFileSystem_getFileBlockLocations_presult result;
  2032.   result.success = &_return;
  2033.   result.read(iprot_);
  2034.   iprot_->readMessageEnd();
  2035.   iprot_->getTransport()->readEnd();
  2037.   if (result.__isset.success) {
  2038.     // _return pointer has now been filled
  2039.     return;
  2040.   }
  2041.   if (result.__isset.ouch) {
  2042.     throw result.ouch;
  2043.   }
  2044.   throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "getFileBlockLocations failed: unknown result");
  2045. }
  2047. bool ThriftHadoopFileSystemProcessor::process(boost::shared_ptr<facebook::thrift::protocol::TProtocol> piprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> poprot) {
  2049.   facebook::thrift::protocol::TProtocol* iprot = piprot.get();
  2050.   facebook::thrift::protocol::TProtocol* oprot = poprot.get();
  2051.   std::string fname;
  2052.   facebook::thrift::protocol::TMessageType mtype;
  2053.   int32_t seqid;
  2055.   iprot->readMessageBegin(fname, mtype, seqid);
  2057.   if (mtype != facebook::thrift::protocol::T_CALL) {
  2058.     iprot->skip(facebook::thrift::protocol::T_STRUCT);
  2059.     iprot->readMessageEnd();
  2060.     iprot->getTransport()->readEnd();
  2061.     facebook::thrift::TApplicationException x(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  2062.     oprot->writeMessageBegin(fname, facebook::thrift::protocol::T_EXCEPTION, seqid);
  2063.     x.write(oprot);
  2064.     oprot->writeMessageEnd();
  2065.     oprot->getTransport()->flush();
  2066.     oprot->getTransport()->writeEnd();
  2067.     return true;
  2068.   }
  2070.   return process_fn(iprot, oprot, fname, seqid);
  2071. }
  2073. bool ThriftHadoopFileSystemProcessor::process_fn(facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid) {
  2074.   std::map<std::string, void (ThriftHadoopFileSystemProcessor::*)(int32_t, facebook::thrift::protocol::TProtocol*, facebook::thrift::protocol::TProtocol*)>::iterator pfn;
  2075.   pfn = processMap_.find(fname);
  2076.   if (pfn == processMap_.end()) {
  2077.     iprot->skip(facebook::thrift::protocol::T_STRUCT);
  2078.     iprot->readMessageEnd();
  2079.     iprot->getTransport()->readEnd();
  2080.     facebook::thrift::TApplicationException x(facebook::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
  2081.     oprot->writeMessageBegin(fname, facebook::thrift::protocol::T_EXCEPTION, seqid);
  2082.     x.write(oprot);
  2083.     oprot->writeMessageEnd();
  2084.     oprot->getTransport()->flush();
  2085.     oprot->getTransport()->writeEnd();
  2086.     return true;
  2087.   }
  2088.   (this->*(pfn->second))(seqid, iprot, oprot);
  2089.   return true;
  2090. }
  2092. void ThriftHadoopFileSystemProcessor::process_setInactivityTimeoutPeriod(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2093. {
  2094.   ThriftHadoopFileSystem_setInactivityTimeoutPeriod_args args;
  2095.   args.read(iprot);
  2096.   iprot->readMessageEnd();
  2097.   iprot->getTransport()->readEnd();
  2099.   ThriftHadoopFileSystem_setInactivityTimeoutPeriod_result result;
  2100.   try {
  2101.     iface_->setInactivityTimeoutPeriod(args.periodInSeconds);
  2102.   } catch (const std::exception& e) {
  2103.     facebook::thrift::TApplicationException x(e.what());
  2104.     oprot->writeMessageBegin("setInactivityTimeoutPeriod", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2105.     x.write(oprot);
  2106.     oprot->writeMessageEnd();
  2107.     oprot->getTransport()->flush();
  2108.     oprot->getTransport()->writeEnd();
  2109.     return;
  2110.   }
  2112.   oprot->writeMessageBegin("setInactivityTimeoutPeriod", facebook::thrift::protocol::T_REPLY, seqid);
  2113.   result.write(oprot);
  2114.   oprot->writeMessageEnd();
  2115.   oprot->getTransport()->flush();
  2116.   oprot->getTransport()->writeEnd();
  2117. }
  2119. void ThriftHadoopFileSystemProcessor::process_shutdown(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2120. {
  2121.   ThriftHadoopFileSystem_shutdown_args args;
  2122.   args.read(iprot);
  2123.   iprot->readMessageEnd();
  2124.   iprot->getTransport()->readEnd();
  2126.   ThriftHadoopFileSystem_shutdown_result result;
  2127.   try {
  2128.     iface_->shutdown(args.status);
  2129.   } catch (const std::exception& e) {
  2130.     facebook::thrift::TApplicationException x(e.what());
  2131.     oprot->writeMessageBegin("shutdown", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2132.     x.write(oprot);
  2133.     oprot->writeMessageEnd();
  2134.     oprot->getTransport()->flush();
  2135.     oprot->getTransport()->writeEnd();
  2136.     return;
  2137.   }
  2139.   oprot->writeMessageBegin("shutdown", facebook::thrift::protocol::T_REPLY, seqid);
  2140.   result.write(oprot);
  2141.   oprot->writeMessageEnd();
  2142.   oprot->getTransport()->flush();
  2143.   oprot->getTransport()->writeEnd();
  2144. }
  2146. void ThriftHadoopFileSystemProcessor::process_create(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2147. {
  2148.   ThriftHadoopFileSystem_create_args args;
  2149.   args.read(iprot);
  2150.   iprot->readMessageEnd();
  2151.   iprot->getTransport()->readEnd();
  2153.   ThriftHadoopFileSystem_create_result result;
  2154.   try {
  2155.     iface_->create(result.success, args.path);
  2156.     result.__isset.success = true;
  2157.   } catch (ThriftIOException &ouch) {
  2158.     result.ouch = ouch;
  2159.     result.__isset.ouch = true;
  2160.   } catch (const std::exception& e) {
  2161.     facebook::thrift::TApplicationException x(e.what());
  2162.     oprot->writeMessageBegin("create", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2163.     x.write(oprot);
  2164.     oprot->writeMessageEnd();
  2165.     oprot->getTransport()->flush();
  2166.     oprot->getTransport()->writeEnd();
  2167.     return;
  2168.   }
  2170.   oprot->writeMessageBegin("create", facebook::thrift::protocol::T_REPLY, seqid);
  2171.   result.write(oprot);
  2172.   oprot->writeMessageEnd();
  2173.   oprot->getTransport()->flush();
  2174.   oprot->getTransport()->writeEnd();
  2175. }
  2177. void ThriftHadoopFileSystemProcessor::process_createFile(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2178. {
  2179.   ThriftHadoopFileSystem_createFile_args args;
  2180.   args.read(iprot);
  2181.   iprot->readMessageEnd();
  2182.   iprot->getTransport()->readEnd();
  2184.   ThriftHadoopFileSystem_createFile_result result;
  2185.   try {
  2186.     iface_->createFile(result.success, args.path, args.mode, args.overwrite, args.bufferSize, args.block_replication, args.blocksize);
  2187.     result.__isset.success = true;
  2188.   } catch (ThriftIOException &ouch) {
  2189.     result.ouch = ouch;
  2190.     result.__isset.ouch = true;
  2191.   } catch (const std::exception& e) {
  2192.     facebook::thrift::TApplicationException x(e.what());
  2193.     oprot->writeMessageBegin("createFile", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2194.     x.write(oprot);
  2195.     oprot->writeMessageEnd();
  2196.     oprot->getTransport()->flush();
  2197.     oprot->getTransport()->writeEnd();
  2198.     return;
  2199.   }
  2201.   oprot->writeMessageBegin("createFile", facebook::thrift::protocol::T_REPLY, seqid);
  2202.   result.write(oprot);
  2203.   oprot->writeMessageEnd();
  2204.   oprot->getTransport()->flush();
  2205.   oprot->getTransport()->writeEnd();
  2206. }
  2208. void ThriftHadoopFileSystemProcessor::process_open(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2209. {
  2210.   ThriftHadoopFileSystem_open_args args;
  2211.   args.read(iprot);
  2212.   iprot->readMessageEnd();
  2213.   iprot->getTransport()->readEnd();
  2215.   ThriftHadoopFileSystem_open_result result;
  2216.   try {
  2217.     iface_->open(result.success, args.path);
  2218.     result.__isset.success = true;
  2219.   } catch (ThriftIOException &ouch) {
  2220.     result.ouch = ouch;
  2221.     result.__isset.ouch = true;
  2222.   } catch (const std::exception& e) {
  2223.     facebook::thrift::TApplicationException x(e.what());
  2224.     oprot->writeMessageBegin("open", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2225.     x.write(oprot);
  2226.     oprot->writeMessageEnd();
  2227.     oprot->getTransport()->flush();
  2228.     oprot->getTransport()->writeEnd();
  2229.     return;
  2230.   }
  2232.   oprot->writeMessageBegin("open", facebook::thrift::protocol::T_REPLY, seqid);
  2233.   result.write(oprot);
  2234.   oprot->writeMessageEnd();
  2235.   oprot->getTransport()->flush();
  2236.   oprot->getTransport()->writeEnd();
  2237. }
  2239. void ThriftHadoopFileSystemProcessor::process_append(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2240. {
  2241.   ThriftHadoopFileSystem_append_args args;
  2242.   args.read(iprot);
  2243.   iprot->readMessageEnd();
  2244.   iprot->getTransport()->readEnd();
  2246.   ThriftHadoopFileSystem_append_result result;
  2247.   try {
  2248.     iface_->append(result.success, args.path);
  2249.     result.__isset.success = true;
  2250.   } catch (ThriftIOException &ouch) {
  2251.     result.ouch = ouch;
  2252.     result.__isset.ouch = true;
  2253.   } catch (const std::exception& e) {
  2254.     facebook::thrift::TApplicationException x(e.what());
  2255.     oprot->writeMessageBegin("append", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2256.     x.write(oprot);
  2257.     oprot->writeMessageEnd();
  2258.     oprot->getTransport()->flush();
  2259.     oprot->getTransport()->writeEnd();
  2260.     return;
  2261.   }
  2263.   oprot->writeMessageBegin("append", facebook::thrift::protocol::T_REPLY, seqid);
  2264.   result.write(oprot);
  2265.   oprot->writeMessageEnd();
  2266.   oprot->getTransport()->flush();
  2267.   oprot->getTransport()->writeEnd();
  2268. }
  2270. void ThriftHadoopFileSystemProcessor::process_write(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2271. {
  2272.   ThriftHadoopFileSystem_write_args args;
  2273.   args.read(iprot);
  2274.   iprot->readMessageEnd();
  2275.   iprot->getTransport()->readEnd();
  2277.   ThriftHadoopFileSystem_write_result result;
  2278.   try {
  2279.     result.success = iface_->write(args.handle, args.data);
  2280.     result.__isset.success = true;
  2281.   } catch (ThriftIOException &ouch) {
  2282.     result.ouch = ouch;
  2283.     result.__isset.ouch = true;
  2284.   } catch (const std::exception& e) {
  2285.     facebook::thrift::TApplicationException x(e.what());
  2286.     oprot->writeMessageBegin("write", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2287.     x.write(oprot);
  2288.     oprot->writeMessageEnd();
  2289.     oprot->getTransport()->flush();
  2290.     oprot->getTransport()->writeEnd();
  2291.     return;
  2292.   }
  2294.   oprot->writeMessageBegin("write", facebook::thrift::protocol::T_REPLY, seqid);
  2295.   result.write(oprot);
  2296.   oprot->writeMessageEnd();
  2297.   oprot->getTransport()->flush();
  2298.   oprot->getTransport()->writeEnd();
  2299. }
  2301. void ThriftHadoopFileSystemProcessor::process_read(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2302. {
  2303.   ThriftHadoopFileSystem_read_args args;
  2304.   args.read(iprot);
  2305.   iprot->readMessageEnd();
  2306.   iprot->getTransport()->readEnd();
  2308.   ThriftHadoopFileSystem_read_result result;
  2309.   try {
  2310.     iface_->read(result.success, args.handle, args.offset, args.size);
  2311.     result.__isset.success = true;
  2312.   } catch (ThriftIOException &ouch) {
  2313.     result.ouch = ouch;
  2314.     result.__isset.ouch = true;
  2315.   } catch (const std::exception& e) {
  2316.     facebook::thrift::TApplicationException x(e.what());
  2317.     oprot->writeMessageBegin("read", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2318.     x.write(oprot);
  2319.     oprot->writeMessageEnd();
  2320.     oprot->getTransport()->flush();
  2321.     oprot->getTransport()->writeEnd();
  2322.     return;
  2323.   }
  2325.   oprot->writeMessageBegin("read", facebook::thrift::protocol::T_REPLY, seqid);
  2326.   result.write(oprot);
  2327.   oprot->writeMessageEnd();
  2328.   oprot->getTransport()->flush();
  2329.   oprot->getTransport()->writeEnd();
  2330. }
  2332. void ThriftHadoopFileSystemProcessor::process_close(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2333. {
  2334.   ThriftHadoopFileSystem_close_args args;
  2335.   args.read(iprot);
  2336.   iprot->readMessageEnd();
  2337.   iprot->getTransport()->readEnd();
  2339.   ThriftHadoopFileSystem_close_result result;
  2340.   try {
  2341.     result.success = iface_->close(args.out);
  2342.     result.__isset.success = true;
  2343.   } catch (ThriftIOException &ouch) {
  2344.     result.ouch = ouch;
  2345.     result.__isset.ouch = true;
  2346.   } catch (const std::exception& e) {
  2347.     facebook::thrift::TApplicationException x(e.what());
  2348.     oprot->writeMessageBegin("close", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2349.     x.write(oprot);
  2350.     oprot->writeMessageEnd();
  2351.     oprot->getTransport()->flush();
  2352.     oprot->getTransport()->writeEnd();
  2353.     return;
  2354.   }
  2356.   oprot->writeMessageBegin("close", facebook::thrift::protocol::T_REPLY, seqid);
  2357.   result.write(oprot);
  2358.   oprot->writeMessageEnd();
  2359.   oprot->getTransport()->flush();
  2360.   oprot->getTransport()->writeEnd();
  2361. }
  2363. void ThriftHadoopFileSystemProcessor::process_rm(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2364. {
  2365.   ThriftHadoopFileSystem_rm_args args;
  2366.   args.read(iprot);
  2367.   iprot->readMessageEnd();
  2368.   iprot->getTransport()->readEnd();
  2370.   ThriftHadoopFileSystem_rm_result result;
  2371.   try {
  2372.     result.success = iface_->rm(args.path, args.recursive);
  2373.     result.__isset.success = true;
  2374.   } catch (ThriftIOException &ouch) {
  2375.     result.ouch = ouch;
  2376.     result.__isset.ouch = true;
  2377.   } catch (const std::exception& e) {
  2378.     facebook::thrift::TApplicationException x(e.what());
  2379.     oprot->writeMessageBegin("rm", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2380.     x.write(oprot);
  2381.     oprot->writeMessageEnd();
  2382.     oprot->getTransport()->flush();
  2383.     oprot->getTransport()->writeEnd();
  2384.     return;
  2385.   }
  2387.   oprot->writeMessageBegin("rm", facebook::thrift::protocol::T_REPLY, seqid);
  2388.   result.write(oprot);
  2389.   oprot->writeMessageEnd();
  2390.   oprot->getTransport()->flush();
  2391.   oprot->getTransport()->writeEnd();
  2392. }
  2394. void ThriftHadoopFileSystemProcessor::process_rename(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2395. {
  2396.   ThriftHadoopFileSystem_rename_args args;
  2397.   args.read(iprot);
  2398.   iprot->readMessageEnd();
  2399.   iprot->getTransport()->readEnd();
  2401.   ThriftHadoopFileSystem_rename_result result;
  2402.   try {
  2403.     result.success = iface_->rename(args.path, args.dest);
  2404.     result.__isset.success = true;
  2405.   } catch (ThriftIOException &ouch) {
  2406.     result.ouch = ouch;
  2407.     result.__isset.ouch = true;
  2408.   } catch (const std::exception& e) {
  2409.     facebook::thrift::TApplicationException x(e.what());
  2410.     oprot->writeMessageBegin("rename", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2411.     x.write(oprot);
  2412.     oprot->writeMessageEnd();
  2413.     oprot->getTransport()->flush();
  2414.     oprot->getTransport()->writeEnd();
  2415.     return;
  2416.   }
  2418.   oprot->writeMessageBegin("rename", facebook::thrift::protocol::T_REPLY, seqid);
  2419.   result.write(oprot);
  2420.   oprot->writeMessageEnd();
  2421.   oprot->getTransport()->flush();
  2422.   oprot->getTransport()->writeEnd();
  2423. }
  2425. void ThriftHadoopFileSystemProcessor::process_mkdirs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2426. {
  2427.   ThriftHadoopFileSystem_mkdirs_args args;
  2428.   args.read(iprot);
  2429.   iprot->readMessageEnd();
  2430.   iprot->getTransport()->readEnd();
  2432.   ThriftHadoopFileSystem_mkdirs_result result;
  2433.   try {
  2434.     result.success = iface_->mkdirs(args.path);
  2435.     result.__isset.success = true;
  2436.   } catch (ThriftIOException &ouch) {
  2437.     result.ouch = ouch;
  2438.     result.__isset.ouch = true;
  2439.   } catch (const std::exception& e) {
  2440.     facebook::thrift::TApplicationException x(e.what());
  2441.     oprot->writeMessageBegin("mkdirs", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2442.     x.write(oprot);
  2443.     oprot->writeMessageEnd();
  2444.     oprot->getTransport()->flush();
  2445.     oprot->getTransport()->writeEnd();
  2446.     return;
  2447.   }
  2449.   oprot->writeMessageBegin("mkdirs", facebook::thrift::protocol::T_REPLY, seqid);
  2450.   result.write(oprot);
  2451.   oprot->writeMessageEnd();
  2452.   oprot->getTransport()->flush();
  2453.   oprot->getTransport()->writeEnd();
  2454. }
  2456. void ThriftHadoopFileSystemProcessor::process_exists(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2457. {
  2458.   ThriftHadoopFileSystem_exists_args args;
  2459.   args.read(iprot);
  2460.   iprot->readMessageEnd();
  2461.   iprot->getTransport()->readEnd();
  2463.   ThriftHadoopFileSystem_exists_result result;
  2464.   try {
  2465.     result.success = iface_->exists(args.path);
  2466.     result.__isset.success = true;
  2467.   } catch (ThriftIOException &ouch) {
  2468.     result.ouch = ouch;
  2469.     result.__isset.ouch = true;
  2470.   } catch (const std::exception& e) {
  2471.     facebook::thrift::TApplicationException x(e.what());
  2472.     oprot->writeMessageBegin("exists", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2473.     x.write(oprot);
  2474.     oprot->writeMessageEnd();
  2475.     oprot->getTransport()->flush();
  2476.     oprot->getTransport()->writeEnd();
  2477.     return;
  2478.   }
  2480.   oprot->writeMessageBegin("exists", facebook::thrift::protocol::T_REPLY, seqid);
  2481.   result.write(oprot);
  2482.   oprot->writeMessageEnd();
  2483.   oprot->getTransport()->flush();
  2484.   oprot->getTransport()->writeEnd();
  2485. }
  2487. void ThriftHadoopFileSystemProcessor::process_stat(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2488. {
  2489.   ThriftHadoopFileSystem_stat_args args;
  2490.   args.read(iprot);
  2491.   iprot->readMessageEnd();
  2492.   iprot->getTransport()->readEnd();
  2494.   ThriftHadoopFileSystem_stat_result result;
  2495.   try {
  2496.     iface_->stat(result.success, args.path);
  2497.     result.__isset.success = true;
  2498.   } catch (ThriftIOException &ouch) {
  2499.     result.ouch = ouch;
  2500.     result.__isset.ouch = true;
  2501.   } catch (const std::exception& e) {
  2502.     facebook::thrift::TApplicationException x(e.what());
  2503.     oprot->writeMessageBegin("stat", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2504.     x.write(oprot);
  2505.     oprot->writeMessageEnd();
  2506.     oprot->getTransport()->flush();
  2507.     oprot->getTransport()->writeEnd();
  2508.     return;
  2509.   }
  2511.   oprot->writeMessageBegin("stat", facebook::thrift::protocol::T_REPLY, seqid);
  2512.   result.write(oprot);
  2513.   oprot->writeMessageEnd();
  2514.   oprot->getTransport()->flush();
  2515.   oprot->getTransport()->writeEnd();
  2516. }
  2518. void ThriftHadoopFileSystemProcessor::process_listStatus(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2519. {
  2520.   ThriftHadoopFileSystem_listStatus_args args;
  2521.   args.read(iprot);
  2522.   iprot->readMessageEnd();
  2523.   iprot->getTransport()->readEnd();
  2525.   ThriftHadoopFileSystem_listStatus_result result;
  2526.   try {
  2527.     iface_->listStatus(result.success, args.path);
  2528.     result.__isset.success = true;
  2529.   } catch (ThriftIOException &ouch) {
  2530.     result.ouch = ouch;
  2531.     result.__isset.ouch = true;
  2532.   } catch (const std::exception& e) {
  2533.     facebook::thrift::TApplicationException x(e.what());
  2534.     oprot->writeMessageBegin("listStatus", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2535.     x.write(oprot);
  2536.     oprot->writeMessageEnd();
  2537.     oprot->getTransport()->flush();
  2538.     oprot->getTransport()->writeEnd();
  2539.     return;
  2540.   }
  2542.   oprot->writeMessageBegin("listStatus", facebook::thrift::protocol::T_REPLY, seqid);
  2543.   result.write(oprot);
  2544.   oprot->writeMessageEnd();
  2545.   oprot->getTransport()->flush();
  2546.   oprot->getTransport()->writeEnd();
  2547. }
  2549. void ThriftHadoopFileSystemProcessor::process_chmod(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2550. {
  2551.   ThriftHadoopFileSystem_chmod_args args;
  2552.   args.read(iprot);
  2553.   iprot->readMessageEnd();
  2554.   iprot->getTransport()->readEnd();
  2556.   ThriftHadoopFileSystem_chmod_result result;
  2557.   try {
  2558.     iface_->chmod(args.path, args.mode);
  2559.   } catch (ThriftIOException &ouch) {
  2560.     result.ouch = ouch;
  2561.     result.__isset.ouch = true;
  2562.   } catch (const std::exception& e) {
  2563.     facebook::thrift::TApplicationException x(e.what());
  2564.     oprot->writeMessageBegin("chmod", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2565.     x.write(oprot);
  2566.     oprot->writeMessageEnd();
  2567.     oprot->getTransport()->flush();
  2568.     oprot->getTransport()->writeEnd();
  2569.     return;
  2570.   }
  2572.   oprot->writeMessageBegin("chmod", facebook::thrift::protocol::T_REPLY, seqid);
  2573.   result.write(oprot);
  2574.   oprot->writeMessageEnd();
  2575.   oprot->getTransport()->flush();
  2576.   oprot->getTransport()->writeEnd();
  2577. }
  2579. void ThriftHadoopFileSystemProcessor::process_chown(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2580. {
  2581.   ThriftHadoopFileSystem_chown_args args;
  2582.   args.read(iprot);
  2583.   iprot->readMessageEnd();
  2584.   iprot->getTransport()->readEnd();
  2586.   ThriftHadoopFileSystem_chown_result result;
  2587.   try {
  2588.     iface_->chown(args.path, args.owner, args.group);
  2589.   } catch (ThriftIOException &ouch) {
  2590.     result.ouch = ouch;
  2591.     result.__isset.ouch = true;
  2592.   } catch (const std::exception& e) {
  2593.     facebook::thrift::TApplicationException x(e.what());
  2594.     oprot->writeMessageBegin("chown", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2595.     x.write(oprot);
  2596.     oprot->writeMessageEnd();
  2597.     oprot->getTransport()->flush();
  2598.     oprot->getTransport()->writeEnd();
  2599.     return;
  2600.   }
  2602.   oprot->writeMessageBegin("chown", facebook::thrift::protocol::T_REPLY, seqid);
  2603.   result.write(oprot);
  2604.   oprot->writeMessageEnd();
  2605.   oprot->getTransport()->flush();
  2606.   oprot->getTransport()->writeEnd();
  2607. }
  2609. void ThriftHadoopFileSystemProcessor::process_setReplication(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2610. {
  2611.   ThriftHadoopFileSystem_setReplication_args args;
  2612.   args.read(iprot);
  2613.   iprot->readMessageEnd();
  2614.   iprot->getTransport()->readEnd();
  2616.   ThriftHadoopFileSystem_setReplication_result result;
  2617.   try {
  2618.     iface_->setReplication(args.path, args.replication);
  2619.   } catch (ThriftIOException &ouch) {
  2620.     result.ouch = ouch;
  2621.     result.__isset.ouch = true;
  2622.   } catch (const std::exception& e) {
  2623.     facebook::thrift::TApplicationException x(e.what());
  2624.     oprot->writeMessageBegin("setReplication", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2625.     x.write(oprot);
  2626.     oprot->writeMessageEnd();
  2627.     oprot->getTransport()->flush();
  2628.     oprot->getTransport()->writeEnd();
  2629.     return;
  2630.   }
  2632.   oprot->writeMessageBegin("setReplication", facebook::thrift::protocol::T_REPLY, seqid);
  2633.   result.write(oprot);
  2634.   oprot->writeMessageEnd();
  2635.   oprot->getTransport()->flush();
  2636.   oprot->getTransport()->writeEnd();
  2637. }
  2639. void ThriftHadoopFileSystemProcessor::process_getFileBlockLocations(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
  2640. {
  2641.   ThriftHadoopFileSystem_getFileBlockLocations_args args;
  2642.   args.read(iprot);
  2643.   iprot->readMessageEnd();
  2644.   iprot->getTransport()->readEnd();
  2646.   ThriftHadoopFileSystem_getFileBlockLocations_result result;
  2647.   try {
  2648.     iface_->getFileBlockLocations(result.success, args.path, args.start, args.length);
  2649.     result.__isset.success = true;
  2650.   } catch (ThriftIOException &ouch) {
  2651.     result.ouch = ouch;
  2652.     result.__isset.ouch = true;
  2653.   } catch (const std::exception& e) {
  2654.     facebook::thrift::TApplicationException x(e.what());
  2655.     oprot->writeMessageBegin("getFileBlockLocations", facebook::thrift::protocol::T_EXCEPTION, seqid);
  2656.     x.write(oprot);
  2657.     oprot->writeMessageEnd();
  2658.     oprot->getTransport()->flush();
  2659.     oprot->getTransport()->writeEnd();
  2660.     return;
  2661.   }
  2663.   oprot->writeMessageBegin("getFileBlockLocations", facebook::thrift::protocol::T_REPLY, seqid);
  2664.   result.write(oprot);
  2665.   oprot->writeMessageEnd();
  2666.   oprot->getTransport()->flush();
  2667.   oprot->getTransport()->writeEnd();
  2668. }