accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From els...@apache.org
Subject [08/29] ACCUMULO-2197 provide generated proxy libraries, with modified generate-thrift script which tacks on headers
Date Tue, 04 Feb 2014 22:58:23 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/3d436e7b/proxy/src/main/cpp/proxy_types.h
----------------------------------------------------------------------
diff --git a/proxy/src/main/cpp/proxy_types.h b/proxy/src/main/cpp/proxy_types.h
new file mode 100644
index 0000000..5b0c554
--- /dev/null
+++ b/proxy/src/main/cpp/proxy_types.h
@@ -0,0 +1,1600 @@
+/*
+ * 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.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef proxy_TYPES_H
+#define proxy_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+
+
+namespace accumulo {
+
+struct PartialKey {
+  enum type {
+    ROW = 0,
+    ROW_COLFAM = 1,
+    ROW_COLFAM_COLQUAL = 2,
+    ROW_COLFAM_COLQUAL_COLVIS = 3,
+    ROW_COLFAM_COLQUAL_COLVIS_TIME = 4,
+    ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL = 5
+  };
+};
+
+extern const std::map<int, const char*> _PartialKey_VALUES_TO_NAMES;
+
+struct TablePermission {
+  enum type {
+    READ = 2,
+    WRITE = 3,
+    BULK_IMPORT = 4,
+    ALTER_TABLE = 5,
+    GRANT = 6,
+    DROP_TABLE = 7
+  };
+};
+
+extern const std::map<int, const char*> _TablePermission_VALUES_TO_NAMES;
+
+struct SystemPermission {
+  enum type {
+    GRANT = 0,
+    CREATE_TABLE = 1,
+    DROP_TABLE = 2,
+    ALTER_TABLE = 3,
+    CREATE_USER = 4,
+    DROP_USER = 5,
+    ALTER_USER = 6,
+    SYSTEM = 7
+  };
+};
+
+extern const std::map<int, const char*> _SystemPermission_VALUES_TO_NAMES;
+
+struct ScanType {
+  enum type {
+    SINGLE = 0,
+    BATCH = 1
+  };
+};
+
+extern const std::map<int, const char*> _ScanType_VALUES_TO_NAMES;
+
+struct ScanState {
+  enum type {
+    IDLE = 0,
+    RUNNING = 1,
+    QUEUED = 2
+  };
+};
+
+extern const std::map<int, const char*> _ScanState_VALUES_TO_NAMES;
+
+struct CompactionType {
+  enum type {
+    MINOR = 0,
+    MERGE = 1,
+    MAJOR = 2,
+    FULL = 3
+  };
+};
+
+extern const std::map<int, const char*> _CompactionType_VALUES_TO_NAMES;
+
+struct CompactionReason {
+  enum type {
+    USER = 0,
+    SYSTEM = 1,
+    CHOP = 2,
+    IDLE = 3,
+    CLOSE = 4
+  };
+};
+
+extern const std::map<int, const char*> _CompactionReason_VALUES_TO_NAMES;
+
+struct IteratorScope {
+  enum type {
+    MINC = 0,
+    MAJC = 1,
+    SCAN = 2
+  };
+};
+
+extern const std::map<int, const char*> _IteratorScope_VALUES_TO_NAMES;
+
+struct TimeType {
+  enum type {
+    LOGICAL = 0,
+    MILLIS = 1
+  };
+};
+
+extern const std::map<int, const char*> _TimeType_VALUES_TO_NAMES;
+
+typedef struct _Key__isset {
+  _Key__isset() : row(false), colFamily(false), colQualifier(false), colVisibility(false), timestamp(true) {}
+  bool row;
+  bool colFamily;
+  bool colQualifier;
+  bool colVisibility;
+  bool timestamp;
+} _Key__isset;
+
+class Key {
+ public:
+
+  static const char* ascii_fingerprint; // = "91151A432E03F5E8564877B5194B48E2";
+  static const uint8_t binary_fingerprint[16]; // = {0x91,0x15,0x1A,0x43,0x2E,0x03,0xF5,0xE8,0x56,0x48,0x77,0xB5,0x19,0x4B,0x48,0xE2};
+
+  Key() : row(), colFamily(), colQualifier(), colVisibility(), timestamp(9223372036854775807LL) {
+  }
+
+  virtual ~Key() throw() {}
+
+  std::string row;
+  std::string colFamily;
+  std::string colQualifier;
+  std::string colVisibility;
+  int64_t timestamp;
+
+  _Key__isset __isset;
+
+  void __set_row(const std::string& val) {
+    row = val;
+  }
+
+  void __set_colFamily(const std::string& val) {
+    colFamily = val;
+  }
+
+  void __set_colQualifier(const std::string& val) {
+    colQualifier = val;
+  }
+
+  void __set_colVisibility(const std::string& val) {
+    colVisibility = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+    __isset.timestamp = true;
+  }
+
+  bool operator == (const Key & rhs) const
+  {
+    if (!(row == rhs.row))
+      return false;
+    if (!(colFamily == rhs.colFamily))
+      return false;
+    if (!(colQualifier == rhs.colQualifier))
+      return false;
+    if (!(colVisibility == rhs.colVisibility))
+      return false;
+    if (__isset.timestamp != rhs.__isset.timestamp)
+      return false;
+    else if (__isset.timestamp && !(timestamp == rhs.timestamp))
+      return false;
+    return true;
+  }
+  bool operator != (const Key &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Key & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Key &a, Key &b);
+
+typedef struct _ColumnUpdate__isset {
+  _ColumnUpdate__isset() : colFamily(false), colQualifier(false), colVisibility(false), timestamp(false), value(false), deleteCell(false) {}
+  bool colFamily;
+  bool colQualifier;
+  bool colVisibility;
+  bool timestamp;
+  bool value;
+  bool deleteCell;
+} _ColumnUpdate__isset;
+
+class ColumnUpdate {
+ public:
+
+  static const char* ascii_fingerprint; // = "65CC1863F7DDC1DE75B9EAF9E2DC0D1F";
+  static const uint8_t binary_fingerprint[16]; // = {0x65,0xCC,0x18,0x63,0xF7,0xDD,0xC1,0xDE,0x75,0xB9,0xEA,0xF9,0xE2,0xDC,0x0D,0x1F};
+
+  ColumnUpdate() : colFamily(), colQualifier(), colVisibility(), timestamp(0), value(), deleteCell(0) {
+  }
+
+  virtual ~ColumnUpdate() throw() {}
+
+  std::string colFamily;
+  std::string colQualifier;
+  std::string colVisibility;
+  int64_t timestamp;
+  std::string value;
+  bool deleteCell;
+
+  _ColumnUpdate__isset __isset;
+
+  void __set_colFamily(const std::string& val) {
+    colFamily = val;
+  }
+
+  void __set_colQualifier(const std::string& val) {
+    colQualifier = val;
+  }
+
+  void __set_colVisibility(const std::string& val) {
+    colVisibility = val;
+    __isset.colVisibility = true;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+    __isset.timestamp = true;
+  }
+
+  void __set_value(const std::string& val) {
+    value = val;
+    __isset.value = true;
+  }
+
+  void __set_deleteCell(const bool val) {
+    deleteCell = val;
+    __isset.deleteCell = true;
+  }
+
+  bool operator == (const ColumnUpdate & rhs) const
+  {
+    if (!(colFamily == rhs.colFamily))
+      return false;
+    if (!(colQualifier == rhs.colQualifier))
+      return false;
+    if (__isset.colVisibility != rhs.__isset.colVisibility)
+      return false;
+    else if (__isset.colVisibility && !(colVisibility == rhs.colVisibility))
+      return false;
+    if (__isset.timestamp != rhs.__isset.timestamp)
+      return false;
+    else if (__isset.timestamp && !(timestamp == rhs.timestamp))
+      return false;
+    if (__isset.value != rhs.__isset.value)
+      return false;
+    else if (__isset.value && !(value == rhs.value))
+      return false;
+    if (__isset.deleteCell != rhs.__isset.deleteCell)
+      return false;
+    else if (__isset.deleteCell && !(deleteCell == rhs.deleteCell))
+      return false;
+    return true;
+  }
+  bool operator != (const ColumnUpdate &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ColumnUpdate & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ColumnUpdate &a, ColumnUpdate &b);
+
+typedef struct _KeyValue__isset {
+  _KeyValue__isset() : key(false), value(false) {}
+  bool key;
+  bool value;
+} _KeyValue__isset;
+
+class KeyValue {
+ public:
+
+  static const char* ascii_fingerprint; // = "0D0CA44F233F983E00E94228C31ABBD4";
+  static const uint8_t binary_fingerprint[16]; // = {0x0D,0x0C,0xA4,0x4F,0x23,0x3F,0x98,0x3E,0x00,0xE9,0x42,0x28,0xC3,0x1A,0xBB,0xD4};
+
+  KeyValue() : value() {
+  }
+
+  virtual ~KeyValue() throw() {}
+
+  Key key;
+  std::string value;
+
+  _KeyValue__isset __isset;
+
+  void __set_key(const Key& val) {
+    key = val;
+  }
+
+  void __set_value(const std::string& val) {
+    value = val;
+  }
+
+  bool operator == (const KeyValue & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(value == rhs.value))
+      return false;
+    return true;
+  }
+  bool operator != (const KeyValue &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const KeyValue & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(KeyValue &a, KeyValue &b);
+
+typedef struct _ScanResult__isset {
+  _ScanResult__isset() : results(false), more(false) {}
+  bool results;
+  bool more;
+} _ScanResult__isset;
+
+class ScanResult {
+ public:
+
+  static const char* ascii_fingerprint; // = "684A3FCA76EA202FE071A17F8B510E7A";
+  static const uint8_t binary_fingerprint[16]; // = {0x68,0x4A,0x3F,0xCA,0x76,0xEA,0x20,0x2F,0xE0,0x71,0xA1,0x7F,0x8B,0x51,0x0E,0x7A};
+
+  ScanResult() : more(0) {
+  }
+
+  virtual ~ScanResult() throw() {}
+
+  std::vector<KeyValue>  results;
+  bool more;
+
+  _ScanResult__isset __isset;
+
+  void __set_results(const std::vector<KeyValue> & val) {
+    results = val;
+  }
+
+  void __set_more(const bool val) {
+    more = val;
+  }
+
+  bool operator == (const ScanResult & rhs) const
+  {
+    if (!(results == rhs.results))
+      return false;
+    if (!(more == rhs.more))
+      return false;
+    return true;
+  }
+  bool operator != (const ScanResult &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ScanResult & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ScanResult &a, ScanResult &b);
+
+typedef struct _Range__isset {
+  _Range__isset() : start(false), startInclusive(false), stop(false), stopInclusive(false) {}
+  bool start;
+  bool startInclusive;
+  bool stop;
+  bool stopInclusive;
+} _Range__isset;
+
+class Range {
+ public:
+
+  static const char* ascii_fingerprint; // = "84C5BA8DB718E60BFBF3F83867647B45";
+  static const uint8_t binary_fingerprint[16]; // = {0x84,0xC5,0xBA,0x8D,0xB7,0x18,0xE6,0x0B,0xFB,0xF3,0xF8,0x38,0x67,0x64,0x7B,0x45};
+
+  Range() : startInclusive(0), stopInclusive(0) {
+  }
+
+  virtual ~Range() throw() {}
+
+  Key start;
+  bool startInclusive;
+  Key stop;
+  bool stopInclusive;
+
+  _Range__isset __isset;
+
+  void __set_start(const Key& val) {
+    start = val;
+  }
+
+  void __set_startInclusive(const bool val) {
+    startInclusive = val;
+  }
+
+  void __set_stop(const Key& val) {
+    stop = val;
+  }
+
+  void __set_stopInclusive(const bool val) {
+    stopInclusive = val;
+  }
+
+  bool operator == (const Range & rhs) const
+  {
+    if (!(start == rhs.start))
+      return false;
+    if (!(startInclusive == rhs.startInclusive))
+      return false;
+    if (!(stop == rhs.stop))
+      return false;
+    if (!(stopInclusive == rhs.stopInclusive))
+      return false;
+    return true;
+  }
+  bool operator != (const Range &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Range & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Range &a, Range &b);
+
+typedef struct _ScanColumn__isset {
+  _ScanColumn__isset() : colFamily(false), colQualifier(false) {}
+  bool colFamily;
+  bool colQualifier;
+} _ScanColumn__isset;
+
+class ScanColumn {
+ public:
+
+  static const char* ascii_fingerprint; // = "5B708A954C550ECA9C1A49D3C5CAFAB9";
+  static const uint8_t binary_fingerprint[16]; // = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
+
+  ScanColumn() : colFamily(), colQualifier() {
+  }
+
+  virtual ~ScanColumn() throw() {}
+
+  std::string colFamily;
+  std::string colQualifier;
+
+  _ScanColumn__isset __isset;
+
+  void __set_colFamily(const std::string& val) {
+    colFamily = val;
+  }
+
+  void __set_colQualifier(const std::string& val) {
+    colQualifier = val;
+    __isset.colQualifier = true;
+  }
+
+  bool operator == (const ScanColumn & rhs) const
+  {
+    if (!(colFamily == rhs.colFamily))
+      return false;
+    if (__isset.colQualifier != rhs.__isset.colQualifier)
+      return false;
+    else if (__isset.colQualifier && !(colQualifier == rhs.colQualifier))
+      return false;
+    return true;
+  }
+  bool operator != (const ScanColumn &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ScanColumn & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ScanColumn &a, ScanColumn &b);
+
+typedef struct _IteratorSetting__isset {
+  _IteratorSetting__isset() : priority(false), name(false), iteratorClass(false), properties(false) {}
+  bool priority;
+  bool name;
+  bool iteratorClass;
+  bool properties;
+} _IteratorSetting__isset;
+
+class IteratorSetting {
+ public:
+
+  static const char* ascii_fingerprint; // = "985C857916964E43205EAC92A157CB4E";
+  static const uint8_t binary_fingerprint[16]; // = {0x98,0x5C,0x85,0x79,0x16,0x96,0x4E,0x43,0x20,0x5E,0xAC,0x92,0xA1,0x57,0xCB,0x4E};
+
+  IteratorSetting() : priority(0), name(), iteratorClass() {
+  }
+
+  virtual ~IteratorSetting() throw() {}
+
+  int32_t priority;
+  std::string name;
+  std::string iteratorClass;
+  std::map<std::string, std::string>  properties;
+
+  _IteratorSetting__isset __isset;
+
+  void __set_priority(const int32_t val) {
+    priority = val;
+  }
+
+  void __set_name(const std::string& val) {
+    name = val;
+  }
+
+  void __set_iteratorClass(const std::string& val) {
+    iteratorClass = val;
+  }
+
+  void __set_properties(const std::map<std::string, std::string> & val) {
+    properties = val;
+  }
+
+  bool operator == (const IteratorSetting & rhs) const
+  {
+    if (!(priority == rhs.priority))
+      return false;
+    if (!(name == rhs.name))
+      return false;
+    if (!(iteratorClass == rhs.iteratorClass))
+      return false;
+    if (!(properties == rhs.properties))
+      return false;
+    return true;
+  }
+  bool operator != (const IteratorSetting &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const IteratorSetting & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(IteratorSetting &a, IteratorSetting &b);
+
+typedef struct _ScanOptions__isset {
+  _ScanOptions__isset() : authorizations(false), range(false), columns(false), iterators(false), bufferSize(false) {}
+  bool authorizations;
+  bool range;
+  bool columns;
+  bool iterators;
+  bool bufferSize;
+} _ScanOptions__isset;
+
+class ScanOptions {
+ public:
+
+  static const char* ascii_fingerprint; // = "3D87D0CD05FA62E15880C4D2C595907C";
+  static const uint8_t binary_fingerprint[16]; // = {0x3D,0x87,0xD0,0xCD,0x05,0xFA,0x62,0xE1,0x58,0x80,0xC4,0xD2,0xC5,0x95,0x90,0x7C};
+
+  ScanOptions() : bufferSize(0) {
+  }
+
+  virtual ~ScanOptions() throw() {}
+
+  std::set<std::string>  authorizations;
+  Range range;
+  std::vector<ScanColumn>  columns;
+  std::vector<IteratorSetting>  iterators;
+  int32_t bufferSize;
+
+  _ScanOptions__isset __isset;
+
+  void __set_authorizations(const std::set<std::string> & val) {
+    authorizations = val;
+    __isset.authorizations = true;
+  }
+
+  void __set_range(const Range& val) {
+    range = val;
+    __isset.range = true;
+  }
+
+  void __set_columns(const std::vector<ScanColumn> & val) {
+    columns = val;
+    __isset.columns = true;
+  }
+
+  void __set_iterators(const std::vector<IteratorSetting> & val) {
+    iterators = val;
+    __isset.iterators = true;
+  }
+
+  void __set_bufferSize(const int32_t val) {
+    bufferSize = val;
+    __isset.bufferSize = true;
+  }
+
+  bool operator == (const ScanOptions & rhs) const
+  {
+    if (__isset.authorizations != rhs.__isset.authorizations)
+      return false;
+    else if (__isset.authorizations && !(authorizations == rhs.authorizations))
+      return false;
+    if (__isset.range != rhs.__isset.range)
+      return false;
+    else if (__isset.range && !(range == rhs.range))
+      return false;
+    if (__isset.columns != rhs.__isset.columns)
+      return false;
+    else if (__isset.columns && !(columns == rhs.columns))
+      return false;
+    if (__isset.iterators != rhs.__isset.iterators)
+      return false;
+    else if (__isset.iterators && !(iterators == rhs.iterators))
+      return false;
+    if (__isset.bufferSize != rhs.__isset.bufferSize)
+      return false;
+    else if (__isset.bufferSize && !(bufferSize == rhs.bufferSize))
+      return false;
+    return true;
+  }
+  bool operator != (const ScanOptions &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ScanOptions & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ScanOptions &a, ScanOptions &b);
+
+typedef struct _BatchScanOptions__isset {
+  _BatchScanOptions__isset() : authorizations(false), ranges(false), columns(false), iterators(false), threads(false) {}
+  bool authorizations;
+  bool ranges;
+  bool columns;
+  bool iterators;
+  bool threads;
+} _BatchScanOptions__isset;
+
+class BatchScanOptions {
+ public:
+
+  static const char* ascii_fingerprint; // = "6ADFA1FBE31B1220D2C103284E002308";
+  static const uint8_t binary_fingerprint[16]; // = {0x6A,0xDF,0xA1,0xFB,0xE3,0x1B,0x12,0x20,0xD2,0xC1,0x03,0x28,0x4E,0x00,0x23,0x08};
+
+  BatchScanOptions() : threads(0) {
+  }
+
+  virtual ~BatchScanOptions() throw() {}
+
+  std::set<std::string>  authorizations;
+  std::vector<Range>  ranges;
+  std::vector<ScanColumn>  columns;
+  std::vector<IteratorSetting>  iterators;
+  int32_t threads;
+
+  _BatchScanOptions__isset __isset;
+
+  void __set_authorizations(const std::set<std::string> & val) {
+    authorizations = val;
+    __isset.authorizations = true;
+  }
+
+  void __set_ranges(const std::vector<Range> & val) {
+    ranges = val;
+    __isset.ranges = true;
+  }
+
+  void __set_columns(const std::vector<ScanColumn> & val) {
+    columns = val;
+    __isset.columns = true;
+  }
+
+  void __set_iterators(const std::vector<IteratorSetting> & val) {
+    iterators = val;
+    __isset.iterators = true;
+  }
+
+  void __set_threads(const int32_t val) {
+    threads = val;
+    __isset.threads = true;
+  }
+
+  bool operator == (const BatchScanOptions & rhs) const
+  {
+    if (__isset.authorizations != rhs.__isset.authorizations)
+      return false;
+    else if (__isset.authorizations && !(authorizations == rhs.authorizations))
+      return false;
+    if (__isset.ranges != rhs.__isset.ranges)
+      return false;
+    else if (__isset.ranges && !(ranges == rhs.ranges))
+      return false;
+    if (__isset.columns != rhs.__isset.columns)
+      return false;
+    else if (__isset.columns && !(columns == rhs.columns))
+      return false;
+    if (__isset.iterators != rhs.__isset.iterators)
+      return false;
+    else if (__isset.iterators && !(iterators == rhs.iterators))
+      return false;
+    if (__isset.threads != rhs.__isset.threads)
+      return false;
+    else if (__isset.threads && !(threads == rhs.threads))
+      return false;
+    return true;
+  }
+  bool operator != (const BatchScanOptions &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const BatchScanOptions & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(BatchScanOptions &a, BatchScanOptions &b);
+
+typedef struct _KeyValueAndPeek__isset {
+  _KeyValueAndPeek__isset() : keyValue(false), hasNext(false) {}
+  bool keyValue;
+  bool hasNext;
+} _KeyValueAndPeek__isset;
+
+class KeyValueAndPeek {
+ public:
+
+  static const char* ascii_fingerprint; // = "CBBC6AB9C7EA5E5E748C13F970862FAB";
+  static const uint8_t binary_fingerprint[16]; // = {0xCB,0xBC,0x6A,0xB9,0xC7,0xEA,0x5E,0x5E,0x74,0x8C,0x13,0xF9,0x70,0x86,0x2F,0xAB};
+
+  KeyValueAndPeek() : hasNext(0) {
+  }
+
+  virtual ~KeyValueAndPeek() throw() {}
+
+  KeyValue keyValue;
+  bool hasNext;
+
+  _KeyValueAndPeek__isset __isset;
+
+  void __set_keyValue(const KeyValue& val) {
+    keyValue = val;
+  }
+
+  void __set_hasNext(const bool val) {
+    hasNext = val;
+  }
+
+  bool operator == (const KeyValueAndPeek & rhs) const
+  {
+    if (!(keyValue == rhs.keyValue))
+      return false;
+    if (!(hasNext == rhs.hasNext))
+      return false;
+    return true;
+  }
+  bool operator != (const KeyValueAndPeek &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const KeyValueAndPeek & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(KeyValueAndPeek &a, KeyValueAndPeek &b);
+
+typedef struct _KeyExtent__isset {
+  _KeyExtent__isset() : tableId(false), endRow(false), prevEndRow(false) {}
+  bool tableId;
+  bool endRow;
+  bool prevEndRow;
+} _KeyExtent__isset;
+
+class KeyExtent {
+ public:
+
+  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
+  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+  KeyExtent() : tableId(), endRow(), prevEndRow() {
+  }
+
+  virtual ~KeyExtent() throw() {}
+
+  std::string tableId;
+  std::string endRow;
+  std::string prevEndRow;
+
+  _KeyExtent__isset __isset;
+
+  void __set_tableId(const std::string& val) {
+    tableId = val;
+  }
+
+  void __set_endRow(const std::string& val) {
+    endRow = val;
+  }
+
+  void __set_prevEndRow(const std::string& val) {
+    prevEndRow = val;
+  }
+
+  bool operator == (const KeyExtent & rhs) const
+  {
+    if (!(tableId == rhs.tableId))
+      return false;
+    if (!(endRow == rhs.endRow))
+      return false;
+    if (!(prevEndRow == rhs.prevEndRow))
+      return false;
+    return true;
+  }
+  bool operator != (const KeyExtent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const KeyExtent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(KeyExtent &a, KeyExtent &b);
+
+typedef struct _Column__isset {
+  _Column__isset() : colFamily(false), colQualifier(false), colVisibility(false) {}
+  bool colFamily;
+  bool colQualifier;
+  bool colVisibility;
+} _Column__isset;
+
+class Column {
+ public:
+
+  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
+  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+  Column() : colFamily(), colQualifier(), colVisibility() {
+  }
+
+  virtual ~Column() throw() {}
+
+  std::string colFamily;
+  std::string colQualifier;
+  std::string colVisibility;
+
+  _Column__isset __isset;
+
+  void __set_colFamily(const std::string& val) {
+    colFamily = val;
+  }
+
+  void __set_colQualifier(const std::string& val) {
+    colQualifier = val;
+  }
+
+  void __set_colVisibility(const std::string& val) {
+    colVisibility = val;
+  }
+
+  bool operator == (const Column & rhs) const
+  {
+    if (!(colFamily == rhs.colFamily))
+      return false;
+    if (!(colQualifier == rhs.colQualifier))
+      return false;
+    if (!(colVisibility == rhs.colVisibility))
+      return false;
+    return true;
+  }
+  bool operator != (const Column &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Column & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Column &a, Column &b);
+
+typedef struct _ActiveScan__isset {
+  _ActiveScan__isset() : client(false), user(false), table(false), age(false), idleTime(false), type(false), state(false), extent(false), columns(false), iterators(false), authorizations(false) {}
+  bool client;
+  bool user;
+  bool table;
+  bool age;
+  bool idleTime;
+  bool type;
+  bool state;
+  bool extent;
+  bool columns;
+  bool iterators;
+  bool authorizations;
+} _ActiveScan__isset;
+
+class ActiveScan {
+ public:
+
+  static const char* ascii_fingerprint; // = "1B97541CB4E900A054266BBBEE61D004";
+  static const uint8_t binary_fingerprint[16]; // = {0x1B,0x97,0x54,0x1C,0xB4,0xE9,0x00,0xA0,0x54,0x26,0x6B,0xBB,0xEE,0x61,0xD0,0x04};
+
+  ActiveScan() : client(), user(), table(), age(0), idleTime(0), type((ScanType::type)0), state((ScanState::type)0) {
+  }
+
+  virtual ~ActiveScan() throw() {}
+
+  std::string client;
+  std::string user;
+  std::string table;
+  int64_t age;
+  int64_t idleTime;
+  ScanType::type type;
+  ScanState::type state;
+  KeyExtent extent;
+  std::vector<Column>  columns;
+  std::vector<IteratorSetting>  iterators;
+  std::vector<std::string>  authorizations;
+
+  _ActiveScan__isset __isset;
+
+  void __set_client(const std::string& val) {
+    client = val;
+  }
+
+  void __set_user(const std::string& val) {
+    user = val;
+  }
+
+  void __set_table(const std::string& val) {
+    table = val;
+  }
+
+  void __set_age(const int64_t val) {
+    age = val;
+  }
+
+  void __set_idleTime(const int64_t val) {
+    idleTime = val;
+  }
+
+  void __set_type(const ScanType::type val) {
+    type = val;
+  }
+
+  void __set_state(const ScanState::type val) {
+    state = val;
+  }
+
+  void __set_extent(const KeyExtent& val) {
+    extent = val;
+  }
+
+  void __set_columns(const std::vector<Column> & val) {
+    columns = val;
+  }
+
+  void __set_iterators(const std::vector<IteratorSetting> & val) {
+    iterators = val;
+  }
+
+  void __set_authorizations(const std::vector<std::string> & val) {
+    authorizations = val;
+  }
+
+  bool operator == (const ActiveScan & rhs) const
+  {
+    if (!(client == rhs.client))
+      return false;
+    if (!(user == rhs.user))
+      return false;
+    if (!(table == rhs.table))
+      return false;
+    if (!(age == rhs.age))
+      return false;
+    if (!(idleTime == rhs.idleTime))
+      return false;
+    if (!(type == rhs.type))
+      return false;
+    if (!(state == rhs.state))
+      return false;
+    if (!(extent == rhs.extent))
+      return false;
+    if (!(columns == rhs.columns))
+      return false;
+    if (!(iterators == rhs.iterators))
+      return false;
+    if (!(authorizations == rhs.authorizations))
+      return false;
+    return true;
+  }
+  bool operator != (const ActiveScan &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ActiveScan & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ActiveScan &a, ActiveScan &b);
+
+typedef struct _ActiveCompaction__isset {
+  _ActiveCompaction__isset() : extent(false), age(false), inputFiles(false), outputFile(false), type(false), reason(false), localityGroup(false), entriesRead(false), entriesWritten(false), iterators(false) {}
+  bool extent;
+  bool age;
+  bool inputFiles;
+  bool outputFile;
+  bool type;
+  bool reason;
+  bool localityGroup;
+  bool entriesRead;
+  bool entriesWritten;
+  bool iterators;
+} _ActiveCompaction__isset;
+
+class ActiveCompaction {
+ public:
+
+  static const char* ascii_fingerprint; // = "2BB155CC901109464666B6C7E6A8C1A6";
+  static const uint8_t binary_fingerprint[16]; // = {0x2B,0xB1,0x55,0xCC,0x90,0x11,0x09,0x46,0x46,0x66,0xB6,0xC7,0xE6,0xA8,0xC1,0xA6};
+
+  ActiveCompaction() : age(0), outputFile(), type((CompactionType::type)0), reason((CompactionReason::type)0), localityGroup(), entriesRead(0), entriesWritten(0) {
+  }
+
+  virtual ~ActiveCompaction() throw() {}
+
+  KeyExtent extent;
+  int64_t age;
+  std::vector<std::string>  inputFiles;
+  std::string outputFile;
+  CompactionType::type type;
+  CompactionReason::type reason;
+  std::string localityGroup;
+  int64_t entriesRead;
+  int64_t entriesWritten;
+  std::vector<IteratorSetting>  iterators;
+
+  _ActiveCompaction__isset __isset;
+
+  void __set_extent(const KeyExtent& val) {
+    extent = val;
+  }
+
+  void __set_age(const int64_t val) {
+    age = val;
+  }
+
+  void __set_inputFiles(const std::vector<std::string> & val) {
+    inputFiles = val;
+  }
+
+  void __set_outputFile(const std::string& val) {
+    outputFile = val;
+  }
+
+  void __set_type(const CompactionType::type val) {
+    type = val;
+  }
+
+  void __set_reason(const CompactionReason::type val) {
+    reason = val;
+  }
+
+  void __set_localityGroup(const std::string& val) {
+    localityGroup = val;
+  }
+
+  void __set_entriesRead(const int64_t val) {
+    entriesRead = val;
+  }
+
+  void __set_entriesWritten(const int64_t val) {
+    entriesWritten = val;
+  }
+
+  void __set_iterators(const std::vector<IteratorSetting> & val) {
+    iterators = val;
+  }
+
+  bool operator == (const ActiveCompaction & rhs) const
+  {
+    if (!(extent == rhs.extent))
+      return false;
+    if (!(age == rhs.age))
+      return false;
+    if (!(inputFiles == rhs.inputFiles))
+      return false;
+    if (!(outputFile == rhs.outputFile))
+      return false;
+    if (!(type == rhs.type))
+      return false;
+    if (!(reason == rhs.reason))
+      return false;
+    if (!(localityGroup == rhs.localityGroup))
+      return false;
+    if (!(entriesRead == rhs.entriesRead))
+      return false;
+    if (!(entriesWritten == rhs.entriesWritten))
+      return false;
+    if (!(iterators == rhs.iterators))
+      return false;
+    return true;
+  }
+  bool operator != (const ActiveCompaction &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ActiveCompaction & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ActiveCompaction &a, ActiveCompaction &b);
+
+typedef struct _WriterOptions__isset {
+  _WriterOptions__isset() : maxMemory(false), latencyMs(false), timeoutMs(false), threads(false) {}
+  bool maxMemory;
+  bool latencyMs;
+  bool timeoutMs;
+  bool threads;
+} _WriterOptions__isset;
+
+class WriterOptions {
+ public:
+
+  static const char* ascii_fingerprint; // = "D6FB71C9973666B9F6B5C20D5B7B19EF";
+  static const uint8_t binary_fingerprint[16]; // = {0xD6,0xFB,0x71,0xC9,0x97,0x36,0x66,0xB9,0xF6,0xB5,0xC2,0x0D,0x5B,0x7B,0x19,0xEF};
+
+  WriterOptions() : maxMemory(0), latencyMs(0), timeoutMs(0), threads(0) {
+  }
+
+  virtual ~WriterOptions() throw() {}
+
+  int64_t maxMemory;
+  int64_t latencyMs;
+  int64_t timeoutMs;
+  int32_t threads;
+
+  _WriterOptions__isset __isset;
+
+  void __set_maxMemory(const int64_t val) {
+    maxMemory = val;
+  }
+
+  void __set_latencyMs(const int64_t val) {
+    latencyMs = val;
+  }
+
+  void __set_timeoutMs(const int64_t val) {
+    timeoutMs = val;
+  }
+
+  void __set_threads(const int32_t val) {
+    threads = val;
+  }
+
+  bool operator == (const WriterOptions & rhs) const
+  {
+    if (!(maxMemory == rhs.maxMemory))
+      return false;
+    if (!(latencyMs == rhs.latencyMs))
+      return false;
+    if (!(timeoutMs == rhs.timeoutMs))
+      return false;
+    if (!(threads == rhs.threads))
+      return false;
+    return true;
+  }
+  bool operator != (const WriterOptions &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WriterOptions & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(WriterOptions &a, WriterOptions &b);
+
+typedef struct _UnknownScanner__isset {
+  _UnknownScanner__isset() : msg(false) {}
+  bool msg;
+} _UnknownScanner__isset;
+
+class UnknownScanner : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  UnknownScanner() : msg() {
+  }
+
+  virtual ~UnknownScanner() throw() {}
+
+  std::string msg;
+
+  _UnknownScanner__isset __isset;
+
+  void __set_msg(const std::string& val) {
+    msg = val;
+  }
+
+  bool operator == (const UnknownScanner & rhs) const
+  {
+    if (!(msg == rhs.msg))
+      return false;
+    return true;
+  }
+  bool operator != (const UnknownScanner &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const UnknownScanner & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(UnknownScanner &a, UnknownScanner &b);
+
+typedef struct _UnknownWriter__isset {
+  _UnknownWriter__isset() : msg(false) {}
+  bool msg;
+} _UnknownWriter__isset;
+
+class UnknownWriter : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  UnknownWriter() : msg() {
+  }
+
+  virtual ~UnknownWriter() throw() {}
+
+  std::string msg;
+
+  _UnknownWriter__isset __isset;
+
+  void __set_msg(const std::string& val) {
+    msg = val;
+  }
+
+  bool operator == (const UnknownWriter & rhs) const
+  {
+    if (!(msg == rhs.msg))
+      return false;
+    return true;
+  }
+  bool operator != (const UnknownWriter &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const UnknownWriter & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(UnknownWriter &a, UnknownWriter &b);
+
+typedef struct _NoMoreEntriesException__isset {
+  _NoMoreEntriesException__isset() : msg(false) {}
+  bool msg;
+} _NoMoreEntriesException__isset;
+
+class NoMoreEntriesException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  NoMoreEntriesException() : msg() {
+  }
+
+  virtual ~NoMoreEntriesException() throw() {}
+
+  std::string msg;
+
+  _NoMoreEntriesException__isset __isset;
+
+  void __set_msg(const std::string& val) {
+    msg = val;
+  }
+
+  bool operator == (const NoMoreEntriesException & rhs) const
+  {
+    if (!(msg == rhs.msg))
+      return false;
+    return true;
+  }
+  bool operator != (const NoMoreEntriesException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const NoMoreEntriesException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(NoMoreEntriesException &a, NoMoreEntriesException &b);
+
+typedef struct _AccumuloException__isset {
+  _AccumuloException__isset() : msg(false) {}
+  bool msg;
+} _AccumuloException__isset;
+
+class AccumuloException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  AccumuloException() : msg() {
+  }
+
+  virtual ~AccumuloException() throw() {}
+
+  std::string msg;
+
+  _AccumuloException__isset __isset;
+
+  void __set_msg(const std::string& val) {
+    msg = val;
+  }
+
+  bool operator == (const AccumuloException & rhs) const
+  {
+    if (!(msg == rhs.msg))
+      return false;
+    return true;
+  }
+  bool operator != (const AccumuloException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const AccumuloException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AccumuloException &a, AccumuloException &b);
+
+typedef struct _AccumuloSecurityException__isset {
+  _AccumuloSecurityException__isset() : msg(false) {}
+  bool msg;
+} _AccumuloSecurityException__isset;
+
+class AccumuloSecurityException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  AccumuloSecurityException() : msg() {
+  }
+
+  virtual ~AccumuloSecurityException() throw() {}
+
+  std::string msg;
+
+  _AccumuloSecurityException__isset __isset;
+
+  void __set_msg(const std::string& val) {
+    msg = val;
+  }
+
+  bool operator == (const AccumuloSecurityException & rhs) const
+  {
+    if (!(msg == rhs.msg))
+      return false;
+    return true;
+  }
+  bool operator != (const AccumuloSecurityException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const AccumuloSecurityException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AccumuloSecurityException &a, AccumuloSecurityException &b);
+
+typedef struct _TableNotFoundException__isset {
+  _TableNotFoundException__isset() : msg(false) {}
+  bool msg;
+} _TableNotFoundException__isset;
+
+class TableNotFoundException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  TableNotFoundException() : msg() {
+  }
+
+  virtual ~TableNotFoundException() throw() {}
+
+  std::string msg;
+
+  _TableNotFoundException__isset __isset;
+
+  void __set_msg(const std::string& val) {
+    msg = val;
+  }
+
+  bool operator == (const TableNotFoundException & rhs) const
+  {
+    if (!(msg == rhs.msg))
+      return false;
+    return true;
+  }
+  bool operator != (const TableNotFoundException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TableNotFoundException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TableNotFoundException &a, TableNotFoundException &b);
+
+typedef struct _TableExistsException__isset {
+  _TableExistsException__isset() : msg(false) {}
+  bool msg;
+} _TableExistsException__isset;
+
+class TableExistsException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  TableExistsException() : msg() {
+  }
+
+  virtual ~TableExistsException() throw() {}
+
+  std::string msg;
+
+  _TableExistsException__isset __isset;
+
+  void __set_msg(const std::string& val) {
+    msg = val;
+  }
+
+  bool operator == (const TableExistsException & rhs) const
+  {
+    if (!(msg == rhs.msg))
+      return false;
+    return true;
+  }
+  bool operator != (const TableExistsException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TableExistsException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TableExistsException &a, TableExistsException &b);
+
+typedef struct _MutationsRejectedException__isset {
+  _MutationsRejectedException__isset() : msg(false) {}
+  bool msg;
+} _MutationsRejectedException__isset;
+
+class MutationsRejectedException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  MutationsRejectedException() : msg() {
+  }
+
+  virtual ~MutationsRejectedException() throw() {}
+
+  std::string msg;
+
+  _MutationsRejectedException__isset __isset;
+
+  void __set_msg(const std::string& val) {
+    msg = val;
+  }
+
+  bool operator == (const MutationsRejectedException & rhs) const
+  {
+    if (!(msg == rhs.msg))
+      return false;
+    return true;
+  }
+  bool operator != (const MutationsRejectedException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const MutationsRejectedException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(MutationsRejectedException &a, MutationsRejectedException &b);
+
+} // namespace
+
+#endif

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3d436e7b/proxy/src/main/python/AccumuloProxy-remote
----------------------------------------------------------------------
diff --git a/proxy/src/main/python/AccumuloProxy-remote b/proxy/src/main/python/AccumuloProxy-remote
new file mode 100644
index 0000000..ac4d1e8
--- /dev/null
+++ b/proxy/src/main/python/AccumuloProxy-remote
@@ -0,0 +1,599 @@
+# 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.
+#!/usr/bin/env python
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+#  options string: py
+#
+
+import sys
+import pprint
+from urlparse import urlparse
+from thrift.transport import TTransport
+from thrift.transport import TSocket
+from thrift.transport import THttpClient
+from thrift.protocol import TBinaryProtocol
+
+import AccumuloProxy
+from ttypes import *
+
+if len(sys.argv) <= 1 or sys.argv[1] == '--help':
+  print ''
+  print 'Usage: ' + sys.argv[0] + ' [-h host[:port]] [-u url] [-f[ramed]] function [arg1 [arg2...]]'
+  print ''
+  print 'Functions:'
+  print '  string login(string principal,  loginProperties)'
+  print '  i32 addConstraint(string login, string tableName, string constraintClassName)'
+  print '  void addSplits(string login, string tableName,  splits)'
+  print '  void attachIterator(string login, string tableName, IteratorSetting setting,  scopes)'
+  print '  void checkIteratorConflicts(string login, string tableName, IteratorSetting setting,  scopes)'
+  print '  void clearLocatorCache(string login, string tableName)'
+  print '  void cloneTable(string login, string tableName, string newTableName, bool flush,  propertiesToSet,  propertiesToExclude)'
+  print '  void compactTable(string login, string tableName, string startRow, string endRow,  iterators, bool flush, bool wait)'
+  print '  void cancelCompaction(string login, string tableName)'
+  print '  void createTable(string login, string tableName, bool versioningIter, TimeType type)'
+  print '  void deleteTable(string login, string tableName)'
+  print '  void deleteRows(string login, string tableName, string startRow, string endRow)'
+  print '  void exportTable(string login, string tableName, string exportDir)'
+  print '  void flushTable(string login, string tableName, string startRow, string endRow, bool wait)'
+  print '   getLocalityGroups(string login, string tableName)'
+  print '  IteratorSetting getIteratorSetting(string login, string tableName, string iteratorName, IteratorScope scope)'
+  print '  string getMaxRow(string login, string tableName,  auths, string startRow, bool startInclusive, string endRow, bool endInclusive)'
+  print '   getTableProperties(string login, string tableName)'
+  print '  void importDirectory(string login, string tableName, string importDir, string failureDir, bool setTime)'
+  print '  void importTable(string login, string tableName, string importDir)'
+  print '   listSplits(string login, string tableName, i32 maxSplits)'
+  print '   listTables(string login)'
+  print '   listIterators(string login, string tableName)'
+  print '   listConstraints(string login, string tableName)'
+  print '  void mergeTablets(string login, string tableName, string startRow, string endRow)'
+  print '  void offlineTable(string login, string tableName)'
+  print '  void onlineTable(string login, string tableName)'
+  print '  void removeConstraint(string login, string tableName, i32 constraint)'
+  print '  void removeIterator(string login, string tableName, string iterName,  scopes)'
+  print '  void removeTableProperty(string login, string tableName, string property)'
+  print '  void renameTable(string login, string oldTableName, string newTableName)'
+  print '  void setLocalityGroups(string login, string tableName,  groups)'
+  print '  void setTableProperty(string login, string tableName, string property, string value)'
+  print '   splitRangeByTablets(string login, string tableName, Range range, i32 maxSplits)'
+  print '  bool tableExists(string login, string tableName)'
+  print '   tableIdMap(string login)'
+  print '  bool testTableClassLoad(string login, string tableName, string className, string asTypeName)'
+  print '  void pingTabletServer(string login, string tserver)'
+  print '   getActiveScans(string login, string tserver)'
+  print '   getActiveCompactions(string login, string tserver)'
+  print '   getSiteConfiguration(string login)'
+  print '   getSystemConfiguration(string login)'
+  print '   getTabletServers(string login)'
+  print '  void removeProperty(string login, string property)'
+  print '  void setProperty(string login, string property, string value)'
+  print '  bool testClassLoad(string login, string className, string asTypeName)'
+  print '  bool authenticateUser(string login, string user,  properties)'
+  print '  void changeUserAuthorizations(string login, string user,  authorizations)'
+  print '  void changeLocalUserPassword(string login, string user, string password)'
+  print '  void createLocalUser(string login, string user, string password)'
+  print '  void dropLocalUser(string login, string user)'
+  print '   getUserAuthorizations(string login, string user)'
+  print '  void grantSystemPermission(string login, string user, SystemPermission perm)'
+  print '  void grantTablePermission(string login, string user, string table, TablePermission perm)'
+  print '  bool hasSystemPermission(string login, string user, SystemPermission perm)'
+  print '  bool hasTablePermission(string login, string user, string table, TablePermission perm)'
+  print '   listLocalUsers(string login)'
+  print '  void revokeSystemPermission(string login, string user, SystemPermission perm)'
+  print '  void revokeTablePermission(string login, string user, string table, TablePermission perm)'
+  print '  string createBatchScanner(string login, string tableName, BatchScanOptions options)'
+  print '  string createScanner(string login, string tableName, ScanOptions options)'
+  print '  bool hasNext(string scanner)'
+  print '  KeyValueAndPeek nextEntry(string scanner)'
+  print '  ScanResult nextK(string scanner, i32 k)'
+  print '  void closeScanner(string scanner)'
+  print '  void updateAndFlush(string login, string tableName,  cells)'
+  print '  string createWriter(string login, string tableName, WriterOptions opts)'
+  print '  void update(string writer,  cells)'
+  print '  void flush(string writer)'
+  print '  void closeWriter(string writer)'
+  print '  Range getRowRange(string row)'
+  print '  Key getFollowing(Key key, PartialKey part)'
+  print ''
+  sys.exit(0)
+
+pp = pprint.PrettyPrinter(indent = 2)
+host = 'localhost'
+port = 9090
+uri = ''
+framed = False
+http = False
+argi = 1
+
+if sys.argv[argi] == '-h':
+  parts = sys.argv[argi+1].split(':')
+  host = parts[0]
+  if len(parts) > 1:
+    port = int(parts[1])
+  argi += 2
+
+if sys.argv[argi] == '-u':
+  url = urlparse(sys.argv[argi+1])
+  parts = url[1].split(':')
+  host = parts[0]
+  if len(parts) > 1:
+    port = int(parts[1])
+  else:
+    port = 80
+  uri = url[2]
+  if url[4]:
+    uri += '?%s' % url[4]
+  http = True
+  argi += 2
+
+if sys.argv[argi] == '-f' or sys.argv[argi] == '-framed':
+  framed = True
+  argi += 1
+
+cmd = sys.argv[argi]
+args = sys.argv[argi+1:]
+
+if http:
+  transport = THttpClient.THttpClient(host, port, uri)
+else:
+  socket = TSocket.TSocket(host, port)
+  if framed:
+    transport = TTransport.TFramedTransport(socket)
+  else:
+    transport = TTransport.TBufferedTransport(socket)
+protocol = TBinaryProtocol.TBinaryProtocol(transport)
+client = AccumuloProxy.Client(protocol)
+transport.open()
+
+if cmd == 'login':
+  if len(args) != 2:
+    print 'login requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.login(args[0],eval(args[1]),))
+
+elif cmd == 'addConstraint':
+  if len(args) != 3:
+    print 'addConstraint requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.addConstraint(args[0],args[1],args[2],))
+
+elif cmd == 'addSplits':
+  if len(args) != 3:
+    print 'addSplits requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.addSplits(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'attachIterator':
+  if len(args) != 4:
+    print 'attachIterator requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.attachIterator(args[0],args[1],eval(args[2]),eval(args[3]),))
+
+elif cmd == 'checkIteratorConflicts':
+  if len(args) != 4:
+    print 'checkIteratorConflicts requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.checkIteratorConflicts(args[0],args[1],eval(args[2]),eval(args[3]),))
+
+elif cmd == 'clearLocatorCache':
+  if len(args) != 2:
+    print 'clearLocatorCache requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.clearLocatorCache(args[0],args[1],))
+
+elif cmd == 'cloneTable':
+  if len(args) != 6:
+    print 'cloneTable requires 6 args'
+    sys.exit(1)
+  pp.pprint(client.cloneTable(args[0],args[1],args[2],eval(args[3]),eval(args[4]),eval(args[5]),))
+
+elif cmd == 'compactTable':
+  if len(args) != 7:
+    print 'compactTable requires 7 args'
+    sys.exit(1)
+  pp.pprint(client.compactTable(args[0],args[1],args[2],args[3],eval(args[4]),eval(args[5]),eval(args[6]),))
+
+elif cmd == 'cancelCompaction':
+  if len(args) != 2:
+    print 'cancelCompaction requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.cancelCompaction(args[0],args[1],))
+
+elif cmd == 'createTable':
+  if len(args) != 4:
+    print 'createTable requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.createTable(args[0],args[1],eval(args[2]),eval(args[3]),))
+
+elif cmd == 'deleteTable':
+  if len(args) != 2:
+    print 'deleteTable requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.deleteTable(args[0],args[1],))
+
+elif cmd == 'deleteRows':
+  if len(args) != 4:
+    print 'deleteRows requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.deleteRows(args[0],args[1],args[2],args[3],))
+
+elif cmd == 'exportTable':
+  if len(args) != 3:
+    print 'exportTable requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.exportTable(args[0],args[1],args[2],))
+
+elif cmd == 'flushTable':
+  if len(args) != 5:
+    print 'flushTable requires 5 args'
+    sys.exit(1)
+  pp.pprint(client.flushTable(args[0],args[1],args[2],args[3],eval(args[4]),))
+
+elif cmd == 'getLocalityGroups':
+  if len(args) != 2:
+    print 'getLocalityGroups requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.getLocalityGroups(args[0],args[1],))
+
+elif cmd == 'getIteratorSetting':
+  if len(args) != 4:
+    print 'getIteratorSetting requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.getIteratorSetting(args[0],args[1],args[2],eval(args[3]),))
+
+elif cmd == 'getMaxRow':
+  if len(args) != 7:
+    print 'getMaxRow requires 7 args'
+    sys.exit(1)
+  pp.pprint(client.getMaxRow(args[0],args[1],eval(args[2]),args[3],eval(args[4]),args[5],eval(args[6]),))
+
+elif cmd == 'getTableProperties':
+  if len(args) != 2:
+    print 'getTableProperties requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.getTableProperties(args[0],args[1],))
+
+elif cmd == 'importDirectory':
+  if len(args) != 5:
+    print 'importDirectory requires 5 args'
+    sys.exit(1)
+  pp.pprint(client.importDirectory(args[0],args[1],args[2],args[3],eval(args[4]),))
+
+elif cmd == 'importTable':
+  if len(args) != 3:
+    print 'importTable requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.importTable(args[0],args[1],args[2],))
+
+elif cmd == 'listSplits':
+  if len(args) != 3:
+    print 'listSplits requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.listSplits(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'listTables':
+  if len(args) != 1:
+    print 'listTables requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.listTables(args[0],))
+
+elif cmd == 'listIterators':
+  if len(args) != 2:
+    print 'listIterators requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.listIterators(args[0],args[1],))
+
+elif cmd == 'listConstraints':
+  if len(args) != 2:
+    print 'listConstraints requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.listConstraints(args[0],args[1],))
+
+elif cmd == 'mergeTablets':
+  if len(args) != 4:
+    print 'mergeTablets requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.mergeTablets(args[0],args[1],args[2],args[3],))
+
+elif cmd == 'offlineTable':
+  if len(args) != 2:
+    print 'offlineTable requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.offlineTable(args[0],args[1],))
+
+elif cmd == 'onlineTable':
+  if len(args) != 2:
+    print 'onlineTable requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.onlineTable(args[0],args[1],))
+
+elif cmd == 'removeConstraint':
+  if len(args) != 3:
+    print 'removeConstraint requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.removeConstraint(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'removeIterator':
+  if len(args) != 4:
+    print 'removeIterator requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.removeIterator(args[0],args[1],args[2],eval(args[3]),))
+
+elif cmd == 'removeTableProperty':
+  if len(args) != 3:
+    print 'removeTableProperty requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.removeTableProperty(args[0],args[1],args[2],))
+
+elif cmd == 'renameTable':
+  if len(args) != 3:
+    print 'renameTable requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.renameTable(args[0],args[1],args[2],))
+
+elif cmd == 'setLocalityGroups':
+  if len(args) != 3:
+    print 'setLocalityGroups requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.setLocalityGroups(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'setTableProperty':
+  if len(args) != 4:
+    print 'setTableProperty requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.setTableProperty(args[0],args[1],args[2],args[3],))
+
+elif cmd == 'splitRangeByTablets':
+  if len(args) != 4:
+    print 'splitRangeByTablets requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.splitRangeByTablets(args[0],args[1],eval(args[2]),eval(args[3]),))
+
+elif cmd == 'tableExists':
+  if len(args) != 2:
+    print 'tableExists requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.tableExists(args[0],args[1],))
+
+elif cmd == 'tableIdMap':
+  if len(args) != 1:
+    print 'tableIdMap requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.tableIdMap(args[0],))
+
+elif cmd == 'testTableClassLoad':
+  if len(args) != 4:
+    print 'testTableClassLoad requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.testTableClassLoad(args[0],args[1],args[2],args[3],))
+
+elif cmd == 'pingTabletServer':
+  if len(args) != 2:
+    print 'pingTabletServer requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.pingTabletServer(args[0],args[1],))
+
+elif cmd == 'getActiveScans':
+  if len(args) != 2:
+    print 'getActiveScans requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.getActiveScans(args[0],args[1],))
+
+elif cmd == 'getActiveCompactions':
+  if len(args) != 2:
+    print 'getActiveCompactions requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.getActiveCompactions(args[0],args[1],))
+
+elif cmd == 'getSiteConfiguration':
+  if len(args) != 1:
+    print 'getSiteConfiguration requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.getSiteConfiguration(args[0],))
+
+elif cmd == 'getSystemConfiguration':
+  if len(args) != 1:
+    print 'getSystemConfiguration requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.getSystemConfiguration(args[0],))
+
+elif cmd == 'getTabletServers':
+  if len(args) != 1:
+    print 'getTabletServers requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.getTabletServers(args[0],))
+
+elif cmd == 'removeProperty':
+  if len(args) != 2:
+    print 'removeProperty requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.removeProperty(args[0],args[1],))
+
+elif cmd == 'setProperty':
+  if len(args) != 3:
+    print 'setProperty requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.setProperty(args[0],args[1],args[2],))
+
+elif cmd == 'testClassLoad':
+  if len(args) != 3:
+    print 'testClassLoad requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.testClassLoad(args[0],args[1],args[2],))
+
+elif cmd == 'authenticateUser':
+  if len(args) != 3:
+    print 'authenticateUser requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.authenticateUser(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'changeUserAuthorizations':
+  if len(args) != 3:
+    print 'changeUserAuthorizations requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.changeUserAuthorizations(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'changeLocalUserPassword':
+  if len(args) != 3:
+    print 'changeLocalUserPassword requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.changeLocalUserPassword(args[0],args[1],args[2],))
+
+elif cmd == 'createLocalUser':
+  if len(args) != 3:
+    print 'createLocalUser requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.createLocalUser(args[0],args[1],args[2],))
+
+elif cmd == 'dropLocalUser':
+  if len(args) != 2:
+    print 'dropLocalUser requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.dropLocalUser(args[0],args[1],))
+
+elif cmd == 'getUserAuthorizations':
+  if len(args) != 2:
+    print 'getUserAuthorizations requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.getUserAuthorizations(args[0],args[1],))
+
+elif cmd == 'grantSystemPermission':
+  if len(args) != 3:
+    print 'grantSystemPermission requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.grantSystemPermission(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'grantTablePermission':
+  if len(args) != 4:
+    print 'grantTablePermission requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.grantTablePermission(args[0],args[1],args[2],eval(args[3]),))
+
+elif cmd == 'hasSystemPermission':
+  if len(args) != 3:
+    print 'hasSystemPermission requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.hasSystemPermission(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'hasTablePermission':
+  if len(args) != 4:
+    print 'hasTablePermission requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.hasTablePermission(args[0],args[1],args[2],eval(args[3]),))
+
+elif cmd == 'listLocalUsers':
+  if len(args) != 1:
+    print 'listLocalUsers requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.listLocalUsers(args[0],))
+
+elif cmd == 'revokeSystemPermission':
+  if len(args) != 3:
+    print 'revokeSystemPermission requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.revokeSystemPermission(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'revokeTablePermission':
+  if len(args) != 4:
+    print 'revokeTablePermission requires 4 args'
+    sys.exit(1)
+  pp.pprint(client.revokeTablePermission(args[0],args[1],args[2],eval(args[3]),))
+
+elif cmd == 'createBatchScanner':
+  if len(args) != 3:
+    print 'createBatchScanner requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.createBatchScanner(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'createScanner':
+  if len(args) != 3:
+    print 'createScanner requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.createScanner(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'hasNext':
+  if len(args) != 1:
+    print 'hasNext requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.hasNext(args[0],))
+
+elif cmd == 'nextEntry':
+  if len(args) != 1:
+    print 'nextEntry requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.nextEntry(args[0],))
+
+elif cmd == 'nextK':
+  if len(args) != 2:
+    print 'nextK requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.nextK(args[0],eval(args[1]),))
+
+elif cmd == 'closeScanner':
+  if len(args) != 1:
+    print 'closeScanner requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.closeScanner(args[0],))
+
+elif cmd == 'updateAndFlush':
+  if len(args) != 3:
+    print 'updateAndFlush requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.updateAndFlush(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'createWriter':
+  if len(args) != 3:
+    print 'createWriter requires 3 args'
+    sys.exit(1)
+  pp.pprint(client.createWriter(args[0],args[1],eval(args[2]),))
+
+elif cmd == 'update':
+  if len(args) != 2:
+    print 'update requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.update(args[0],eval(args[1]),))
+
+elif cmd == 'flush':
+  if len(args) != 1:
+    print 'flush requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.flush(args[0],))
+
+elif cmd == 'closeWriter':
+  if len(args) != 1:
+    print 'closeWriter requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.closeWriter(args[0],))
+
+elif cmd == 'getRowRange':
+  if len(args) != 1:
+    print 'getRowRange requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.getRowRange(args[0],))
+
+elif cmd == 'getFollowing':
+  if len(args) != 2:
+    print 'getFollowing requires 2 args'
+    sys.exit(1)
+  pp.pprint(client.getFollowing(eval(args[0]),eval(args[1]),))
+
+else:
+  print 'Unrecognized method %s' % cmd
+  sys.exit(1)
+
+transport.close()


Mime
View raw message