You are viewing a plain text version of this content. The canonical link for it is here.
Posted to common-commits@hadoop.apache.org by om...@apache.org on 2008/08/29 06:32:00 UTC
svn commit: r690096 [4/15] - in /hadoop/core/trunk: ./ src/contrib/thriftfs/
src/contrib/thriftfs/gen-cocoa/ src/contrib/thriftfs/gen-cpp/
src/contrib/thriftfs/gen-java/ src/contrib/thriftfs/gen-java/org/
src/contrib/thriftfs/gen-java/org/apache/ src/c...
Added: hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/ThriftHadoopFileSystem.h
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/ThriftHadoopFileSystem.h?rev=690096&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/ThriftHadoopFileSystem.h (added)
+++ hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/ThriftHadoopFileSystem.h Thu Aug 28 21:31:57 2008
@@ -0,0 +1,2359 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef ThriftHadoopFileSystem_H
+#define ThriftHadoopFileSystem_H
+
+#include <TProcessor.h>
+#include "hadoopfs_types.h"
+
+
+
+class ThriftHadoopFileSystemIf {
+ public:
+ virtual ~ThriftHadoopFileSystemIf() {}
+ virtual void setInactivityTimeoutPeriod(const int64_t periodInSeconds) = 0;
+ virtual void shutdown(const int32_t status) = 0;
+ virtual void create(ThriftHandle& _return, const Pathname& path) = 0;
+ virtual void 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) = 0;
+ virtual void open(ThriftHandle& _return, const Pathname& path) = 0;
+ virtual void append(ThriftHandle& _return, const Pathname& path) = 0;
+ virtual bool write(const ThriftHandle& handle, const std::string& data) = 0;
+ virtual void read(std::string& _return, const ThriftHandle& handle, const int64_t offset, const int32_t size) = 0;
+ virtual bool close(const ThriftHandle& out) = 0;
+ virtual bool rm(const Pathname& path, const bool recursive) = 0;
+ virtual bool rename(const Pathname& path, const Pathname& dest) = 0;
+ virtual bool mkdirs(const Pathname& path) = 0;
+ virtual bool exists(const Pathname& path) = 0;
+ virtual void stat(FileStatus& _return, const Pathname& path) = 0;
+ virtual void listStatus(std::vector<FileStatus> & _return, const Pathname& path) = 0;
+ virtual void chmod(const Pathname& path, const int16_t mode) = 0;
+ virtual void chown(const Pathname& path, const std::string& owner, const std::string& group) = 0;
+ virtual void setReplication(const Pathname& path, const int16_t replication) = 0;
+ virtual void getFileBlockLocations(std::vector<BlockLocation> & _return, const Pathname& path, const int64_t start, const int64_t length) = 0;
+};
+
+class ThriftHadoopFileSystemNull : virtual public ThriftHadoopFileSystemIf {
+ public:
+ virtual ~ThriftHadoopFileSystemNull() {}
+ void setInactivityTimeoutPeriod(const int64_t /* periodInSeconds */) {
+ return;
+ }
+ void shutdown(const int32_t /* status */) {
+ return;
+ }
+ void create(ThriftHandle& /* _return */, const Pathname& /* path */) {
+ return;
+ }
+ void 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 */) {
+ return;
+ }
+ void open(ThriftHandle& /* _return */, const Pathname& /* path */) {
+ return;
+ }
+ void append(ThriftHandle& /* _return */, const Pathname& /* path */) {
+ return;
+ }
+ bool write(const ThriftHandle& /* handle */, const std::string& /* data */) {
+ bool _return = false;
+ return _return;
+ }
+ void read(std::string& /* _return */, const ThriftHandle& /* handle */, const int64_t /* offset */, const int32_t /* size */) {
+ return;
+ }
+ bool close(const ThriftHandle& /* out */) {
+ bool _return = false;
+ return _return;
+ }
+ bool rm(const Pathname& /* path */, const bool /* recursive */) {
+ bool _return = false;
+ return _return;
+ }
+ bool rename(const Pathname& /* path */, const Pathname& /* dest */) {
+ bool _return = false;
+ return _return;
+ }
+ bool mkdirs(const Pathname& /* path */) {
+ bool _return = false;
+ return _return;
+ }
+ bool exists(const Pathname& /* path */) {
+ bool _return = false;
+ return _return;
+ }
+ void stat(FileStatus& /* _return */, const Pathname& /* path */) {
+ return;
+ }
+ void listStatus(std::vector<FileStatus> & /* _return */, const Pathname& /* path */) {
+ return;
+ }
+ void chmod(const Pathname& /* path */, const int16_t /* mode */) {
+ return;
+ }
+ void chown(const Pathname& /* path */, const std::string& /* owner */, const std::string& /* group */) {
+ return;
+ }
+ void setReplication(const Pathname& /* path */, const int16_t /* replication */) {
+ return;
+ }
+ void getFileBlockLocations(std::vector<BlockLocation> & /* _return */, const Pathname& /* path */, const int64_t /* start */, const int64_t /* length */) {
+ return;
+ }
+};
+
+class ThriftHadoopFileSystem_setInactivityTimeoutPeriod_args {
+ public:
+
+ ThriftHadoopFileSystem_setInactivityTimeoutPeriod_args() : periodInSeconds(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_setInactivityTimeoutPeriod_args() throw() {}
+
+ int64_t periodInSeconds;
+
+ struct __isset {
+ __isset() : periodInSeconds(false) {}
+ bool periodInSeconds;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_setInactivityTimeoutPeriod_args & rhs) const
+ {
+ if (!(periodInSeconds == rhs.periodInSeconds))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_setInactivityTimeoutPeriod_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_setInactivityTimeoutPeriod_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_setInactivityTimeoutPeriod_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_setInactivityTimeoutPeriod_pargs() throw() {}
+
+ const int64_t* periodInSeconds;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_setInactivityTimeoutPeriod_result {
+ public:
+
+ ThriftHadoopFileSystem_setInactivityTimeoutPeriod_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_setInactivityTimeoutPeriod_result() throw() {}
+
+
+ bool operator == (const ThriftHadoopFileSystem_setInactivityTimeoutPeriod_result & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_setInactivityTimeoutPeriod_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_setInactivityTimeoutPeriod_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_setInactivityTimeoutPeriod_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_setInactivityTimeoutPeriod_presult() throw() {}
+
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_shutdown_args {
+ public:
+
+ ThriftHadoopFileSystem_shutdown_args() : status(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_shutdown_args() throw() {}
+
+ int32_t status;
+
+ struct __isset {
+ __isset() : status(false) {}
+ bool status;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_shutdown_args & rhs) const
+ {
+ if (!(status == rhs.status))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_shutdown_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_shutdown_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_shutdown_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_shutdown_pargs() throw() {}
+
+ const int32_t* status;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_shutdown_result {
+ public:
+
+ ThriftHadoopFileSystem_shutdown_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_shutdown_result() throw() {}
+
+
+ bool operator == (const ThriftHadoopFileSystem_shutdown_result & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_shutdown_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_shutdown_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_shutdown_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_shutdown_presult() throw() {}
+
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_create_args {
+ public:
+
+ ThriftHadoopFileSystem_create_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_create_args() throw() {}
+
+ Pathname path;
+
+ struct __isset {
+ __isset() : path(false) {}
+ bool path;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_create_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_create_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_create_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_create_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_create_pargs() throw() {}
+
+ const Pathname* path;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_create_result {
+ public:
+
+ ThriftHadoopFileSystem_create_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_create_result() throw() {}
+
+ ThriftHandle success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_create_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_create_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_create_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_create_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_create_presult() throw() {}
+
+ ThriftHandle* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_createFile_args {
+ public:
+
+ ThriftHadoopFileSystem_createFile_args() : mode(0), overwrite(0), bufferSize(0), block_replication(0), blocksize(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_createFile_args() throw() {}
+
+ Pathname path;
+ int16_t mode;
+ bool overwrite;
+ int32_t bufferSize;
+ int16_t block_replication;
+ int64_t blocksize;
+
+ struct __isset {
+ __isset() : path(false), mode(false), overwrite(false), bufferSize(false), block_replication(false), blocksize(false) {}
+ bool path;
+ bool mode;
+ bool overwrite;
+ bool bufferSize;
+ bool block_replication;
+ bool blocksize;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_createFile_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ if (!(mode == rhs.mode))
+ return false;
+ if (!(overwrite == rhs.overwrite))
+ return false;
+ if (!(bufferSize == rhs.bufferSize))
+ return false;
+ if (!(block_replication == rhs.block_replication))
+ return false;
+ if (!(blocksize == rhs.blocksize))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_createFile_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_createFile_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_createFile_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_createFile_pargs() throw() {}
+
+ const Pathname* path;
+ const int16_t* mode;
+ const bool* overwrite;
+ const int32_t* bufferSize;
+ const int16_t* block_replication;
+ const int64_t* blocksize;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_createFile_result {
+ public:
+
+ ThriftHadoopFileSystem_createFile_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_createFile_result() throw() {}
+
+ ThriftHandle success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_createFile_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_createFile_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_createFile_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_createFile_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_createFile_presult() throw() {}
+
+ ThriftHandle* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_open_args {
+ public:
+
+ ThriftHadoopFileSystem_open_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_open_args() throw() {}
+
+ Pathname path;
+
+ struct __isset {
+ __isset() : path(false) {}
+ bool path;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_open_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_open_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_open_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_open_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_open_pargs() throw() {}
+
+ const Pathname* path;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_open_result {
+ public:
+
+ ThriftHadoopFileSystem_open_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_open_result() throw() {}
+
+ ThriftHandle success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_open_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_open_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_open_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_open_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_open_presult() throw() {}
+
+ ThriftHandle* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_append_args {
+ public:
+
+ ThriftHadoopFileSystem_append_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_append_args() throw() {}
+
+ Pathname path;
+
+ struct __isset {
+ __isset() : path(false) {}
+ bool path;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_append_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_append_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_append_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_append_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_append_pargs() throw() {}
+
+ const Pathname* path;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_append_result {
+ public:
+
+ ThriftHadoopFileSystem_append_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_append_result() throw() {}
+
+ ThriftHandle success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_append_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_append_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_append_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_append_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_append_presult() throw() {}
+
+ ThriftHandle* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_write_args {
+ public:
+
+ ThriftHadoopFileSystem_write_args() : data("") {
+ }
+
+ virtual ~ThriftHadoopFileSystem_write_args() throw() {}
+
+ ThriftHandle handle;
+ std::string data;
+
+ struct __isset {
+ __isset() : handle(false), data(false) {}
+ bool handle;
+ bool data;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_write_args & rhs) const
+ {
+ if (!(handle == rhs.handle))
+ return false;
+ if (!(data == rhs.data))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_write_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_write_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_write_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_write_pargs() throw() {}
+
+ const ThriftHandle* handle;
+ const std::string* data;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_write_result {
+ public:
+
+ ThriftHadoopFileSystem_write_result() : success(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_write_result() throw() {}
+
+ bool success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_write_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_write_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_write_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_write_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_write_presult() throw() {}
+
+ bool* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_read_args {
+ public:
+
+ ThriftHadoopFileSystem_read_args() : offset(0), size(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_read_args() throw() {}
+
+ ThriftHandle handle;
+ int64_t offset;
+ int32_t size;
+
+ struct __isset {
+ __isset() : handle(false), offset(false), size(false) {}
+ bool handle;
+ bool offset;
+ bool size;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_read_args & rhs) const
+ {
+ if (!(handle == rhs.handle))
+ return false;
+ if (!(offset == rhs.offset))
+ return false;
+ if (!(size == rhs.size))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_read_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_read_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_read_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_read_pargs() throw() {}
+
+ const ThriftHandle* handle;
+ const int64_t* offset;
+ const int32_t* size;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_read_result {
+ public:
+
+ ThriftHadoopFileSystem_read_result() : success("") {
+ }
+
+ virtual ~ThriftHadoopFileSystem_read_result() throw() {}
+
+ std::string success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_read_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_read_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_read_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_read_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_read_presult() throw() {}
+
+ std::string* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_close_args {
+ public:
+
+ ThriftHadoopFileSystem_close_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_close_args() throw() {}
+
+ ThriftHandle out;
+
+ struct __isset {
+ __isset() : out(false) {}
+ bool out;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_close_args & rhs) const
+ {
+ if (!(out == rhs.out))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_close_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_close_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_close_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_close_pargs() throw() {}
+
+ const ThriftHandle* out;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_close_result {
+ public:
+
+ ThriftHadoopFileSystem_close_result() : success(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_close_result() throw() {}
+
+ bool success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_close_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_close_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_close_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_close_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_close_presult() throw() {}
+
+ bool* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_rm_args {
+ public:
+
+ ThriftHadoopFileSystem_rm_args() : recursive(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_rm_args() throw() {}
+
+ Pathname path;
+ bool recursive;
+
+ struct __isset {
+ __isset() : path(false), recursive(false) {}
+ bool path;
+ bool recursive;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_rm_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ if (!(recursive == rhs.recursive))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_rm_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_rm_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_rm_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_rm_pargs() throw() {}
+
+ const Pathname* path;
+ const bool* recursive;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_rm_result {
+ public:
+
+ ThriftHadoopFileSystem_rm_result() : success(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_rm_result() throw() {}
+
+ bool success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_rm_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_rm_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_rm_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_rm_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_rm_presult() throw() {}
+
+ bool* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_rename_args {
+ public:
+
+ ThriftHadoopFileSystem_rename_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_rename_args() throw() {}
+
+ Pathname path;
+ Pathname dest;
+
+ struct __isset {
+ __isset() : path(false), dest(false) {}
+ bool path;
+ bool dest;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_rename_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ if (!(dest == rhs.dest))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_rename_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_rename_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_rename_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_rename_pargs() throw() {}
+
+ const Pathname* path;
+ const Pathname* dest;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_rename_result {
+ public:
+
+ ThriftHadoopFileSystem_rename_result() : success(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_rename_result() throw() {}
+
+ bool success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_rename_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_rename_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_rename_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_rename_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_rename_presult() throw() {}
+
+ bool* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_mkdirs_args {
+ public:
+
+ ThriftHadoopFileSystem_mkdirs_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_mkdirs_args() throw() {}
+
+ Pathname path;
+
+ struct __isset {
+ __isset() : path(false) {}
+ bool path;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_mkdirs_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_mkdirs_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_mkdirs_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_mkdirs_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_mkdirs_pargs() throw() {}
+
+ const Pathname* path;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_mkdirs_result {
+ public:
+
+ ThriftHadoopFileSystem_mkdirs_result() : success(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_mkdirs_result() throw() {}
+
+ bool success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_mkdirs_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_mkdirs_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_mkdirs_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_mkdirs_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_mkdirs_presult() throw() {}
+
+ bool* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_exists_args {
+ public:
+
+ ThriftHadoopFileSystem_exists_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_exists_args() throw() {}
+
+ Pathname path;
+
+ struct __isset {
+ __isset() : path(false) {}
+ bool path;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_exists_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_exists_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_exists_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_exists_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_exists_pargs() throw() {}
+
+ const Pathname* path;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_exists_result {
+ public:
+
+ ThriftHadoopFileSystem_exists_result() : success(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_exists_result() throw() {}
+
+ bool success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_exists_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_exists_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_exists_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_exists_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_exists_presult() throw() {}
+
+ bool* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_stat_args {
+ public:
+
+ ThriftHadoopFileSystem_stat_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_stat_args() throw() {}
+
+ Pathname path;
+
+ struct __isset {
+ __isset() : path(false) {}
+ bool path;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_stat_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_stat_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_stat_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_stat_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_stat_pargs() throw() {}
+
+ const Pathname* path;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_stat_result {
+ public:
+
+ ThriftHadoopFileSystem_stat_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_stat_result() throw() {}
+
+ FileStatus success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_stat_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_stat_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_stat_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_stat_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_stat_presult() throw() {}
+
+ FileStatus* success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_listStatus_args {
+ public:
+
+ ThriftHadoopFileSystem_listStatus_args() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_listStatus_args() throw() {}
+
+ Pathname path;
+
+ struct __isset {
+ __isset() : path(false) {}
+ bool path;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_listStatus_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_listStatus_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_listStatus_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_listStatus_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_listStatus_pargs() throw() {}
+
+ const Pathname* path;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_listStatus_result {
+ public:
+
+ ThriftHadoopFileSystem_listStatus_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_listStatus_result() throw() {}
+
+ std::vector<FileStatus> success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_listStatus_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_listStatus_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_listStatus_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_listStatus_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_listStatus_presult() throw() {}
+
+ std::vector<FileStatus> * success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_chmod_args {
+ public:
+
+ ThriftHadoopFileSystem_chmod_args() : mode(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_chmod_args() throw() {}
+
+ Pathname path;
+ int16_t mode;
+
+ struct __isset {
+ __isset() : path(false), mode(false) {}
+ bool path;
+ bool mode;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_chmod_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ if (!(mode == rhs.mode))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_chmod_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_chmod_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_chmod_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_chmod_pargs() throw() {}
+
+ const Pathname* path;
+ const int16_t* mode;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_chmod_result {
+ public:
+
+ ThriftHadoopFileSystem_chmod_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_chmod_result() throw() {}
+
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : ouch(false) {}
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_chmod_result & rhs) const
+ {
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_chmod_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_chmod_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_chmod_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_chmod_presult() throw() {}
+
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : ouch(false) {}
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_chown_args {
+ public:
+
+ ThriftHadoopFileSystem_chown_args() : owner(""), group("") {
+ }
+
+ virtual ~ThriftHadoopFileSystem_chown_args() throw() {}
+
+ Pathname path;
+ std::string owner;
+ std::string group;
+
+ struct __isset {
+ __isset() : path(false), owner(false), group(false) {}
+ bool path;
+ bool owner;
+ bool group;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_chown_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ if (!(owner == rhs.owner))
+ return false;
+ if (!(group == rhs.group))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_chown_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_chown_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_chown_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_chown_pargs() throw() {}
+
+ const Pathname* path;
+ const std::string* owner;
+ const std::string* group;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_chown_result {
+ public:
+
+ ThriftHadoopFileSystem_chown_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_chown_result() throw() {}
+
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : ouch(false) {}
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_chown_result & rhs) const
+ {
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_chown_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_chown_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_chown_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_chown_presult() throw() {}
+
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : ouch(false) {}
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_setReplication_args {
+ public:
+
+ ThriftHadoopFileSystem_setReplication_args() : replication(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_setReplication_args() throw() {}
+
+ Pathname path;
+ int16_t replication;
+
+ struct __isset {
+ __isset() : path(false), replication(false) {}
+ bool path;
+ bool replication;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_setReplication_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ if (!(replication == rhs.replication))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_setReplication_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_setReplication_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_setReplication_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_setReplication_pargs() throw() {}
+
+ const Pathname* path;
+ const int16_t* replication;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_setReplication_result {
+ public:
+
+ ThriftHadoopFileSystem_setReplication_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_setReplication_result() throw() {}
+
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : ouch(false) {}
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_setReplication_result & rhs) const
+ {
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_setReplication_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_setReplication_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_setReplication_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_setReplication_presult() throw() {}
+
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : ouch(false) {}
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystem_getFileBlockLocations_args {
+ public:
+
+ ThriftHadoopFileSystem_getFileBlockLocations_args() : start(0), length(0) {
+ }
+
+ virtual ~ThriftHadoopFileSystem_getFileBlockLocations_args() throw() {}
+
+ Pathname path;
+ int64_t start;
+ int64_t length;
+
+ struct __isset {
+ __isset() : path(false), start(false), length(false) {}
+ bool path;
+ bool start;
+ bool length;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_getFileBlockLocations_args & rhs) const
+ {
+ if (!(path == rhs.path))
+ return false;
+ if (!(start == rhs.start))
+ return false;
+ if (!(length == rhs.length))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_getFileBlockLocations_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_getFileBlockLocations_args & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_getFileBlockLocations_pargs {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_getFileBlockLocations_pargs() throw() {}
+
+ const Pathname* path;
+ const int64_t* start;
+ const int64_t* length;
+
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_getFileBlockLocations_result {
+ public:
+
+ ThriftHadoopFileSystem_getFileBlockLocations_result() {
+ }
+
+ virtual ~ThriftHadoopFileSystem_getFileBlockLocations_result() throw() {}
+
+ std::vector<BlockLocation> success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ bool operator == (const ThriftHadoopFileSystem_getFileBlockLocations_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ouch == rhs.ouch))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHadoopFileSystem_getFileBlockLocations_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHadoopFileSystem_getFileBlockLocations_result & ) const;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+ uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHadoopFileSystem_getFileBlockLocations_presult {
+ public:
+
+
+ virtual ~ThriftHadoopFileSystem_getFileBlockLocations_presult() throw() {}
+
+ std::vector<BlockLocation> * success;
+ ThriftIOException ouch;
+
+ struct __isset {
+ __isset() : success(false), ouch(false) {}
+ bool success;
+ bool ouch;
+ } __isset;
+
+ uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHadoopFileSystemClient : virtual public ThriftHadoopFileSystemIf {
+ public:
+ ThriftHadoopFileSystemClient(boost::shared_ptr<facebook::thrift::protocol::TProtocol> prot) :
+ piprot_(prot),
+ poprot_(prot) {
+ iprot_ = prot.get();
+ oprot_ = prot.get();
+ }
+ ThriftHadoopFileSystemClient(boost::shared_ptr<facebook::thrift::protocol::TProtocol> iprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> oprot) :
+ piprot_(iprot),
+ poprot_(oprot) {
+ iprot_ = iprot.get();
+ oprot_ = oprot.get();
+ }
+ boost::shared_ptr<facebook::thrift::protocol::TProtocol> getInputProtocol() {
+ return piprot_;
+ }
+ boost::shared_ptr<facebook::thrift::protocol::TProtocol> getOutputProtocol() {
+ return poprot_;
+ }
+ void setInactivityTimeoutPeriod(const int64_t periodInSeconds);
+ void send_setInactivityTimeoutPeriod(const int64_t periodInSeconds);
+ void recv_setInactivityTimeoutPeriod();
+ void shutdown(const int32_t status);
+ void send_shutdown(const int32_t status);
+ void recv_shutdown();
+ void create(ThriftHandle& _return, const Pathname& path);
+ void send_create(const Pathname& path);
+ void recv_create(ThriftHandle& _return);
+ void 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);
+ void 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);
+ void recv_createFile(ThriftHandle& _return);
+ void open(ThriftHandle& _return, const Pathname& path);
+ void send_open(const Pathname& path);
+ void recv_open(ThriftHandle& _return);
+ void append(ThriftHandle& _return, const Pathname& path);
+ void send_append(const Pathname& path);
+ void recv_append(ThriftHandle& _return);
+ bool write(const ThriftHandle& handle, const std::string& data);
+ void send_write(const ThriftHandle& handle, const std::string& data);
+ bool recv_write();
+ void read(std::string& _return, const ThriftHandle& handle, const int64_t offset, const int32_t size);
+ void send_read(const ThriftHandle& handle, const int64_t offset, const int32_t size);
+ void recv_read(std::string& _return);
+ bool close(const ThriftHandle& out);
+ void send_close(const ThriftHandle& out);
+ bool recv_close();
+ bool rm(const Pathname& path, const bool recursive);
+ void send_rm(const Pathname& path, const bool recursive);
+ bool recv_rm();
+ bool rename(const Pathname& path, const Pathname& dest);
+ void send_rename(const Pathname& path, const Pathname& dest);
+ bool recv_rename();
+ bool mkdirs(const Pathname& path);
+ void send_mkdirs(const Pathname& path);
+ bool recv_mkdirs();
+ bool exists(const Pathname& path);
+ void send_exists(const Pathname& path);
+ bool recv_exists();
+ void stat(FileStatus& _return, const Pathname& path);
+ void send_stat(const Pathname& path);
+ void recv_stat(FileStatus& _return);
+ void listStatus(std::vector<FileStatus> & _return, const Pathname& path);
+ void send_listStatus(const Pathname& path);
+ void recv_listStatus(std::vector<FileStatus> & _return);
+ void chmod(const Pathname& path, const int16_t mode);
+ void send_chmod(const Pathname& path, const int16_t mode);
+ void recv_chmod();
+ void chown(const Pathname& path, const std::string& owner, const std::string& group);
+ void send_chown(const Pathname& path, const std::string& owner, const std::string& group);
+ void recv_chown();
+ void setReplication(const Pathname& path, const int16_t replication);
+ void send_setReplication(const Pathname& path, const int16_t replication);
+ void recv_setReplication();
+ void getFileBlockLocations(std::vector<BlockLocation> & _return, const Pathname& path, const int64_t start, const int64_t length);
+ void send_getFileBlockLocations(const Pathname& path, const int64_t start, const int64_t length);
+ void recv_getFileBlockLocations(std::vector<BlockLocation> & _return);
+ protected:
+ boost::shared_ptr<facebook::thrift::protocol::TProtocol> piprot_;
+ boost::shared_ptr<facebook::thrift::protocol::TProtocol> poprot_;
+ facebook::thrift::protocol::TProtocol* iprot_;
+ facebook::thrift::protocol::TProtocol* oprot_;
+};
+
+class ThriftHadoopFileSystemProcessor : virtual public facebook::thrift::TProcessor {
+ protected:
+ boost::shared_ptr<ThriftHadoopFileSystemIf> iface_;
+ virtual bool process_fn(facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid);
+ private:
+ std::map<std::string, void (ThriftHadoopFileSystemProcessor::*)(int32_t, facebook::thrift::protocol::TProtocol*, facebook::thrift::protocol::TProtocol*)> processMap_;
+ void process_setInactivityTimeoutPeriod(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_shutdown(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_create(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_createFile(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_open(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_append(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_write(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_read(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_close(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_rm(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_rename(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_mkdirs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_exists(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_stat(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_listStatus(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_chmod(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_chown(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_setReplication(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ void process_getFileBlockLocations(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
+ public:
+ ThriftHadoopFileSystemProcessor(boost::shared_ptr<ThriftHadoopFileSystemIf> iface) :
+ iface_(iface) {
+ processMap_["setInactivityTimeoutPeriod"] = &ThriftHadoopFileSystemProcessor::process_setInactivityTimeoutPeriod;
+ processMap_["shutdown"] = &ThriftHadoopFileSystemProcessor::process_shutdown;
+ processMap_["create"] = &ThriftHadoopFileSystemProcessor::process_create;
+ processMap_["createFile"] = &ThriftHadoopFileSystemProcessor::process_createFile;
+ processMap_["open"] = &ThriftHadoopFileSystemProcessor::process_open;
+ processMap_["append"] = &ThriftHadoopFileSystemProcessor::process_append;
+ processMap_["write"] = &ThriftHadoopFileSystemProcessor::process_write;
+ processMap_["read"] = &ThriftHadoopFileSystemProcessor::process_read;
+ processMap_["close"] = &ThriftHadoopFileSystemProcessor::process_close;
+ processMap_["rm"] = &ThriftHadoopFileSystemProcessor::process_rm;
+ processMap_["rename"] = &ThriftHadoopFileSystemProcessor::process_rename;
+ processMap_["mkdirs"] = &ThriftHadoopFileSystemProcessor::process_mkdirs;
+ processMap_["exists"] = &ThriftHadoopFileSystemProcessor::process_exists;
+ processMap_["stat"] = &ThriftHadoopFileSystemProcessor::process_stat;
+ processMap_["listStatus"] = &ThriftHadoopFileSystemProcessor::process_listStatus;
+ processMap_["chmod"] = &ThriftHadoopFileSystemProcessor::process_chmod;
+ processMap_["chown"] = &ThriftHadoopFileSystemProcessor::process_chown;
+ processMap_["setReplication"] = &ThriftHadoopFileSystemProcessor::process_setReplication;
+ processMap_["getFileBlockLocations"] = &ThriftHadoopFileSystemProcessor::process_getFileBlockLocations;
+ }
+
+ virtual bool process(boost::shared_ptr<facebook::thrift::protocol::TProtocol> piprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> poprot);
+ virtual ~ThriftHadoopFileSystemProcessor() {}
+};
+
+class ThriftHadoopFileSystemMultiface : virtual public ThriftHadoopFileSystemIf {
+ public:
+ ThriftHadoopFileSystemMultiface(std::vector<boost::shared_ptr<ThriftHadoopFileSystemIf> >& ifaces) : ifaces_(ifaces) {
+ }
+ virtual ~ThriftHadoopFileSystemMultiface() {}
+ protected:
+ std::vector<boost::shared_ptr<ThriftHadoopFileSystemIf> > ifaces_;
+ ThriftHadoopFileSystemMultiface() {}
+ void add(boost::shared_ptr<ThriftHadoopFileSystemIf> iface) {
+ ifaces_.push_back(iface);
+ }
+ public:
+ void setInactivityTimeoutPeriod(const int64_t periodInSeconds) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ ifaces_[i]->setInactivityTimeoutPeriod(periodInSeconds);
+ }
+ }
+
+ void shutdown(const int32_t status) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ ifaces_[i]->shutdown(status);
+ }
+ }
+
+ void create(ThriftHandle& _return, const Pathname& path) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ ifaces_[i]->create(_return, path);
+ return;
+ } else {
+ ifaces_[i]->create(_return, path);
+ }
+ }
+ }
+
+ void 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) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ ifaces_[i]->createFile(_return, path, mode, overwrite, bufferSize, block_replication, blocksize);
+ return;
+ } else {
+ ifaces_[i]->createFile(_return, path, mode, overwrite, bufferSize, block_replication, blocksize);
+ }
+ }
+ }
+
+ void open(ThriftHandle& _return, const Pathname& path) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ ifaces_[i]->open(_return, path);
+ return;
+ } else {
+ ifaces_[i]->open(_return, path);
+ }
+ }
+ }
+
+ void append(ThriftHandle& _return, const Pathname& path) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ ifaces_[i]->append(_return, path);
+ return;
+ } else {
+ ifaces_[i]->append(_return, path);
+ }
+ }
+ }
+
+ bool write(const ThriftHandle& handle, const std::string& data) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ return ifaces_[i]->write(handle, data);
+ } else {
+ ifaces_[i]->write(handle, data);
+ }
+ }
+ }
+
+ void read(std::string& _return, const ThriftHandle& handle, const int64_t offset, const int32_t size) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ ifaces_[i]->read(_return, handle, offset, size);
+ return;
+ } else {
+ ifaces_[i]->read(_return, handle, offset, size);
+ }
+ }
+ }
+
+ bool close(const ThriftHandle& out) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ return ifaces_[i]->close(out);
+ } else {
+ ifaces_[i]->close(out);
+ }
+ }
+ }
+
+ bool rm(const Pathname& path, const bool recursive) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ return ifaces_[i]->rm(path, recursive);
+ } else {
+ ifaces_[i]->rm(path, recursive);
+ }
+ }
+ }
+
+ bool rename(const Pathname& path, const Pathname& dest) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ return ifaces_[i]->rename(path, dest);
+ } else {
+ ifaces_[i]->rename(path, dest);
+ }
+ }
+ }
+
+ bool mkdirs(const Pathname& path) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ return ifaces_[i]->mkdirs(path);
+ } else {
+ ifaces_[i]->mkdirs(path);
+ }
+ }
+ }
+
+ bool exists(const Pathname& path) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ return ifaces_[i]->exists(path);
+ } else {
+ ifaces_[i]->exists(path);
+ }
+ }
+ }
+
+ void stat(FileStatus& _return, const Pathname& path) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ ifaces_[i]->stat(_return, path);
+ return;
+ } else {
+ ifaces_[i]->stat(_return, path);
+ }
+ }
+ }
+
+ void listStatus(std::vector<FileStatus> & _return, const Pathname& path) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ ifaces_[i]->listStatus(_return, path);
+ return;
+ } else {
+ ifaces_[i]->listStatus(_return, path);
+ }
+ }
+ }
+
+ void chmod(const Pathname& path, const int16_t mode) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ ifaces_[i]->chmod(path, mode);
+ }
+ }
+
+ void chown(const Pathname& path, const std::string& owner, const std::string& group) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ ifaces_[i]->chown(path, owner, group);
+ }
+ }
+
+ void setReplication(const Pathname& path, const int16_t replication) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ ifaces_[i]->setReplication(path, replication);
+ }
+ }
+
+ void getFileBlockLocations(std::vector<BlockLocation> & _return, const Pathname& path, const int64_t start, const int64_t length) {
+ uint32_t sz = ifaces_.size();
+ for (uint32_t i = 0; i < sz; ++i) {
+ if (i == sz - 1) {
+ ifaces_[i]->getFileBlockLocations(_return, path, start, length);
+ return;
+ } else {
+ ifaces_[i]->getFileBlockLocations(_return, path, start, length);
+ }
+ }
+ }
+
+};
+
+
+
+#endif
Added: hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/ThriftHadoopFileSystem_server.skeleton.cpp
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/ThriftHadoopFileSystem_server.skeleton.cpp?rev=690096&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/ThriftHadoopFileSystem_server.skeleton.cpp (added)
+++ hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/ThriftHadoopFileSystem_server.skeleton.cpp Thu Aug 28 21:31:57 2008
@@ -0,0 +1,132 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "ThriftHadoopFileSystem.h"
+#include <protocol/TBinaryProtocol.h>
+#include <server/TSimpleServer.h>
+#include <transport/TServerSocket.h>
+#include <transport/TBufferTransports.h>
+
+using namespace facebook::thrift;
+using namespace facebook::thrift::protocol;
+using namespace facebook::thrift::transport;
+using namespace facebook::thrift::server;
+
+using boost::shared_ptr;
+
+class ThriftHadoopFileSystemHandler : virtual public ThriftHadoopFileSystemIf {
+ public:
+ ThriftHadoopFileSystemHandler() {
+ // Your initialization goes here
+ }
+
+ void setInactivityTimeoutPeriod(const int64_t periodInSeconds) {
+ // Your implementation goes here
+ printf("setInactivityTimeoutPeriod\n");
+ }
+
+ void shutdown(const int32_t status) {
+ // Your implementation goes here
+ printf("shutdown\n");
+ }
+
+ void create(ThriftHandle& _return, const Pathname& path) {
+ // Your implementation goes here
+ printf("create\n");
+ }
+
+ void 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) {
+ // Your implementation goes here
+ printf("createFile\n");
+ }
+
+ void open(ThriftHandle& _return, const Pathname& path) {
+ // Your implementation goes here
+ printf("open\n");
+ }
+
+ void append(ThriftHandle& _return, const Pathname& path) {
+ // Your implementation goes here
+ printf("append\n");
+ }
+
+ bool write(const ThriftHandle& handle, const std::string& data) {
+ // Your implementation goes here
+ printf("write\n");
+ }
+
+ void read(std::string& _return, const ThriftHandle& handle, const int64_t offset, const int32_t size) {
+ // Your implementation goes here
+ printf("read\n");
+ }
+
+ bool close(const ThriftHandle& out) {
+ // Your implementation goes here
+ printf("close\n");
+ }
+
+ bool rm(const Pathname& path, const bool recursive) {
+ // Your implementation goes here
+ printf("rm\n");
+ }
+
+ bool rename(const Pathname& path, const Pathname& dest) {
+ // Your implementation goes here
+ printf("rename\n");
+ }
+
+ bool mkdirs(const Pathname& path) {
+ // Your implementation goes here
+ printf("mkdirs\n");
+ }
+
+ bool exists(const Pathname& path) {
+ // Your implementation goes here
+ printf("exists\n");
+ }
+
+ void stat(FileStatus& _return, const Pathname& path) {
+ // Your implementation goes here
+ printf("stat\n");
+ }
+
+ void listStatus(std::vector<FileStatus> & _return, const Pathname& path) {
+ // Your implementation goes here
+ printf("listStatus\n");
+ }
+
+ void chmod(const Pathname& path, const int16_t mode) {
+ // Your implementation goes here
+ printf("chmod\n");
+ }
+
+ void chown(const Pathname& path, const std::string& owner, const std::string& group) {
+ // Your implementation goes here
+ printf("chown\n");
+ }
+
+ void setReplication(const Pathname& path, const int16_t replication) {
+ // Your implementation goes here
+ printf("setReplication\n");
+ }
+
+ void getFileBlockLocations(std::vector<BlockLocation> & _return, const Pathname& path, const int64_t start, const int64_t length) {
+ // Your implementation goes here
+ printf("getFileBlockLocations\n");
+ }
+
+};
+
+int main(int argc, char **argv) {
+ int port = 9090;
+ shared_ptr<ThriftHadoopFileSystemHandler> handler(new ThriftHadoopFileSystemHandler());
+ shared_ptr<TProcessor> processor(new ThriftHadoopFileSystemProcessor(handler));
+ shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+ shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+ shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+ TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+ server.serve();
+ return 0;
+}
+
Added: hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_constants.cpp
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_constants.cpp?rev=690096&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_constants.cpp (added)
+++ hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_constants.cpp Thu Aug 28 21:31:57 2008
@@ -0,0 +1,16 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "hadoopfs_constants.h"
+
+
+
+const hadoopfsConstants g_hadoopfs_constants;
+
+hadoopfsConstants::hadoopfsConstants() {
+}
+
+
+
Added: hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_constants.h
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_constants.h?rev=690096&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_constants.h (added)
+++ hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_constants.h Thu Aug 28 21:31:57 2008
@@ -0,0 +1,23 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef hadoopfs_CONSTANTS_H
+#define hadoopfs_CONSTANTS_H
+
+#include "hadoopfs_types.h"
+
+
+
+class hadoopfsConstants {
+ public:
+ hadoopfsConstants();
+
+};
+
+extern const hadoopfsConstants g_hadoopfs_constants;
+
+
+
+#endif
Added: hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_types.cpp
URL: http://svn.apache.org/viewvc/hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_types.cpp?rev=690096&view=auto
==============================================================================
--- hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_types.cpp (added)
+++ hadoop/core/trunk/src/contrib/thriftfs/gen-cpp/hadoopfs_types.cpp Thu Aug 28 21:31:57 2008
@@ -0,0 +1,495 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "hadoopfs_types.h"
+
+
+
+const char* ThriftHandle::ascii_fingerprint = "2317B51D4172A111734AAB85F990F7C6";
+const uint8_t ThriftHandle::binary_fingerprint[16] = {0x23,0x17,0xB5,0x1D,0x41,0x72,0xA1,0x11,0x73,0x4A,0xAB,0x85,0xF9,0x90,0xF7,0xC6};
+
+uint32_t ThriftHandle::read(facebook::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ facebook::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using facebook::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == facebook::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case -1:
+ if (ftype == facebook::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->id);
+ this->__isset.id = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHandle::write(facebook::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHandle");
+ xfer += oprot->writeFieldBegin("id", facebook::thrift::protocol::T_I64, -1);
+ xfer += oprot->writeI64(this->id);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Pathname::ascii_fingerprint = "E2167DA91A8F7459A2FE1B5F56D14B5D";
+const uint8_t Pathname::binary_fingerprint[16] = {0xE2,0x16,0x7D,0xA9,0x1A,0x8F,0x74,0x59,0xA2,0xFE,0x1B,0x5F,0x56,0xD1,0x4B,0x5D};
+
+uint32_t Pathname::read(facebook::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ facebook::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using facebook::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == facebook::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case -1:
+ if (ftype == facebook::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->pathname);
+ this->__isset.pathname = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Pathname::write(facebook::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Pathname");
+ xfer += oprot->writeFieldBegin("pathname", facebook::thrift::protocol::T_STRING, -1);
+ xfer += oprot->writeString(this->pathname);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* FileStatus::ascii_fingerprint = "68FE7242A6727149B291A86FB9570D2B";
+const uint8_t FileStatus::binary_fingerprint[16] = {0x68,0xFE,0x72,0x42,0xA6,0x72,0x71,0x49,0xB2,0x91,0xA8,0x6F,0xB9,0x57,0x0D,0x2B};
+
+uint32_t FileStatus::read(facebook::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ facebook::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using facebook::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == facebook::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == facebook::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->path);
+ this->__isset.path = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == facebook::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->length);
+ this->__isset.length = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == facebook::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->isdir);
+ this->__isset.isdir = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == facebook::thrift::protocol::T_I16) {
+ xfer += iprot->readI16(this->block_replication);
+ this->__isset.block_replication = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == facebook::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->blocksize);
+ this->__isset.blocksize = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == facebook::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->modification_time);
+ this->__isset.modification_time = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == facebook::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->permission);
+ this->__isset.permission = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == facebook::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->owner);
+ this->__isset.owner = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 9:
+ if (ftype == facebook::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->group);
+ this->__isset.group = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t FileStatus::write(facebook::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("FileStatus");
+ xfer += oprot->writeFieldBegin("path", facebook::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->path);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("length", facebook::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->length);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("isdir", facebook::thrift::protocol::T_BOOL, 3);
+ xfer += oprot->writeBool(this->isdir);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("block_replication", facebook::thrift::protocol::T_I16, 4);
+ xfer += oprot->writeI16(this->block_replication);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("blocksize", facebook::thrift::protocol::T_I64, 5);
+ xfer += oprot->writeI64(this->blocksize);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("modification_time", facebook::thrift::protocol::T_I64, 6);
+ xfer += oprot->writeI64(this->modification_time);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("permission", facebook::thrift::protocol::T_STRING, 7);
+ xfer += oprot->writeString(this->permission);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("owner", facebook::thrift::protocol::T_STRING, 8);
+ xfer += oprot->writeString(this->owner);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("group", facebook::thrift::protocol::T_STRING, 9);
+ xfer += oprot->writeString(this->group);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* BlockLocation::ascii_fingerprint = "8BF3B16BED96367B21783389BDF8B1C0";
+const uint8_t BlockLocation::binary_fingerprint[16] = {0x8B,0xF3,0xB1,0x6B,0xED,0x96,0x36,0x7B,0x21,0x78,0x33,0x89,0xBD,0xF8,0xB1,0xC0};
+
+uint32_t BlockLocation::read(facebook::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ facebook::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using facebook::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == facebook::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == facebook::thrift::protocol::T_LIST) {
+ {
+ this->hosts.clear();
+ uint32_t _size0;
+ facebook::thrift::protocol::TType _etype3;
+ iprot->readListBegin(_etype3, _size0);
+ this->hosts.resize(_size0);
+ uint32_t _i4;
+ for (_i4 = 0; _i4 < _size0; ++_i4)
+ {
+ xfer += iprot->readString(this->hosts[_i4]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.hosts = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == facebook::thrift::protocol::T_LIST) {
+ {
+ this->names.clear();
+ uint32_t _size5;
+ facebook::thrift::protocol::TType _etype8;
+ iprot->readListBegin(_etype8, _size5);
+ this->names.resize(_size5);
+ uint32_t _i9;
+ for (_i9 = 0; _i9 < _size5; ++_i9)
+ {
+ xfer += iprot->readString(this->names[_i9]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.names = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == facebook::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->offset);
+ this->__isset.offset = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == facebook::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->length);
+ this->__isset.length = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t BlockLocation::write(facebook::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("BlockLocation");
+ xfer += oprot->writeFieldBegin("hosts", facebook::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, this->hosts.size());
+ std::vector<std::string> ::const_iterator _iter10;
+ for (_iter10 = this->hosts.begin(); _iter10 != this->hosts.end(); ++_iter10)
+ {
+ xfer += oprot->writeString((*_iter10));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("names", facebook::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, this->names.size());
+ std::vector<std::string> ::const_iterator _iter11;
+ for (_iter11 = this->names.begin(); _iter11 != this->names.end(); ++_iter11)
+ {
+ xfer += oprot->writeString((*_iter11));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("offset", facebook::thrift::protocol::T_I64, 3);
+ xfer += oprot->writeI64(this->offset);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("length", facebook::thrift::protocol::T_I64, 4);
+ xfer += oprot->writeI64(this->length);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* MalformedInputException::ascii_fingerprint = "E2167DA91A8F7459A2FE1B5F56D14B5D";
+const uint8_t MalformedInputException::binary_fingerprint[16] = {0xE2,0x16,0x7D,0xA9,0x1A,0x8F,0x74,0x59,0xA2,0xFE,0x1B,0x5F,0x56,0xD1,0x4B,0x5D};
+
+uint32_t MalformedInputException::read(facebook::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ facebook::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using facebook::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == facebook::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case -1:
+ if (ftype == facebook::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t MalformedInputException::write(facebook::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("MalformedInputException");
+ xfer += oprot->writeFieldBegin("message", facebook::thrift::protocol::T_STRING, -1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* ThriftIOException::ascii_fingerprint = "E2167DA91A8F7459A2FE1B5F56D14B5D";
+const uint8_t ThriftIOException::binary_fingerprint[16] = {0xE2,0x16,0x7D,0xA9,0x1A,0x8F,0x74,0x59,0xA2,0xFE,0x1B,0x5F,0x56,0xD1,0x4B,0x5D};
+
+uint32_t ThriftIOException::read(facebook::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ facebook::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using facebook::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == facebook::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case -1:
+ if (ftype == facebook::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftIOException::write(facebook::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftIOException");
+ xfer += oprot->writeFieldBegin("message", facebook::thrift::protocol::T_STRING, -1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+