Return-Path: Delivered-To: apmail-hadoop-core-commits-archive@www.apache.org Received: (qmail 10328 invoked from network); 29 Aug 2008 04:32:55 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.2) by minotaur.apache.org with SMTP; 29 Aug 2008 04:32:55 -0000 Received: (qmail 34083 invoked by uid 500); 29 Aug 2008 04:32:53 -0000 Delivered-To: apmail-hadoop-core-commits-archive@hadoop.apache.org Received: (qmail 34055 invoked by uid 500); 29 Aug 2008 04:32:53 -0000 Mailing-List: contact core-commits-help@hadoop.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: core-dev@hadoop.apache.org Delivered-To: mailing list core-commits@hadoop.apache.org Received: (qmail 34045 invoked by uid 99); 29 Aug 2008 04:32:53 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 28 Aug 2008 21:32:53 -0700 X-ASF-Spam-Status: No, hits=-2000.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 29 Aug 2008 04:32:02 +0000 Received: by eris.apache.org (Postfix, from userid 65534) id BAD7B2388A16; Thu, 28 Aug 2008 21:32:02 -0700 (PDT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: 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... Date: Fri, 29 Aug 2008 04:32:00 -0000 To: core-commits@hadoop.apache.org From: omalley@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20080829043202.BAD7B2388A16@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org 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 +#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 & _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 & _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 & /* _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 & /* _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 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 * 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 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 * 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 prot) : + piprot_(prot), + poprot_(prot) { + iprot_ = prot.get(); + oprot_ = prot.get(); + } + ThriftHadoopFileSystemClient(boost::shared_ptr iprot, boost::shared_ptr oprot) : + piprot_(iprot), + poprot_(oprot) { + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + boost::shared_ptr getInputProtocol() { + return piprot_; + } + boost::shared_ptr 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 & _return, const Pathname& path); + void send_listStatus(const Pathname& path); + void recv_listStatus(std::vector & _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 & _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 & _return); + protected: + boost::shared_ptr piprot_; + boost::shared_ptr poprot_; + facebook::thrift::protocol::TProtocol* iprot_; + facebook::thrift::protocol::TProtocol* oprot_; +}; + +class ThriftHadoopFileSystemProcessor : virtual public facebook::thrift::TProcessor { + protected: + boost::shared_ptr iface_; + virtual bool process_fn(facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid); + private: + std::map 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 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 piprot, boost::shared_ptr poprot); + virtual ~ThriftHadoopFileSystemProcessor() {} +}; + +class ThriftHadoopFileSystemMultiface : virtual public ThriftHadoopFileSystemIf { + public: + ThriftHadoopFileSystemMultiface(std::vector >& ifaces) : ifaces_(ifaces) { + } + virtual ~ThriftHadoopFileSystemMultiface() {} + protected: + std::vector > ifaces_; + ThriftHadoopFileSystemMultiface() {} + void add(boost::shared_ptr 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 & _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 & _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 +#include +#include +#include + +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 & _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 & _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 handler(new ThriftHadoopFileSystemHandler()); + shared_ptr processor(new ThriftHadoopFileSystemProcessor(handler)); + shared_ptr serverTransport(new TServerSocket(port)); + shared_ptr transportFactory(new TBufferedTransportFactory()); + shared_ptr 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 ::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 ::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; +} + +