/*
 * 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 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>

#include <thrift/cxxfunctional.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,
    CREATE_NAMESPACE = 8,
    DROP_NAMESPACE = 9,
    ALTER_NAMESPACE = 10,
    OBTAIN_DELEGATION_TOKEN = 11
  };
};

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 ConditionalStatus {
  enum type {
    ACCEPTED = 0,
    REJECTED = 1,
    VIOLATED = 2,
    UNKNOWN = 3,
    INVISIBLE_VISIBILITY = 4
  };
};

extern const std::map<int, const char*> _ConditionalStatus_VALUES_TO_NAMES;

struct Durability {
  enum type {
    DEFAULT = 0,
    NONE = 1,
    LOG = 2,
    FLUSH = 3,
    SYNC = 4
  };
};

extern const std::map<int, const char*> _Durability_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 _DiskUsage__isset {
  _DiskUsage__isset() : tables(false), usage(false) {}
  bool tables;
  bool usage;
} _DiskUsage__isset;

class DiskUsage {
 public:

  static const char* ascii_fingerprint; // = "D26F4F5E2867D41CF7E0391263932D6B";
  static const uint8_t binary_fingerprint[16]; // = {0xD2,0x6F,0x4F,0x5E,0x28,0x67,0xD4,0x1C,0xF7,0xE0,0x39,0x12,0x63,0x93,0x2D,0x6B};

  DiskUsage() : usage(0) {
  }

  virtual ~DiskUsage() throw() {}

  std::vector<std::string>  tables;
  int64_t usage;

  _DiskUsage__isset __isset;

  void __set_tables(const std::vector<std::string> & val) {
    tables = val;
  }

  void __set_usage(const int64_t val) {
    usage = val;
  }

  bool operator == (const DiskUsage & rhs) const
  {
    if (!(tables == rhs.tables))
      return false;
    if (!(usage == rhs.usage))
      return false;
    return true;
  }
  bool operator != (const DiskUsage &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const DiskUsage & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

void swap(DiskUsage &a, DiskUsage &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 _Condition__isset {
  _Condition__isset() : column(false), timestamp(false), value(false), iterators(false) {}
  bool column;
  bool timestamp;
  bool value;
  bool iterators;
} _Condition__isset;

class Condition {
 public:

  static const char* ascii_fingerprint; // = "C4022914C22D89E33B1A46A7D511C58F";
  static const uint8_t binary_fingerprint[16]; // = {0xC4,0x02,0x29,0x14,0xC2,0x2D,0x89,0xE3,0x3B,0x1A,0x46,0xA7,0xD5,0x11,0xC5,0x8F};

  Condition() : timestamp(0), value() {
  }

  virtual ~Condition() throw() {}

  Column column;
  int64_t timestamp;
  std::string value;
  std::vector<IteratorSetting>  iterators;

  _Condition__isset __isset;

  void __set_column(const Column& val) {
    column = val;
  }

  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_iterators(const std::vector<IteratorSetting> & val) {
    iterators = val;
    __isset.iterators = true;
  }

  bool operator == (const Condition & rhs) const
  {
    if (!(column == rhs.column))
      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.iterators != rhs.__isset.iterators)
      return false;
    else if (__isset.iterators && !(iterators == rhs.iterators))
      return false;
    return true;
  }
  bool operator != (const Condition &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Condition & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

void swap(Condition &a, Condition &b);

typedef struct _ConditionalUpdates__isset {
  _ConditionalUpdates__isset() : conditions(false), updates(false) {}
  bool conditions;
  bool updates;
} _ConditionalUpdates__isset;

class ConditionalUpdates {
 public:

  static const char* ascii_fingerprint; // = "1C1808872D1A8E04F114974ADD77F356";
  static const uint8_t binary_fingerprint[16]; // = {0x1C,0x18,0x08,0x87,0x2D,0x1A,0x8E,0x04,0xF1,0x14,0x97,0x4A,0xDD,0x77,0xF3,0x56};

  ConditionalUpdates() {
  }

  virtual ~ConditionalUpdates() throw() {}

  std::vector<Condition>  conditions;
  std::vector<ColumnUpdate>  updates;

  _ConditionalUpdates__isset __isset;

  void __set_conditions(const std::vector<Condition> & val) {
    conditions = val;
  }

  void __set_updates(const std::vector<ColumnUpdate> & val) {
    updates = val;
  }

  bool operator == (const ConditionalUpdates & rhs) const
  {
    if (!(conditions == rhs.conditions))
      return false;
    if (!(updates == rhs.updates))
      return false;
    return true;
  }
  bool operator != (const ConditionalUpdates &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ConditionalUpdates & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

void swap(ConditionalUpdates &a, ConditionalUpdates &b);

typedef struct _ConditionalWriterOptions__isset {
  _ConditionalWriterOptions__isset() : maxMemory(false), timeoutMs(false), threads(false), authorizations(false), durability(false) {}
  bool maxMemory;
  bool timeoutMs;
  bool threads;
  bool authorizations;
  bool durability;
} _ConditionalWriterOptions__isset;

class ConditionalWriterOptions {
 public:

  static const char* ascii_fingerprint; // = "C345C04E84A351638B6EACB741BD600E";
  static const uint8_t binary_fingerprint[16]; // = {0xC3,0x45,0xC0,0x4E,0x84,0xA3,0x51,0x63,0x8B,0x6E,0xAC,0xB7,0x41,0xBD,0x60,0x0E};

  ConditionalWriterOptions() : maxMemory(0), timeoutMs(0), threads(0), durability((Durability::type)0) {
  }

  virtual ~ConditionalWriterOptions() throw() {}

  int64_t maxMemory;
  int64_t timeoutMs;
  int32_t threads;
  std::set<std::string>  authorizations;
  Durability::type durability;

  _ConditionalWriterOptions__isset __isset;

  void __set_maxMemory(const int64_t val) {
    maxMemory = val;
    __isset.maxMemory = true;
  }

  void __set_timeoutMs(const int64_t val) {
    timeoutMs = val;
    __isset.timeoutMs = true;
  }

  void __set_threads(const int32_t val) {
    threads = val;
    __isset.threads = true;
  }

  void __set_authorizations(const std::set<std::string> & val) {
    authorizations = val;
    __isset.authorizations = true;
  }

  void __set_durability(const Durability::type val) {
    durability = val;
    __isset.durability = true;
  }

  bool operator == (const ConditionalWriterOptions & rhs) const
  {
    if (__isset.maxMemory != rhs.__isset.maxMemory)
      return false;
    else if (__isset.maxMemory && !(maxMemory == rhs.maxMemory))
      return false;
    if (__isset.timeoutMs != rhs.__isset.timeoutMs)
      return false;
    else if (__isset.timeoutMs && !(timeoutMs == rhs.timeoutMs))
      return false;
    if (__isset.threads != rhs.__isset.threads)
      return false;
    else if (__isset.threads && !(threads == rhs.threads))
      return false;
    if (__isset.authorizations != rhs.__isset.authorizations)
      return false;
    else if (__isset.authorizations && !(authorizations == rhs.authorizations))
      return false;
    if (__isset.durability != rhs.__isset.durability)
      return false;
    else if (__isset.durability && !(durability == rhs.durability))
      return false;
    return true;
  }
  bool operator != (const ConditionalWriterOptions &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ConditionalWriterOptions & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

void swap(ConditionalWriterOptions &a, ConditionalWriterOptions &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), durability(false) {}
  bool maxMemory;
  bool latencyMs;
  bool timeoutMs;
  bool threads;
  bool durability;
} _WriterOptions__isset;

class WriterOptions {
 public:

  static const char* ascii_fingerprint; // = "6640C55D2C0D4C8C2E7589456EA0C61A";
  static const uint8_t binary_fingerprint[16]; // = {0x66,0x40,0xC5,0x5D,0x2C,0x0D,0x4C,0x8C,0x2E,0x75,0x89,0x45,0x6E,0xA0,0xC6,0x1A};

  WriterOptions() : maxMemory(0), latencyMs(0), timeoutMs(0), threads(0), durability((Durability::type)0) {
  }

  virtual ~WriterOptions() throw() {}

  int64_t maxMemory;
  int64_t latencyMs;
  int64_t timeoutMs;
  int32_t threads;
  Durability::type durability;

  _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;
  }

  void __set_durability(const Durability::type val) {
    durability = val;
    __isset.durability = true;
  }

  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;
    if (__isset.durability != rhs.__isset.durability)
      return false;
    else if (__isset.durability && !(durability == rhs.durability))
      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 _CompactionStrategyConfig__isset {
  _CompactionStrategyConfig__isset() : className(false), options(false) {}
  bool className;
  bool options;
} _CompactionStrategyConfig__isset;

class CompactionStrategyConfig {
 public:

  static const char* ascii_fingerprint; // = "F7C641917C22B35AE581CCD54910B00D";
  static const uint8_t binary_fingerprint[16]; // = {0xF7,0xC6,0x41,0x91,0x7C,0x22,0xB3,0x5A,0xE5,0x81,0xCC,0xD5,0x49,0x10,0xB0,0x0D};

  CompactionStrategyConfig() : className() {
  }

  virtual ~CompactionStrategyConfig() throw() {}

  std::string className;
  std::map<std::string, std::string>  options;

  _CompactionStrategyConfig__isset __isset;

  void __set_className(const std::string& val) {
    className = val;
  }

  void __set_options(const std::map<std::string, std::string> & val) {
    options = val;
  }

  bool operator == (const CompactionStrategyConfig & rhs) const
  {
    if (!(className == rhs.className))
      return false;
    if (!(options == rhs.options))
      return false;
    return true;
  }
  bool operator != (const CompactionStrategyConfig &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CompactionStrategyConfig & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

void swap(CompactionStrategyConfig &a, CompactionStrategyConfig &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