| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * Autogenerated by Thrift Compiler (0.9.1) |
| * |
| * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| * @generated |
| */ |
| #ifndef AccumuloProxy_H |
| #define AccumuloProxy_H |
| |
| #include <thrift/TDispatchProcessor.h> |
| #include "proxy_types.h" |
| |
| namespace accumulo { |
| |
| class AccumuloProxyIf { |
| public: |
| virtual ~AccumuloProxyIf() {} |
| virtual void login(std::string& _return, const std::string& principal, const std::map<std::string, std::string> & loginProperties) = 0; |
| virtual int32_t addConstraint(const std::string& login, const std::string& tableName, const std::string& constraintClassName) = 0; |
| virtual void addSplits(const std::string& login, const std::string& tableName, const std::set<std::string> & splits) = 0; |
| virtual void attachIterator(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes) = 0; |
| virtual void checkIteratorConflicts(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes) = 0; |
| virtual void clearLocatorCache(const std::string& login, const std::string& tableName) = 0; |
| virtual void cloneTable(const std::string& login, const std::string& tableName, const std::string& newTableName, const bool flush, const std::map<std::string, std::string> & propertiesToSet, const std::set<std::string> & propertiesToExclude) = 0; |
| virtual void compactTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const std::vector<IteratorSetting> & iterators, const bool flush, const bool wait, const CompactionStrategyConfig& compactionStrategy) = 0; |
| virtual void cancelCompaction(const std::string& login, const std::string& tableName) = 0; |
| virtual void createTable(const std::string& login, const std::string& tableName, const bool versioningIter, const TimeType::type type) = 0; |
| virtual void deleteTable(const std::string& login, const std::string& tableName) = 0; |
| virtual void deleteRows(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow) = 0; |
| virtual void exportTable(const std::string& login, const std::string& tableName, const std::string& exportDir) = 0; |
| virtual void flushTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const bool wait) = 0; |
| virtual void getDiskUsage(std::vector<DiskUsage> & _return, const std::string& login, const std::set<std::string> & tables) = 0; |
| virtual void getLocalityGroups(std::map<std::string, std::set<std::string> > & _return, const std::string& login, const std::string& tableName) = 0; |
| virtual void getIteratorSetting(IteratorSetting& _return, const std::string& login, const std::string& tableName, const std::string& iteratorName, const IteratorScope::type scope) = 0; |
| virtual void getMaxRow(std::string& _return, const std::string& login, const std::string& tableName, const std::set<std::string> & auths, const std::string& startRow, const bool startInclusive, const std::string& endRow, const bool endInclusive) = 0; |
| virtual void getTableProperties(std::map<std::string, std::string> & _return, const std::string& login, const std::string& tableName) = 0; |
| virtual void importDirectory(const std::string& login, const std::string& tableName, const std::string& importDir, const std::string& failureDir, const bool setTime) = 0; |
| virtual void importTable(const std::string& login, const std::string& tableName, const std::string& importDir) = 0; |
| virtual void listSplits(std::vector<std::string> & _return, const std::string& login, const std::string& tableName, const int32_t maxSplits) = 0; |
| virtual void listTables(std::set<std::string> & _return, const std::string& login) = 0; |
| virtual void listIterators(std::map<std::string, std::set<IteratorScope::type> > & _return, const std::string& login, const std::string& tableName) = 0; |
| virtual void listConstraints(std::map<std::string, int32_t> & _return, const std::string& login, const std::string& tableName) = 0; |
| virtual void mergeTablets(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow) = 0; |
| virtual void offlineTable(const std::string& login, const std::string& tableName, const bool wait) = 0; |
| virtual void onlineTable(const std::string& login, const std::string& tableName, const bool wait) = 0; |
| virtual void removeConstraint(const std::string& login, const std::string& tableName, const int32_t constraint) = 0; |
| virtual void removeIterator(const std::string& login, const std::string& tableName, const std::string& iterName, const std::set<IteratorScope::type> & scopes) = 0; |
| virtual void removeTableProperty(const std::string& login, const std::string& tableName, const std::string& property) = 0; |
| virtual void renameTable(const std::string& login, const std::string& oldTableName, const std::string& newTableName) = 0; |
| virtual void setLocalityGroups(const std::string& login, const std::string& tableName, const std::map<std::string, std::set<std::string> > & groups) = 0; |
| virtual void setTableProperty(const std::string& login, const std::string& tableName, const std::string& property, const std::string& value) = 0; |
| virtual void splitRangeByTablets(std::set<Range> & _return, const std::string& login, const std::string& tableName, const Range& range, const int32_t maxSplits) = 0; |
| virtual bool tableExists(const std::string& login, const std::string& tableName) = 0; |
| virtual void tableIdMap(std::map<std::string, std::string> & _return, const std::string& login) = 0; |
| virtual bool testTableClassLoad(const std::string& login, const std::string& tableName, const std::string& className, const std::string& asTypeName) = 0; |
| virtual void pingTabletServer(const std::string& login, const std::string& tserver) = 0; |
| virtual void getActiveScans(std::vector<ActiveScan> & _return, const std::string& login, const std::string& tserver) = 0; |
| virtual void getActiveCompactions(std::vector<ActiveCompaction> & _return, const std::string& login, const std::string& tserver) = 0; |
| virtual void getSiteConfiguration(std::map<std::string, std::string> & _return, const std::string& login) = 0; |
| virtual void getSystemConfiguration(std::map<std::string, std::string> & _return, const std::string& login) = 0; |
| virtual void getTabletServers(std::vector<std::string> & _return, const std::string& login) = 0; |
| virtual void removeProperty(const std::string& login, const std::string& property) = 0; |
| virtual void setProperty(const std::string& login, const std::string& property, const std::string& value) = 0; |
| virtual bool testClassLoad(const std::string& login, const std::string& className, const std::string& asTypeName) = 0; |
| virtual bool authenticateUser(const std::string& login, const std::string& user, const std::map<std::string, std::string> & properties) = 0; |
| virtual void changeUserAuthorizations(const std::string& login, const std::string& user, const std::set<std::string> & authorizations) = 0; |
| virtual void changeLocalUserPassword(const std::string& login, const std::string& user, const std::string& password) = 0; |
| virtual void createLocalUser(const std::string& login, const std::string& user, const std::string& password) = 0; |
| virtual void dropLocalUser(const std::string& login, const std::string& user) = 0; |
| virtual void getUserAuthorizations(std::vector<std::string> & _return, const std::string& login, const std::string& user) = 0; |
| virtual void grantSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) = 0; |
| virtual void grantTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) = 0; |
| virtual bool hasSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) = 0; |
| virtual bool hasTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) = 0; |
| virtual void listLocalUsers(std::set<std::string> & _return, const std::string& login) = 0; |
| virtual void revokeSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) = 0; |
| virtual void revokeTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) = 0; |
| virtual void createBatchScanner(std::string& _return, const std::string& login, const std::string& tableName, const BatchScanOptions& options) = 0; |
| virtual void createScanner(std::string& _return, const std::string& login, const std::string& tableName, const ScanOptions& options) = 0; |
| virtual bool hasNext(const std::string& scanner) = 0; |
| virtual void nextEntry(KeyValueAndPeek& _return, const std::string& scanner) = 0; |
| virtual void nextK(ScanResult& _return, const std::string& scanner, const int32_t k) = 0; |
| virtual void closeScanner(const std::string& scanner) = 0; |
| virtual void updateAndFlush(const std::string& login, const std::string& tableName, const std::map<std::string, std::vector<ColumnUpdate> > & cells) = 0; |
| virtual void createWriter(std::string& _return, const std::string& login, const std::string& tableName, const WriterOptions& opts) = 0; |
| virtual void update(const std::string& writer, const std::map<std::string, std::vector<ColumnUpdate> > & cells) = 0; |
| virtual void flush(const std::string& writer) = 0; |
| virtual void closeWriter(const std::string& writer) = 0; |
| virtual ConditionalStatus::type updateRowConditionally(const std::string& login, const std::string& tableName, const std::string& row, const ConditionalUpdates& updates) = 0; |
| virtual void createConditionalWriter(std::string& _return, const std::string& login, const std::string& tableName, const ConditionalWriterOptions& options) = 0; |
| virtual void updateRowsConditionally(std::map<std::string, ConditionalStatus::type> & _return, const std::string& conditionalWriter, const std::map<std::string, ConditionalUpdates> & updates) = 0; |
| virtual void closeConditionalWriter(const std::string& conditionalWriter) = 0; |
| virtual void getRowRange(Range& _return, const std::string& row) = 0; |
| virtual void getFollowing(Key& _return, const Key& key, const PartialKey::type part) = 0; |
| }; |
| |
| class AccumuloProxyIfFactory { |
| public: |
| typedef AccumuloProxyIf Handler; |
| |
| virtual ~AccumuloProxyIfFactory() {} |
| |
| virtual AccumuloProxyIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; |
| virtual void releaseHandler(AccumuloProxyIf* /* handler */) = 0; |
| }; |
| |
| class AccumuloProxyIfSingletonFactory : virtual public AccumuloProxyIfFactory { |
| public: |
| AccumuloProxyIfSingletonFactory(const boost::shared_ptr<AccumuloProxyIf>& iface) : iface_(iface) {} |
| virtual ~AccumuloProxyIfSingletonFactory() {} |
| |
| virtual AccumuloProxyIf* getHandler(const ::apache::thrift::TConnectionInfo&) { |
| return iface_.get(); |
| } |
| virtual void releaseHandler(AccumuloProxyIf* /* handler */) {} |
| |
| protected: |
| boost::shared_ptr<AccumuloProxyIf> iface_; |
| }; |
| |
| class AccumuloProxyNull : virtual public AccumuloProxyIf { |
| public: |
| virtual ~AccumuloProxyNull() {} |
| void login(std::string& /* _return */, const std::string& /* principal */, const std::map<std::string, std::string> & /* loginProperties */) { |
| return; |
| } |
| int32_t addConstraint(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* constraintClassName */) { |
| int32_t _return = 0; |
| return _return; |
| } |
| void addSplits(const std::string& /* login */, const std::string& /* tableName */, const std::set<std::string> & /* splits */) { |
| return; |
| } |
| void attachIterator(const std::string& /* login */, const std::string& /* tableName */, const IteratorSetting& /* setting */, const std::set<IteratorScope::type> & /* scopes */) { |
| return; |
| } |
| void checkIteratorConflicts(const std::string& /* login */, const std::string& /* tableName */, const IteratorSetting& /* setting */, const std::set<IteratorScope::type> & /* scopes */) { |
| return; |
| } |
| void clearLocatorCache(const std::string& /* login */, const std::string& /* tableName */) { |
| return; |
| } |
| void cloneTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* newTableName */, const bool /* flush */, const std::map<std::string, std::string> & /* propertiesToSet */, const std::set<std::string> & /* propertiesToExclude */) { |
| return; |
| } |
| void compactTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* startRow */, const std::string& /* endRow */, const std::vector<IteratorSetting> & /* iterators */, const bool /* flush */, const bool /* wait */, const CompactionStrategyConfig& /* compactionStrategy */) { |
| return; |
| } |
| void cancelCompaction(const std::string& /* login */, const std::string& /* tableName */) { |
| return; |
| } |
| void createTable(const std::string& /* login */, const std::string& /* tableName */, const bool /* versioningIter */, const TimeType::type /* type */) { |
| return; |
| } |
| void deleteTable(const std::string& /* login */, const std::string& /* tableName */) { |
| return; |
| } |
| void deleteRows(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* startRow */, const std::string& /* endRow */) { |
| return; |
| } |
| void exportTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* exportDir */) { |
| return; |
| } |
| void flushTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* startRow */, const std::string& /* endRow */, const bool /* wait */) { |
| return; |
| } |
| void getDiskUsage(std::vector<DiskUsage> & /* _return */, const std::string& /* login */, const std::set<std::string> & /* tables */) { |
| return; |
| } |
| void getLocalityGroups(std::map<std::string, std::set<std::string> > & /* _return */, const std::string& /* login */, const std::string& /* tableName */) { |
| return; |
| } |
| void getIteratorSetting(IteratorSetting& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const std::string& /* iteratorName */, const IteratorScope::type /* scope */) { |
| return; |
| } |
| void getMaxRow(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const std::set<std::string> & /* auths */, const std::string& /* startRow */, const bool /* startInclusive */, const std::string& /* endRow */, const bool /* endInclusive */) { |
| return; |
| } |
| void getTableProperties(std::map<std::string, std::string> & /* _return */, const std::string& /* login */, const std::string& /* tableName */) { |
| return; |
| } |
| void importDirectory(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* importDir */, const std::string& /* failureDir */, const bool /* setTime */) { |
| return; |
| } |
| void importTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* importDir */) { |
| return; |
| } |
| void listSplits(std::vector<std::string> & /* _return */, const std::string& /* login */, const std::string& /* tableName */, const int32_t /* maxSplits */) { |
| return; |
| } |
| void listTables(std::set<std::string> & /* _return */, const std::string& /* login */) { |
| return; |
| } |
| void listIterators(std::map<std::string, std::set<IteratorScope::type> > & /* _return */, const std::string& /* login */, const std::string& /* tableName */) { |
| return; |
| } |
| void listConstraints(std::map<std::string, int32_t> & /* _return */, const std::string& /* login */, const std::string& /* tableName */) { |
| return; |
| } |
| void mergeTablets(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* startRow */, const std::string& /* endRow */) { |
| return; |
| } |
| void offlineTable(const std::string& /* login */, const std::string& /* tableName */, const bool /* wait */) { |
| return; |
| } |
| void onlineTable(const std::string& /* login */, const std::string& /* tableName */, const bool /* wait */) { |
| return; |
| } |
| void removeConstraint(const std::string& /* login */, const std::string& /* tableName */, const int32_t /* constraint */) { |
| return; |
| } |
| void removeIterator(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* iterName */, const std::set<IteratorScope::type> & /* scopes */) { |
| return; |
| } |
| void removeTableProperty(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* property */) { |
| return; |
| } |
| void renameTable(const std::string& /* login */, const std::string& /* oldTableName */, const std::string& /* newTableName */) { |
| return; |
| } |
| void setLocalityGroups(const std::string& /* login */, const std::string& /* tableName */, const std::map<std::string, std::set<std::string> > & /* groups */) { |
| return; |
| } |
| void setTableProperty(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* property */, const std::string& /* value */) { |
| return; |
| } |
| void splitRangeByTablets(std::set<Range> & /* _return */, const std::string& /* login */, const std::string& /* tableName */, const Range& /* range */, const int32_t /* maxSplits */) { |
| return; |
| } |
| bool tableExists(const std::string& /* login */, const std::string& /* tableName */) { |
| bool _return = false; |
| return _return; |
| } |
| void tableIdMap(std::map<std::string, std::string> & /* _return */, const std::string& /* login */) { |
| return; |
| } |
| bool testTableClassLoad(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* className */, const std::string& /* asTypeName */) { |
| bool _return = false; |
| return _return; |
| } |
| void pingTabletServer(const std::string& /* login */, const std::string& /* tserver */) { |
| return; |
| } |
| void getActiveScans(std::vector<ActiveScan> & /* _return */, const std::string& /* login */, const std::string& /* tserver */) { |
| return; |
| } |
| void getActiveCompactions(std::vector<ActiveCompaction> & /* _return */, const std::string& /* login */, const std::string& /* tserver */) { |
| return; |
| } |
| void getSiteConfiguration(std::map<std::string, std::string> & /* _return */, const std::string& /* login */) { |
| return; |
| } |
| void getSystemConfiguration(std::map<std::string, std::string> & /* _return */, const std::string& /* login */) { |
| return; |
| } |
| void getTabletServers(std::vector<std::string> & /* _return */, const std::string& /* login */) { |
| return; |
| } |
| void removeProperty(const std::string& /* login */, const std::string& /* property */) { |
| return; |
| } |
| void setProperty(const std::string& /* login */, const std::string& /* property */, const std::string& /* value */) { |
| return; |
| } |
| bool testClassLoad(const std::string& /* login */, const std::string& /* className */, const std::string& /* asTypeName */) { |
| bool _return = false; |
| return _return; |
| } |
| bool authenticateUser(const std::string& /* login */, const std::string& /* user */, const std::map<std::string, std::string> & /* properties */) { |
| bool _return = false; |
| return _return; |
| } |
| void changeUserAuthorizations(const std::string& /* login */, const std::string& /* user */, const std::set<std::string> & /* authorizations */) { |
| return; |
| } |
| void changeLocalUserPassword(const std::string& /* login */, const std::string& /* user */, const std::string& /* password */) { |
| return; |
| } |
| void createLocalUser(const std::string& /* login */, const std::string& /* user */, const std::string& /* password */) { |
| return; |
| } |
| void dropLocalUser(const std::string& /* login */, const std::string& /* user */) { |
| return; |
| } |
| void getUserAuthorizations(std::vector<std::string> & /* _return */, const std::string& /* login */, const std::string& /* user */) { |
| return; |
| } |
| void grantSystemPermission(const std::string& /* login */, const std::string& /* user */, const SystemPermission::type /* perm */) { |
| return; |
| } |
| void grantTablePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* table */, const TablePermission::type /* perm */) { |
| return; |
| } |
| bool hasSystemPermission(const std::string& /* login */, const std::string& /* user */, const SystemPermission::type /* perm */) { |
| bool _return = false; |
| return _return; |
| } |
| bool hasTablePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* table */, const TablePermission::type /* perm */) { |
| bool _return = false; |
| return _return; |
| } |
| void listLocalUsers(std::set<std::string> & /* _return */, const std::string& /* login */) { |
| return; |
| } |
| void revokeSystemPermission(const std::string& /* login */, const std::string& /* user */, const SystemPermission::type /* perm */) { |
| return; |
| } |
| void revokeTablePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* table */, const TablePermission::type /* perm */) { |
| return; |
| } |
| void createBatchScanner(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const BatchScanOptions& /* options */) { |
| return; |
| } |
| void createScanner(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const ScanOptions& /* options */) { |
| return; |
| } |
| bool hasNext(const std::string& /* scanner */) { |
| bool _return = false; |
| return _return; |
| } |
| void nextEntry(KeyValueAndPeek& /* _return */, const std::string& /* scanner */) { |
| return; |
| } |
| void nextK(ScanResult& /* _return */, const std::string& /* scanner */, const int32_t /* k */) { |
| return; |
| } |
| void closeScanner(const std::string& /* scanner */) { |
| return; |
| } |
| void updateAndFlush(const std::string& /* login */, const std::string& /* tableName */, const std::map<std::string, std::vector<ColumnUpdate> > & /* cells */) { |
| return; |
| } |
| void createWriter(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const WriterOptions& /* opts */) { |
| return; |
| } |
| void update(const std::string& /* writer */, const std::map<std::string, std::vector<ColumnUpdate> > & /* cells */) { |
| return; |
| } |
| void flush(const std::string& /* writer */) { |
| return; |
| } |
| void closeWriter(const std::string& /* writer */) { |
| return; |
| } |
| ConditionalStatus::type updateRowConditionally(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* row */, const ConditionalUpdates& /* updates */) { |
| ConditionalStatus::type _return = (ConditionalStatus::type)0; |
| return _return; |
| } |
| void createConditionalWriter(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const ConditionalWriterOptions& /* options */) { |
| return; |
| } |
| void updateRowsConditionally(std::map<std::string, ConditionalStatus::type> & /* _return */, const std::string& /* conditionalWriter */, const std::map<std::string, ConditionalUpdates> & /* updates */) { |
| return; |
| } |
| void closeConditionalWriter(const std::string& /* conditionalWriter */) { |
| return; |
| } |
| void getRowRange(Range& /* _return */, const std::string& /* row */) { |
| return; |
| } |
| void getFollowing(Key& /* _return */, const Key& /* key */, const PartialKey::type /* part */) { |
| return; |
| } |
| }; |
| |
| typedef struct _AccumuloProxy_login_args__isset { |
| _AccumuloProxy_login_args__isset() : principal(false), loginProperties(false) {} |
| bool principal; |
| bool loginProperties; |
| } _AccumuloProxy_login_args__isset; |
| |
| class AccumuloProxy_login_args { |
| public: |
| |
| AccumuloProxy_login_args() : principal() { |
| } |
| |
| virtual ~AccumuloProxy_login_args() throw() {} |
| |
| std::string principal; |
| std::map<std::string, std::string> loginProperties; |
| |
| _AccumuloProxy_login_args__isset __isset; |
| |
| void __set_principal(const std::string& val) { |
| principal = val; |
| } |
| |
| void __set_loginProperties(const std::map<std::string, std::string> & val) { |
| loginProperties = val; |
| } |
| |
| bool operator == (const AccumuloProxy_login_args & rhs) const |
| { |
| if (!(principal == rhs.principal)) |
| return false; |
| if (!(loginProperties == rhs.loginProperties)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_login_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_login_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_login_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_login_pargs() throw() {} |
| |
| const std::string* principal; |
| const std::map<std::string, std::string> * loginProperties; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_login_result__isset { |
| _AccumuloProxy_login_result__isset() : success(false), ouch2(false) {} |
| bool success; |
| bool ouch2; |
| } _AccumuloProxy_login_result__isset; |
| |
| class AccumuloProxy_login_result { |
| public: |
| |
| AccumuloProxy_login_result() : success() { |
| } |
| |
| virtual ~AccumuloProxy_login_result() throw() {} |
| |
| std::string success; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_login_result__isset __isset; |
| |
| void __set_success(const std::string& val) { |
| success = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_login_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_login_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_login_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_login_presult__isset { |
| _AccumuloProxy_login_presult__isset() : success(false), ouch2(false) {} |
| bool success; |
| bool ouch2; |
| } _AccumuloProxy_login_presult__isset; |
| |
| class AccumuloProxy_login_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_login_presult() throw() {} |
| |
| std::string* success; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_login_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_addConstraint_args__isset { |
| _AccumuloProxy_addConstraint_args__isset() : login(false), tableName(false), constraintClassName(false) {} |
| bool login; |
| bool tableName; |
| bool constraintClassName; |
| } _AccumuloProxy_addConstraint_args__isset; |
| |
| class AccumuloProxy_addConstraint_args { |
| public: |
| |
| AccumuloProxy_addConstraint_args() : login(), tableName(), constraintClassName() { |
| } |
| |
| virtual ~AccumuloProxy_addConstraint_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string constraintClassName; |
| |
| _AccumuloProxy_addConstraint_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_constraintClassName(const std::string& val) { |
| constraintClassName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_addConstraint_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(constraintClassName == rhs.constraintClassName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_addConstraint_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_addConstraint_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_addConstraint_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_addConstraint_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* constraintClassName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_addConstraint_result__isset { |
| _AccumuloProxy_addConstraint_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_addConstraint_result__isset; |
| |
| class AccumuloProxy_addConstraint_result { |
| public: |
| |
| AccumuloProxy_addConstraint_result() : success(0) { |
| } |
| |
| virtual ~AccumuloProxy_addConstraint_result() throw() {} |
| |
| int32_t success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_addConstraint_result__isset __isset; |
| |
| void __set_success(const int32_t val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_addConstraint_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_addConstraint_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_addConstraint_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_addConstraint_presult__isset { |
| _AccumuloProxy_addConstraint_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_addConstraint_presult__isset; |
| |
| class AccumuloProxy_addConstraint_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_addConstraint_presult() throw() {} |
| |
| int32_t* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_addConstraint_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_addSplits_args__isset { |
| _AccumuloProxy_addSplits_args__isset() : login(false), tableName(false), splits(false) {} |
| bool login; |
| bool tableName; |
| bool splits; |
| } _AccumuloProxy_addSplits_args__isset; |
| |
| class AccumuloProxy_addSplits_args { |
| public: |
| |
| AccumuloProxy_addSplits_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_addSplits_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::set<std::string> splits; |
| |
| _AccumuloProxy_addSplits_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_splits(const std::set<std::string> & val) { |
| splits = val; |
| } |
| |
| bool operator == (const AccumuloProxy_addSplits_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(splits == rhs.splits)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_addSplits_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_addSplits_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_addSplits_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_addSplits_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::set<std::string> * splits; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_addSplits_result__isset { |
| _AccumuloProxy_addSplits_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_addSplits_result__isset; |
| |
| class AccumuloProxy_addSplits_result { |
| public: |
| |
| AccumuloProxy_addSplits_result() { |
| } |
| |
| virtual ~AccumuloProxy_addSplits_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_addSplits_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_addSplits_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_addSplits_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_addSplits_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_addSplits_presult__isset { |
| _AccumuloProxy_addSplits_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_addSplits_presult__isset; |
| |
| class AccumuloProxy_addSplits_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_addSplits_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_addSplits_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_attachIterator_args__isset { |
| _AccumuloProxy_attachIterator_args__isset() : login(false), tableName(false), setting(false), scopes(false) {} |
| bool login; |
| bool tableName; |
| bool setting; |
| bool scopes; |
| } _AccumuloProxy_attachIterator_args__isset; |
| |
| class AccumuloProxy_attachIterator_args { |
| public: |
| |
| AccumuloProxy_attachIterator_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_attachIterator_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| IteratorSetting setting; |
| std::set<IteratorScope::type> scopes; |
| |
| _AccumuloProxy_attachIterator_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_setting(const IteratorSetting& val) { |
| setting = val; |
| } |
| |
| void __set_scopes(const std::set<IteratorScope::type> & val) { |
| scopes = val; |
| } |
| |
| bool operator == (const AccumuloProxy_attachIterator_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(setting == rhs.setting)) |
| return false; |
| if (!(scopes == rhs.scopes)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_attachIterator_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_attachIterator_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_attachIterator_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_attachIterator_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const IteratorSetting* setting; |
| const std::set<IteratorScope::type> * scopes; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_attachIterator_result__isset { |
| _AccumuloProxy_attachIterator_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_attachIterator_result__isset; |
| |
| class AccumuloProxy_attachIterator_result { |
| public: |
| |
| AccumuloProxy_attachIterator_result() { |
| } |
| |
| virtual ~AccumuloProxy_attachIterator_result() throw() {} |
| |
| AccumuloSecurityException ouch1; |
| AccumuloException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_attachIterator_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloSecurityException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_attachIterator_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_attachIterator_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_attachIterator_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_attachIterator_presult__isset { |
| _AccumuloProxy_attachIterator_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_attachIterator_presult__isset; |
| |
| class AccumuloProxy_attachIterator_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_attachIterator_presult() throw() {} |
| |
| AccumuloSecurityException ouch1; |
| AccumuloException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_attachIterator_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_checkIteratorConflicts_args__isset { |
| _AccumuloProxy_checkIteratorConflicts_args__isset() : login(false), tableName(false), setting(false), scopes(false) {} |
| bool login; |
| bool tableName; |
| bool setting; |
| bool scopes; |
| } _AccumuloProxy_checkIteratorConflicts_args__isset; |
| |
| class AccumuloProxy_checkIteratorConflicts_args { |
| public: |
| |
| AccumuloProxy_checkIteratorConflicts_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_checkIteratorConflicts_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| IteratorSetting setting; |
| std::set<IteratorScope::type> scopes; |
| |
| _AccumuloProxy_checkIteratorConflicts_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_setting(const IteratorSetting& val) { |
| setting = val; |
| } |
| |
| void __set_scopes(const std::set<IteratorScope::type> & val) { |
| scopes = val; |
| } |
| |
| bool operator == (const AccumuloProxy_checkIteratorConflicts_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(setting == rhs.setting)) |
| return false; |
| if (!(scopes == rhs.scopes)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_checkIteratorConflicts_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_checkIteratorConflicts_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_checkIteratorConflicts_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_checkIteratorConflicts_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const IteratorSetting* setting; |
| const std::set<IteratorScope::type> * scopes; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_checkIteratorConflicts_result__isset { |
| _AccumuloProxy_checkIteratorConflicts_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_checkIteratorConflicts_result__isset; |
| |
| class AccumuloProxy_checkIteratorConflicts_result { |
| public: |
| |
| AccumuloProxy_checkIteratorConflicts_result() { |
| } |
| |
| virtual ~AccumuloProxy_checkIteratorConflicts_result() throw() {} |
| |
| AccumuloSecurityException ouch1; |
| AccumuloException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_checkIteratorConflicts_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloSecurityException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_checkIteratorConflicts_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_checkIteratorConflicts_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_checkIteratorConflicts_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_checkIteratorConflicts_presult__isset { |
| _AccumuloProxy_checkIteratorConflicts_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_checkIteratorConflicts_presult__isset; |
| |
| class AccumuloProxy_checkIteratorConflicts_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_checkIteratorConflicts_presult() throw() {} |
| |
| AccumuloSecurityException ouch1; |
| AccumuloException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_checkIteratorConflicts_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_clearLocatorCache_args__isset { |
| _AccumuloProxy_clearLocatorCache_args__isset() : login(false), tableName(false) {} |
| bool login; |
| bool tableName; |
| } _AccumuloProxy_clearLocatorCache_args__isset; |
| |
| class AccumuloProxy_clearLocatorCache_args { |
| public: |
| |
| AccumuloProxy_clearLocatorCache_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_clearLocatorCache_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| |
| _AccumuloProxy_clearLocatorCache_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_clearLocatorCache_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_clearLocatorCache_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_clearLocatorCache_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_clearLocatorCache_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_clearLocatorCache_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_clearLocatorCache_result__isset { |
| _AccumuloProxy_clearLocatorCache_result__isset() : ouch1(false) {} |
| bool ouch1; |
| } _AccumuloProxy_clearLocatorCache_result__isset; |
| |
| class AccumuloProxy_clearLocatorCache_result { |
| public: |
| |
| AccumuloProxy_clearLocatorCache_result() { |
| } |
| |
| virtual ~AccumuloProxy_clearLocatorCache_result() throw() {} |
| |
| TableNotFoundException ouch1; |
| |
| _AccumuloProxy_clearLocatorCache_result__isset __isset; |
| |
| void __set_ouch1(const TableNotFoundException& val) { |
| ouch1 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_clearLocatorCache_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_clearLocatorCache_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_clearLocatorCache_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_clearLocatorCache_presult__isset { |
| _AccumuloProxy_clearLocatorCache_presult__isset() : ouch1(false) {} |
| bool ouch1; |
| } _AccumuloProxy_clearLocatorCache_presult__isset; |
| |
| class AccumuloProxy_clearLocatorCache_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_clearLocatorCache_presult() throw() {} |
| |
| TableNotFoundException ouch1; |
| |
| _AccumuloProxy_clearLocatorCache_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_cloneTable_args__isset { |
| _AccumuloProxy_cloneTable_args__isset() : login(false), tableName(false), newTableName(false), flush(false), propertiesToSet(false), propertiesToExclude(false) {} |
| bool login; |
| bool tableName; |
| bool newTableName; |
| bool flush; |
| bool propertiesToSet; |
| bool propertiesToExclude; |
| } _AccumuloProxy_cloneTable_args__isset; |
| |
| class AccumuloProxy_cloneTable_args { |
| public: |
| |
| AccumuloProxy_cloneTable_args() : login(), tableName(), newTableName(), flush(0) { |
| } |
| |
| virtual ~AccumuloProxy_cloneTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string newTableName; |
| bool flush; |
| std::map<std::string, std::string> propertiesToSet; |
| std::set<std::string> propertiesToExclude; |
| |
| _AccumuloProxy_cloneTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_newTableName(const std::string& val) { |
| newTableName = val; |
| } |
| |
| void __set_flush(const bool val) { |
| flush = val; |
| } |
| |
| void __set_propertiesToSet(const std::map<std::string, std::string> & val) { |
| propertiesToSet = val; |
| } |
| |
| void __set_propertiesToExclude(const std::set<std::string> & val) { |
| propertiesToExclude = val; |
| } |
| |
| bool operator == (const AccumuloProxy_cloneTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(newTableName == rhs.newTableName)) |
| return false; |
| if (!(flush == rhs.flush)) |
| return false; |
| if (!(propertiesToSet == rhs.propertiesToSet)) |
| return false; |
| if (!(propertiesToExclude == rhs.propertiesToExclude)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_cloneTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_cloneTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_cloneTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_cloneTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* newTableName; |
| const bool* flush; |
| const std::map<std::string, std::string> * propertiesToSet; |
| const std::set<std::string> * propertiesToExclude; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_cloneTable_result__isset { |
| _AccumuloProxy_cloneTable_result__isset() : ouch1(false), ouch2(false), ouch3(false), ouch4(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| bool ouch4; |
| } _AccumuloProxy_cloneTable_result__isset; |
| |
| class AccumuloProxy_cloneTable_result { |
| public: |
| |
| AccumuloProxy_cloneTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_cloneTable_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| TableExistsException ouch4; |
| |
| _AccumuloProxy_cloneTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| void __set_ouch4(const TableExistsException& val) { |
| ouch4 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_cloneTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| if (!(ouch4 == rhs.ouch4)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_cloneTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_cloneTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_cloneTable_presult__isset { |
| _AccumuloProxy_cloneTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false), ouch4(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| bool ouch4; |
| } _AccumuloProxy_cloneTable_presult__isset; |
| |
| class AccumuloProxy_cloneTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_cloneTable_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| TableExistsException ouch4; |
| |
| _AccumuloProxy_cloneTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_compactTable_args__isset { |
| _AccumuloProxy_compactTable_args__isset() : login(false), tableName(false), startRow(false), endRow(false), iterators(false), flush(false), wait(false), compactionStrategy(false) {} |
| bool login; |
| bool tableName; |
| bool startRow; |
| bool endRow; |
| bool iterators; |
| bool flush; |
| bool wait; |
| bool compactionStrategy; |
| } _AccumuloProxy_compactTable_args__isset; |
| |
| class AccumuloProxy_compactTable_args { |
| public: |
| |
| AccumuloProxy_compactTable_args() : login(), tableName(), startRow(), endRow(), flush(0), wait(0) { |
| } |
| |
| virtual ~AccumuloProxy_compactTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string startRow; |
| std::string endRow; |
| std::vector<IteratorSetting> iterators; |
| bool flush; |
| bool wait; |
| CompactionStrategyConfig compactionStrategy; |
| |
| _AccumuloProxy_compactTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_startRow(const std::string& val) { |
| startRow = val; |
| } |
| |
| void __set_endRow(const std::string& val) { |
| endRow = val; |
| } |
| |
| void __set_iterators(const std::vector<IteratorSetting> & val) { |
| iterators = val; |
| } |
| |
| void __set_flush(const bool val) { |
| flush = val; |
| } |
| |
| void __set_wait(const bool val) { |
| wait = val; |
| } |
| |
| void __set_compactionStrategy(const CompactionStrategyConfig& val) { |
| compactionStrategy = val; |
| } |
| |
| bool operator == (const AccumuloProxy_compactTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(startRow == rhs.startRow)) |
| return false; |
| if (!(endRow == rhs.endRow)) |
| return false; |
| if (!(iterators == rhs.iterators)) |
| return false; |
| if (!(flush == rhs.flush)) |
| return false; |
| if (!(wait == rhs.wait)) |
| return false; |
| if (!(compactionStrategy == rhs.compactionStrategy)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_compactTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_compactTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_compactTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_compactTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* startRow; |
| const std::string* endRow; |
| const std::vector<IteratorSetting> * iterators; |
| const bool* flush; |
| const bool* wait; |
| const CompactionStrategyConfig* compactionStrategy; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_compactTable_result__isset { |
| _AccumuloProxy_compactTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_compactTable_result__isset; |
| |
| class AccumuloProxy_compactTable_result { |
| public: |
| |
| AccumuloProxy_compactTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_compactTable_result() throw() {} |
| |
| AccumuloSecurityException ouch1; |
| TableNotFoundException ouch2; |
| AccumuloException ouch3; |
| |
| _AccumuloProxy_compactTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloSecurityException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const TableNotFoundException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const AccumuloException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_compactTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_compactTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_compactTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_compactTable_presult__isset { |
| _AccumuloProxy_compactTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_compactTable_presult__isset; |
| |
| class AccumuloProxy_compactTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_compactTable_presult() throw() {} |
| |
| AccumuloSecurityException ouch1; |
| TableNotFoundException ouch2; |
| AccumuloException ouch3; |
| |
| _AccumuloProxy_compactTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_cancelCompaction_args__isset { |
| _AccumuloProxy_cancelCompaction_args__isset() : login(false), tableName(false) {} |
| bool login; |
| bool tableName; |
| } _AccumuloProxy_cancelCompaction_args__isset; |
| |
| class AccumuloProxy_cancelCompaction_args { |
| public: |
| |
| AccumuloProxy_cancelCompaction_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_cancelCompaction_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| |
| _AccumuloProxy_cancelCompaction_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_cancelCompaction_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_cancelCompaction_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_cancelCompaction_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_cancelCompaction_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_cancelCompaction_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_cancelCompaction_result__isset { |
| _AccumuloProxy_cancelCompaction_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_cancelCompaction_result__isset; |
| |
| class AccumuloProxy_cancelCompaction_result { |
| public: |
| |
| AccumuloProxy_cancelCompaction_result() { |
| } |
| |
| virtual ~AccumuloProxy_cancelCompaction_result() throw() {} |
| |
| AccumuloSecurityException ouch1; |
| TableNotFoundException ouch2; |
| AccumuloException ouch3; |
| |
| _AccumuloProxy_cancelCompaction_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloSecurityException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const TableNotFoundException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const AccumuloException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_cancelCompaction_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_cancelCompaction_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_cancelCompaction_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_cancelCompaction_presult__isset { |
| _AccumuloProxy_cancelCompaction_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_cancelCompaction_presult__isset; |
| |
| class AccumuloProxy_cancelCompaction_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_cancelCompaction_presult() throw() {} |
| |
| AccumuloSecurityException ouch1; |
| TableNotFoundException ouch2; |
| AccumuloException ouch3; |
| |
| _AccumuloProxy_cancelCompaction_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createTable_args__isset { |
| _AccumuloProxy_createTable_args__isset() : login(false), tableName(false), versioningIter(false), type(false) {} |
| bool login; |
| bool tableName; |
| bool versioningIter; |
| bool type; |
| } _AccumuloProxy_createTable_args__isset; |
| |
| class AccumuloProxy_createTable_args { |
| public: |
| |
| AccumuloProxy_createTable_args() : login(), tableName(), versioningIter(0), type((TimeType::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_createTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| bool versioningIter; |
| TimeType::type type; |
| |
| _AccumuloProxy_createTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_versioningIter(const bool val) { |
| versioningIter = val; |
| } |
| |
| void __set_type(const TimeType::type val) { |
| type = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(versioningIter == rhs.versioningIter)) |
| return false; |
| if (!(type == rhs.type)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_createTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const bool* versioningIter; |
| const TimeType::type* type; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createTable_result__isset { |
| _AccumuloProxy_createTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createTable_result__isset; |
| |
| class AccumuloProxy_createTable_result { |
| public: |
| |
| AccumuloProxy_createTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_createTable_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableExistsException ouch3; |
| |
| _AccumuloProxy_createTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableExistsException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createTable_presult__isset { |
| _AccumuloProxy_createTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createTable_presult__isset; |
| |
| class AccumuloProxy_createTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createTable_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableExistsException ouch3; |
| |
| _AccumuloProxy_createTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_deleteTable_args__isset { |
| _AccumuloProxy_deleteTable_args__isset() : login(false), tableName(false) {} |
| bool login; |
| bool tableName; |
| } _AccumuloProxy_deleteTable_args__isset; |
| |
| class AccumuloProxy_deleteTable_args { |
| public: |
| |
| AccumuloProxy_deleteTable_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_deleteTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| |
| _AccumuloProxy_deleteTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_deleteTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_deleteTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_deleteTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_deleteTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_deleteTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_deleteTable_result__isset { |
| _AccumuloProxy_deleteTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_deleteTable_result__isset; |
| |
| class AccumuloProxy_deleteTable_result { |
| public: |
| |
| AccumuloProxy_deleteTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_deleteTable_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_deleteTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_deleteTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_deleteTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_deleteTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_deleteTable_presult__isset { |
| _AccumuloProxy_deleteTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_deleteTable_presult__isset; |
| |
| class AccumuloProxy_deleteTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_deleteTable_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_deleteTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_deleteRows_args__isset { |
| _AccumuloProxy_deleteRows_args__isset() : login(false), tableName(false), startRow(false), endRow(false) {} |
| bool login; |
| bool tableName; |
| bool startRow; |
| bool endRow; |
| } _AccumuloProxy_deleteRows_args__isset; |
| |
| class AccumuloProxy_deleteRows_args { |
| public: |
| |
| AccumuloProxy_deleteRows_args() : login(), tableName(), startRow(), endRow() { |
| } |
| |
| virtual ~AccumuloProxy_deleteRows_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string startRow; |
| std::string endRow; |
| |
| _AccumuloProxy_deleteRows_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_startRow(const std::string& val) { |
| startRow = val; |
| } |
| |
| void __set_endRow(const std::string& val) { |
| endRow = val; |
| } |
| |
| bool operator == (const AccumuloProxy_deleteRows_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(startRow == rhs.startRow)) |
| return false; |
| if (!(endRow == rhs.endRow)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_deleteRows_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_deleteRows_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_deleteRows_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_deleteRows_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* startRow; |
| const std::string* endRow; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_deleteRows_result__isset { |
| _AccumuloProxy_deleteRows_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_deleteRows_result__isset; |
| |
| class AccumuloProxy_deleteRows_result { |
| public: |
| |
| AccumuloProxy_deleteRows_result() { |
| } |
| |
| virtual ~AccumuloProxy_deleteRows_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_deleteRows_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_deleteRows_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_deleteRows_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_deleteRows_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_deleteRows_presult__isset { |
| _AccumuloProxy_deleteRows_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_deleteRows_presult__isset; |
| |
| class AccumuloProxy_deleteRows_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_deleteRows_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_deleteRows_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_exportTable_args__isset { |
| _AccumuloProxy_exportTable_args__isset() : login(false), tableName(false), exportDir(false) {} |
| bool login; |
| bool tableName; |
| bool exportDir; |
| } _AccumuloProxy_exportTable_args__isset; |
| |
| class AccumuloProxy_exportTable_args { |
| public: |
| |
| AccumuloProxy_exportTable_args() : login(), tableName(), exportDir() { |
| } |
| |
| virtual ~AccumuloProxy_exportTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string exportDir; |
| |
| _AccumuloProxy_exportTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_exportDir(const std::string& val) { |
| exportDir = val; |
| } |
| |
| bool operator == (const AccumuloProxy_exportTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(exportDir == rhs.exportDir)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_exportTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_exportTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_exportTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_exportTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* exportDir; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_exportTable_result__isset { |
| _AccumuloProxy_exportTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_exportTable_result__isset; |
| |
| class AccumuloProxy_exportTable_result { |
| public: |
| |
| AccumuloProxy_exportTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_exportTable_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_exportTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_exportTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_exportTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_exportTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_exportTable_presult__isset { |
| _AccumuloProxy_exportTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_exportTable_presult__isset; |
| |
| class AccumuloProxy_exportTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_exportTable_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_exportTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_flushTable_args__isset { |
| _AccumuloProxy_flushTable_args__isset() : login(false), tableName(false), startRow(false), endRow(false), wait(false) {} |
| bool login; |
| bool tableName; |
| bool startRow; |
| bool endRow; |
| bool wait; |
| } _AccumuloProxy_flushTable_args__isset; |
| |
| class AccumuloProxy_flushTable_args { |
| public: |
| |
| AccumuloProxy_flushTable_args() : login(), tableName(), startRow(), endRow(), wait(0) { |
| } |
| |
| virtual ~AccumuloProxy_flushTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string startRow; |
| std::string endRow; |
| bool wait; |
| |
| _AccumuloProxy_flushTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_startRow(const std::string& val) { |
| startRow = val; |
| } |
| |
| void __set_endRow(const std::string& val) { |
| endRow = val; |
| } |
| |
| void __set_wait(const bool val) { |
| wait = val; |
| } |
| |
| bool operator == (const AccumuloProxy_flushTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(startRow == rhs.startRow)) |
| return false; |
| if (!(endRow == rhs.endRow)) |
| return false; |
| if (!(wait == rhs.wait)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_flushTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_flushTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_flushTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_flushTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* startRow; |
| const std::string* endRow; |
| const bool* wait; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_flushTable_result__isset { |
| _AccumuloProxy_flushTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_flushTable_result__isset; |
| |
| class AccumuloProxy_flushTable_result { |
| public: |
| |
| AccumuloProxy_flushTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_flushTable_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_flushTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_flushTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_flushTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_flushTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_flushTable_presult__isset { |
| _AccumuloProxy_flushTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_flushTable_presult__isset; |
| |
| class AccumuloProxy_flushTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_flushTable_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_flushTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getDiskUsage_args__isset { |
| _AccumuloProxy_getDiskUsage_args__isset() : login(false), tables(false) {} |
| bool login; |
| bool tables; |
| } _AccumuloProxy_getDiskUsage_args__isset; |
| |
| class AccumuloProxy_getDiskUsage_args { |
| public: |
| |
| AccumuloProxy_getDiskUsage_args() : login() { |
| } |
| |
| virtual ~AccumuloProxy_getDiskUsage_args() throw() {} |
| |
| std::string login; |
| std::set<std::string> tables; |
| |
| _AccumuloProxy_getDiskUsage_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tables(const std::set<std::string> & val) { |
| tables = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getDiskUsage_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tables == rhs.tables)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getDiskUsage_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getDiskUsage_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getDiskUsage_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getDiskUsage_pargs() throw() {} |
| |
| const std::string* login; |
| const std::set<std::string> * tables; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getDiskUsage_result__isset { |
| _AccumuloProxy_getDiskUsage_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getDiskUsage_result__isset; |
| |
| class AccumuloProxy_getDiskUsage_result { |
| public: |
| |
| AccumuloProxy_getDiskUsage_result() { |
| } |
| |
| virtual ~AccumuloProxy_getDiskUsage_result() throw() {} |
| |
| std::vector<DiskUsage> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getDiskUsage_result__isset __isset; |
| |
| void __set_success(const std::vector<DiskUsage> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getDiskUsage_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getDiskUsage_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getDiskUsage_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getDiskUsage_presult__isset { |
| _AccumuloProxy_getDiskUsage_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getDiskUsage_presult__isset; |
| |
| class AccumuloProxy_getDiskUsage_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getDiskUsage_presult() throw() {} |
| |
| std::vector<DiskUsage> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getDiskUsage_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getLocalityGroups_args__isset { |
| _AccumuloProxy_getLocalityGroups_args__isset() : login(false), tableName(false) {} |
| bool login; |
| bool tableName; |
| } _AccumuloProxy_getLocalityGroups_args__isset; |
| |
| class AccumuloProxy_getLocalityGroups_args { |
| public: |
| |
| AccumuloProxy_getLocalityGroups_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_getLocalityGroups_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| |
| _AccumuloProxy_getLocalityGroups_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getLocalityGroups_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getLocalityGroups_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getLocalityGroups_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getLocalityGroups_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getLocalityGroups_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getLocalityGroups_result__isset { |
| _AccumuloProxy_getLocalityGroups_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getLocalityGroups_result__isset; |
| |
| class AccumuloProxy_getLocalityGroups_result { |
| public: |
| |
| AccumuloProxy_getLocalityGroups_result() { |
| } |
| |
| virtual ~AccumuloProxy_getLocalityGroups_result() throw() {} |
| |
| std::map<std::string, std::set<std::string> > success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getLocalityGroups_result__isset __isset; |
| |
| void __set_success(const std::map<std::string, std::set<std::string> > & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getLocalityGroups_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getLocalityGroups_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getLocalityGroups_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getLocalityGroups_presult__isset { |
| _AccumuloProxy_getLocalityGroups_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getLocalityGroups_presult__isset; |
| |
| class AccumuloProxy_getLocalityGroups_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getLocalityGroups_presult() throw() {} |
| |
| std::map<std::string, std::set<std::string> > * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getLocalityGroups_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getIteratorSetting_args__isset { |
| _AccumuloProxy_getIteratorSetting_args__isset() : login(false), tableName(false), iteratorName(false), scope(false) {} |
| bool login; |
| bool tableName; |
| bool iteratorName; |
| bool scope; |
| } _AccumuloProxy_getIteratorSetting_args__isset; |
| |
| class AccumuloProxy_getIteratorSetting_args { |
| public: |
| |
| AccumuloProxy_getIteratorSetting_args() : login(), tableName(), iteratorName(), scope((IteratorScope::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_getIteratorSetting_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string iteratorName; |
| IteratorScope::type scope; |
| |
| _AccumuloProxy_getIteratorSetting_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_iteratorName(const std::string& val) { |
| iteratorName = val; |
| } |
| |
| void __set_scope(const IteratorScope::type val) { |
| scope = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getIteratorSetting_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(iteratorName == rhs.iteratorName)) |
| return false; |
| if (!(scope == rhs.scope)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getIteratorSetting_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getIteratorSetting_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getIteratorSetting_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getIteratorSetting_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* iteratorName; |
| const IteratorScope::type* scope; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getIteratorSetting_result__isset { |
| _AccumuloProxy_getIteratorSetting_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getIteratorSetting_result__isset; |
| |
| class AccumuloProxy_getIteratorSetting_result { |
| public: |
| |
| AccumuloProxy_getIteratorSetting_result() { |
| } |
| |
| virtual ~AccumuloProxy_getIteratorSetting_result() throw() {} |
| |
| IteratorSetting success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getIteratorSetting_result__isset __isset; |
| |
| void __set_success(const IteratorSetting& val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getIteratorSetting_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getIteratorSetting_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getIteratorSetting_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getIteratorSetting_presult__isset { |
| _AccumuloProxy_getIteratorSetting_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getIteratorSetting_presult__isset; |
| |
| class AccumuloProxy_getIteratorSetting_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getIteratorSetting_presult() throw() {} |
| |
| IteratorSetting* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getIteratorSetting_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getMaxRow_args__isset { |
| _AccumuloProxy_getMaxRow_args__isset() : login(false), tableName(false), auths(false), startRow(false), startInclusive(false), endRow(false), endInclusive(false) {} |
| bool login; |
| bool tableName; |
| bool auths; |
| bool startRow; |
| bool startInclusive; |
| bool endRow; |
| bool endInclusive; |
| } _AccumuloProxy_getMaxRow_args__isset; |
| |
| class AccumuloProxy_getMaxRow_args { |
| public: |
| |
| AccumuloProxy_getMaxRow_args() : login(), tableName(), startRow(), startInclusive(0), endRow(), endInclusive(0) { |
| } |
| |
| virtual ~AccumuloProxy_getMaxRow_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::set<std::string> auths; |
| std::string startRow; |
| bool startInclusive; |
| std::string endRow; |
| bool endInclusive; |
| |
| _AccumuloProxy_getMaxRow_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_auths(const std::set<std::string> & val) { |
| auths = val; |
| } |
| |
| void __set_startRow(const std::string& val) { |
| startRow = val; |
| } |
| |
| void __set_startInclusive(const bool val) { |
| startInclusive = val; |
| } |
| |
| void __set_endRow(const std::string& val) { |
| endRow = val; |
| } |
| |
| void __set_endInclusive(const bool val) { |
| endInclusive = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getMaxRow_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(auths == rhs.auths)) |
| return false; |
| if (!(startRow == rhs.startRow)) |
| return false; |
| if (!(startInclusive == rhs.startInclusive)) |
| return false; |
| if (!(endRow == rhs.endRow)) |
| return false; |
| if (!(endInclusive == rhs.endInclusive)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getMaxRow_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getMaxRow_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getMaxRow_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getMaxRow_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::set<std::string> * auths; |
| const std::string* startRow; |
| const bool* startInclusive; |
| const std::string* endRow; |
| const bool* endInclusive; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getMaxRow_result__isset { |
| _AccumuloProxy_getMaxRow_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getMaxRow_result__isset; |
| |
| class AccumuloProxy_getMaxRow_result { |
| public: |
| |
| AccumuloProxy_getMaxRow_result() : success() { |
| } |
| |
| virtual ~AccumuloProxy_getMaxRow_result() throw() {} |
| |
| std::string success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getMaxRow_result__isset __isset; |
| |
| void __set_success(const std::string& val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getMaxRow_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getMaxRow_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getMaxRow_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getMaxRow_presult__isset { |
| _AccumuloProxy_getMaxRow_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getMaxRow_presult__isset; |
| |
| class AccumuloProxy_getMaxRow_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getMaxRow_presult() throw() {} |
| |
| std::string* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getMaxRow_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getTableProperties_args__isset { |
| _AccumuloProxy_getTableProperties_args__isset() : login(false), tableName(false) {} |
| bool login; |
| bool tableName; |
| } _AccumuloProxy_getTableProperties_args__isset; |
| |
| class AccumuloProxy_getTableProperties_args { |
| public: |
| |
| AccumuloProxy_getTableProperties_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_getTableProperties_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| |
| _AccumuloProxy_getTableProperties_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getTableProperties_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getTableProperties_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getTableProperties_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getTableProperties_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getTableProperties_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getTableProperties_result__isset { |
| _AccumuloProxy_getTableProperties_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getTableProperties_result__isset; |
| |
| class AccumuloProxy_getTableProperties_result { |
| public: |
| |
| AccumuloProxy_getTableProperties_result() { |
| } |
| |
| virtual ~AccumuloProxy_getTableProperties_result() throw() {} |
| |
| std::map<std::string, std::string> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getTableProperties_result__isset __isset; |
| |
| void __set_success(const std::map<std::string, std::string> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getTableProperties_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getTableProperties_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getTableProperties_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getTableProperties_presult__isset { |
| _AccumuloProxy_getTableProperties_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_getTableProperties_presult__isset; |
| |
| class AccumuloProxy_getTableProperties_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getTableProperties_presult() throw() {} |
| |
| std::map<std::string, std::string> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_getTableProperties_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_importDirectory_args__isset { |
| _AccumuloProxy_importDirectory_args__isset() : login(false), tableName(false), importDir(false), failureDir(false), setTime(false) {} |
| bool login; |
| bool tableName; |
| bool importDir; |
| bool failureDir; |
| bool setTime; |
| } _AccumuloProxy_importDirectory_args__isset; |
| |
| class AccumuloProxy_importDirectory_args { |
| public: |
| |
| AccumuloProxy_importDirectory_args() : login(), tableName(), importDir(), failureDir(), setTime(0) { |
| } |
| |
| virtual ~AccumuloProxy_importDirectory_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string importDir; |
| std::string failureDir; |
| bool setTime; |
| |
| _AccumuloProxy_importDirectory_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_importDir(const std::string& val) { |
| importDir = val; |
| } |
| |
| void __set_failureDir(const std::string& val) { |
| failureDir = val; |
| } |
| |
| void __set_setTime(const bool val) { |
| setTime = val; |
| } |
| |
| bool operator == (const AccumuloProxy_importDirectory_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(importDir == rhs.importDir)) |
| return false; |
| if (!(failureDir == rhs.failureDir)) |
| return false; |
| if (!(setTime == rhs.setTime)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_importDirectory_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_importDirectory_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_importDirectory_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_importDirectory_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* importDir; |
| const std::string* failureDir; |
| const bool* setTime; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_importDirectory_result__isset { |
| _AccumuloProxy_importDirectory_result__isset() : ouch1(false), ouch3(false), ouch4(false) {} |
| bool ouch1; |
| bool ouch3; |
| bool ouch4; |
| } _AccumuloProxy_importDirectory_result__isset; |
| |
| class AccumuloProxy_importDirectory_result { |
| public: |
| |
| AccumuloProxy_importDirectory_result() { |
| } |
| |
| virtual ~AccumuloProxy_importDirectory_result() throw() {} |
| |
| TableNotFoundException ouch1; |
| AccumuloException ouch3; |
| AccumuloSecurityException ouch4; |
| |
| _AccumuloProxy_importDirectory_result__isset __isset; |
| |
| void __set_ouch1(const TableNotFoundException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch3(const AccumuloException& val) { |
| ouch3 = val; |
| } |
| |
| void __set_ouch4(const AccumuloSecurityException& val) { |
| ouch4 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_importDirectory_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| if (!(ouch4 == rhs.ouch4)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_importDirectory_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_importDirectory_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_importDirectory_presult__isset { |
| _AccumuloProxy_importDirectory_presult__isset() : ouch1(false), ouch3(false), ouch4(false) {} |
| bool ouch1; |
| bool ouch3; |
| bool ouch4; |
| } _AccumuloProxy_importDirectory_presult__isset; |
| |
| class AccumuloProxy_importDirectory_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_importDirectory_presult() throw() {} |
| |
| TableNotFoundException ouch1; |
| AccumuloException ouch3; |
| AccumuloSecurityException ouch4; |
| |
| _AccumuloProxy_importDirectory_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_importTable_args__isset { |
| _AccumuloProxy_importTable_args__isset() : login(false), tableName(false), importDir(false) {} |
| bool login; |
| bool tableName; |
| bool importDir; |
| } _AccumuloProxy_importTable_args__isset; |
| |
| class AccumuloProxy_importTable_args { |
| public: |
| |
| AccumuloProxy_importTable_args() : login(), tableName(), importDir() { |
| } |
| |
| virtual ~AccumuloProxy_importTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string importDir; |
| |
| _AccumuloProxy_importTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_importDir(const std::string& val) { |
| importDir = val; |
| } |
| |
| bool operator == (const AccumuloProxy_importTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(importDir == rhs.importDir)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_importTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_importTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_importTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_importTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* importDir; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_importTable_result__isset { |
| _AccumuloProxy_importTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_importTable_result__isset; |
| |
| class AccumuloProxy_importTable_result { |
| public: |
| |
| AccumuloProxy_importTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_importTable_result() throw() {} |
| |
| TableExistsException ouch1; |
| AccumuloException ouch2; |
| AccumuloSecurityException ouch3; |
| |
| _AccumuloProxy_importTable_result__isset __isset; |
| |
| void __set_ouch1(const TableExistsException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const AccumuloSecurityException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_importTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_importTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_importTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_importTable_presult__isset { |
| _AccumuloProxy_importTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_importTable_presult__isset; |
| |
| class AccumuloProxy_importTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_importTable_presult() throw() {} |
| |
| TableExistsException ouch1; |
| AccumuloException ouch2; |
| AccumuloSecurityException ouch3; |
| |
| _AccumuloProxy_importTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listSplits_args__isset { |
| _AccumuloProxy_listSplits_args__isset() : login(false), tableName(false), maxSplits(false) {} |
| bool login; |
| bool tableName; |
| bool maxSplits; |
| } _AccumuloProxy_listSplits_args__isset; |
| |
| class AccumuloProxy_listSplits_args { |
| public: |
| |
| AccumuloProxy_listSplits_args() : login(), tableName(), maxSplits(0) { |
| } |
| |
| virtual ~AccumuloProxy_listSplits_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| int32_t maxSplits; |
| |
| _AccumuloProxy_listSplits_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_maxSplits(const int32_t val) { |
| maxSplits = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listSplits_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(maxSplits == rhs.maxSplits)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listSplits_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listSplits_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_listSplits_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listSplits_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const int32_t* maxSplits; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listSplits_result__isset { |
| _AccumuloProxy_listSplits_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_listSplits_result__isset; |
| |
| class AccumuloProxy_listSplits_result { |
| public: |
| |
| AccumuloProxy_listSplits_result() { |
| } |
| |
| virtual ~AccumuloProxy_listSplits_result() throw() {} |
| |
| std::vector<std::string> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_listSplits_result__isset __isset; |
| |
| void __set_success(const std::vector<std::string> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listSplits_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listSplits_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listSplits_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listSplits_presult__isset { |
| _AccumuloProxy_listSplits_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_listSplits_presult__isset; |
| |
| class AccumuloProxy_listSplits_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listSplits_presult() throw() {} |
| |
| std::vector<std::string> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_listSplits_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listTables_args__isset { |
| _AccumuloProxy_listTables_args__isset() : login(false) {} |
| bool login; |
| } _AccumuloProxy_listTables_args__isset; |
| |
| class AccumuloProxy_listTables_args { |
| public: |
| |
| AccumuloProxy_listTables_args() : login() { |
| } |
| |
| virtual ~AccumuloProxy_listTables_args() throw() {} |
| |
| std::string login; |
| |
| _AccumuloProxy_listTables_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listTables_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listTables_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listTables_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_listTables_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listTables_pargs() throw() {} |
| |
| const std::string* login; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listTables_result__isset { |
| _AccumuloProxy_listTables_result__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_listTables_result__isset; |
| |
| class AccumuloProxy_listTables_result { |
| public: |
| |
| AccumuloProxy_listTables_result() { |
| } |
| |
| virtual ~AccumuloProxy_listTables_result() throw() {} |
| |
| std::set<std::string> success; |
| |
| _AccumuloProxy_listTables_result__isset __isset; |
| |
| void __set_success(const std::set<std::string> & val) { |
| success = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listTables_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listTables_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listTables_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listTables_presult__isset { |
| _AccumuloProxy_listTables_presult__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_listTables_presult__isset; |
| |
| class AccumuloProxy_listTables_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listTables_presult() throw() {} |
| |
| std::set<std::string> * success; |
| |
| _AccumuloProxy_listTables_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listIterators_args__isset { |
| _AccumuloProxy_listIterators_args__isset() : login(false), tableName(false) {} |
| bool login; |
| bool tableName; |
| } _AccumuloProxy_listIterators_args__isset; |
| |
| class AccumuloProxy_listIterators_args { |
| public: |
| |
| AccumuloProxy_listIterators_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_listIterators_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| |
| _AccumuloProxy_listIterators_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listIterators_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listIterators_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listIterators_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_listIterators_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listIterators_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listIterators_result__isset { |
| _AccumuloProxy_listIterators_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_listIterators_result__isset; |
| |
| class AccumuloProxy_listIterators_result { |
| public: |
| |
| AccumuloProxy_listIterators_result() { |
| } |
| |
| virtual ~AccumuloProxy_listIterators_result() throw() {} |
| |
| std::map<std::string, std::set<IteratorScope::type> > success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_listIterators_result__isset __isset; |
| |
| void __set_success(const std::map<std::string, std::set<IteratorScope::type> > & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listIterators_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listIterators_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listIterators_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listIterators_presult__isset { |
| _AccumuloProxy_listIterators_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_listIterators_presult__isset; |
| |
| class AccumuloProxy_listIterators_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listIterators_presult() throw() {} |
| |
| std::map<std::string, std::set<IteratorScope::type> > * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_listIterators_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listConstraints_args__isset { |
| _AccumuloProxy_listConstraints_args__isset() : login(false), tableName(false) {} |
| bool login; |
| bool tableName; |
| } _AccumuloProxy_listConstraints_args__isset; |
| |
| class AccumuloProxy_listConstraints_args { |
| public: |
| |
| AccumuloProxy_listConstraints_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_listConstraints_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| |
| _AccumuloProxy_listConstraints_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listConstraints_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listConstraints_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listConstraints_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_listConstraints_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listConstraints_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listConstraints_result__isset { |
| _AccumuloProxy_listConstraints_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_listConstraints_result__isset; |
| |
| class AccumuloProxy_listConstraints_result { |
| public: |
| |
| AccumuloProxy_listConstraints_result() { |
| } |
| |
| virtual ~AccumuloProxy_listConstraints_result() throw() {} |
| |
| std::map<std::string, int32_t> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_listConstraints_result__isset __isset; |
| |
| void __set_success(const std::map<std::string, int32_t> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listConstraints_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listConstraints_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listConstraints_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listConstraints_presult__isset { |
| _AccumuloProxy_listConstraints_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_listConstraints_presult__isset; |
| |
| class AccumuloProxy_listConstraints_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listConstraints_presult() throw() {} |
| |
| std::map<std::string, int32_t> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_listConstraints_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_mergeTablets_args__isset { |
| _AccumuloProxy_mergeTablets_args__isset() : login(false), tableName(false), startRow(false), endRow(false) {} |
| bool login; |
| bool tableName; |
| bool startRow; |
| bool endRow; |
| } _AccumuloProxy_mergeTablets_args__isset; |
| |
| class AccumuloProxy_mergeTablets_args { |
| public: |
| |
| AccumuloProxy_mergeTablets_args() : login(), tableName(), startRow(), endRow() { |
| } |
| |
| virtual ~AccumuloProxy_mergeTablets_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string startRow; |
| std::string endRow; |
| |
| _AccumuloProxy_mergeTablets_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_startRow(const std::string& val) { |
| startRow = val; |
| } |
| |
| void __set_endRow(const std::string& val) { |
| endRow = val; |
| } |
| |
| bool operator == (const AccumuloProxy_mergeTablets_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(startRow == rhs.startRow)) |
| return false; |
| if (!(endRow == rhs.endRow)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_mergeTablets_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_mergeTablets_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_mergeTablets_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_mergeTablets_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* startRow; |
| const std::string* endRow; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_mergeTablets_result__isset { |
| _AccumuloProxy_mergeTablets_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_mergeTablets_result__isset; |
| |
| class AccumuloProxy_mergeTablets_result { |
| public: |
| |
| AccumuloProxy_mergeTablets_result() { |
| } |
| |
| virtual ~AccumuloProxy_mergeTablets_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_mergeTablets_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_mergeTablets_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_mergeTablets_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_mergeTablets_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_mergeTablets_presult__isset { |
| _AccumuloProxy_mergeTablets_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_mergeTablets_presult__isset; |
| |
| class AccumuloProxy_mergeTablets_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_mergeTablets_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_mergeTablets_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_offlineTable_args__isset { |
| _AccumuloProxy_offlineTable_args__isset() : login(false), tableName(false), wait(true) {} |
| bool login; |
| bool tableName; |
| bool wait; |
| } _AccumuloProxy_offlineTable_args__isset; |
| |
| class AccumuloProxy_offlineTable_args { |
| public: |
| |
| AccumuloProxy_offlineTable_args() : login(), tableName(), wait(false) { |
| } |
| |
| virtual ~AccumuloProxy_offlineTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| bool wait; |
| |
| _AccumuloProxy_offlineTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_wait(const bool val) { |
| wait = val; |
| } |
| |
| bool operator == (const AccumuloProxy_offlineTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(wait == rhs.wait)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_offlineTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_offlineTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_offlineTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_offlineTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const bool* wait; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_offlineTable_result__isset { |
| _AccumuloProxy_offlineTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_offlineTable_result__isset; |
| |
| class AccumuloProxy_offlineTable_result { |
| public: |
| |
| AccumuloProxy_offlineTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_offlineTable_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_offlineTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_offlineTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_offlineTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_offlineTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_offlineTable_presult__isset { |
| _AccumuloProxy_offlineTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_offlineTable_presult__isset; |
| |
| class AccumuloProxy_offlineTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_offlineTable_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_offlineTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_onlineTable_args__isset { |
| _AccumuloProxy_onlineTable_args__isset() : login(false), tableName(false), wait(true) {} |
| bool login; |
| bool tableName; |
| bool wait; |
| } _AccumuloProxy_onlineTable_args__isset; |
| |
| class AccumuloProxy_onlineTable_args { |
| public: |
| |
| AccumuloProxy_onlineTable_args() : login(), tableName(), wait(false) { |
| } |
| |
| virtual ~AccumuloProxy_onlineTable_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| bool wait; |
| |
| _AccumuloProxy_onlineTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_wait(const bool val) { |
| wait = val; |
| } |
| |
| bool operator == (const AccumuloProxy_onlineTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(wait == rhs.wait)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_onlineTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_onlineTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_onlineTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_onlineTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const bool* wait; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_onlineTable_result__isset { |
| _AccumuloProxy_onlineTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_onlineTable_result__isset; |
| |
| class AccumuloProxy_onlineTable_result { |
| public: |
| |
| AccumuloProxy_onlineTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_onlineTable_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_onlineTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_onlineTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_onlineTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_onlineTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_onlineTable_presult__isset { |
| _AccumuloProxy_onlineTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_onlineTable_presult__isset; |
| |
| class AccumuloProxy_onlineTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_onlineTable_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_onlineTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeConstraint_args__isset { |
| _AccumuloProxy_removeConstraint_args__isset() : login(false), tableName(false), constraint(false) {} |
| bool login; |
| bool tableName; |
| bool constraint; |
| } _AccumuloProxy_removeConstraint_args__isset; |
| |
| class AccumuloProxy_removeConstraint_args { |
| public: |
| |
| AccumuloProxy_removeConstraint_args() : login(), tableName(), constraint(0) { |
| } |
| |
| virtual ~AccumuloProxy_removeConstraint_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| int32_t constraint; |
| |
| _AccumuloProxy_removeConstraint_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_constraint(const int32_t val) { |
| constraint = val; |
| } |
| |
| bool operator == (const AccumuloProxy_removeConstraint_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(constraint == rhs.constraint)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_removeConstraint_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_removeConstraint_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_removeConstraint_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_removeConstraint_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const int32_t* constraint; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeConstraint_result__isset { |
| _AccumuloProxy_removeConstraint_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_removeConstraint_result__isset; |
| |
| class AccumuloProxy_removeConstraint_result { |
| public: |
| |
| AccumuloProxy_removeConstraint_result() { |
| } |
| |
| virtual ~AccumuloProxy_removeConstraint_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_removeConstraint_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_removeConstraint_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_removeConstraint_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_removeConstraint_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeConstraint_presult__isset { |
| _AccumuloProxy_removeConstraint_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_removeConstraint_presult__isset; |
| |
| class AccumuloProxy_removeConstraint_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_removeConstraint_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_removeConstraint_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeIterator_args__isset { |
| _AccumuloProxy_removeIterator_args__isset() : login(false), tableName(false), iterName(false), scopes(false) {} |
| bool login; |
| bool tableName; |
| bool iterName; |
| bool scopes; |
| } _AccumuloProxy_removeIterator_args__isset; |
| |
| class AccumuloProxy_removeIterator_args { |
| public: |
| |
| AccumuloProxy_removeIterator_args() : login(), tableName(), iterName() { |
| } |
| |
| virtual ~AccumuloProxy_removeIterator_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string iterName; |
| std::set<IteratorScope::type> scopes; |
| |
| _AccumuloProxy_removeIterator_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_iterName(const std::string& val) { |
| iterName = val; |
| } |
| |
| void __set_scopes(const std::set<IteratorScope::type> & val) { |
| scopes = val; |
| } |
| |
| bool operator == (const AccumuloProxy_removeIterator_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(iterName == rhs.iterName)) |
| return false; |
| if (!(scopes == rhs.scopes)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_removeIterator_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_removeIterator_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_removeIterator_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_removeIterator_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* iterName; |
| const std::set<IteratorScope::type> * scopes; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeIterator_result__isset { |
| _AccumuloProxy_removeIterator_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_removeIterator_result__isset; |
| |
| class AccumuloProxy_removeIterator_result { |
| public: |
| |
| AccumuloProxy_removeIterator_result() { |
| } |
| |
| virtual ~AccumuloProxy_removeIterator_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_removeIterator_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_removeIterator_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_removeIterator_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_removeIterator_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeIterator_presult__isset { |
| _AccumuloProxy_removeIterator_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_removeIterator_presult__isset; |
| |
| class AccumuloProxy_removeIterator_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_removeIterator_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_removeIterator_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeTableProperty_args__isset { |
| _AccumuloProxy_removeTableProperty_args__isset() : login(false), tableName(false), property(false) {} |
| bool login; |
| bool tableName; |
| bool property; |
| } _AccumuloProxy_removeTableProperty_args__isset; |
| |
| class AccumuloProxy_removeTableProperty_args { |
| public: |
| |
| AccumuloProxy_removeTableProperty_args() : login(), tableName(), property() { |
| } |
| |
| virtual ~AccumuloProxy_removeTableProperty_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string property; |
| |
| _AccumuloProxy_removeTableProperty_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_property(const std::string& val) { |
| property = val; |
| } |
| |
| bool operator == (const AccumuloProxy_removeTableProperty_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(property == rhs.property)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_removeTableProperty_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_removeTableProperty_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_removeTableProperty_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_removeTableProperty_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* property; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeTableProperty_result__isset { |
| _AccumuloProxy_removeTableProperty_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_removeTableProperty_result__isset; |
| |
| class AccumuloProxy_removeTableProperty_result { |
| public: |
| |
| AccumuloProxy_removeTableProperty_result() { |
| } |
| |
| virtual ~AccumuloProxy_removeTableProperty_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_removeTableProperty_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_removeTableProperty_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_removeTableProperty_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_removeTableProperty_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeTableProperty_presult__isset { |
| _AccumuloProxy_removeTableProperty_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_removeTableProperty_presult__isset; |
| |
| class AccumuloProxy_removeTableProperty_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_removeTableProperty_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_removeTableProperty_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_renameTable_args__isset { |
| _AccumuloProxy_renameTable_args__isset() : login(false), oldTableName(false), newTableName(false) {} |
| bool login; |
| bool oldTableName; |
| bool newTableName; |
| } _AccumuloProxy_renameTable_args__isset; |
| |
| class AccumuloProxy_renameTable_args { |
| public: |
| |
| AccumuloProxy_renameTable_args() : login(), oldTableName(), newTableName() { |
| } |
| |
| virtual ~AccumuloProxy_renameTable_args() throw() {} |
| |
| std::string login; |
| std::string oldTableName; |
| std::string newTableName; |
| |
| _AccumuloProxy_renameTable_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_oldTableName(const std::string& val) { |
| oldTableName = val; |
| } |
| |
| void __set_newTableName(const std::string& val) { |
| newTableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_renameTable_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(oldTableName == rhs.oldTableName)) |
| return false; |
| if (!(newTableName == rhs.newTableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_renameTable_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_renameTable_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_renameTable_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_renameTable_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* oldTableName; |
| const std::string* newTableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_renameTable_result__isset { |
| _AccumuloProxy_renameTable_result__isset() : ouch1(false), ouch2(false), ouch3(false), ouch4(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| bool ouch4; |
| } _AccumuloProxy_renameTable_result__isset; |
| |
| class AccumuloProxy_renameTable_result { |
| public: |
| |
| AccumuloProxy_renameTable_result() { |
| } |
| |
| virtual ~AccumuloProxy_renameTable_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| TableExistsException ouch4; |
| |
| _AccumuloProxy_renameTable_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| void __set_ouch4(const TableExistsException& val) { |
| ouch4 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_renameTable_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| if (!(ouch4 == rhs.ouch4)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_renameTable_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_renameTable_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_renameTable_presult__isset { |
| _AccumuloProxy_renameTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false), ouch4(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| bool ouch4; |
| } _AccumuloProxy_renameTable_presult__isset; |
| |
| class AccumuloProxy_renameTable_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_renameTable_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| TableExistsException ouch4; |
| |
| _AccumuloProxy_renameTable_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setLocalityGroups_args__isset { |
| _AccumuloProxy_setLocalityGroups_args__isset() : login(false), tableName(false), groups(false) {} |
| bool login; |
| bool tableName; |
| bool groups; |
| } _AccumuloProxy_setLocalityGroups_args__isset; |
| |
| class AccumuloProxy_setLocalityGroups_args { |
| public: |
| |
| AccumuloProxy_setLocalityGroups_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_setLocalityGroups_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::map<std::string, std::set<std::string> > groups; |
| |
| _AccumuloProxy_setLocalityGroups_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_groups(const std::map<std::string, std::set<std::string> > & val) { |
| groups = val; |
| } |
| |
| bool operator == (const AccumuloProxy_setLocalityGroups_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(groups == rhs.groups)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_setLocalityGroups_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_setLocalityGroups_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_setLocalityGroups_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_setLocalityGroups_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::map<std::string, std::set<std::string> > * groups; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setLocalityGroups_result__isset { |
| _AccumuloProxy_setLocalityGroups_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_setLocalityGroups_result__isset; |
| |
| class AccumuloProxy_setLocalityGroups_result { |
| public: |
| |
| AccumuloProxy_setLocalityGroups_result() { |
| } |
| |
| virtual ~AccumuloProxy_setLocalityGroups_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_setLocalityGroups_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_setLocalityGroups_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_setLocalityGroups_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_setLocalityGroups_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setLocalityGroups_presult__isset { |
| _AccumuloProxy_setLocalityGroups_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_setLocalityGroups_presult__isset; |
| |
| class AccumuloProxy_setLocalityGroups_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_setLocalityGroups_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_setLocalityGroups_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setTableProperty_args__isset { |
| _AccumuloProxy_setTableProperty_args__isset() : login(false), tableName(false), property(false), value(false) {} |
| bool login; |
| bool tableName; |
| bool property; |
| bool value; |
| } _AccumuloProxy_setTableProperty_args__isset; |
| |
| class AccumuloProxy_setTableProperty_args { |
| public: |
| |
| AccumuloProxy_setTableProperty_args() : login(), tableName(), property(), value() { |
| } |
| |
| virtual ~AccumuloProxy_setTableProperty_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string property; |
| std::string value; |
| |
| _AccumuloProxy_setTableProperty_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_property(const std::string& val) { |
| property = val; |
| } |
| |
| void __set_value(const std::string& val) { |
| value = val; |
| } |
| |
| bool operator == (const AccumuloProxy_setTableProperty_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(property == rhs.property)) |
| return false; |
| if (!(value == rhs.value)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_setTableProperty_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_setTableProperty_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_setTableProperty_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_setTableProperty_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* property; |
| const std::string* value; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setTableProperty_result__isset { |
| _AccumuloProxy_setTableProperty_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_setTableProperty_result__isset; |
| |
| class AccumuloProxy_setTableProperty_result { |
| public: |
| |
| AccumuloProxy_setTableProperty_result() { |
| } |
| |
| virtual ~AccumuloProxy_setTableProperty_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_setTableProperty_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_setTableProperty_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_setTableProperty_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_setTableProperty_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setTableProperty_presult__isset { |
| _AccumuloProxy_setTableProperty_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_setTableProperty_presult__isset; |
| |
| class AccumuloProxy_setTableProperty_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_setTableProperty_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_setTableProperty_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_splitRangeByTablets_args__isset { |
| _AccumuloProxy_splitRangeByTablets_args__isset() : login(false), tableName(false), range(false), maxSplits(false) {} |
| bool login; |
| bool tableName; |
| bool range; |
| bool maxSplits; |
| } _AccumuloProxy_splitRangeByTablets_args__isset; |
| |
| class AccumuloProxy_splitRangeByTablets_args { |
| public: |
| |
| AccumuloProxy_splitRangeByTablets_args() : login(), tableName(), maxSplits(0) { |
| } |
| |
| virtual ~AccumuloProxy_splitRangeByTablets_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| Range range; |
| int32_t maxSplits; |
| |
| _AccumuloProxy_splitRangeByTablets_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_range(const Range& val) { |
| range = val; |
| } |
| |
| void __set_maxSplits(const int32_t val) { |
| maxSplits = val; |
| } |
| |
| bool operator == (const AccumuloProxy_splitRangeByTablets_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(range == rhs.range)) |
| return false; |
| if (!(maxSplits == rhs.maxSplits)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_splitRangeByTablets_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_splitRangeByTablets_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_splitRangeByTablets_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_splitRangeByTablets_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const Range* range; |
| const int32_t* maxSplits; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_splitRangeByTablets_result__isset { |
| _AccumuloProxy_splitRangeByTablets_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_splitRangeByTablets_result__isset; |
| |
| class AccumuloProxy_splitRangeByTablets_result { |
| public: |
| |
| AccumuloProxy_splitRangeByTablets_result() { |
| } |
| |
| virtual ~AccumuloProxy_splitRangeByTablets_result() throw() {} |
| |
| std::set<Range> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_splitRangeByTablets_result__isset __isset; |
| |
| void __set_success(const std::set<Range> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_splitRangeByTablets_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_splitRangeByTablets_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_splitRangeByTablets_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_splitRangeByTablets_presult__isset { |
| _AccumuloProxy_splitRangeByTablets_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_splitRangeByTablets_presult__isset; |
| |
| class AccumuloProxy_splitRangeByTablets_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_splitRangeByTablets_presult() throw() {} |
| |
| std::set<Range> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_splitRangeByTablets_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_tableExists_args__isset { |
| _AccumuloProxy_tableExists_args__isset() : login(false), tableName(false) {} |
| bool login; |
| bool tableName; |
| } _AccumuloProxy_tableExists_args__isset; |
| |
| class AccumuloProxy_tableExists_args { |
| public: |
| |
| AccumuloProxy_tableExists_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_tableExists_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| |
| _AccumuloProxy_tableExists_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_tableExists_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_tableExists_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_tableExists_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_tableExists_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_tableExists_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_tableExists_result__isset { |
| _AccumuloProxy_tableExists_result__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_tableExists_result__isset; |
| |
| class AccumuloProxy_tableExists_result { |
| public: |
| |
| AccumuloProxy_tableExists_result() : success(0) { |
| } |
| |
| virtual ~AccumuloProxy_tableExists_result() throw() {} |
| |
| bool success; |
| |
| _AccumuloProxy_tableExists_result__isset __isset; |
| |
| void __set_success(const bool val) { |
| success = val; |
| } |
| |
| bool operator == (const AccumuloProxy_tableExists_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_tableExists_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_tableExists_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_tableExists_presult__isset { |
| _AccumuloProxy_tableExists_presult__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_tableExists_presult__isset; |
| |
| class AccumuloProxy_tableExists_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_tableExists_presult() throw() {} |
| |
| bool* success; |
| |
| _AccumuloProxy_tableExists_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_tableIdMap_args__isset { |
| _AccumuloProxy_tableIdMap_args__isset() : login(false) {} |
| bool login; |
| } _AccumuloProxy_tableIdMap_args__isset; |
| |
| class AccumuloProxy_tableIdMap_args { |
| public: |
| |
| AccumuloProxy_tableIdMap_args() : login() { |
| } |
| |
| virtual ~AccumuloProxy_tableIdMap_args() throw() {} |
| |
| std::string login; |
| |
| _AccumuloProxy_tableIdMap_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| bool operator == (const AccumuloProxy_tableIdMap_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_tableIdMap_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_tableIdMap_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_tableIdMap_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_tableIdMap_pargs() throw() {} |
| |
| const std::string* login; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_tableIdMap_result__isset { |
| _AccumuloProxy_tableIdMap_result__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_tableIdMap_result__isset; |
| |
| class AccumuloProxy_tableIdMap_result { |
| public: |
| |
| AccumuloProxy_tableIdMap_result() { |
| } |
| |
| virtual ~AccumuloProxy_tableIdMap_result() throw() {} |
| |
| std::map<std::string, std::string> success; |
| |
| _AccumuloProxy_tableIdMap_result__isset __isset; |
| |
| void __set_success(const std::map<std::string, std::string> & val) { |
| success = val; |
| } |
| |
| bool operator == (const AccumuloProxy_tableIdMap_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_tableIdMap_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_tableIdMap_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_tableIdMap_presult__isset { |
| _AccumuloProxy_tableIdMap_presult__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_tableIdMap_presult__isset; |
| |
| class AccumuloProxy_tableIdMap_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_tableIdMap_presult() throw() {} |
| |
| std::map<std::string, std::string> * success; |
| |
| _AccumuloProxy_tableIdMap_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_testTableClassLoad_args__isset { |
| _AccumuloProxy_testTableClassLoad_args__isset() : login(false), tableName(false), className(false), asTypeName(false) {} |
| bool login; |
| bool tableName; |
| bool className; |
| bool asTypeName; |
| } _AccumuloProxy_testTableClassLoad_args__isset; |
| |
| class AccumuloProxy_testTableClassLoad_args { |
| public: |
| |
| AccumuloProxy_testTableClassLoad_args() : login(), tableName(), className(), asTypeName() { |
| } |
| |
| virtual ~AccumuloProxy_testTableClassLoad_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string className; |
| std::string asTypeName; |
| |
| _AccumuloProxy_testTableClassLoad_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_className(const std::string& val) { |
| className = val; |
| } |
| |
| void __set_asTypeName(const std::string& val) { |
| asTypeName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_testTableClassLoad_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(className == rhs.className)) |
| return false; |
| if (!(asTypeName == rhs.asTypeName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_testTableClassLoad_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_testTableClassLoad_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_testTableClassLoad_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_testTableClassLoad_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* className; |
| const std::string* asTypeName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_testTableClassLoad_result__isset { |
| _AccumuloProxy_testTableClassLoad_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_testTableClassLoad_result__isset; |
| |
| class AccumuloProxy_testTableClassLoad_result { |
| public: |
| |
| AccumuloProxy_testTableClassLoad_result() : success(0) { |
| } |
| |
| virtual ~AccumuloProxy_testTableClassLoad_result() throw() {} |
| |
| bool success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_testTableClassLoad_result__isset __isset; |
| |
| void __set_success(const bool val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_testTableClassLoad_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_testTableClassLoad_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_testTableClassLoad_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_testTableClassLoad_presult__isset { |
| _AccumuloProxy_testTableClassLoad_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_testTableClassLoad_presult__isset; |
| |
| class AccumuloProxy_testTableClassLoad_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_testTableClassLoad_presult() throw() {} |
| |
| bool* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_testTableClassLoad_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_pingTabletServer_args__isset { |
| _AccumuloProxy_pingTabletServer_args__isset() : login(false), tserver(false) {} |
| bool login; |
| bool tserver; |
| } _AccumuloProxy_pingTabletServer_args__isset; |
| |
| class AccumuloProxy_pingTabletServer_args { |
| public: |
| |
| AccumuloProxy_pingTabletServer_args() : login(), tserver() { |
| } |
| |
| virtual ~AccumuloProxy_pingTabletServer_args() throw() {} |
| |
| std::string login; |
| std::string tserver; |
| |
| _AccumuloProxy_pingTabletServer_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tserver(const std::string& val) { |
| tserver = val; |
| } |
| |
| bool operator == (const AccumuloProxy_pingTabletServer_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tserver == rhs.tserver)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_pingTabletServer_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_pingTabletServer_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_pingTabletServer_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_pingTabletServer_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tserver; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_pingTabletServer_result__isset { |
| _AccumuloProxy_pingTabletServer_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_pingTabletServer_result__isset; |
| |
| class AccumuloProxy_pingTabletServer_result { |
| public: |
| |
| AccumuloProxy_pingTabletServer_result() { |
| } |
| |
| virtual ~AccumuloProxy_pingTabletServer_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_pingTabletServer_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_pingTabletServer_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_pingTabletServer_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_pingTabletServer_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_pingTabletServer_presult__isset { |
| _AccumuloProxy_pingTabletServer_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_pingTabletServer_presult__isset; |
| |
| class AccumuloProxy_pingTabletServer_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_pingTabletServer_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_pingTabletServer_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getActiveScans_args__isset { |
| _AccumuloProxy_getActiveScans_args__isset() : login(false), tserver(false) {} |
| bool login; |
| bool tserver; |
| } _AccumuloProxy_getActiveScans_args__isset; |
| |
| class AccumuloProxy_getActiveScans_args { |
| public: |
| |
| AccumuloProxy_getActiveScans_args() : login(), tserver() { |
| } |
| |
| virtual ~AccumuloProxy_getActiveScans_args() throw() {} |
| |
| std::string login; |
| std::string tserver; |
| |
| _AccumuloProxy_getActiveScans_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tserver(const std::string& val) { |
| tserver = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getActiveScans_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tserver == rhs.tserver)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getActiveScans_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getActiveScans_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getActiveScans_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getActiveScans_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tserver; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getActiveScans_result__isset { |
| _AccumuloProxy_getActiveScans_result__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getActiveScans_result__isset; |
| |
| class AccumuloProxy_getActiveScans_result { |
| public: |
| |
| AccumuloProxy_getActiveScans_result() { |
| } |
| |
| virtual ~AccumuloProxy_getActiveScans_result() throw() {} |
| |
| std::vector<ActiveScan> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getActiveScans_result__isset __isset; |
| |
| void __set_success(const std::vector<ActiveScan> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getActiveScans_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getActiveScans_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getActiveScans_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getActiveScans_presult__isset { |
| _AccumuloProxy_getActiveScans_presult__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getActiveScans_presult__isset; |
| |
| class AccumuloProxy_getActiveScans_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getActiveScans_presult() throw() {} |
| |
| std::vector<ActiveScan> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getActiveScans_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getActiveCompactions_args__isset { |
| _AccumuloProxy_getActiveCompactions_args__isset() : login(false), tserver(false) {} |
| bool login; |
| bool tserver; |
| } _AccumuloProxy_getActiveCompactions_args__isset; |
| |
| class AccumuloProxy_getActiveCompactions_args { |
| public: |
| |
| AccumuloProxy_getActiveCompactions_args() : login(), tserver() { |
| } |
| |
| virtual ~AccumuloProxy_getActiveCompactions_args() throw() {} |
| |
| std::string login; |
| std::string tserver; |
| |
| _AccumuloProxy_getActiveCompactions_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tserver(const std::string& val) { |
| tserver = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getActiveCompactions_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tserver == rhs.tserver)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getActiveCompactions_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getActiveCompactions_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getActiveCompactions_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getActiveCompactions_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tserver; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getActiveCompactions_result__isset { |
| _AccumuloProxy_getActiveCompactions_result__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getActiveCompactions_result__isset; |
| |
| class AccumuloProxy_getActiveCompactions_result { |
| public: |
| |
| AccumuloProxy_getActiveCompactions_result() { |
| } |
| |
| virtual ~AccumuloProxy_getActiveCompactions_result() throw() {} |
| |
| std::vector<ActiveCompaction> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getActiveCompactions_result__isset __isset; |
| |
| void __set_success(const std::vector<ActiveCompaction> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getActiveCompactions_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getActiveCompactions_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getActiveCompactions_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getActiveCompactions_presult__isset { |
| _AccumuloProxy_getActiveCompactions_presult__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getActiveCompactions_presult__isset; |
| |
| class AccumuloProxy_getActiveCompactions_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getActiveCompactions_presult() throw() {} |
| |
| std::vector<ActiveCompaction> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getActiveCompactions_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getSiteConfiguration_args__isset { |
| _AccumuloProxy_getSiteConfiguration_args__isset() : login(false) {} |
| bool login; |
| } _AccumuloProxy_getSiteConfiguration_args__isset; |
| |
| class AccumuloProxy_getSiteConfiguration_args { |
| public: |
| |
| AccumuloProxy_getSiteConfiguration_args() : login() { |
| } |
| |
| virtual ~AccumuloProxy_getSiteConfiguration_args() throw() {} |
| |
| std::string login; |
| |
| _AccumuloProxy_getSiteConfiguration_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getSiteConfiguration_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getSiteConfiguration_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getSiteConfiguration_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getSiteConfiguration_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getSiteConfiguration_pargs() throw() {} |
| |
| const std::string* login; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getSiteConfiguration_result__isset { |
| _AccumuloProxy_getSiteConfiguration_result__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getSiteConfiguration_result__isset; |
| |
| class AccumuloProxy_getSiteConfiguration_result { |
| public: |
| |
| AccumuloProxy_getSiteConfiguration_result() { |
| } |
| |
| virtual ~AccumuloProxy_getSiteConfiguration_result() throw() {} |
| |
| std::map<std::string, std::string> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getSiteConfiguration_result__isset __isset; |
| |
| void __set_success(const std::map<std::string, std::string> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getSiteConfiguration_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getSiteConfiguration_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getSiteConfiguration_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getSiteConfiguration_presult__isset { |
| _AccumuloProxy_getSiteConfiguration_presult__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getSiteConfiguration_presult__isset; |
| |
| class AccumuloProxy_getSiteConfiguration_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getSiteConfiguration_presult() throw() {} |
| |
| std::map<std::string, std::string> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getSiteConfiguration_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getSystemConfiguration_args__isset { |
| _AccumuloProxy_getSystemConfiguration_args__isset() : login(false) {} |
| bool login; |
| } _AccumuloProxy_getSystemConfiguration_args__isset; |
| |
| class AccumuloProxy_getSystemConfiguration_args { |
| public: |
| |
| AccumuloProxy_getSystemConfiguration_args() : login() { |
| } |
| |
| virtual ~AccumuloProxy_getSystemConfiguration_args() throw() {} |
| |
| std::string login; |
| |
| _AccumuloProxy_getSystemConfiguration_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getSystemConfiguration_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getSystemConfiguration_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getSystemConfiguration_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getSystemConfiguration_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getSystemConfiguration_pargs() throw() {} |
| |
| const std::string* login; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getSystemConfiguration_result__isset { |
| _AccumuloProxy_getSystemConfiguration_result__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getSystemConfiguration_result__isset; |
| |
| class AccumuloProxy_getSystemConfiguration_result { |
| public: |
| |
| AccumuloProxy_getSystemConfiguration_result() { |
| } |
| |
| virtual ~AccumuloProxy_getSystemConfiguration_result() throw() {} |
| |
| std::map<std::string, std::string> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getSystemConfiguration_result__isset __isset; |
| |
| void __set_success(const std::map<std::string, std::string> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getSystemConfiguration_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getSystemConfiguration_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getSystemConfiguration_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getSystemConfiguration_presult__isset { |
| _AccumuloProxy_getSystemConfiguration_presult__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getSystemConfiguration_presult__isset; |
| |
| class AccumuloProxy_getSystemConfiguration_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getSystemConfiguration_presult() throw() {} |
| |
| std::map<std::string, std::string> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getSystemConfiguration_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getTabletServers_args__isset { |
| _AccumuloProxy_getTabletServers_args__isset() : login(false) {} |
| bool login; |
| } _AccumuloProxy_getTabletServers_args__isset; |
| |
| class AccumuloProxy_getTabletServers_args { |
| public: |
| |
| AccumuloProxy_getTabletServers_args() : login() { |
| } |
| |
| virtual ~AccumuloProxy_getTabletServers_args() throw() {} |
| |
| std::string login; |
| |
| _AccumuloProxy_getTabletServers_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getTabletServers_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getTabletServers_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getTabletServers_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getTabletServers_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getTabletServers_pargs() throw() {} |
| |
| const std::string* login; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getTabletServers_result__isset { |
| _AccumuloProxy_getTabletServers_result__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_getTabletServers_result__isset; |
| |
| class AccumuloProxy_getTabletServers_result { |
| public: |
| |
| AccumuloProxy_getTabletServers_result() { |
| } |
| |
| virtual ~AccumuloProxy_getTabletServers_result() throw() {} |
| |
| std::vector<std::string> success; |
| |
| _AccumuloProxy_getTabletServers_result__isset __isset; |
| |
| void __set_success(const std::vector<std::string> & val) { |
| success = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getTabletServers_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getTabletServers_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getTabletServers_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getTabletServers_presult__isset { |
| _AccumuloProxy_getTabletServers_presult__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_getTabletServers_presult__isset; |
| |
| class AccumuloProxy_getTabletServers_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getTabletServers_presult() throw() {} |
| |
| std::vector<std::string> * success; |
| |
| _AccumuloProxy_getTabletServers_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeProperty_args__isset { |
| _AccumuloProxy_removeProperty_args__isset() : login(false), property(false) {} |
| bool login; |
| bool property; |
| } _AccumuloProxy_removeProperty_args__isset; |
| |
| class AccumuloProxy_removeProperty_args { |
| public: |
| |
| AccumuloProxy_removeProperty_args() : login(), property() { |
| } |
| |
| virtual ~AccumuloProxy_removeProperty_args() throw() {} |
| |
| std::string login; |
| std::string property; |
| |
| _AccumuloProxy_removeProperty_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_property(const std::string& val) { |
| property = val; |
| } |
| |
| bool operator == (const AccumuloProxy_removeProperty_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(property == rhs.property)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_removeProperty_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_removeProperty_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_removeProperty_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_removeProperty_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* property; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeProperty_result__isset { |
| _AccumuloProxy_removeProperty_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_removeProperty_result__isset; |
| |
| class AccumuloProxy_removeProperty_result { |
| public: |
| |
| AccumuloProxy_removeProperty_result() { |
| } |
| |
| virtual ~AccumuloProxy_removeProperty_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_removeProperty_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_removeProperty_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_removeProperty_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_removeProperty_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_removeProperty_presult__isset { |
| _AccumuloProxy_removeProperty_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_removeProperty_presult__isset; |
| |
| class AccumuloProxy_removeProperty_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_removeProperty_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_removeProperty_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setProperty_args__isset { |
| _AccumuloProxy_setProperty_args__isset() : login(false), property(false), value(false) {} |
| bool login; |
| bool property; |
| bool value; |
| } _AccumuloProxy_setProperty_args__isset; |
| |
| class AccumuloProxy_setProperty_args { |
| public: |
| |
| AccumuloProxy_setProperty_args() : login(), property(), value() { |
| } |
| |
| virtual ~AccumuloProxy_setProperty_args() throw() {} |
| |
| std::string login; |
| std::string property; |
| std::string value; |
| |
| _AccumuloProxy_setProperty_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_property(const std::string& val) { |
| property = val; |
| } |
| |
| void __set_value(const std::string& val) { |
| value = val; |
| } |
| |
| bool operator == (const AccumuloProxy_setProperty_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(property == rhs.property)) |
| return false; |
| if (!(value == rhs.value)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_setProperty_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_setProperty_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_setProperty_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_setProperty_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* property; |
| const std::string* value; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setProperty_result__isset { |
| _AccumuloProxy_setProperty_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_setProperty_result__isset; |
| |
| class AccumuloProxy_setProperty_result { |
| public: |
| |
| AccumuloProxy_setProperty_result() { |
| } |
| |
| virtual ~AccumuloProxy_setProperty_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_setProperty_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_setProperty_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_setProperty_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_setProperty_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_setProperty_presult__isset { |
| _AccumuloProxy_setProperty_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_setProperty_presult__isset; |
| |
| class AccumuloProxy_setProperty_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_setProperty_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_setProperty_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_testClassLoad_args__isset { |
| _AccumuloProxy_testClassLoad_args__isset() : login(false), className(false), asTypeName(false) {} |
| bool login; |
| bool className; |
| bool asTypeName; |
| } _AccumuloProxy_testClassLoad_args__isset; |
| |
| class AccumuloProxy_testClassLoad_args { |
| public: |
| |
| AccumuloProxy_testClassLoad_args() : login(), className(), asTypeName() { |
| } |
| |
| virtual ~AccumuloProxy_testClassLoad_args() throw() {} |
| |
| std::string login; |
| std::string className; |
| std::string asTypeName; |
| |
| _AccumuloProxy_testClassLoad_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_className(const std::string& val) { |
| className = val; |
| } |
| |
| void __set_asTypeName(const std::string& val) { |
| asTypeName = val; |
| } |
| |
| bool operator == (const AccumuloProxy_testClassLoad_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(className == rhs.className)) |
| return false; |
| if (!(asTypeName == rhs.asTypeName)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_testClassLoad_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_testClassLoad_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_testClassLoad_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_testClassLoad_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* className; |
| const std::string* asTypeName; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_testClassLoad_result__isset { |
| _AccumuloProxy_testClassLoad_result__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_testClassLoad_result__isset; |
| |
| class AccumuloProxy_testClassLoad_result { |
| public: |
| |
| AccumuloProxy_testClassLoad_result() : success(0) { |
| } |
| |
| virtual ~AccumuloProxy_testClassLoad_result() throw() {} |
| |
| bool success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_testClassLoad_result__isset __isset; |
| |
| void __set_success(const bool val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_testClassLoad_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_testClassLoad_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_testClassLoad_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_testClassLoad_presult__isset { |
| _AccumuloProxy_testClassLoad_presult__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_testClassLoad_presult__isset; |
| |
| class AccumuloProxy_testClassLoad_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_testClassLoad_presult() throw() {} |
| |
| bool* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_testClassLoad_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_authenticateUser_args__isset { |
| _AccumuloProxy_authenticateUser_args__isset() : login(false), user(false), properties(false) {} |
| bool login; |
| bool user; |
| bool properties; |
| } _AccumuloProxy_authenticateUser_args__isset; |
| |
| class AccumuloProxy_authenticateUser_args { |
| public: |
| |
| AccumuloProxy_authenticateUser_args() : login(), user() { |
| } |
| |
| virtual ~AccumuloProxy_authenticateUser_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| std::map<std::string, std::string> properties; |
| |
| _AccumuloProxy_authenticateUser_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_properties(const std::map<std::string, std::string> & val) { |
| properties = val; |
| } |
| |
| bool operator == (const AccumuloProxy_authenticateUser_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(properties == rhs.properties)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_authenticateUser_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_authenticateUser_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_authenticateUser_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_authenticateUser_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const std::map<std::string, std::string> * properties; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_authenticateUser_result__isset { |
| _AccumuloProxy_authenticateUser_result__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_authenticateUser_result__isset; |
| |
| class AccumuloProxy_authenticateUser_result { |
| public: |
| |
| AccumuloProxy_authenticateUser_result() : success(0) { |
| } |
| |
| virtual ~AccumuloProxy_authenticateUser_result() throw() {} |
| |
| bool success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_authenticateUser_result__isset __isset; |
| |
| void __set_success(const bool val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_authenticateUser_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_authenticateUser_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_authenticateUser_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_authenticateUser_presult__isset { |
| _AccumuloProxy_authenticateUser_presult__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_authenticateUser_presult__isset; |
| |
| class AccumuloProxy_authenticateUser_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_authenticateUser_presult() throw() {} |
| |
| bool* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_authenticateUser_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_changeUserAuthorizations_args__isset { |
| _AccumuloProxy_changeUserAuthorizations_args__isset() : login(false), user(false), authorizations(false) {} |
| bool login; |
| bool user; |
| bool authorizations; |
| } _AccumuloProxy_changeUserAuthorizations_args__isset; |
| |
| class AccumuloProxy_changeUserAuthorizations_args { |
| public: |
| |
| AccumuloProxy_changeUserAuthorizations_args() : login(), user() { |
| } |
| |
| virtual ~AccumuloProxy_changeUserAuthorizations_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| std::set<std::string> authorizations; |
| |
| _AccumuloProxy_changeUserAuthorizations_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_authorizations(const std::set<std::string> & val) { |
| authorizations = val; |
| } |
| |
| bool operator == (const AccumuloProxy_changeUserAuthorizations_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(authorizations == rhs.authorizations)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_changeUserAuthorizations_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_changeUserAuthorizations_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_changeUserAuthorizations_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_changeUserAuthorizations_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const std::set<std::string> * authorizations; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_changeUserAuthorizations_result__isset { |
| _AccumuloProxy_changeUserAuthorizations_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_changeUserAuthorizations_result__isset; |
| |
| class AccumuloProxy_changeUserAuthorizations_result { |
| public: |
| |
| AccumuloProxy_changeUserAuthorizations_result() { |
| } |
| |
| virtual ~AccumuloProxy_changeUserAuthorizations_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_changeUserAuthorizations_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_changeUserAuthorizations_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_changeUserAuthorizations_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_changeUserAuthorizations_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_changeUserAuthorizations_presult__isset { |
| _AccumuloProxy_changeUserAuthorizations_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_changeUserAuthorizations_presult__isset; |
| |
| class AccumuloProxy_changeUserAuthorizations_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_changeUserAuthorizations_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_changeUserAuthorizations_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_changeLocalUserPassword_args__isset { |
| _AccumuloProxy_changeLocalUserPassword_args__isset() : login(false), user(false), password(false) {} |
| bool login; |
| bool user; |
| bool password; |
| } _AccumuloProxy_changeLocalUserPassword_args__isset; |
| |
| class AccumuloProxy_changeLocalUserPassword_args { |
| public: |
| |
| AccumuloProxy_changeLocalUserPassword_args() : login(), user(), password() { |
| } |
| |
| virtual ~AccumuloProxy_changeLocalUserPassword_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| std::string password; |
| |
| _AccumuloProxy_changeLocalUserPassword_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_password(const std::string& val) { |
| password = val; |
| } |
| |
| bool operator == (const AccumuloProxy_changeLocalUserPassword_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(password == rhs.password)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_changeLocalUserPassword_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_changeLocalUserPassword_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_changeLocalUserPassword_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_changeLocalUserPassword_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const std::string* password; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_changeLocalUserPassword_result__isset { |
| _AccumuloProxy_changeLocalUserPassword_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_changeLocalUserPassword_result__isset; |
| |
| class AccumuloProxy_changeLocalUserPassword_result { |
| public: |
| |
| AccumuloProxy_changeLocalUserPassword_result() { |
| } |
| |
| virtual ~AccumuloProxy_changeLocalUserPassword_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_changeLocalUserPassword_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_changeLocalUserPassword_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_changeLocalUserPassword_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_changeLocalUserPassword_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_changeLocalUserPassword_presult__isset { |
| _AccumuloProxy_changeLocalUserPassword_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_changeLocalUserPassword_presult__isset; |
| |
| class AccumuloProxy_changeLocalUserPassword_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_changeLocalUserPassword_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_changeLocalUserPassword_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createLocalUser_args__isset { |
| _AccumuloProxy_createLocalUser_args__isset() : login(false), user(false), password(false) {} |
| bool login; |
| bool user; |
| bool password; |
| } _AccumuloProxy_createLocalUser_args__isset; |
| |
| class AccumuloProxy_createLocalUser_args { |
| public: |
| |
| AccumuloProxy_createLocalUser_args() : login(), user(), password() { |
| } |
| |
| virtual ~AccumuloProxy_createLocalUser_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| std::string password; |
| |
| _AccumuloProxy_createLocalUser_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_password(const std::string& val) { |
| password = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createLocalUser_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(password == rhs.password)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createLocalUser_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createLocalUser_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_createLocalUser_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createLocalUser_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const std::string* password; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createLocalUser_result__isset { |
| _AccumuloProxy_createLocalUser_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_createLocalUser_result__isset; |
| |
| class AccumuloProxy_createLocalUser_result { |
| public: |
| |
| AccumuloProxy_createLocalUser_result() { |
| } |
| |
| virtual ~AccumuloProxy_createLocalUser_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_createLocalUser_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createLocalUser_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createLocalUser_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createLocalUser_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createLocalUser_presult__isset { |
| _AccumuloProxy_createLocalUser_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_createLocalUser_presult__isset; |
| |
| class AccumuloProxy_createLocalUser_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createLocalUser_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_createLocalUser_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_dropLocalUser_args__isset { |
| _AccumuloProxy_dropLocalUser_args__isset() : login(false), user(false) {} |
| bool login; |
| bool user; |
| } _AccumuloProxy_dropLocalUser_args__isset; |
| |
| class AccumuloProxy_dropLocalUser_args { |
| public: |
| |
| AccumuloProxy_dropLocalUser_args() : login(), user() { |
| } |
| |
| virtual ~AccumuloProxy_dropLocalUser_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| |
| _AccumuloProxy_dropLocalUser_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| bool operator == (const AccumuloProxy_dropLocalUser_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_dropLocalUser_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_dropLocalUser_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_dropLocalUser_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_dropLocalUser_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_dropLocalUser_result__isset { |
| _AccumuloProxy_dropLocalUser_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_dropLocalUser_result__isset; |
| |
| class AccumuloProxy_dropLocalUser_result { |
| public: |
| |
| AccumuloProxy_dropLocalUser_result() { |
| } |
| |
| virtual ~AccumuloProxy_dropLocalUser_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_dropLocalUser_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_dropLocalUser_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_dropLocalUser_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_dropLocalUser_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_dropLocalUser_presult__isset { |
| _AccumuloProxy_dropLocalUser_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_dropLocalUser_presult__isset; |
| |
| class AccumuloProxy_dropLocalUser_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_dropLocalUser_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_dropLocalUser_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getUserAuthorizations_args__isset { |
| _AccumuloProxy_getUserAuthorizations_args__isset() : login(false), user(false) {} |
| bool login; |
| bool user; |
| } _AccumuloProxy_getUserAuthorizations_args__isset; |
| |
| class AccumuloProxy_getUserAuthorizations_args { |
| public: |
| |
| AccumuloProxy_getUserAuthorizations_args() : login(), user() { |
| } |
| |
| virtual ~AccumuloProxy_getUserAuthorizations_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| |
| _AccumuloProxy_getUserAuthorizations_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getUserAuthorizations_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getUserAuthorizations_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getUserAuthorizations_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getUserAuthorizations_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getUserAuthorizations_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getUserAuthorizations_result__isset { |
| _AccumuloProxy_getUserAuthorizations_result__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getUserAuthorizations_result__isset; |
| |
| class AccumuloProxy_getUserAuthorizations_result { |
| public: |
| |
| AccumuloProxy_getUserAuthorizations_result() { |
| } |
| |
| virtual ~AccumuloProxy_getUserAuthorizations_result() throw() {} |
| |
| std::vector<std::string> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getUserAuthorizations_result__isset __isset; |
| |
| void __set_success(const std::vector<std::string> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getUserAuthorizations_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getUserAuthorizations_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getUserAuthorizations_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getUserAuthorizations_presult__isset { |
| _AccumuloProxy_getUserAuthorizations_presult__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_getUserAuthorizations_presult__isset; |
| |
| class AccumuloProxy_getUserAuthorizations_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getUserAuthorizations_presult() throw() {} |
| |
| std::vector<std::string> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_getUserAuthorizations_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_grantSystemPermission_args__isset { |
| _AccumuloProxy_grantSystemPermission_args__isset() : login(false), user(false), perm(false) {} |
| bool login; |
| bool user; |
| bool perm; |
| } _AccumuloProxy_grantSystemPermission_args__isset; |
| |
| class AccumuloProxy_grantSystemPermission_args { |
| public: |
| |
| AccumuloProxy_grantSystemPermission_args() : login(), user(), perm((SystemPermission::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_grantSystemPermission_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| SystemPermission::type perm; |
| |
| _AccumuloProxy_grantSystemPermission_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_perm(const SystemPermission::type val) { |
| perm = val; |
| } |
| |
| bool operator == (const AccumuloProxy_grantSystemPermission_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(perm == rhs.perm)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_grantSystemPermission_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_grantSystemPermission_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_grantSystemPermission_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_grantSystemPermission_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const SystemPermission::type* perm; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_grantSystemPermission_result__isset { |
| _AccumuloProxy_grantSystemPermission_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_grantSystemPermission_result__isset; |
| |
| class AccumuloProxy_grantSystemPermission_result { |
| public: |
| |
| AccumuloProxy_grantSystemPermission_result() { |
| } |
| |
| virtual ~AccumuloProxy_grantSystemPermission_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_grantSystemPermission_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_grantSystemPermission_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_grantSystemPermission_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_grantSystemPermission_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_grantSystemPermission_presult__isset { |
| _AccumuloProxy_grantSystemPermission_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_grantSystemPermission_presult__isset; |
| |
| class AccumuloProxy_grantSystemPermission_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_grantSystemPermission_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_grantSystemPermission_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_grantTablePermission_args__isset { |
| _AccumuloProxy_grantTablePermission_args__isset() : login(false), user(false), table(false), perm(false) {} |
| bool login; |
| bool user; |
| bool table; |
| bool perm; |
| } _AccumuloProxy_grantTablePermission_args__isset; |
| |
| class AccumuloProxy_grantTablePermission_args { |
| public: |
| |
| AccumuloProxy_grantTablePermission_args() : login(), user(), table(), perm((TablePermission::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_grantTablePermission_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| std::string table; |
| TablePermission::type perm; |
| |
| _AccumuloProxy_grantTablePermission_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_table(const std::string& val) { |
| table = val; |
| } |
| |
| void __set_perm(const TablePermission::type val) { |
| perm = val; |
| } |
| |
| bool operator == (const AccumuloProxy_grantTablePermission_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(table == rhs.table)) |
| return false; |
| if (!(perm == rhs.perm)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_grantTablePermission_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_grantTablePermission_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_grantTablePermission_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_grantTablePermission_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const std::string* table; |
| const TablePermission::type* perm; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_grantTablePermission_result__isset { |
| _AccumuloProxy_grantTablePermission_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_grantTablePermission_result__isset; |
| |
| class AccumuloProxy_grantTablePermission_result { |
| public: |
| |
| AccumuloProxy_grantTablePermission_result() { |
| } |
| |
| virtual ~AccumuloProxy_grantTablePermission_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_grantTablePermission_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_grantTablePermission_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_grantTablePermission_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_grantTablePermission_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_grantTablePermission_presult__isset { |
| _AccumuloProxy_grantTablePermission_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_grantTablePermission_presult__isset; |
| |
| class AccumuloProxy_grantTablePermission_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_grantTablePermission_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_grantTablePermission_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasSystemPermission_args__isset { |
| _AccumuloProxy_hasSystemPermission_args__isset() : login(false), user(false), perm(false) {} |
| bool login; |
| bool user; |
| bool perm; |
| } _AccumuloProxy_hasSystemPermission_args__isset; |
| |
| class AccumuloProxy_hasSystemPermission_args { |
| public: |
| |
| AccumuloProxy_hasSystemPermission_args() : login(), user(), perm((SystemPermission::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_hasSystemPermission_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| SystemPermission::type perm; |
| |
| _AccumuloProxy_hasSystemPermission_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_perm(const SystemPermission::type val) { |
| perm = val; |
| } |
| |
| bool operator == (const AccumuloProxy_hasSystemPermission_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(perm == rhs.perm)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_hasSystemPermission_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_hasSystemPermission_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_hasSystemPermission_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_hasSystemPermission_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const SystemPermission::type* perm; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasSystemPermission_result__isset { |
| _AccumuloProxy_hasSystemPermission_result__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_hasSystemPermission_result__isset; |
| |
| class AccumuloProxy_hasSystemPermission_result { |
| public: |
| |
| AccumuloProxy_hasSystemPermission_result() : success(0) { |
| } |
| |
| virtual ~AccumuloProxy_hasSystemPermission_result() throw() {} |
| |
| bool success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_hasSystemPermission_result__isset __isset; |
| |
| void __set_success(const bool val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_hasSystemPermission_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_hasSystemPermission_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_hasSystemPermission_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasSystemPermission_presult__isset { |
| _AccumuloProxy_hasSystemPermission_presult__isset() : success(false), ouch1(false), ouch2(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_hasSystemPermission_presult__isset; |
| |
| class AccumuloProxy_hasSystemPermission_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_hasSystemPermission_presult() throw() {} |
| |
| bool* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_hasSystemPermission_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasTablePermission_args__isset { |
| _AccumuloProxy_hasTablePermission_args__isset() : login(false), user(false), table(false), perm(false) {} |
| bool login; |
| bool user; |
| bool table; |
| bool perm; |
| } _AccumuloProxy_hasTablePermission_args__isset; |
| |
| class AccumuloProxy_hasTablePermission_args { |
| public: |
| |
| AccumuloProxy_hasTablePermission_args() : login(), user(), table(), perm((TablePermission::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_hasTablePermission_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| std::string table; |
| TablePermission::type perm; |
| |
| _AccumuloProxy_hasTablePermission_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_table(const std::string& val) { |
| table = val; |
| } |
| |
| void __set_perm(const TablePermission::type val) { |
| perm = val; |
| } |
| |
| bool operator == (const AccumuloProxy_hasTablePermission_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(table == rhs.table)) |
| return false; |
| if (!(perm == rhs.perm)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_hasTablePermission_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_hasTablePermission_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_hasTablePermission_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_hasTablePermission_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const std::string* table; |
| const TablePermission::type* perm; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasTablePermission_result__isset { |
| _AccumuloProxy_hasTablePermission_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_hasTablePermission_result__isset; |
| |
| class AccumuloProxy_hasTablePermission_result { |
| public: |
| |
| AccumuloProxy_hasTablePermission_result() : success(0) { |
| } |
| |
| virtual ~AccumuloProxy_hasTablePermission_result() throw() {} |
| |
| bool success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_hasTablePermission_result__isset __isset; |
| |
| void __set_success(const bool val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_hasTablePermission_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_hasTablePermission_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_hasTablePermission_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasTablePermission_presult__isset { |
| _AccumuloProxy_hasTablePermission_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_hasTablePermission_presult__isset; |
| |
| class AccumuloProxy_hasTablePermission_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_hasTablePermission_presult() throw() {} |
| |
| bool* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_hasTablePermission_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listLocalUsers_args__isset { |
| _AccumuloProxy_listLocalUsers_args__isset() : login(false) {} |
| bool login; |
| } _AccumuloProxy_listLocalUsers_args__isset; |
| |
| class AccumuloProxy_listLocalUsers_args { |
| public: |
| |
| AccumuloProxy_listLocalUsers_args() : login() { |
| } |
| |
| virtual ~AccumuloProxy_listLocalUsers_args() throw() {} |
| |
| std::string login; |
| |
| _AccumuloProxy_listLocalUsers_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listLocalUsers_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listLocalUsers_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listLocalUsers_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_listLocalUsers_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listLocalUsers_pargs() throw() {} |
| |
| const std::string* login; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listLocalUsers_result__isset { |
| _AccumuloProxy_listLocalUsers_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_listLocalUsers_result__isset; |
| |
| class AccumuloProxy_listLocalUsers_result { |
| public: |
| |
| AccumuloProxy_listLocalUsers_result() { |
| } |
| |
| virtual ~AccumuloProxy_listLocalUsers_result() throw() {} |
| |
| std::set<std::string> success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_listLocalUsers_result__isset __isset; |
| |
| void __set_success(const std::set<std::string> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_listLocalUsers_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_listLocalUsers_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_listLocalUsers_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_listLocalUsers_presult__isset { |
| _AccumuloProxy_listLocalUsers_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_listLocalUsers_presult__isset; |
| |
| class AccumuloProxy_listLocalUsers_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_listLocalUsers_presult() throw() {} |
| |
| std::set<std::string> * success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_listLocalUsers_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_revokeSystemPermission_args__isset { |
| _AccumuloProxy_revokeSystemPermission_args__isset() : login(false), user(false), perm(false) {} |
| bool login; |
| bool user; |
| bool perm; |
| } _AccumuloProxy_revokeSystemPermission_args__isset; |
| |
| class AccumuloProxy_revokeSystemPermission_args { |
| public: |
| |
| AccumuloProxy_revokeSystemPermission_args() : login(), user(), perm((SystemPermission::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_revokeSystemPermission_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| SystemPermission::type perm; |
| |
| _AccumuloProxy_revokeSystemPermission_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_perm(const SystemPermission::type val) { |
| perm = val; |
| } |
| |
| bool operator == (const AccumuloProxy_revokeSystemPermission_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(perm == rhs.perm)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_revokeSystemPermission_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_revokeSystemPermission_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_revokeSystemPermission_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_revokeSystemPermission_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const SystemPermission::type* perm; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_revokeSystemPermission_result__isset { |
| _AccumuloProxy_revokeSystemPermission_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_revokeSystemPermission_result__isset; |
| |
| class AccumuloProxy_revokeSystemPermission_result { |
| public: |
| |
| AccumuloProxy_revokeSystemPermission_result() { |
| } |
| |
| virtual ~AccumuloProxy_revokeSystemPermission_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_revokeSystemPermission_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_revokeSystemPermission_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_revokeSystemPermission_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_revokeSystemPermission_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_revokeSystemPermission_presult__isset { |
| _AccumuloProxy_revokeSystemPermission_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_revokeSystemPermission_presult__isset; |
| |
| class AccumuloProxy_revokeSystemPermission_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_revokeSystemPermission_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| |
| _AccumuloProxy_revokeSystemPermission_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_revokeTablePermission_args__isset { |
| _AccumuloProxy_revokeTablePermission_args__isset() : login(false), user(false), table(false), perm(false) {} |
| bool login; |
| bool user; |
| bool table; |
| bool perm; |
| } _AccumuloProxy_revokeTablePermission_args__isset; |
| |
| class AccumuloProxy_revokeTablePermission_args { |
| public: |
| |
| AccumuloProxy_revokeTablePermission_args() : login(), user(), table(), perm((TablePermission::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_revokeTablePermission_args() throw() {} |
| |
| std::string login; |
| std::string user; |
| std::string table; |
| TablePermission::type perm; |
| |
| _AccumuloProxy_revokeTablePermission_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_user(const std::string& val) { |
| user = val; |
| } |
| |
| void __set_table(const std::string& val) { |
| table = val; |
| } |
| |
| void __set_perm(const TablePermission::type val) { |
| perm = val; |
| } |
| |
| bool operator == (const AccumuloProxy_revokeTablePermission_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(user == rhs.user)) |
| return false; |
| if (!(table == rhs.table)) |
| return false; |
| if (!(perm == rhs.perm)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_revokeTablePermission_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_revokeTablePermission_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_revokeTablePermission_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_revokeTablePermission_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* user; |
| const std::string* table; |
| const TablePermission::type* perm; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_revokeTablePermission_result__isset { |
| _AccumuloProxy_revokeTablePermission_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_revokeTablePermission_result__isset; |
| |
| class AccumuloProxy_revokeTablePermission_result { |
| public: |
| |
| AccumuloProxy_revokeTablePermission_result() { |
| } |
| |
| virtual ~AccumuloProxy_revokeTablePermission_result() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_revokeTablePermission_result__isset __isset; |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_revokeTablePermission_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_revokeTablePermission_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_revokeTablePermission_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_revokeTablePermission_presult__isset { |
| _AccumuloProxy_revokeTablePermission_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_revokeTablePermission_presult__isset; |
| |
| class AccumuloProxy_revokeTablePermission_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_revokeTablePermission_presult() throw() {} |
| |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_revokeTablePermission_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createBatchScanner_args__isset { |
| _AccumuloProxy_createBatchScanner_args__isset() : login(false), tableName(false), options(false) {} |
| bool login; |
| bool tableName; |
| bool options; |
| } _AccumuloProxy_createBatchScanner_args__isset; |
| |
| class AccumuloProxy_createBatchScanner_args { |
| public: |
| |
| AccumuloProxy_createBatchScanner_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_createBatchScanner_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| BatchScanOptions options; |
| |
| _AccumuloProxy_createBatchScanner_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_options(const BatchScanOptions& val) { |
| options = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createBatchScanner_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(options == rhs.options)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createBatchScanner_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createBatchScanner_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_createBatchScanner_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createBatchScanner_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const BatchScanOptions* options; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createBatchScanner_result__isset { |
| _AccumuloProxy_createBatchScanner_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createBatchScanner_result__isset; |
| |
| class AccumuloProxy_createBatchScanner_result { |
| public: |
| |
| AccumuloProxy_createBatchScanner_result() : success() { |
| } |
| |
| virtual ~AccumuloProxy_createBatchScanner_result() throw() {} |
| |
| std::string success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_createBatchScanner_result__isset __isset; |
| |
| void __set_success(const std::string& val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createBatchScanner_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createBatchScanner_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createBatchScanner_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createBatchScanner_presult__isset { |
| _AccumuloProxy_createBatchScanner_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createBatchScanner_presult__isset; |
| |
| class AccumuloProxy_createBatchScanner_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createBatchScanner_presult() throw() {} |
| |
| std::string* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_createBatchScanner_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createScanner_args__isset { |
| _AccumuloProxy_createScanner_args__isset() : login(false), tableName(false), options(false) {} |
| bool login; |
| bool tableName; |
| bool options; |
| } _AccumuloProxy_createScanner_args__isset; |
| |
| class AccumuloProxy_createScanner_args { |
| public: |
| |
| AccumuloProxy_createScanner_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_createScanner_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| ScanOptions options; |
| |
| _AccumuloProxy_createScanner_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_options(const ScanOptions& val) { |
| options = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createScanner_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(options == rhs.options)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createScanner_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createScanner_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_createScanner_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createScanner_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const ScanOptions* options; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createScanner_result__isset { |
| _AccumuloProxy_createScanner_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createScanner_result__isset; |
| |
| class AccumuloProxy_createScanner_result { |
| public: |
| |
| AccumuloProxy_createScanner_result() : success() { |
| } |
| |
| virtual ~AccumuloProxy_createScanner_result() throw() {} |
| |
| std::string success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_createScanner_result__isset __isset; |
| |
| void __set_success(const std::string& val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createScanner_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createScanner_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createScanner_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createScanner_presult__isset { |
| _AccumuloProxy_createScanner_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createScanner_presult__isset; |
| |
| class AccumuloProxy_createScanner_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createScanner_presult() throw() {} |
| |
| std::string* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_createScanner_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasNext_args__isset { |
| _AccumuloProxy_hasNext_args__isset() : scanner(false) {} |
| bool scanner; |
| } _AccumuloProxy_hasNext_args__isset; |
| |
| class AccumuloProxy_hasNext_args { |
| public: |
| |
| AccumuloProxy_hasNext_args() : scanner() { |
| } |
| |
| virtual ~AccumuloProxy_hasNext_args() throw() {} |
| |
| std::string scanner; |
| |
| _AccumuloProxy_hasNext_args__isset __isset; |
| |
| void __set_scanner(const std::string& val) { |
| scanner = val; |
| } |
| |
| bool operator == (const AccumuloProxy_hasNext_args & rhs) const |
| { |
| if (!(scanner == rhs.scanner)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_hasNext_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_hasNext_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_hasNext_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_hasNext_pargs() throw() {} |
| |
| const std::string* scanner; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasNext_result__isset { |
| _AccumuloProxy_hasNext_result__isset() : success(false), ouch1(false) {} |
| bool success; |
| bool ouch1; |
| } _AccumuloProxy_hasNext_result__isset; |
| |
| class AccumuloProxy_hasNext_result { |
| public: |
| |
| AccumuloProxy_hasNext_result() : success(0) { |
| } |
| |
| virtual ~AccumuloProxy_hasNext_result() throw() {} |
| |
| bool success; |
| UnknownScanner ouch1; |
| |
| _AccumuloProxy_hasNext_result__isset __isset; |
| |
| void __set_success(const bool val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const UnknownScanner& val) { |
| ouch1 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_hasNext_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_hasNext_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_hasNext_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_hasNext_presult__isset { |
| _AccumuloProxy_hasNext_presult__isset() : success(false), ouch1(false) {} |
| bool success; |
| bool ouch1; |
| } _AccumuloProxy_hasNext_presult__isset; |
| |
| class AccumuloProxy_hasNext_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_hasNext_presult() throw() {} |
| |
| bool* success; |
| UnknownScanner ouch1; |
| |
| _AccumuloProxy_hasNext_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_nextEntry_args__isset { |
| _AccumuloProxy_nextEntry_args__isset() : scanner(false) {} |
| bool scanner; |
| } _AccumuloProxy_nextEntry_args__isset; |
| |
| class AccumuloProxy_nextEntry_args { |
| public: |
| |
| AccumuloProxy_nextEntry_args() : scanner() { |
| } |
| |
| virtual ~AccumuloProxy_nextEntry_args() throw() {} |
| |
| std::string scanner; |
| |
| _AccumuloProxy_nextEntry_args__isset __isset; |
| |
| void __set_scanner(const std::string& val) { |
| scanner = val; |
| } |
| |
| bool operator == (const AccumuloProxy_nextEntry_args & rhs) const |
| { |
| if (!(scanner == rhs.scanner)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_nextEntry_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_nextEntry_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_nextEntry_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_nextEntry_pargs() throw() {} |
| |
| const std::string* scanner; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_nextEntry_result__isset { |
| _AccumuloProxy_nextEntry_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_nextEntry_result__isset; |
| |
| class AccumuloProxy_nextEntry_result { |
| public: |
| |
| AccumuloProxy_nextEntry_result() { |
| } |
| |
| virtual ~AccumuloProxy_nextEntry_result() throw() {} |
| |
| KeyValueAndPeek success; |
| NoMoreEntriesException ouch1; |
| UnknownScanner ouch2; |
| AccumuloSecurityException ouch3; |
| |
| _AccumuloProxy_nextEntry_result__isset __isset; |
| |
| void __set_success(const KeyValueAndPeek& val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const NoMoreEntriesException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const UnknownScanner& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const AccumuloSecurityException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_nextEntry_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_nextEntry_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_nextEntry_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_nextEntry_presult__isset { |
| _AccumuloProxy_nextEntry_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_nextEntry_presult__isset; |
| |
| class AccumuloProxy_nextEntry_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_nextEntry_presult() throw() {} |
| |
| KeyValueAndPeek* success; |
| NoMoreEntriesException ouch1; |
| UnknownScanner ouch2; |
| AccumuloSecurityException ouch3; |
| |
| _AccumuloProxy_nextEntry_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_nextK_args__isset { |
| _AccumuloProxy_nextK_args__isset() : scanner(false), k(false) {} |
| bool scanner; |
| bool k; |
| } _AccumuloProxy_nextK_args__isset; |
| |
| class AccumuloProxy_nextK_args { |
| public: |
| |
| AccumuloProxy_nextK_args() : scanner(), k(0) { |
| } |
| |
| virtual ~AccumuloProxy_nextK_args() throw() {} |
| |
| std::string scanner; |
| int32_t k; |
| |
| _AccumuloProxy_nextK_args__isset __isset; |
| |
| void __set_scanner(const std::string& val) { |
| scanner = val; |
| } |
| |
| void __set_k(const int32_t val) { |
| k = val; |
| } |
| |
| bool operator == (const AccumuloProxy_nextK_args & rhs) const |
| { |
| if (!(scanner == rhs.scanner)) |
| return false; |
| if (!(k == rhs.k)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_nextK_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_nextK_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_nextK_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_nextK_pargs() throw() {} |
| |
| const std::string* scanner; |
| const int32_t* k; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_nextK_result__isset { |
| _AccumuloProxy_nextK_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_nextK_result__isset; |
| |
| class AccumuloProxy_nextK_result { |
| public: |
| |
| AccumuloProxy_nextK_result() { |
| } |
| |
| virtual ~AccumuloProxy_nextK_result() throw() {} |
| |
| ScanResult success; |
| NoMoreEntriesException ouch1; |
| UnknownScanner ouch2; |
| AccumuloSecurityException ouch3; |
| |
| _AccumuloProxy_nextK_result__isset __isset; |
| |
| void __set_success(const ScanResult& val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const NoMoreEntriesException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const UnknownScanner& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const AccumuloSecurityException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_nextK_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_nextK_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_nextK_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_nextK_presult__isset { |
| _AccumuloProxy_nextK_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_nextK_presult__isset; |
| |
| class AccumuloProxy_nextK_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_nextK_presult() throw() {} |
| |
| ScanResult* success; |
| NoMoreEntriesException ouch1; |
| UnknownScanner ouch2; |
| AccumuloSecurityException ouch3; |
| |
| _AccumuloProxy_nextK_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_closeScanner_args__isset { |
| _AccumuloProxy_closeScanner_args__isset() : scanner(false) {} |
| bool scanner; |
| } _AccumuloProxy_closeScanner_args__isset; |
| |
| class AccumuloProxy_closeScanner_args { |
| public: |
| |
| AccumuloProxy_closeScanner_args() : scanner() { |
| } |
| |
| virtual ~AccumuloProxy_closeScanner_args() throw() {} |
| |
| std::string scanner; |
| |
| _AccumuloProxy_closeScanner_args__isset __isset; |
| |
| void __set_scanner(const std::string& val) { |
| scanner = val; |
| } |
| |
| bool operator == (const AccumuloProxy_closeScanner_args & rhs) const |
| { |
| if (!(scanner == rhs.scanner)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_closeScanner_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_closeScanner_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_closeScanner_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_closeScanner_pargs() throw() {} |
| |
| const std::string* scanner; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_closeScanner_result__isset { |
| _AccumuloProxy_closeScanner_result__isset() : ouch1(false) {} |
| bool ouch1; |
| } _AccumuloProxy_closeScanner_result__isset; |
| |
| class AccumuloProxy_closeScanner_result { |
| public: |
| |
| AccumuloProxy_closeScanner_result() { |
| } |
| |
| virtual ~AccumuloProxy_closeScanner_result() throw() {} |
| |
| UnknownScanner ouch1; |
| |
| _AccumuloProxy_closeScanner_result__isset __isset; |
| |
| void __set_ouch1(const UnknownScanner& val) { |
| ouch1 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_closeScanner_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_closeScanner_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_closeScanner_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_closeScanner_presult__isset { |
| _AccumuloProxy_closeScanner_presult__isset() : ouch1(false) {} |
| bool ouch1; |
| } _AccumuloProxy_closeScanner_presult__isset; |
| |
| class AccumuloProxy_closeScanner_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_closeScanner_presult() throw() {} |
| |
| UnknownScanner ouch1; |
| |
| _AccumuloProxy_closeScanner_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateAndFlush_args__isset { |
| _AccumuloProxy_updateAndFlush_args__isset() : login(false), tableName(false), cells(false) {} |
| bool login; |
| bool tableName; |
| bool cells; |
| } _AccumuloProxy_updateAndFlush_args__isset; |
| |
| class AccumuloProxy_updateAndFlush_args { |
| public: |
| |
| AccumuloProxy_updateAndFlush_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_updateAndFlush_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::map<std::string, std::vector<ColumnUpdate> > cells; |
| |
| _AccumuloProxy_updateAndFlush_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_cells(const std::map<std::string, std::vector<ColumnUpdate> > & val) { |
| cells = val; |
| } |
| |
| bool operator == (const AccumuloProxy_updateAndFlush_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(cells == rhs.cells)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_updateAndFlush_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_updateAndFlush_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_updateAndFlush_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_updateAndFlush_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::map<std::string, std::vector<ColumnUpdate> > * cells; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateAndFlush_result__isset { |
| _AccumuloProxy_updateAndFlush_result__isset() : outch1(false), ouch2(false), ouch3(false), ouch4(false) {} |
| bool outch1; |
| bool ouch2; |
| bool ouch3; |
| bool ouch4; |
| } _AccumuloProxy_updateAndFlush_result__isset; |
| |
| class AccumuloProxy_updateAndFlush_result { |
| public: |
| |
| AccumuloProxy_updateAndFlush_result() { |
| } |
| |
| virtual ~AccumuloProxy_updateAndFlush_result() throw() {} |
| |
| AccumuloException outch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| MutationsRejectedException ouch4; |
| |
| _AccumuloProxy_updateAndFlush_result__isset __isset; |
| |
| void __set_outch1(const AccumuloException& val) { |
| outch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| void __set_ouch4(const MutationsRejectedException& val) { |
| ouch4 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_updateAndFlush_result & rhs) const |
| { |
| if (!(outch1 == rhs.outch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| if (!(ouch4 == rhs.ouch4)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_updateAndFlush_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_updateAndFlush_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateAndFlush_presult__isset { |
| _AccumuloProxy_updateAndFlush_presult__isset() : outch1(false), ouch2(false), ouch3(false), ouch4(false) {} |
| bool outch1; |
| bool ouch2; |
| bool ouch3; |
| bool ouch4; |
| } _AccumuloProxy_updateAndFlush_presult__isset; |
| |
| class AccumuloProxy_updateAndFlush_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_updateAndFlush_presult() throw() {} |
| |
| AccumuloException outch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| MutationsRejectedException ouch4; |
| |
| _AccumuloProxy_updateAndFlush_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createWriter_args__isset { |
| _AccumuloProxy_createWriter_args__isset() : login(false), tableName(false), opts(false) {} |
| bool login; |
| bool tableName; |
| bool opts; |
| } _AccumuloProxy_createWriter_args__isset; |
| |
| class AccumuloProxy_createWriter_args { |
| public: |
| |
| AccumuloProxy_createWriter_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_createWriter_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| WriterOptions opts; |
| |
| _AccumuloProxy_createWriter_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_opts(const WriterOptions& val) { |
| opts = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createWriter_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(opts == rhs.opts)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createWriter_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createWriter_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_createWriter_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createWriter_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const WriterOptions* opts; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createWriter_result__isset { |
| _AccumuloProxy_createWriter_result__isset() : success(false), outch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool outch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createWriter_result__isset; |
| |
| class AccumuloProxy_createWriter_result { |
| public: |
| |
| AccumuloProxy_createWriter_result() : success() { |
| } |
| |
| virtual ~AccumuloProxy_createWriter_result() throw() {} |
| |
| std::string success; |
| AccumuloException outch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_createWriter_result__isset __isset; |
| |
| void __set_success(const std::string& val) { |
| success = val; |
| } |
| |
| void __set_outch1(const AccumuloException& val) { |
| outch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createWriter_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(outch1 == rhs.outch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createWriter_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createWriter_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createWriter_presult__isset { |
| _AccumuloProxy_createWriter_presult__isset() : success(false), outch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool outch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createWriter_presult__isset; |
| |
| class AccumuloProxy_createWriter_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createWriter_presult() throw() {} |
| |
| std::string* success; |
| AccumuloException outch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_createWriter_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_update_args__isset { |
| _AccumuloProxy_update_args__isset() : writer(false), cells(false) {} |
| bool writer; |
| bool cells; |
| } _AccumuloProxy_update_args__isset; |
| |
| class AccumuloProxy_update_args { |
| public: |
| |
| AccumuloProxy_update_args() : writer() { |
| } |
| |
| virtual ~AccumuloProxy_update_args() throw() {} |
| |
| std::string writer; |
| std::map<std::string, std::vector<ColumnUpdate> > cells; |
| |
| _AccumuloProxy_update_args__isset __isset; |
| |
| void __set_writer(const std::string& val) { |
| writer = val; |
| } |
| |
| void __set_cells(const std::map<std::string, std::vector<ColumnUpdate> > & val) { |
| cells = val; |
| } |
| |
| bool operator == (const AccumuloProxy_update_args & rhs) const |
| { |
| if (!(writer == rhs.writer)) |
| return false; |
| if (!(cells == rhs.cells)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_update_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_update_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_update_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_update_pargs() throw() {} |
| |
| const std::string* writer; |
| const std::map<std::string, std::vector<ColumnUpdate> > * cells; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_flush_args__isset { |
| _AccumuloProxy_flush_args__isset() : writer(false) {} |
| bool writer; |
| } _AccumuloProxy_flush_args__isset; |
| |
| class AccumuloProxy_flush_args { |
| public: |
| |
| AccumuloProxy_flush_args() : writer() { |
| } |
| |
| virtual ~AccumuloProxy_flush_args() throw() {} |
| |
| std::string writer; |
| |
| _AccumuloProxy_flush_args__isset __isset; |
| |
| void __set_writer(const std::string& val) { |
| writer = val; |
| } |
| |
| bool operator == (const AccumuloProxy_flush_args & rhs) const |
| { |
| if (!(writer == rhs.writer)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_flush_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_flush_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_flush_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_flush_pargs() throw() {} |
| |
| const std::string* writer; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_flush_result__isset { |
| _AccumuloProxy_flush_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_flush_result__isset; |
| |
| class AccumuloProxy_flush_result { |
| public: |
| |
| AccumuloProxy_flush_result() { |
| } |
| |
| virtual ~AccumuloProxy_flush_result() throw() {} |
| |
| UnknownWriter ouch1; |
| MutationsRejectedException ouch2; |
| |
| _AccumuloProxy_flush_result__isset __isset; |
| |
| void __set_ouch1(const UnknownWriter& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const MutationsRejectedException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_flush_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_flush_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_flush_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_flush_presult__isset { |
| _AccumuloProxy_flush_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_flush_presult__isset; |
| |
| class AccumuloProxy_flush_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_flush_presult() throw() {} |
| |
| UnknownWriter ouch1; |
| MutationsRejectedException ouch2; |
| |
| _AccumuloProxy_flush_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_closeWriter_args__isset { |
| _AccumuloProxy_closeWriter_args__isset() : writer(false) {} |
| bool writer; |
| } _AccumuloProxy_closeWriter_args__isset; |
| |
| class AccumuloProxy_closeWriter_args { |
| public: |
| |
| AccumuloProxy_closeWriter_args() : writer() { |
| } |
| |
| virtual ~AccumuloProxy_closeWriter_args() throw() {} |
| |
| std::string writer; |
| |
| _AccumuloProxy_closeWriter_args__isset __isset; |
| |
| void __set_writer(const std::string& val) { |
| writer = val; |
| } |
| |
| bool operator == (const AccumuloProxy_closeWriter_args & rhs) const |
| { |
| if (!(writer == rhs.writer)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_closeWriter_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_closeWriter_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_closeWriter_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_closeWriter_pargs() throw() {} |
| |
| const std::string* writer; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_closeWriter_result__isset { |
| _AccumuloProxy_closeWriter_result__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_closeWriter_result__isset; |
| |
| class AccumuloProxy_closeWriter_result { |
| public: |
| |
| AccumuloProxy_closeWriter_result() { |
| } |
| |
| virtual ~AccumuloProxy_closeWriter_result() throw() {} |
| |
| UnknownWriter ouch1; |
| MutationsRejectedException ouch2; |
| |
| _AccumuloProxy_closeWriter_result__isset __isset; |
| |
| void __set_ouch1(const UnknownWriter& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const MutationsRejectedException& val) { |
| ouch2 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_closeWriter_result & rhs) const |
| { |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_closeWriter_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_closeWriter_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_closeWriter_presult__isset { |
| _AccumuloProxy_closeWriter_presult__isset() : ouch1(false), ouch2(false) {} |
| bool ouch1; |
| bool ouch2; |
| } _AccumuloProxy_closeWriter_presult__isset; |
| |
| class AccumuloProxy_closeWriter_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_closeWriter_presult() throw() {} |
| |
| UnknownWriter ouch1; |
| MutationsRejectedException ouch2; |
| |
| _AccumuloProxy_closeWriter_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateRowConditionally_args__isset { |
| _AccumuloProxy_updateRowConditionally_args__isset() : login(false), tableName(false), row(false), updates(false) {} |
| bool login; |
| bool tableName; |
| bool row; |
| bool updates; |
| } _AccumuloProxy_updateRowConditionally_args__isset; |
| |
| class AccumuloProxy_updateRowConditionally_args { |
| public: |
| |
| AccumuloProxy_updateRowConditionally_args() : login(), tableName(), row() { |
| } |
| |
| virtual ~AccumuloProxy_updateRowConditionally_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| std::string row; |
| ConditionalUpdates updates; |
| |
| _AccumuloProxy_updateRowConditionally_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_row(const std::string& val) { |
| row = val; |
| } |
| |
| void __set_updates(const ConditionalUpdates& val) { |
| updates = val; |
| } |
| |
| bool operator == (const AccumuloProxy_updateRowConditionally_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(row == rhs.row)) |
| return false; |
| if (!(updates == rhs.updates)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_updateRowConditionally_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_updateRowConditionally_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_updateRowConditionally_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_updateRowConditionally_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const std::string* row; |
| const ConditionalUpdates* updates; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateRowConditionally_result__isset { |
| _AccumuloProxy_updateRowConditionally_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_updateRowConditionally_result__isset; |
| |
| class AccumuloProxy_updateRowConditionally_result { |
| public: |
| |
| AccumuloProxy_updateRowConditionally_result() : success((ConditionalStatus::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_updateRowConditionally_result() throw() {} |
| |
| ConditionalStatus::type success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_updateRowConditionally_result__isset __isset; |
| |
| void __set_success(const ConditionalStatus::type val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_updateRowConditionally_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_updateRowConditionally_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_updateRowConditionally_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateRowConditionally_presult__isset { |
| _AccumuloProxy_updateRowConditionally_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_updateRowConditionally_presult__isset; |
| |
| class AccumuloProxy_updateRowConditionally_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_updateRowConditionally_presult() throw() {} |
| |
| ConditionalStatus::type* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_updateRowConditionally_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createConditionalWriter_args__isset { |
| _AccumuloProxy_createConditionalWriter_args__isset() : login(false), tableName(false), options(false) {} |
| bool login; |
| bool tableName; |
| bool options; |
| } _AccumuloProxy_createConditionalWriter_args__isset; |
| |
| class AccumuloProxy_createConditionalWriter_args { |
| public: |
| |
| AccumuloProxy_createConditionalWriter_args() : login(), tableName() { |
| } |
| |
| virtual ~AccumuloProxy_createConditionalWriter_args() throw() {} |
| |
| std::string login; |
| std::string tableName; |
| ConditionalWriterOptions options; |
| |
| _AccumuloProxy_createConditionalWriter_args__isset __isset; |
| |
| void __set_login(const std::string& val) { |
| login = val; |
| } |
| |
| void __set_tableName(const std::string& val) { |
| tableName = val; |
| } |
| |
| void __set_options(const ConditionalWriterOptions& val) { |
| options = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createConditionalWriter_args & rhs) const |
| { |
| if (!(login == rhs.login)) |
| return false; |
| if (!(tableName == rhs.tableName)) |
| return false; |
| if (!(options == rhs.options)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createConditionalWriter_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createConditionalWriter_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_createConditionalWriter_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createConditionalWriter_pargs() throw() {} |
| |
| const std::string* login; |
| const std::string* tableName; |
| const ConditionalWriterOptions* options; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createConditionalWriter_result__isset { |
| _AccumuloProxy_createConditionalWriter_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createConditionalWriter_result__isset; |
| |
| class AccumuloProxy_createConditionalWriter_result { |
| public: |
| |
| AccumuloProxy_createConditionalWriter_result() : success() { |
| } |
| |
| virtual ~AccumuloProxy_createConditionalWriter_result() throw() {} |
| |
| std::string success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_createConditionalWriter_result__isset __isset; |
| |
| void __set_success(const std::string& val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const AccumuloException& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloSecurityException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const TableNotFoundException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_createConditionalWriter_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_createConditionalWriter_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_createConditionalWriter_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_createConditionalWriter_presult__isset { |
| _AccumuloProxy_createConditionalWriter_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_createConditionalWriter_presult__isset; |
| |
| class AccumuloProxy_createConditionalWriter_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_createConditionalWriter_presult() throw() {} |
| |
| std::string* success; |
| AccumuloException ouch1; |
| AccumuloSecurityException ouch2; |
| TableNotFoundException ouch3; |
| |
| _AccumuloProxy_createConditionalWriter_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateRowsConditionally_args__isset { |
| _AccumuloProxy_updateRowsConditionally_args__isset() : conditionalWriter(false), updates(false) {} |
| bool conditionalWriter; |
| bool updates; |
| } _AccumuloProxy_updateRowsConditionally_args__isset; |
| |
| class AccumuloProxy_updateRowsConditionally_args { |
| public: |
| |
| AccumuloProxy_updateRowsConditionally_args() : conditionalWriter() { |
| } |
| |
| virtual ~AccumuloProxy_updateRowsConditionally_args() throw() {} |
| |
| std::string conditionalWriter; |
| std::map<std::string, ConditionalUpdates> updates; |
| |
| _AccumuloProxy_updateRowsConditionally_args__isset __isset; |
| |
| void __set_conditionalWriter(const std::string& val) { |
| conditionalWriter = val; |
| } |
| |
| void __set_updates(const std::map<std::string, ConditionalUpdates> & val) { |
| updates = val; |
| } |
| |
| bool operator == (const AccumuloProxy_updateRowsConditionally_args & rhs) const |
| { |
| if (!(conditionalWriter == rhs.conditionalWriter)) |
| return false; |
| if (!(updates == rhs.updates)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_updateRowsConditionally_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_updateRowsConditionally_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_updateRowsConditionally_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_updateRowsConditionally_pargs() throw() {} |
| |
| const std::string* conditionalWriter; |
| const std::map<std::string, ConditionalUpdates> * updates; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateRowsConditionally_result__isset { |
| _AccumuloProxy_updateRowsConditionally_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_updateRowsConditionally_result__isset; |
| |
| class AccumuloProxy_updateRowsConditionally_result { |
| public: |
| |
| AccumuloProxy_updateRowsConditionally_result() { |
| } |
| |
| virtual ~AccumuloProxy_updateRowsConditionally_result() throw() {} |
| |
| std::map<std::string, ConditionalStatus::type> success; |
| UnknownWriter ouch1; |
| AccumuloException ouch2; |
| AccumuloSecurityException ouch3; |
| |
| _AccumuloProxy_updateRowsConditionally_result__isset __isset; |
| |
| void __set_success(const std::map<std::string, ConditionalStatus::type> & val) { |
| success = val; |
| } |
| |
| void __set_ouch1(const UnknownWriter& val) { |
| ouch1 = val; |
| } |
| |
| void __set_ouch2(const AccumuloException& val) { |
| ouch2 = val; |
| } |
| |
| void __set_ouch3(const AccumuloSecurityException& val) { |
| ouch3 = val; |
| } |
| |
| bool operator == (const AccumuloProxy_updateRowsConditionally_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| if (!(ouch1 == rhs.ouch1)) |
| return false; |
| if (!(ouch2 == rhs.ouch2)) |
| return false; |
| if (!(ouch3 == rhs.ouch3)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_updateRowsConditionally_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_updateRowsConditionally_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_updateRowsConditionally_presult__isset { |
| _AccumuloProxy_updateRowsConditionally_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} |
| bool success; |
| bool ouch1; |
| bool ouch2; |
| bool ouch3; |
| } _AccumuloProxy_updateRowsConditionally_presult__isset; |
| |
| class AccumuloProxy_updateRowsConditionally_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_updateRowsConditionally_presult() throw() {} |
| |
| std::map<std::string, ConditionalStatus::type> * success; |
| UnknownWriter ouch1; |
| AccumuloException ouch2; |
| AccumuloSecurityException ouch3; |
| |
| _AccumuloProxy_updateRowsConditionally_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_closeConditionalWriter_args__isset { |
| _AccumuloProxy_closeConditionalWriter_args__isset() : conditionalWriter(false) {} |
| bool conditionalWriter; |
| } _AccumuloProxy_closeConditionalWriter_args__isset; |
| |
| class AccumuloProxy_closeConditionalWriter_args { |
| public: |
| |
| AccumuloProxy_closeConditionalWriter_args() : conditionalWriter() { |
| } |
| |
| virtual ~AccumuloProxy_closeConditionalWriter_args() throw() {} |
| |
| std::string conditionalWriter; |
| |
| _AccumuloProxy_closeConditionalWriter_args__isset __isset; |
| |
| void __set_conditionalWriter(const std::string& val) { |
| conditionalWriter = val; |
| } |
| |
| bool operator == (const AccumuloProxy_closeConditionalWriter_args & rhs) const |
| { |
| if (!(conditionalWriter == rhs.conditionalWriter)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_closeConditionalWriter_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_closeConditionalWriter_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_closeConditionalWriter_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_closeConditionalWriter_pargs() throw() {} |
| |
| const std::string* conditionalWriter; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_closeConditionalWriter_result { |
| public: |
| |
| AccumuloProxy_closeConditionalWriter_result() { |
| } |
| |
| virtual ~AccumuloProxy_closeConditionalWriter_result() throw() {} |
| |
| |
| bool operator == (const AccumuloProxy_closeConditionalWriter_result & /* rhs */) const |
| { |
| return true; |
| } |
| bool operator != (const AccumuloProxy_closeConditionalWriter_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_closeConditionalWriter_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_closeConditionalWriter_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_closeConditionalWriter_presult() throw() {} |
| |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getRowRange_args__isset { |
| _AccumuloProxy_getRowRange_args__isset() : row(false) {} |
| bool row; |
| } _AccumuloProxy_getRowRange_args__isset; |
| |
| class AccumuloProxy_getRowRange_args { |
| public: |
| |
| AccumuloProxy_getRowRange_args() : row() { |
| } |
| |
| virtual ~AccumuloProxy_getRowRange_args() throw() {} |
| |
| std::string row; |
| |
| _AccumuloProxy_getRowRange_args__isset __isset; |
| |
| void __set_row(const std::string& val) { |
| row = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getRowRange_args & rhs) const |
| { |
| if (!(row == rhs.row)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getRowRange_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getRowRange_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getRowRange_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getRowRange_pargs() throw() {} |
| |
| const std::string* row; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getRowRange_result__isset { |
| _AccumuloProxy_getRowRange_result__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_getRowRange_result__isset; |
| |
| class AccumuloProxy_getRowRange_result { |
| public: |
| |
| AccumuloProxy_getRowRange_result() { |
| } |
| |
| virtual ~AccumuloProxy_getRowRange_result() throw() {} |
| |
| Range success; |
| |
| _AccumuloProxy_getRowRange_result__isset __isset; |
| |
| void __set_success(const Range& val) { |
| success = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getRowRange_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getRowRange_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getRowRange_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getRowRange_presult__isset { |
| _AccumuloProxy_getRowRange_presult__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_getRowRange_presult__isset; |
| |
| class AccumuloProxy_getRowRange_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getRowRange_presult() throw() {} |
| |
| Range* success; |
| |
| _AccumuloProxy_getRowRange_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getFollowing_args__isset { |
| _AccumuloProxy_getFollowing_args__isset() : key(false), part(false) {} |
| bool key; |
| bool part; |
| } _AccumuloProxy_getFollowing_args__isset; |
| |
| class AccumuloProxy_getFollowing_args { |
| public: |
| |
| AccumuloProxy_getFollowing_args() : part((PartialKey::type)0) { |
| } |
| |
| virtual ~AccumuloProxy_getFollowing_args() throw() {} |
| |
| Key key; |
| PartialKey::type part; |
| |
| _AccumuloProxy_getFollowing_args__isset __isset; |
| |
| void __set_key(const Key& val) { |
| key = val; |
| } |
| |
| void __set_part(const PartialKey::type val) { |
| part = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getFollowing_args & rhs) const |
| { |
| if (!(key == rhs.key)) |
| return false; |
| if (!(part == rhs.part)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getFollowing_args &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getFollowing_args & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| |
| class AccumuloProxy_getFollowing_pargs { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getFollowing_pargs() throw() {} |
| |
| const Key* key; |
| const PartialKey::type* part; |
| |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getFollowing_result__isset { |
| _AccumuloProxy_getFollowing_result__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_getFollowing_result__isset; |
| |
| class AccumuloProxy_getFollowing_result { |
| public: |
| |
| AccumuloProxy_getFollowing_result() { |
| } |
| |
| virtual ~AccumuloProxy_getFollowing_result() throw() {} |
| |
| Key success; |
| |
| _AccumuloProxy_getFollowing_result__isset __isset; |
| |
| void __set_success(const Key& val) { |
| success = val; |
| } |
| |
| bool operator == (const AccumuloProxy_getFollowing_result & rhs) const |
| { |
| if (!(success == rhs.success)) |
| return false; |
| return true; |
| } |
| bool operator != (const AccumuloProxy_getFollowing_result &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const AccumuloProxy_getFollowing_result & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; |
| |
| }; |
| |
| typedef struct _AccumuloProxy_getFollowing_presult__isset { |
| _AccumuloProxy_getFollowing_presult__isset() : success(false) {} |
| bool success; |
| } _AccumuloProxy_getFollowing_presult__isset; |
| |
| class AccumuloProxy_getFollowing_presult { |
| public: |
| |
| |
| virtual ~AccumuloProxy_getFollowing_presult() throw() {} |
| |
| Key* success; |
| |
| _AccumuloProxy_getFollowing_presult__isset __isset; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot); |
| |
| }; |
| |
| class AccumuloProxyClient : virtual public AccumuloProxyIf { |
| public: |
| AccumuloProxyClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : |
| piprot_(prot), |
| poprot_(prot) { |
| iprot_ = prot.get(); |
| oprot_ = prot.get(); |
| } |
| AccumuloProxyClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : |
| piprot_(iprot), |
| poprot_(oprot) { |
| iprot_ = iprot.get(); |
| oprot_ = oprot.get(); |
| } |
| boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { |
| return piprot_; |
| } |
| boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { |
| return poprot_; |
| } |
| void login(std::string& _return, const std::string& principal, const std::map<std::string, std::string> & loginProperties); |
| void send_login(const std::string& principal, const std::map<std::string, std::string> & loginProperties); |
| void recv_login(std::string& _return); |
| int32_t addConstraint(const std::string& login, const std::string& tableName, const std::string& constraintClassName); |
| void send_addConstraint(const std::string& login, const std::string& tableName, const std::string& constraintClassName); |
| int32_t recv_addConstraint(); |
| void addSplits(const std::string& login, const std::string& tableName, const std::set<std::string> & splits); |
| void send_addSplits(const std::string& login, const std::string& tableName, const std::set<std::string> & splits); |
| void recv_addSplits(); |
| void attachIterator(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes); |
| void send_attachIterator(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes); |
| void recv_attachIterator(); |
| void checkIteratorConflicts(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes); |
| void send_checkIteratorConflicts(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes); |
| void recv_checkIteratorConflicts(); |
| void clearLocatorCache(const std::string& login, const std::string& tableName); |
| void send_clearLocatorCache(const std::string& login, const std::string& tableName); |
| void recv_clearLocatorCache(); |
| void cloneTable(const std::string& login, const std::string& tableName, const std::string& newTableName, const bool flush, const std::map<std::string, std::string> & propertiesToSet, const std::set<std::string> & propertiesToExclude); |
| void send_cloneTable(const std::string& login, const std::string& tableName, const std::string& newTableName, const bool flush, const std::map<std::string, std::string> & propertiesToSet, const std::set<std::string> & propertiesToExclude); |
| void recv_cloneTable(); |
| void compactTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const std::vector<IteratorSetting> & iterators, const bool flush, const bool wait, const CompactionStrategyConfig& compactionStrategy); |
| void send_compactTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const std::vector<IteratorSetting> & iterators, const bool flush, const bool wait, const CompactionStrategyConfig& compactionStrategy); |
| void recv_compactTable(); |
| void cancelCompaction(const std::string& login, const std::string& tableName); |
| void send_cancelCompaction(const std::string& login, const std::string& tableName); |
| void recv_cancelCompaction(); |
| void createTable(const std::string& login, const std::string& tableName, const bool versioningIter, const TimeType::type type); |
| void send_createTable(const std::string& login, const std::string& tableName, const bool versioningIter, const TimeType::type type); |
| void recv_createTable(); |
| void deleteTable(const std::string& login, const std::string& tableName); |
| void send_deleteTable(const std::string& login, const std::string& tableName); |
| void recv_deleteTable(); |
| void deleteRows(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow); |
| void send_deleteRows(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow); |
| void recv_deleteRows(); |
| void exportTable(const std::string& login, const std::string& tableName, const std::string& exportDir); |
| void send_exportTable(const std::string& login, const std::string& tableName, const std::string& exportDir); |
| void recv_exportTable(); |
| void flushTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const bool wait); |
| void send_flushTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const bool wait); |
| void recv_flushTable(); |
| void getDiskUsage(std::vector<DiskUsage> & _return, const std::string& login, const std::set<std::string> & tables); |
| void send_getDiskUsage(const std::string& login, const std::set<std::string> & tables); |
| void recv_getDiskUsage(std::vector<DiskUsage> & _return); |
| void getLocalityGroups(std::map<std::string, std::set<std::string> > & _return, const std::string& login, const std::string& tableName); |
| void send_getLocalityGroups(const std::string& login, const std::string& tableName); |
| void recv_getLocalityGroups(std::map<std::string, std::set<std::string> > & _return); |
| void getIteratorSetting(IteratorSetting& _return, const std::string& login, const std::string& tableName, const std::string& iteratorName, const IteratorScope::type scope); |
| void send_getIteratorSetting(const std::string& login, const std::string& tableName, const std::string& iteratorName, const IteratorScope::type scope); |
| void recv_getIteratorSetting(IteratorSetting& _return); |
| void getMaxRow(std::string& _return, const std::string& login, const std::string& tableName, const std::set<std::string> & auths, const std::string& startRow, const bool startInclusive, const std::string& endRow, const bool endInclusive); |
| void send_getMaxRow(const std::string& login, const std::string& tableName, const std::set<std::string> & auths, const std::string& startRow, const bool startInclusive, const std::string& endRow, const bool endInclusive); |
| void recv_getMaxRow(std::string& _return); |
| void getTableProperties(std::map<std::string, std::string> & _return, const std::string& login, const std::string& tableName); |
| void send_getTableProperties(const std::string& login, const std::string& tableName); |
| void recv_getTableProperties(std::map<std::string, std::string> & _return); |
| void importDirectory(const std::string& login, const std::string& tableName, const std::string& importDir, const std::string& failureDir, const bool setTime); |
| void send_importDirectory(const std::string& login, const std::string& tableName, const std::string& importDir, const std::string& failureDir, const bool setTime); |
| void recv_importDirectory(); |
| void importTable(const std::string& login, const std::string& tableName, const std::string& importDir); |
| void send_importTable(const std::string& login, const std::string& tableName, const std::string& importDir); |
| void recv_importTable(); |
| void listSplits(std::vector<std::string> & _return, const std::string& login, const std::string& tableName, const int32_t maxSplits); |
| void send_listSplits(const std::string& login, const std::string& tableName, const int32_t maxSplits); |
| void recv_listSplits(std::vector<std::string> & _return); |
| void listTables(std::set<std::string> & _return, const std::string& login); |
| void send_listTables(const std::string& login); |
| void recv_listTables(std::set<std::string> & _return); |
| void listIterators(std::map<std::string, std::set<IteratorScope::type> > & _return, const std::string& login, const std::string& tableName); |
| void send_listIterators(const std::string& login, const std::string& tableName); |
| void recv_listIterators(std::map<std::string, std::set<IteratorScope::type> > & _return); |
| void listConstraints(std::map<std::string, int32_t> & _return, const std::string& login, const std::string& tableName); |
| void send_listConstraints(const std::string& login, const std::string& tableName); |
| void recv_listConstraints(std::map<std::string, int32_t> & _return); |
| void mergeTablets(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow); |
| void send_mergeTablets(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow); |
| void recv_mergeTablets(); |
| void offlineTable(const std::string& login, const std::string& tableName, const bool wait); |
| void send_offlineTable(const std::string& login, const std::string& tableName, const bool wait); |
| void recv_offlineTable(); |
| void onlineTable(const std::string& login, const std::string& tableName, const bool wait); |
| void send_onlineTable(const std::string& login, const std::string& tableName, const bool wait); |
| void recv_onlineTable(); |
| void removeConstraint(const std::string& login, const std::string& tableName, const int32_t constraint); |
| void send_removeConstraint(const std::string& login, const std::string& tableName, const int32_t constraint); |
| void recv_removeConstraint(); |
| void removeIterator(const std::string& login, const std::string& tableName, const std::string& iterName, const std::set<IteratorScope::type> & scopes); |
| void send_removeIterator(const std::string& login, const std::string& tableName, const std::string& iterName, const std::set<IteratorScope::type> & scopes); |
| void recv_removeIterator(); |
| void removeTableProperty(const std::string& login, const std::string& tableName, const std::string& property); |
| void send_removeTableProperty(const std::string& login, const std::string& tableName, const std::string& property); |
| void recv_removeTableProperty(); |
| void renameTable(const std::string& login, const std::string& oldTableName, const std::string& newTableName); |
| void send_renameTable(const std::string& login, const std::string& oldTableName, const std::string& newTableName); |
| void recv_renameTable(); |
| void setLocalityGroups(const std::string& login, const std::string& tableName, const std::map<std::string, std::set<std::string> > & groups); |
| void send_setLocalityGroups(const std::string& login, const std::string& tableName, const std::map<std::string, std::set<std::string> > & groups); |
| void recv_setLocalityGroups(); |
| void setTableProperty(const std::string& login, const std::string& tableName, const std::string& property, const std::string& value); |
| void send_setTableProperty(const std::string& login, const std::string& tableName, const std::string& property, const std::string& value); |
| void recv_setTableProperty(); |
| void splitRangeByTablets(std::set<Range> & _return, const std::string& login, const std::string& tableName, const Range& range, const int32_t maxSplits); |
| void send_splitRangeByTablets(const std::string& login, const std::string& tableName, const Range& range, const int32_t maxSplits); |
| void recv_splitRangeByTablets(std::set<Range> & _return); |
| bool tableExists(const std::string& login, const std::string& tableName); |
| void send_tableExists(const std::string& login, const std::string& tableName); |
| bool recv_tableExists(); |
| void tableIdMap(std::map<std::string, std::string> & _return, const std::string& login); |
| void send_tableIdMap(const std::string& login); |
| void recv_tableIdMap(std::map<std::string, std::string> & _return); |
| bool testTableClassLoad(const std::string& login, const std::string& tableName, const std::string& className, const std::string& asTypeName); |
| void send_testTableClassLoad(const std::string& login, const std::string& tableName, const std::string& className, const std::string& asTypeName); |
| bool recv_testTableClassLoad(); |
| void pingTabletServer(const std::string& login, const std::string& tserver); |
| void send_pingTabletServer(const std::string& login, const std::string& tserver); |
| void recv_pingTabletServer(); |
| void getActiveScans(std::vector<ActiveScan> & _return, const std::string& login, const std::string& tserver); |
| void send_getActiveScans(const std::string& login, const std::string& tserver); |
| void recv_getActiveScans(std::vector<ActiveScan> & _return); |
| void getActiveCompactions(std::vector<ActiveCompaction> & _return, const std::string& login, const std::string& tserver); |
| void send_getActiveCompactions(const std::string& login, const std::string& tserver); |
| void recv_getActiveCompactions(std::vector<ActiveCompaction> & _return); |
| void getSiteConfiguration(std::map<std::string, std::string> & _return, const std::string& login); |
| void send_getSiteConfiguration(const std::string& login); |
| void recv_getSiteConfiguration(std::map<std::string, std::string> & _return); |
| void getSystemConfiguration(std::map<std::string, std::string> & _return, const std::string& login); |
| void send_getSystemConfiguration(const std::string& login); |
| void recv_getSystemConfiguration(std::map<std::string, std::string> & _return); |
| void getTabletServers(std::vector<std::string> & _return, const std::string& login); |
| void send_getTabletServers(const std::string& login); |
| void recv_getTabletServers(std::vector<std::string> & _return); |
| void removeProperty(const std::string& login, const std::string& property); |
| void send_removeProperty(const std::string& login, const std::string& property); |
| void recv_removeProperty(); |
| void setProperty(const std::string& login, const std::string& property, const std::string& value); |
| void send_setProperty(const std::string& login, const std::string& property, const std::string& value); |
| void recv_setProperty(); |
| bool testClassLoad(const std::string& login, const std::string& className, const std::string& asTypeName); |
| void send_testClassLoad(const std::string& login, const std::string& className, const std::string& asTypeName); |
| bool recv_testClassLoad(); |
| bool authenticateUser(const std::string& login, const std::string& user, const std::map<std::string, std::string> & properties); |
| void send_authenticateUser(const std::string& login, const std::string& user, const std::map<std::string, std::string> & properties); |
| bool recv_authenticateUser(); |
| void changeUserAuthorizations(const std::string& login, const std::string& user, const std::set<std::string> & authorizations); |
| void send_changeUserAuthorizations(const std::string& login, const std::string& user, const std::set<std::string> & authorizations); |
| void recv_changeUserAuthorizations(); |
| void changeLocalUserPassword(const std::string& login, const std::string& user, const std::string& password); |
| void send_changeLocalUserPassword(const std::string& login, const std::string& user, const std::string& password); |
| void recv_changeLocalUserPassword(); |
| void createLocalUser(const std::string& login, const std::string& user, const std::string& password); |
| void send_createLocalUser(const std::string& login, const std::string& user, const std::string& password); |
| void recv_createLocalUser(); |
| void dropLocalUser(const std::string& login, const std::string& user); |
| void send_dropLocalUser(const std::string& login, const std::string& user); |
| void recv_dropLocalUser(); |
| void getUserAuthorizations(std::vector<std::string> & _return, const std::string& login, const std::string& user); |
| void send_getUserAuthorizations(const std::string& login, const std::string& user); |
| void recv_getUserAuthorizations(std::vector<std::string> & _return); |
| void grantSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm); |
| void send_grantSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm); |
| void recv_grantSystemPermission(); |
| void grantTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm); |
| void send_grantTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm); |
| void recv_grantTablePermission(); |
| bool hasSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm); |
| void send_hasSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm); |
| bool recv_hasSystemPermission(); |
| bool hasTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm); |
| void send_hasTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm); |
| bool recv_hasTablePermission(); |
| void listLocalUsers(std::set<std::string> & _return, const std::string& login); |
| void send_listLocalUsers(const std::string& login); |
| void recv_listLocalUsers(std::set<std::string> & _return); |
| void revokeSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm); |
| void send_revokeSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm); |
| void recv_revokeSystemPermission(); |
| void revokeTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm); |
| void send_revokeTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm); |
| void recv_revokeTablePermission(); |
| void createBatchScanner(std::string& _return, const std::string& login, const std::string& tableName, const BatchScanOptions& options); |
| void send_createBatchScanner(const std::string& login, const std::string& tableName, const BatchScanOptions& options); |
| void recv_createBatchScanner(std::string& _return); |
| void createScanner(std::string& _return, const std::string& login, const std::string& tableName, const ScanOptions& options); |
| void send_createScanner(const std::string& login, const std::string& tableName, const ScanOptions& options); |
| void recv_createScanner(std::string& _return); |
| bool hasNext(const std::string& scanner); |
| void send_hasNext(const std::string& scanner); |
| bool recv_hasNext(); |
| void nextEntry(KeyValueAndPeek& _return, const std::string& scanner); |
| void send_nextEntry(const std::string& scanner); |
| void recv_nextEntry(KeyValueAndPeek& _return); |
| void nextK(ScanResult& _return, const std::string& scanner, const int32_t k); |
| void send_nextK(const std::string& scanner, const int32_t k); |
| void recv_nextK(ScanResult& _return); |
| void closeScanner(const std::string& scanner); |
| void send_closeScanner(const std::string& scanner); |
| void recv_closeScanner(); |
| void updateAndFlush(const std::string& login, const std::string& tableName, const std::map<std::string, std::vector<ColumnUpdate> > & cells); |
| void send_updateAndFlush(const std::string& login, const std::string& tableName, const std::map<std::string, std::vector<ColumnUpdate> > & cells); |
| void recv_updateAndFlush(); |
| void createWriter(std::string& _return, const std::string& login, const std::string& tableName, const WriterOptions& opts); |
| void send_createWriter(const std::string& login, const std::string& tableName, const WriterOptions& opts); |
| void recv_createWriter(std::string& _return); |
| void update(const std::string& writer, const std::map<std::string, std::vector<ColumnUpdate> > & cells); |
| void send_update(const std::string& writer, const std::map<std::string, std::vector<ColumnUpdate> > & cells); |
| void flush(const std::string& writer); |
| void send_flush(const std::string& writer); |
| void recv_flush(); |
| void closeWriter(const std::string& writer); |
| void send_closeWriter(const std::string& writer); |
| void recv_closeWriter(); |
| ConditionalStatus::type updateRowConditionally(const std::string& login, const std::string& tableName, const std::string& row, const ConditionalUpdates& updates); |
| void send_updateRowConditionally(const std::string& login, const std::string& tableName, const std::string& row, const ConditionalUpdates& updates); |
| ConditionalStatus::type recv_updateRowConditionally(); |
| void createConditionalWriter(std::string& _return, const std::string& login, const std::string& tableName, const ConditionalWriterOptions& options); |
| void send_createConditionalWriter(const std::string& login, const std::string& tableName, const ConditionalWriterOptions& options); |
| void recv_createConditionalWriter(std::string& _return); |
| void updateRowsConditionally(std::map<std::string, ConditionalStatus::type> & _return, const std::string& conditionalWriter, const std::map<std::string, ConditionalUpdates> & updates); |
| void send_updateRowsConditionally(const std::string& conditionalWriter, const std::map<std::string, ConditionalUpdates> & updates); |
| void recv_updateRowsConditionally(std::map<std::string, ConditionalStatus::type> & _return); |
| void closeConditionalWriter(const std::string& conditionalWriter); |
| void send_closeConditionalWriter(const std::string& conditionalWriter); |
| void recv_closeConditionalWriter(); |
| void getRowRange(Range& _return, const std::string& row); |
| void send_getRowRange(const std::string& row); |
| void recv_getRowRange(Range& _return); |
| void getFollowing(Key& _return, const Key& key, const PartialKey::type part); |
| void send_getFollowing(const Key& key, const PartialKey::type part); |
| void recv_getFollowing(Key& _return); |
| protected: |
| boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; |
| boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; |
| ::apache::thrift::protocol::TProtocol* iprot_; |
| ::apache::thrift::protocol::TProtocol* oprot_; |
| }; |
| |
| class AccumuloProxyProcessor : public ::apache::thrift::TDispatchProcessor { |
| protected: |
| boost::shared_ptr<AccumuloProxyIf> iface_; |
| virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); |
| private: |
| typedef void (AccumuloProxyProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); |
| typedef std::map<std::string, ProcessFunction> ProcessMap; |
| ProcessMap processMap_; |
| void process_login(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_addConstraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_addSplits(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_attachIterator(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_checkIteratorConflicts(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_clearLocatorCache(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_cloneTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_compactTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_cancelCompaction(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_createTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_deleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_deleteRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_exportTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_flushTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getDiskUsage(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getLocalityGroups(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getIteratorSetting(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getMaxRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getTableProperties(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_importDirectory(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_importTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_listSplits(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_listTables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_listIterators(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_listConstraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_mergeTablets(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_offlineTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_onlineTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_removeConstraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_removeIterator(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_removeTableProperty(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_renameTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_setLocalityGroups(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_setTableProperty(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_splitRangeByTablets(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_tableExists(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_tableIdMap(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_testTableClassLoad(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_pingTabletServer(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getActiveScans(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getActiveCompactions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getSiteConfiguration(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getSystemConfiguration(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getTabletServers(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_removeProperty(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_setProperty(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_testClassLoad(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_authenticateUser(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_changeUserAuthorizations(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_changeLocalUserPassword(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_createLocalUser(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_dropLocalUser(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getUserAuthorizations(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_grantSystemPermission(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_grantTablePermission(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_hasSystemPermission(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_hasTablePermission(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_listLocalUsers(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_revokeSystemPermission(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_revokeTablePermission(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_createBatchScanner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_createScanner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_hasNext(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_nextEntry(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_nextK(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_closeScanner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_updateAndFlush(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_createWriter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_update(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_flush(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_closeWriter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_updateRowConditionally(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_createConditionalWriter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_updateRowsConditionally(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_closeConditionalWriter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getRowRange(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| void process_getFollowing(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); |
| public: |
| AccumuloProxyProcessor(boost::shared_ptr<AccumuloProxyIf> iface) : |
| iface_(iface) { |
| processMap_["login"] = &AccumuloProxyProcessor::process_login; |
| processMap_["addConstraint"] = &AccumuloProxyProcessor::process_addConstraint; |
| processMap_["addSplits"] = &AccumuloProxyProcessor::process_addSplits; |
| processMap_["attachIterator"] = &AccumuloProxyProcessor::process_attachIterator; |
| processMap_["checkIteratorConflicts"] = &AccumuloProxyProcessor::process_checkIteratorConflicts; |
| processMap_["clearLocatorCache"] = &AccumuloProxyProcessor::process_clearLocatorCache; |
| processMap_["cloneTable"] = &AccumuloProxyProcessor::process_cloneTable; |
| processMap_["compactTable"] = &AccumuloProxyProcessor::process_compactTable; |
| processMap_["cancelCompaction"] = &AccumuloProxyProcessor::process_cancelCompaction; |
| processMap_["createTable"] = &AccumuloProxyProcessor::process_createTable; |
| processMap_["deleteTable"] = &AccumuloProxyProcessor::process_deleteTable; |
| processMap_["deleteRows"] = &AccumuloProxyProcessor::process_deleteRows; |
| processMap_["exportTable"] = &AccumuloProxyProcessor::process_exportTable; |
| processMap_["flushTable"] = &AccumuloProxyProcessor::process_flushTable; |
| processMap_["getDiskUsage"] = &AccumuloProxyProcessor::process_getDiskUsage; |
| processMap_["getLocalityGroups"] = &AccumuloProxyProcessor::process_getLocalityGroups; |
| processMap_["getIteratorSetting"] = &AccumuloProxyProcessor::process_getIteratorSetting; |
| processMap_["getMaxRow"] = &AccumuloProxyProcessor::process_getMaxRow; |
| processMap_["getTableProperties"] = &AccumuloProxyProcessor::process_getTableProperties; |
| processMap_["importDirectory"] = &AccumuloProxyProcessor::process_importDirectory; |
| processMap_["importTable"] = &AccumuloProxyProcessor::process_importTable; |
| processMap_["listSplits"] = &AccumuloProxyProcessor::process_listSplits; |
| processMap_["listTables"] = &AccumuloProxyProcessor::process_listTables; |
| processMap_["listIterators"] = &AccumuloProxyProcessor::process_listIterators; |
| processMap_["listConstraints"] = &AccumuloProxyProcessor::process_listConstraints; |
| processMap_["mergeTablets"] = &AccumuloProxyProcessor::process_mergeTablets; |
| processMap_["offlineTable"] = &AccumuloProxyProcessor::process_offlineTable; |
| processMap_["onlineTable"] = &AccumuloProxyProcessor::process_onlineTable; |
| processMap_["removeConstraint"] = &AccumuloProxyProcessor::process_removeConstraint; |
| processMap_["removeIterator"] = &AccumuloProxyProcessor::process_removeIterator; |
| processMap_["removeTableProperty"] = &AccumuloProxyProcessor::process_removeTableProperty; |
| processMap_["renameTable"] = &AccumuloProxyProcessor::process_renameTable; |
| processMap_["setLocalityGroups"] = &AccumuloProxyProcessor::process_setLocalityGroups; |
| processMap_["setTableProperty"] = &AccumuloProxyProcessor::process_setTableProperty; |
| processMap_["splitRangeByTablets"] = &AccumuloProxyProcessor::process_splitRangeByTablets; |
| processMap_["tableExists"] = &AccumuloProxyProcessor::process_tableExists; |
| processMap_["tableIdMap"] = &AccumuloProxyProcessor::process_tableIdMap; |
| processMap_["testTableClassLoad"] = &AccumuloProxyProcessor::process_testTableClassLoad; |
| processMap_["pingTabletServer"] = &AccumuloProxyProcessor::process_pingTabletServer; |
| processMap_["getActiveScans"] = &AccumuloProxyProcessor::process_getActiveScans; |
| processMap_["getActiveCompactions"] = &AccumuloProxyProcessor::process_getActiveCompactions; |
| processMap_["getSiteConfiguration"] = &AccumuloProxyProcessor::process_getSiteConfiguration; |
| processMap_["getSystemConfiguration"] = &AccumuloProxyProcessor::process_getSystemConfiguration; |
| processMap_["getTabletServers"] = &AccumuloProxyProcessor::process_getTabletServers; |
| processMap_["removeProperty"] = &AccumuloProxyProcessor::process_removeProperty; |
| processMap_["setProperty"] = &AccumuloProxyProcessor::process_setProperty; |
| processMap_["testClassLoad"] = &AccumuloProxyProcessor::process_testClassLoad; |
| processMap_["authenticateUser"] = &AccumuloProxyProcessor::process_authenticateUser; |
| processMap_["changeUserAuthorizations"] = &AccumuloProxyProcessor::process_changeUserAuthorizations; |
| processMap_["changeLocalUserPassword"] = &AccumuloProxyProcessor::process_changeLocalUserPassword; |
| processMap_["createLocalUser"] = &AccumuloProxyProcessor::process_createLocalUser; |
| processMap_["dropLocalUser"] = &AccumuloProxyProcessor::process_dropLocalUser; |
| processMap_["getUserAuthorizations"] = &AccumuloProxyProcessor::process_getUserAuthorizations; |
| processMap_["grantSystemPermission"] = &AccumuloProxyProcessor::process_grantSystemPermission; |
| processMap_["grantTablePermission"] = &AccumuloProxyProcessor::process_grantTablePermission; |
| processMap_["hasSystemPermission"] = &AccumuloProxyProcessor::process_hasSystemPermission; |
| processMap_["hasTablePermission"] = &AccumuloProxyProcessor::process_hasTablePermission; |
| processMap_["listLocalUsers"] = &AccumuloProxyProcessor::process_listLocalUsers; |
| processMap_["revokeSystemPermission"] = &AccumuloProxyProcessor::process_revokeSystemPermission; |
| processMap_["revokeTablePermission"] = &AccumuloProxyProcessor::process_revokeTablePermission; |
| processMap_["createBatchScanner"] = &AccumuloProxyProcessor::process_createBatchScanner; |
| processMap_["createScanner"] = &AccumuloProxyProcessor::process_createScanner; |
| processMap_["hasNext"] = &AccumuloProxyProcessor::process_hasNext; |
| processMap_["nextEntry"] = &AccumuloProxyProcessor::process_nextEntry; |
| processMap_["nextK"] = &AccumuloProxyProcessor::process_nextK; |
| processMap_["closeScanner"] = &AccumuloProxyProcessor::process_closeScanner; |
| processMap_["updateAndFlush"] = &AccumuloProxyProcessor::process_updateAndFlush; |
| processMap_["createWriter"] = &AccumuloProxyProcessor::process_createWriter; |
| processMap_["update"] = &AccumuloProxyProcessor::process_update; |
| processMap_["flush"] = &AccumuloProxyProcessor::process_flush; |
| processMap_["closeWriter"] = &AccumuloProxyProcessor::process_closeWriter; |
| processMap_["updateRowConditionally"] = &AccumuloProxyProcessor::process_updateRowConditionally; |
| processMap_["createConditionalWriter"] = &AccumuloProxyProcessor::process_createConditionalWriter; |
| processMap_["updateRowsConditionally"] = &AccumuloProxyProcessor::process_updateRowsConditionally; |
| processMap_["closeConditionalWriter"] = &AccumuloProxyProcessor::process_closeConditionalWriter; |
| processMap_["getRowRange"] = &AccumuloProxyProcessor::process_getRowRange; |
| processMap_["getFollowing"] = &AccumuloProxyProcessor::process_getFollowing; |
| } |
| |
| virtual ~AccumuloProxyProcessor() {} |
| }; |
| |
| class AccumuloProxyProcessorFactory : public ::apache::thrift::TProcessorFactory { |
| public: |
| AccumuloProxyProcessorFactory(const ::boost::shared_ptr< AccumuloProxyIfFactory >& handlerFactory) : |
| handlerFactory_(handlerFactory) {} |
| |
| ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); |
| |
| protected: |
| ::boost::shared_ptr< AccumuloProxyIfFactory > handlerFactory_; |
| }; |
| |
| class AccumuloProxyMultiface : virtual public AccumuloProxyIf { |
| public: |
| AccumuloProxyMultiface(std::vector<boost::shared_ptr<AccumuloProxyIf> >& ifaces) : ifaces_(ifaces) { |
| } |
| virtual ~AccumuloProxyMultiface() {} |
| protected: |
| std::vector<boost::shared_ptr<AccumuloProxyIf> > ifaces_; |
| AccumuloProxyMultiface() {} |
| void add(boost::shared_ptr<AccumuloProxyIf> iface) { |
| ifaces_.push_back(iface); |
| } |
| public: |
| void login(std::string& _return, const std::string& principal, const std::map<std::string, std::string> & loginProperties) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->login(_return, principal, loginProperties); |
| } |
| ifaces_[i]->login(_return, principal, loginProperties); |
| return; |
| } |
| |
| int32_t addConstraint(const std::string& login, const std::string& tableName, const std::string& constraintClassName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->addConstraint(login, tableName, constraintClassName); |
| } |
| return ifaces_[i]->addConstraint(login, tableName, constraintClassName); |
| } |
| |
| void addSplits(const std::string& login, const std::string& tableName, const std::set<std::string> & splits) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->addSplits(login, tableName, splits); |
| } |
| ifaces_[i]->addSplits(login, tableName, splits); |
| } |
| |
| void attachIterator(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->attachIterator(login, tableName, setting, scopes); |
| } |
| ifaces_[i]->attachIterator(login, tableName, setting, scopes); |
| } |
| |
| void checkIteratorConflicts(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->checkIteratorConflicts(login, tableName, setting, scopes); |
| } |
| ifaces_[i]->checkIteratorConflicts(login, tableName, setting, scopes); |
| } |
| |
| void clearLocatorCache(const std::string& login, const std::string& tableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->clearLocatorCache(login, tableName); |
| } |
| ifaces_[i]->clearLocatorCache(login, tableName); |
| } |
| |
| void cloneTable(const std::string& login, const std::string& tableName, const std::string& newTableName, const bool flush, const std::map<std::string, std::string> & propertiesToSet, const std::set<std::string> & propertiesToExclude) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->cloneTable(login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude); |
| } |
| ifaces_[i]->cloneTable(login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude); |
| } |
| |
| void compactTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const std::vector<IteratorSetting> & iterators, const bool flush, const bool wait, const CompactionStrategyConfig& compactionStrategy) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->compactTable(login, tableName, startRow, endRow, iterators, flush, wait, compactionStrategy); |
| } |
| ifaces_[i]->compactTable(login, tableName, startRow, endRow, iterators, flush, wait, compactionStrategy); |
| } |
| |
| void cancelCompaction(const std::string& login, const std::string& tableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->cancelCompaction(login, tableName); |
| } |
| ifaces_[i]->cancelCompaction(login, tableName); |
| } |
| |
| void createTable(const std::string& login, const std::string& tableName, const bool versioningIter, const TimeType::type type) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->createTable(login, tableName, versioningIter, type); |
| } |
| ifaces_[i]->createTable(login, tableName, versioningIter, type); |
| } |
| |
| void deleteTable(const std::string& login, const std::string& tableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->deleteTable(login, tableName); |
| } |
| ifaces_[i]->deleteTable(login, tableName); |
| } |
| |
| void deleteRows(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->deleteRows(login, tableName, startRow, endRow); |
| } |
| ifaces_[i]->deleteRows(login, tableName, startRow, endRow); |
| } |
| |
| void exportTable(const std::string& login, const std::string& tableName, const std::string& exportDir) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->exportTable(login, tableName, exportDir); |
| } |
| ifaces_[i]->exportTable(login, tableName, exportDir); |
| } |
| |
| void flushTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const bool wait) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->flushTable(login, tableName, startRow, endRow, wait); |
| } |
| ifaces_[i]->flushTable(login, tableName, startRow, endRow, wait); |
| } |
| |
| void getDiskUsage(std::vector<DiskUsage> & _return, const std::string& login, const std::set<std::string> & tables) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getDiskUsage(_return, login, tables); |
| } |
| ifaces_[i]->getDiskUsage(_return, login, tables); |
| return; |
| } |
| |
| void getLocalityGroups(std::map<std::string, std::set<std::string> > & _return, const std::string& login, const std::string& tableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getLocalityGroups(_return, login, tableName); |
| } |
| ifaces_[i]->getLocalityGroups(_return, login, tableName); |
| return; |
| } |
| |
| void getIteratorSetting(IteratorSetting& _return, const std::string& login, const std::string& tableName, const std::string& iteratorName, const IteratorScope::type scope) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getIteratorSetting(_return, login, tableName, iteratorName, scope); |
| } |
| ifaces_[i]->getIteratorSetting(_return, login, tableName, iteratorName, scope); |
| return; |
| } |
| |
| void getMaxRow(std::string& _return, const std::string& login, const std::string& tableName, const std::set<std::string> & auths, const std::string& startRow, const bool startInclusive, const std::string& endRow, const bool endInclusive) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getMaxRow(_return, login, tableName, auths, startRow, startInclusive, endRow, endInclusive); |
| } |
| ifaces_[i]->getMaxRow(_return, login, tableName, auths, startRow, startInclusive, endRow, endInclusive); |
| return; |
| } |
| |
| void getTableProperties(std::map<std::string, std::string> & _return, const std::string& login, const std::string& tableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getTableProperties(_return, login, tableName); |
| } |
| ifaces_[i]->getTableProperties(_return, login, tableName); |
| return; |
| } |
| |
| void importDirectory(const std::string& login, const std::string& tableName, const std::string& importDir, const std::string& failureDir, const bool setTime) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->importDirectory(login, tableName, importDir, failureDir, setTime); |
| } |
| ifaces_[i]->importDirectory(login, tableName, importDir, failureDir, setTime); |
| } |
| |
| void importTable(const std::string& login, const std::string& tableName, const std::string& importDir) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->importTable(login, tableName, importDir); |
| } |
| ifaces_[i]->importTable(login, tableName, importDir); |
| } |
| |
| void listSplits(std::vector<std::string> & _return, const std::string& login, const std::string& tableName, const int32_t maxSplits) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->listSplits(_return, login, tableName, maxSplits); |
| } |
| ifaces_[i]->listSplits(_return, login, tableName, maxSplits); |
| return; |
| } |
| |
| void listTables(std::set<std::string> & _return, const std::string& login) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->listTables(_return, login); |
| } |
| ifaces_[i]->listTables(_return, login); |
| return; |
| } |
| |
| void listIterators(std::map<std::string, std::set<IteratorScope::type> > & _return, const std::string& login, const std::string& tableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->listIterators(_return, login, tableName); |
| } |
| ifaces_[i]->listIterators(_return, login, tableName); |
| return; |
| } |
| |
| void listConstraints(std::map<std::string, int32_t> & _return, const std::string& login, const std::string& tableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->listConstraints(_return, login, tableName); |
| } |
| ifaces_[i]->listConstraints(_return, login, tableName); |
| return; |
| } |
| |
| void mergeTablets(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->mergeTablets(login, tableName, startRow, endRow); |
| } |
| ifaces_[i]->mergeTablets(login, tableName, startRow, endRow); |
| } |
| |
| void offlineTable(const std::string& login, const std::string& tableName, const bool wait) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->offlineTable(login, tableName, wait); |
| } |
| ifaces_[i]->offlineTable(login, tableName, wait); |
| } |
| |
| void onlineTable(const std::string& login, const std::string& tableName, const bool wait) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->onlineTable(login, tableName, wait); |
| } |
| ifaces_[i]->onlineTable(login, tableName, wait); |
| } |
| |
| void removeConstraint(const std::string& login, const std::string& tableName, const int32_t constraint) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->removeConstraint(login, tableName, constraint); |
| } |
| ifaces_[i]->removeConstraint(login, tableName, constraint); |
| } |
| |
| void removeIterator(const std::string& login, const std::string& tableName, const std::string& iterName, const std::set<IteratorScope::type> & scopes) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->removeIterator(login, tableName, iterName, scopes); |
| } |
| ifaces_[i]->removeIterator(login, tableName, iterName, scopes); |
| } |
| |
| void removeTableProperty(const std::string& login, const std::string& tableName, const std::string& property) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->removeTableProperty(login, tableName, property); |
| } |
| ifaces_[i]->removeTableProperty(login, tableName, property); |
| } |
| |
| void renameTable(const std::string& login, const std::string& oldTableName, const std::string& newTableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->renameTable(login, oldTableName, newTableName); |
| } |
| ifaces_[i]->renameTable(login, oldTableName, newTableName); |
| } |
| |
| void setLocalityGroups(const std::string& login, const std::string& tableName, const std::map<std::string, std::set<std::string> > & groups) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->setLocalityGroups(login, tableName, groups); |
| } |
| ifaces_[i]->setLocalityGroups(login, tableName, groups); |
| } |
| |
| void setTableProperty(const std::string& login, const std::string& tableName, const std::string& property, const std::string& value) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->setTableProperty(login, tableName, property, value); |
| } |
| ifaces_[i]->setTableProperty(login, tableName, property, value); |
| } |
| |
| void splitRangeByTablets(std::set<Range> & _return, const std::string& login, const std::string& tableName, const Range& range, const int32_t maxSplits) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->splitRangeByTablets(_return, login, tableName, range, maxSplits); |
| } |
| ifaces_[i]->splitRangeByTablets(_return, login, tableName, range, maxSplits); |
| return; |
| } |
| |
| bool tableExists(const std::string& login, const std::string& tableName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->tableExists(login, tableName); |
| } |
| return ifaces_[i]->tableExists(login, tableName); |
| } |
| |
| void tableIdMap(std::map<std::string, std::string> & _return, const std::string& login) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->tableIdMap(_return, login); |
| } |
| ifaces_[i]->tableIdMap(_return, login); |
| return; |
| } |
| |
| bool testTableClassLoad(const std::string& login, const std::string& tableName, const std::string& className, const std::string& asTypeName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->testTableClassLoad(login, tableName, className, asTypeName); |
| } |
| return ifaces_[i]->testTableClassLoad(login, tableName, className, asTypeName); |
| } |
| |
| void pingTabletServer(const std::string& login, const std::string& tserver) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->pingTabletServer(login, tserver); |
| } |
| ifaces_[i]->pingTabletServer(login, tserver); |
| } |
| |
| void getActiveScans(std::vector<ActiveScan> & _return, const std::string& login, const std::string& tserver) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getActiveScans(_return, login, tserver); |
| } |
| ifaces_[i]->getActiveScans(_return, login, tserver); |
| return; |
| } |
| |
| void getActiveCompactions(std::vector<ActiveCompaction> & _return, const std::string& login, const std::string& tserver) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getActiveCompactions(_return, login, tserver); |
| } |
| ifaces_[i]->getActiveCompactions(_return, login, tserver); |
| return; |
| } |
| |
| void getSiteConfiguration(std::map<std::string, std::string> & _return, const std::string& login) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getSiteConfiguration(_return, login); |
| } |
| ifaces_[i]->getSiteConfiguration(_return, login); |
| return; |
| } |
| |
| void getSystemConfiguration(std::map<std::string, std::string> & _return, const std::string& login) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getSystemConfiguration(_return, login); |
| } |
| ifaces_[i]->getSystemConfiguration(_return, login); |
| return; |
| } |
| |
| void getTabletServers(std::vector<std::string> & _return, const std::string& login) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getTabletServers(_return, login); |
| } |
| ifaces_[i]->getTabletServers(_return, login); |
| return; |
| } |
| |
| void removeProperty(const std::string& login, const std::string& property) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->removeProperty(login, property); |
| } |
| ifaces_[i]->removeProperty(login, property); |
| } |
| |
| void setProperty(const std::string& login, const std::string& property, const std::string& value) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->setProperty(login, property, value); |
| } |
| ifaces_[i]->setProperty(login, property, value); |
| } |
| |
| bool testClassLoad(const std::string& login, const std::string& className, const std::string& asTypeName) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->testClassLoad(login, className, asTypeName); |
| } |
| return ifaces_[i]->testClassLoad(login, className, asTypeName); |
| } |
| |
| bool authenticateUser(const std::string& login, const std::string& user, const std::map<std::string, std::string> & properties) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->authenticateUser(login, user, properties); |
| } |
| return ifaces_[i]->authenticateUser(login, user, properties); |
| } |
| |
| void changeUserAuthorizations(const std::string& login, const std::string& user, const std::set<std::string> & authorizations) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->changeUserAuthorizations(login, user, authorizations); |
| } |
| ifaces_[i]->changeUserAuthorizations(login, user, authorizations); |
| } |
| |
| void changeLocalUserPassword(const std::string& login, const std::string& user, const std::string& password) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->changeLocalUserPassword(login, user, password); |
| } |
| ifaces_[i]->changeLocalUserPassword(login, user, password); |
| } |
| |
| void createLocalUser(const std::string& login, const std::string& user, const std::string& password) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->createLocalUser(login, user, password); |
| } |
| ifaces_[i]->createLocalUser(login, user, password); |
| } |
| |
| void dropLocalUser(const std::string& login, const std::string& user) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->dropLocalUser(login, user); |
| } |
| ifaces_[i]->dropLocalUser(login, user); |
| } |
| |
| void getUserAuthorizations(std::vector<std::string> & _return, const std::string& login, const std::string& user) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getUserAuthorizations(_return, login, user); |
| } |
| ifaces_[i]->getUserAuthorizations(_return, login, user); |
| return; |
| } |
| |
| void grantSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->grantSystemPermission(login, user, perm); |
| } |
| ifaces_[i]->grantSystemPermission(login, user, perm); |
| } |
| |
| void grantTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->grantTablePermission(login, user, table, perm); |
| } |
| ifaces_[i]->grantTablePermission(login, user, table, perm); |
| } |
| |
| bool hasSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->hasSystemPermission(login, user, perm); |
| } |
| return ifaces_[i]->hasSystemPermission(login, user, perm); |
| } |
| |
| bool hasTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->hasTablePermission(login, user, table, perm); |
| } |
| return ifaces_[i]->hasTablePermission(login, user, table, perm); |
| } |
| |
| void listLocalUsers(std::set<std::string> & _return, const std::string& login) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->listLocalUsers(_return, login); |
| } |
| ifaces_[i]->listLocalUsers(_return, login); |
| return; |
| } |
| |
| void revokeSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->revokeSystemPermission(login, user, perm); |
| } |
| ifaces_[i]->revokeSystemPermission(login, user, perm); |
| } |
| |
| void revokeTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->revokeTablePermission(login, user, table, perm); |
| } |
| ifaces_[i]->revokeTablePermission(login, user, table, perm); |
| } |
| |
| void createBatchScanner(std::string& _return, const std::string& login, const std::string& tableName, const BatchScanOptions& options) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->createBatchScanner(_return, login, tableName, options); |
| } |
| ifaces_[i]->createBatchScanner(_return, login, tableName, options); |
| return; |
| } |
| |
| void createScanner(std::string& _return, const std::string& login, const std::string& tableName, const ScanOptions& options) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->createScanner(_return, login, tableName, options); |
| } |
| ifaces_[i]->createScanner(_return, login, tableName, options); |
| return; |
| } |
| |
| bool hasNext(const std::string& scanner) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->hasNext(scanner); |
| } |
| return ifaces_[i]->hasNext(scanner); |
| } |
| |
| void nextEntry(KeyValueAndPeek& _return, const std::string& scanner) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->nextEntry(_return, scanner); |
| } |
| ifaces_[i]->nextEntry(_return, scanner); |
| return; |
| } |
| |
| void nextK(ScanResult& _return, const std::string& scanner, const int32_t k) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->nextK(_return, scanner, k); |
| } |
| ifaces_[i]->nextK(_return, scanner, k); |
| return; |
| } |
| |
| void closeScanner(const std::string& scanner) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->closeScanner(scanner); |
| } |
| ifaces_[i]->closeScanner(scanner); |
| } |
| |
| void updateAndFlush(const std::string& login, const std::string& tableName, const std::map<std::string, std::vector<ColumnUpdate> > & cells) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->updateAndFlush(login, tableName, cells); |
| } |
| ifaces_[i]->updateAndFlush(login, tableName, cells); |
| } |
| |
| void createWriter(std::string& _return, const std::string& login, const std::string& tableName, const WriterOptions& opts) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->createWriter(_return, login, tableName, opts); |
| } |
| ifaces_[i]->createWriter(_return, login, tableName, opts); |
| return; |
| } |
| |
| void update(const std::string& writer, const std::map<std::string, std::vector<ColumnUpdate> > & cells) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->update(writer, cells); |
| } |
| ifaces_[i]->update(writer, cells); |
| } |
| |
| void flush(const std::string& writer) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->flush(writer); |
| } |
| ifaces_[i]->flush(writer); |
| } |
| |
| void closeWriter(const std::string& writer) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->closeWriter(writer); |
| } |
| ifaces_[i]->closeWriter(writer); |
| } |
| |
| ConditionalStatus::type updateRowConditionally(const std::string& login, const std::string& tableName, const std::string& row, const ConditionalUpdates& updates) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->updateRowConditionally(login, tableName, row, updates); |
| } |
| return ifaces_[i]->updateRowConditionally(login, tableName, row, updates); |
| } |
| |
| void createConditionalWriter(std::string& _return, const std::string& login, const std::string& tableName, const ConditionalWriterOptions& options) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->createConditionalWriter(_return, login, tableName, options); |
| } |
| ifaces_[i]->createConditionalWriter(_return, login, tableName, options); |
| return; |
| } |
| |
| void updateRowsConditionally(std::map<std::string, ConditionalStatus::type> & _return, const std::string& conditionalWriter, const std::map<std::string, ConditionalUpdates> & updates) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->updateRowsConditionally(_return, conditionalWriter, updates); |
| } |
| ifaces_[i]->updateRowsConditionally(_return, conditionalWriter, updates); |
| return; |
| } |
| |
| void closeConditionalWriter(const std::string& conditionalWriter) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->closeConditionalWriter(conditionalWriter); |
| } |
| ifaces_[i]->closeConditionalWriter(conditionalWriter); |
| } |
| |
| void getRowRange(Range& _return, const std::string& row) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getRowRange(_return, row); |
| } |
| ifaces_[i]->getRowRange(_return, row); |
| return; |
| } |
| |
| void getFollowing(Key& _return, const Key& key, const PartialKey::type part) { |
| size_t sz = ifaces_.size(); |
| size_t i = 0; |
| for (; i < (sz - 1); ++i) { |
| ifaces_[i]->getFollowing(_return, key, part); |
| } |
| ifaces_[i]->getFollowing(_return, key, part); |
| return; |
| } |
| |
| }; |
| |
| } // namespace |
| |
| #endif |
