#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  options string: py
#

from thrift.Thrift import TType, TMessageType, TException, TApplicationException
from ttypes import *
from thrift.Thrift import TProcessor
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol, TProtocol
try:
  from thrift.protocol import fastbinary
except:
  fastbinary = None


class Iface:
  def login(self, principal, loginProperties):
    """
    Parameters:
     - principal
     - loginProperties
    """
    pass

  def addConstraint(self, login, tableName, constraintClassName):
    """
    Parameters:
     - login
     - tableName
     - constraintClassName
    """
    pass

  def addSplits(self, login, tableName, splits):
    """
    Parameters:
     - login
     - tableName
     - splits
    """
    pass

  def attachIterator(self, login, tableName, setting, scopes):
    """
    Parameters:
     - login
     - tableName
     - setting
     - scopes
    """
    pass

  def checkIteratorConflicts(self, login, tableName, setting, scopes):
    """
    Parameters:
     - login
     - tableName
     - setting
     - scopes
    """
    pass

  def clearLocatorCache(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def cloneTable(self, login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude):
    """
    Parameters:
     - login
     - tableName
     - newTableName
     - flush
     - propertiesToSet
     - propertiesToExclude
    """
    pass

  def compactTable(self, login, tableName, startRow, endRow, iterators, flush, wait):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
     - iterators
     - flush
     - wait
    """
    pass

  def cancelCompaction(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def createTable(self, login, tableName, versioningIter, type):
    """
    Parameters:
     - login
     - tableName
     - versioningIter
     - type
    """
    pass

  def deleteTable(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def deleteRows(self, login, tableName, startRow, endRow):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
    """
    pass

  def exportTable(self, login, tableName, exportDir):
    """
    Parameters:
     - login
     - tableName
     - exportDir
    """
    pass

  def flushTable(self, login, tableName, startRow, endRow, wait):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
     - wait
    """
    pass

  def getLocalityGroups(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def getIteratorSetting(self, login, tableName, iteratorName, scope):
    """
    Parameters:
     - login
     - tableName
     - iteratorName
     - scope
    """
    pass

  def getMaxRow(self, login, tableName, auths, startRow, startInclusive, endRow, endInclusive):
    """
    Parameters:
     - login
     - tableName
     - auths
     - startRow
     - startInclusive
     - endRow
     - endInclusive
    """
    pass

  def getTableProperties(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def getSplits(self, login, tableName, maxSplits):
    """
    Parameters:
     - login
     - tableName
     - maxSplits
    """
    pass

  def importDirectory(self, login, tableName, importDir, failureDir, setTime):
    """
    Parameters:
     - login
     - tableName
     - importDir
     - failureDir
     - setTime
    """
    pass

  def importTable(self, login, tableName, importDir):
    """
    Parameters:
     - login
     - tableName
     - importDir
    """
    pass

  def listTables(self, login):
    """
    Parameters:
     - login
    """
    pass

  def listIterators(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def listConstraints(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def mergeTablets(self, login, tableName, startRow, endRow):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
    """
    pass

  def offlineTable(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def onlineTable(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def removeConstraint(self, login, tableName, constraint):
    """
    Parameters:
     - login
     - tableName
     - constraint
    """
    pass

  def removeIterator(self, login, tableName, iterName, scopes):
    """
    Parameters:
     - login
     - tableName
     - iterName
     - scopes
    """
    pass

  def removeTableProperty(self, login, tableName, property):
    """
    Parameters:
     - login
     - tableName
     - property
    """
    pass

  def renameTable(self, login, oldTableName, newTableName):
    """
    Parameters:
     - login
     - oldTableName
     - newTableName
    """
    pass

  def setLocalityGroups(self, login, tableName, groups):
    """
    Parameters:
     - login
     - tableName
     - groups
    """
    pass

  def setTableProperty(self, login, tableName, property, value):
    """
    Parameters:
     - login
     - tableName
     - property
     - value
    """
    pass

  def splitRangeByTablets(self, login, tableName, range, maxSplits):
    """
    Parameters:
     - login
     - tableName
     - range
     - maxSplits
    """
    pass

  def tableExists(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    pass

  def tableIdMap(self, login):
    """
    Parameters:
     - login
    """
    pass

  def pingTabletServer(self, login, tserver):
    """
    Parameters:
     - login
     - tserver
    """
    pass

  def getActiveScans(self, login, tserver):
    """
    Parameters:
     - login
     - tserver
    """
    pass

  def getActiveCompactions(self, login, tserver):
    """
    Parameters:
     - login
     - tserver
    """
    pass

  def getSiteConfiguration(self, login):
    """
    Parameters:
     - login
    """
    pass

  def getSystemConfiguration(self, login):
    """
    Parameters:
     - login
    """
    pass

  def getTabletServers(self, login):
    """
    Parameters:
     - login
    """
    pass

  def removeProperty(self, login, property):
    """
    Parameters:
     - login
     - property
    """
    pass

  def setProperty(self, login, property, value):
    """
    Parameters:
     - login
     - property
     - value
    """
    pass

  def testClassLoad(self, login, className, asTypeName):
    """
    Parameters:
     - login
     - className
     - asTypeName
    """
    pass

  def authenticateUser(self, login, user, properties):
    """
    Parameters:
     - login
     - user
     - properties
    """
    pass

  def changeUserAuthorizations(self, login, user, authorizations):
    """
    Parameters:
     - login
     - user
     - authorizations
    """
    pass

  def changeLocalUserPassword(self, login, user, password):
    """
    Parameters:
     - login
     - user
     - password
    """
    pass

  def createLocalUser(self, login, user, password):
    """
    Parameters:
     - login
     - user
     - password
    """
    pass

  def dropLocalUser(self, login, user):
    """
    Parameters:
     - login
     - user
    """
    pass

  def getUserAuthorizations(self, login, user):
    """
    Parameters:
     - login
     - user
    """
    pass

  def grantSystemPermission(self, login, user, perm):
    """
    Parameters:
     - login
     - user
     - perm
    """
    pass

  def grantTablePermission(self, login, user, table, perm):
    """
    Parameters:
     - login
     - user
     - table
     - perm
    """
    pass

  def hasSystemPermission(self, login, user, perm):
    """
    Parameters:
     - login
     - user
     - perm
    """
    pass

  def hasTablePermission(self, login, user, table, perm):
    """
    Parameters:
     - login
     - user
     - table
     - perm
    """
    pass

  def listLocalUsers(self, login):
    """
    Parameters:
     - login
    """
    pass

  def revokeSystemPermission(self, login, user, perm):
    """
    Parameters:
     - login
     - user
     - perm
    """
    pass

  def revokeTablePermission(self, login, user, table, perm):
    """
    Parameters:
     - login
     - user
     - table
     - perm
    """
    pass

  def createBatchScanner(self, login, tableName, options):
    """
    Parameters:
     - login
     - tableName
     - options
    """
    pass

  def createScanner(self, login, tableName, options):
    """
    Parameters:
     - login
     - tableName
     - options
    """
    pass

  def hasNext(self, scanner):
    """
    Parameters:
     - scanner
    """
    pass

  def nextEntry(self, scanner):
    """
    Parameters:
     - scanner
    """
    pass

  def nextK(self, scanner, k):
    """
    Parameters:
     - scanner
     - k
    """
    pass

  def closeScanner(self, scanner):
    """
    Parameters:
     - scanner
    """
    pass

  def updateAndFlush(self, login, tableName, cells):
    """
    Parameters:
     - login
     - tableName
     - cells
    """
    pass

  def createWriter(self, login, tableName, opts):
    """
    Parameters:
     - login
     - tableName
     - opts
    """
    pass

  def update(self, writer, cells):
    """
    Parameters:
     - writer
     - cells
    """
    pass

  def flush(self, writer):
    """
    Parameters:
     - writer
    """
    pass

  def closeWriter(self, writer):
    """
    Parameters:
     - writer
    """
    pass

  def getRowRange(self, row):
    """
    Parameters:
     - row
    """
    pass

  def getFollowing(self, key, part):
    """
    Parameters:
     - key
     - part
    """
    pass


class Client(Iface):
  def __init__(self, iprot, oprot=None):
    self._iprot = self._oprot = iprot
    if oprot is not None:
      self._oprot = oprot
    self._seqid = 0

  def login(self, principal, loginProperties):
    """
    Parameters:
     - principal
     - loginProperties
    """
    self.send_login(principal, loginProperties)
    return self.recv_login()

  def send_login(self, principal, loginProperties):
    self._oprot.writeMessageBegin('login', TMessageType.CALL, self._seqid)
    args = login_args()
    args.principal = principal
    args.loginProperties = loginProperties
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_login(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = login_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "login failed: unknown result");

  def addConstraint(self, login, tableName, constraintClassName):
    """
    Parameters:
     - login
     - tableName
     - constraintClassName
    """
    self.send_addConstraint(login, tableName, constraintClassName)
    return self.recv_addConstraint()

  def send_addConstraint(self, login, tableName, constraintClassName):
    self._oprot.writeMessageBegin('addConstraint', TMessageType.CALL, self._seqid)
    args = addConstraint_args()
    args.login = login
    args.tableName = tableName
    args.constraintClassName = constraintClassName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_addConstraint(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = addConstraint_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addConstraint failed: unknown result");

  def addSplits(self, login, tableName, splits):
    """
    Parameters:
     - login
     - tableName
     - splits
    """
    self.send_addSplits(login, tableName, splits)
    self.recv_addSplits()

  def send_addSplits(self, login, tableName, splits):
    self._oprot.writeMessageBegin('addSplits', TMessageType.CALL, self._seqid)
    args = addSplits_args()
    args.login = login
    args.tableName = tableName
    args.splits = splits
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_addSplits(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = addSplits_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def attachIterator(self, login, tableName, setting, scopes):
    """
    Parameters:
     - login
     - tableName
     - setting
     - scopes
    """
    self.send_attachIterator(login, tableName, setting, scopes)
    self.recv_attachIterator()

  def send_attachIterator(self, login, tableName, setting, scopes):
    self._oprot.writeMessageBegin('attachIterator', TMessageType.CALL, self._seqid)
    args = attachIterator_args()
    args.login = login
    args.tableName = tableName
    args.setting = setting
    args.scopes = scopes
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_attachIterator(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = attachIterator_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def checkIteratorConflicts(self, login, tableName, setting, scopes):
    """
    Parameters:
     - login
     - tableName
     - setting
     - scopes
    """
    self.send_checkIteratorConflicts(login, tableName, setting, scopes)
    self.recv_checkIteratorConflicts()

  def send_checkIteratorConflicts(self, login, tableName, setting, scopes):
    self._oprot.writeMessageBegin('checkIteratorConflicts', TMessageType.CALL, self._seqid)
    args = checkIteratorConflicts_args()
    args.login = login
    args.tableName = tableName
    args.setting = setting
    args.scopes = scopes
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_checkIteratorConflicts(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = checkIteratorConflicts_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def clearLocatorCache(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_clearLocatorCache(login, tableName)
    self.recv_clearLocatorCache()

  def send_clearLocatorCache(self, login, tableName):
    self._oprot.writeMessageBegin('clearLocatorCache', TMessageType.CALL, self._seqid)
    args = clearLocatorCache_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_clearLocatorCache(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = clearLocatorCache_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    return

  def cloneTable(self, login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude):
    """
    Parameters:
     - login
     - tableName
     - newTableName
     - flush
     - propertiesToSet
     - propertiesToExclude
    """
    self.send_cloneTable(login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude)
    self.recv_cloneTable()

  def send_cloneTable(self, login, tableName, newTableName, flush, propertiesToSet, propertiesToExclude):
    self._oprot.writeMessageBegin('cloneTable', TMessageType.CALL, self._seqid)
    args = cloneTable_args()
    args.login = login
    args.tableName = tableName
    args.newTableName = newTableName
    args.flush = flush
    args.propertiesToSet = propertiesToSet
    args.propertiesToExclude = propertiesToExclude
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_cloneTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = cloneTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    if result.ouch4 is not None:
      raise result.ouch4
    return

  def compactTable(self, login, tableName, startRow, endRow, iterators, flush, wait):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
     - iterators
     - flush
     - wait
    """
    self.send_compactTable(login, tableName, startRow, endRow, iterators, flush, wait)
    self.recv_compactTable()

  def send_compactTable(self, login, tableName, startRow, endRow, iterators, flush, wait):
    self._oprot.writeMessageBegin('compactTable', TMessageType.CALL, self._seqid)
    args = compactTable_args()
    args.login = login
    args.tableName = tableName
    args.startRow = startRow
    args.endRow = endRow
    args.iterators = iterators
    args.flush = flush
    args.wait = wait
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_compactTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = compactTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def cancelCompaction(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_cancelCompaction(login, tableName)
    self.recv_cancelCompaction()

  def send_cancelCompaction(self, login, tableName):
    self._oprot.writeMessageBegin('cancelCompaction', TMessageType.CALL, self._seqid)
    args = cancelCompaction_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_cancelCompaction(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = cancelCompaction_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def createTable(self, login, tableName, versioningIter, type):
    """
    Parameters:
     - login
     - tableName
     - versioningIter
     - type
    """
    self.send_createTable(login, tableName, versioningIter, type)
    self.recv_createTable()

  def send_createTable(self, login, tableName, versioningIter, type):
    self._oprot.writeMessageBegin('createTable', TMessageType.CALL, self._seqid)
    args = createTable_args()
    args.login = login
    args.tableName = tableName
    args.versioningIter = versioningIter
    args.type = type
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def deleteTable(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_deleteTable(login, tableName)
    self.recv_deleteTable()

  def send_deleteTable(self, login, tableName):
    self._oprot.writeMessageBegin('deleteTable', TMessageType.CALL, self._seqid)
    args = deleteTable_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_deleteTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = deleteTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def deleteRows(self, login, tableName, startRow, endRow):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
    """
    self.send_deleteRows(login, tableName, startRow, endRow)
    self.recv_deleteRows()

  def send_deleteRows(self, login, tableName, startRow, endRow):
    self._oprot.writeMessageBegin('deleteRows', TMessageType.CALL, self._seqid)
    args = deleteRows_args()
    args.login = login
    args.tableName = tableName
    args.startRow = startRow
    args.endRow = endRow
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_deleteRows(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = deleteRows_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def exportTable(self, login, tableName, exportDir):
    """
    Parameters:
     - login
     - tableName
     - exportDir
    """
    self.send_exportTable(login, tableName, exportDir)
    self.recv_exportTable()

  def send_exportTable(self, login, tableName, exportDir):
    self._oprot.writeMessageBegin('exportTable', TMessageType.CALL, self._seqid)
    args = exportTable_args()
    args.login = login
    args.tableName = tableName
    args.exportDir = exportDir
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_exportTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = exportTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def flushTable(self, login, tableName, startRow, endRow, wait):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
     - wait
    """
    self.send_flushTable(login, tableName, startRow, endRow, wait)
    self.recv_flushTable()

  def send_flushTable(self, login, tableName, startRow, endRow, wait):
    self._oprot.writeMessageBegin('flushTable', TMessageType.CALL, self._seqid)
    args = flushTable_args()
    args.login = login
    args.tableName = tableName
    args.startRow = startRow
    args.endRow = endRow
    args.wait = wait
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_flushTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = flushTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def getLocalityGroups(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_getLocalityGroups(login, tableName)
    return self.recv_getLocalityGroups()

  def send_getLocalityGroups(self, login, tableName):
    self._oprot.writeMessageBegin('getLocalityGroups', TMessageType.CALL, self._seqid)
    args = getLocalityGroups_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getLocalityGroups(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getLocalityGroups_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLocalityGroups failed: unknown result");

  def getIteratorSetting(self, login, tableName, iteratorName, scope):
    """
    Parameters:
     - login
     - tableName
     - iteratorName
     - scope
    """
    self.send_getIteratorSetting(login, tableName, iteratorName, scope)
    return self.recv_getIteratorSetting()

  def send_getIteratorSetting(self, login, tableName, iteratorName, scope):
    self._oprot.writeMessageBegin('getIteratorSetting', TMessageType.CALL, self._seqid)
    args = getIteratorSetting_args()
    args.login = login
    args.tableName = tableName
    args.iteratorName = iteratorName
    args.scope = scope
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getIteratorSetting(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getIteratorSetting_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIteratorSetting failed: unknown result");

  def getMaxRow(self, login, tableName, auths, startRow, startInclusive, endRow, endInclusive):
    """
    Parameters:
     - login
     - tableName
     - auths
     - startRow
     - startInclusive
     - endRow
     - endInclusive
    """
    self.send_getMaxRow(login, tableName, auths, startRow, startInclusive, endRow, endInclusive)
    return self.recv_getMaxRow()

  def send_getMaxRow(self, login, tableName, auths, startRow, startInclusive, endRow, endInclusive):
    self._oprot.writeMessageBegin('getMaxRow', TMessageType.CALL, self._seqid)
    args = getMaxRow_args()
    args.login = login
    args.tableName = tableName
    args.auths = auths
    args.startRow = startRow
    args.startInclusive = startInclusive
    args.endRow = endRow
    args.endInclusive = endInclusive
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getMaxRow(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getMaxRow_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMaxRow failed: unknown result");

  def getTableProperties(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_getTableProperties(login, tableName)
    return self.recv_getTableProperties()

  def send_getTableProperties(self, login, tableName):
    self._oprot.writeMessageBegin('getTableProperties', TMessageType.CALL, self._seqid)
    args = getTableProperties_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getTableProperties(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getTableProperties_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableProperties failed: unknown result");

  def getSplits(self, login, tableName, maxSplits):
    """
    Parameters:
     - login
     - tableName
     - maxSplits
    """
    self.send_getSplits(login, tableName, maxSplits)
    return self.recv_getSplits()

  def send_getSplits(self, login, tableName, maxSplits):
    self._oprot.writeMessageBegin('getSplits', TMessageType.CALL, self._seqid)
    args = getSplits_args()
    args.login = login
    args.tableName = tableName
    args.maxSplits = maxSplits
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getSplits(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getSplits_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSplits failed: unknown result");

  def importDirectory(self, login, tableName, importDir, failureDir, setTime):
    """
    Parameters:
     - login
     - tableName
     - importDir
     - failureDir
     - setTime
    """
    self.send_importDirectory(login, tableName, importDir, failureDir, setTime)
    self.recv_importDirectory()

  def send_importDirectory(self, login, tableName, importDir, failureDir, setTime):
    self._oprot.writeMessageBegin('importDirectory', TMessageType.CALL, self._seqid)
    args = importDirectory_args()
    args.login = login
    args.tableName = tableName
    args.importDir = importDir
    args.failureDir = failureDir
    args.setTime = setTime
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_importDirectory(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = importDirectory_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch3 is not None:
      raise result.ouch3
    if result.ouch4 is not None:
      raise result.ouch4
    return

  def importTable(self, login, tableName, importDir):
    """
    Parameters:
     - login
     - tableName
     - importDir
    """
    self.send_importTable(login, tableName, importDir)
    self.recv_importTable()

  def send_importTable(self, login, tableName, importDir):
    self._oprot.writeMessageBegin('importTable', TMessageType.CALL, self._seqid)
    args = importTable_args()
    args.login = login
    args.tableName = tableName
    args.importDir = importDir
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_importTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = importTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def listTables(self, login):
    """
    Parameters:
     - login
    """
    self.send_listTables(login)
    return self.recv_listTables()

  def send_listTables(self, login):
    self._oprot.writeMessageBegin('listTables', TMessageType.CALL, self._seqid)
    args = listTables_args()
    args.login = login
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_listTables(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = listTables_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "listTables failed: unknown result");

  def listIterators(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_listIterators(login, tableName)
    return self.recv_listIterators()

  def send_listIterators(self, login, tableName):
    self._oprot.writeMessageBegin('listIterators', TMessageType.CALL, self._seqid)
    args = listIterators_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_listIterators(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = listIterators_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    raise TApplicationException(TApplicationException.MISSING_RESULT, "listIterators failed: unknown result");

  def listConstraints(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_listConstraints(login, tableName)
    return self.recv_listConstraints()

  def send_listConstraints(self, login, tableName):
    self._oprot.writeMessageBegin('listConstraints', TMessageType.CALL, self._seqid)
    args = listConstraints_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_listConstraints(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = listConstraints_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "listConstraints failed: unknown result");

  def mergeTablets(self, login, tableName, startRow, endRow):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
    """
    self.send_mergeTablets(login, tableName, startRow, endRow)
    self.recv_mergeTablets()

  def send_mergeTablets(self, login, tableName, startRow, endRow):
    self._oprot.writeMessageBegin('mergeTablets', TMessageType.CALL, self._seqid)
    args = mergeTablets_args()
    args.login = login
    args.tableName = tableName
    args.startRow = startRow
    args.endRow = endRow
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_mergeTablets(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = mergeTablets_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def offlineTable(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_offlineTable(login, tableName)
    self.recv_offlineTable()

  def send_offlineTable(self, login, tableName):
    self._oprot.writeMessageBegin('offlineTable', TMessageType.CALL, self._seqid)
    args = offlineTable_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_offlineTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = offlineTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def onlineTable(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_onlineTable(login, tableName)
    self.recv_onlineTable()

  def send_onlineTable(self, login, tableName):
    self._oprot.writeMessageBegin('onlineTable', TMessageType.CALL, self._seqid)
    args = onlineTable_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_onlineTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = onlineTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def removeConstraint(self, login, tableName, constraint):
    """
    Parameters:
     - login
     - tableName
     - constraint
    """
    self.send_removeConstraint(login, tableName, constraint)
    self.recv_removeConstraint()

  def send_removeConstraint(self, login, tableName, constraint):
    self._oprot.writeMessageBegin('removeConstraint', TMessageType.CALL, self._seqid)
    args = removeConstraint_args()
    args.login = login
    args.tableName = tableName
    args.constraint = constraint
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_removeConstraint(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = removeConstraint_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def removeIterator(self, login, tableName, iterName, scopes):
    """
    Parameters:
     - login
     - tableName
     - iterName
     - scopes
    """
    self.send_removeIterator(login, tableName, iterName, scopes)
    self.recv_removeIterator()

  def send_removeIterator(self, login, tableName, iterName, scopes):
    self._oprot.writeMessageBegin('removeIterator', TMessageType.CALL, self._seqid)
    args = removeIterator_args()
    args.login = login
    args.tableName = tableName
    args.iterName = iterName
    args.scopes = scopes
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_removeIterator(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = removeIterator_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def removeTableProperty(self, login, tableName, property):
    """
    Parameters:
     - login
     - tableName
     - property
    """
    self.send_removeTableProperty(login, tableName, property)
    self.recv_removeTableProperty()

  def send_removeTableProperty(self, login, tableName, property):
    self._oprot.writeMessageBegin('removeTableProperty', TMessageType.CALL, self._seqid)
    args = removeTableProperty_args()
    args.login = login
    args.tableName = tableName
    args.property = property
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_removeTableProperty(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = removeTableProperty_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def renameTable(self, login, oldTableName, newTableName):
    """
    Parameters:
     - login
     - oldTableName
     - newTableName
    """
    self.send_renameTable(login, oldTableName, newTableName)
    self.recv_renameTable()

  def send_renameTable(self, login, oldTableName, newTableName):
    self._oprot.writeMessageBegin('renameTable', TMessageType.CALL, self._seqid)
    args = renameTable_args()
    args.login = login
    args.oldTableName = oldTableName
    args.newTableName = newTableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_renameTable(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = renameTable_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    if result.ouch4 is not None:
      raise result.ouch4
    return

  def setLocalityGroups(self, login, tableName, groups):
    """
    Parameters:
     - login
     - tableName
     - groups
    """
    self.send_setLocalityGroups(login, tableName, groups)
    self.recv_setLocalityGroups()

  def send_setLocalityGroups(self, login, tableName, groups):
    self._oprot.writeMessageBegin('setLocalityGroups', TMessageType.CALL, self._seqid)
    args = setLocalityGroups_args()
    args.login = login
    args.tableName = tableName
    args.groups = groups
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_setLocalityGroups(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = setLocalityGroups_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def setTableProperty(self, login, tableName, property, value):
    """
    Parameters:
     - login
     - tableName
     - property
     - value
    """
    self.send_setTableProperty(login, tableName, property, value)
    self.recv_setTableProperty()

  def send_setTableProperty(self, login, tableName, property, value):
    self._oprot.writeMessageBegin('setTableProperty', TMessageType.CALL, self._seqid)
    args = setTableProperty_args()
    args.login = login
    args.tableName = tableName
    args.property = property
    args.value = value
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_setTableProperty(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = setTableProperty_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def splitRangeByTablets(self, login, tableName, range, maxSplits):
    """
    Parameters:
     - login
     - tableName
     - range
     - maxSplits
    """
    self.send_splitRangeByTablets(login, tableName, range, maxSplits)
    return self.recv_splitRangeByTablets()

  def send_splitRangeByTablets(self, login, tableName, range, maxSplits):
    self._oprot.writeMessageBegin('splitRangeByTablets', TMessageType.CALL, self._seqid)
    args = splitRangeByTablets_args()
    args.login = login
    args.tableName = tableName
    args.range = range
    args.maxSplits = maxSplits
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_splitRangeByTablets(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = splitRangeByTablets_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    raise TApplicationException(TApplicationException.MISSING_RESULT, "splitRangeByTablets failed: unknown result");

  def tableExists(self, login, tableName):
    """
    Parameters:
     - login
     - tableName
    """
    self.send_tableExists(login, tableName)
    return self.recv_tableExists()

  def send_tableExists(self, login, tableName):
    self._oprot.writeMessageBegin('tableExists', TMessageType.CALL, self._seqid)
    args = tableExists_args()
    args.login = login
    args.tableName = tableName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_tableExists(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = tableExists_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "tableExists failed: unknown result");

  def tableIdMap(self, login):
    """
    Parameters:
     - login
    """
    self.send_tableIdMap(login)
    return self.recv_tableIdMap()

  def send_tableIdMap(self, login):
    self._oprot.writeMessageBegin('tableIdMap', TMessageType.CALL, self._seqid)
    args = tableIdMap_args()
    args.login = login
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_tableIdMap(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = tableIdMap_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "tableIdMap failed: unknown result");

  def pingTabletServer(self, login, tserver):
    """
    Parameters:
     - login
     - tserver
    """
    self.send_pingTabletServer(login, tserver)
    self.recv_pingTabletServer()

  def send_pingTabletServer(self, login, tserver):
    self._oprot.writeMessageBegin('pingTabletServer', TMessageType.CALL, self._seqid)
    args = pingTabletServer_args()
    args.login = login
    args.tserver = tserver
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_pingTabletServer(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = pingTabletServer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def getActiveScans(self, login, tserver):
    """
    Parameters:
     - login
     - tserver
    """
    self.send_getActiveScans(login, tserver)
    return self.recv_getActiveScans()

  def send_getActiveScans(self, login, tserver):
    self._oprot.writeMessageBegin('getActiveScans', TMessageType.CALL, self._seqid)
    args = getActiveScans_args()
    args.login = login
    args.tserver = tserver
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getActiveScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getActiveScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveScans failed: unknown result");

  def getActiveCompactions(self, login, tserver):
    """
    Parameters:
     - login
     - tserver
    """
    self.send_getActiveCompactions(login, tserver)
    return self.recv_getActiveCompactions()

  def send_getActiveCompactions(self, login, tserver):
    self._oprot.writeMessageBegin('getActiveCompactions', TMessageType.CALL, self._seqid)
    args = getActiveCompactions_args()
    args.login = login
    args.tserver = tserver
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getActiveCompactions(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getActiveCompactions_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveCompactions failed: unknown result");

  def getSiteConfiguration(self, login):
    """
    Parameters:
     - login
    """
    self.send_getSiteConfiguration(login)
    return self.recv_getSiteConfiguration()

  def send_getSiteConfiguration(self, login):
    self._oprot.writeMessageBegin('getSiteConfiguration', TMessageType.CALL, self._seqid)
    args = getSiteConfiguration_args()
    args.login = login
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getSiteConfiguration(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getSiteConfiguration_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSiteConfiguration failed: unknown result");

  def getSystemConfiguration(self, login):
    """
    Parameters:
     - login
    """
    self.send_getSystemConfiguration(login)
    return self.recv_getSystemConfiguration()

  def send_getSystemConfiguration(self, login):
    self._oprot.writeMessageBegin('getSystemConfiguration', TMessageType.CALL, self._seqid)
    args = getSystemConfiguration_args()
    args.login = login
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getSystemConfiguration(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getSystemConfiguration_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSystemConfiguration failed: unknown result");

  def getTabletServers(self, login):
    """
    Parameters:
     - login
    """
    self.send_getTabletServers(login)
    return self.recv_getTabletServers()

  def send_getTabletServers(self, login):
    self._oprot.writeMessageBegin('getTabletServers', TMessageType.CALL, self._seqid)
    args = getTabletServers_args()
    args.login = login
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getTabletServers(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getTabletServers_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTabletServers failed: unknown result");

  def removeProperty(self, login, property):
    """
    Parameters:
     - login
     - property
    """
    self.send_removeProperty(login, property)
    self.recv_removeProperty()

  def send_removeProperty(self, login, property):
    self._oprot.writeMessageBegin('removeProperty', TMessageType.CALL, self._seqid)
    args = removeProperty_args()
    args.login = login
    args.property = property
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_removeProperty(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = removeProperty_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def setProperty(self, login, property, value):
    """
    Parameters:
     - login
     - property
     - value
    """
    self.send_setProperty(login, property, value)
    self.recv_setProperty()

  def send_setProperty(self, login, property, value):
    self._oprot.writeMessageBegin('setProperty', TMessageType.CALL, self._seqid)
    args = setProperty_args()
    args.login = login
    args.property = property
    args.value = value
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_setProperty(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = setProperty_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def testClassLoad(self, login, className, asTypeName):
    """
    Parameters:
     - login
     - className
     - asTypeName
    """
    self.send_testClassLoad(login, className, asTypeName)
    return self.recv_testClassLoad()

  def send_testClassLoad(self, login, className, asTypeName):
    self._oprot.writeMessageBegin('testClassLoad', TMessageType.CALL, self._seqid)
    args = testClassLoad_args()
    args.login = login
    args.className = className
    args.asTypeName = asTypeName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_testClassLoad(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = testClassLoad_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "testClassLoad failed: unknown result");

  def authenticateUser(self, login, user, properties):
    """
    Parameters:
     - login
     - user
     - properties
    """
    self.send_authenticateUser(login, user, properties)
    return self.recv_authenticateUser()

  def send_authenticateUser(self, login, user, properties):
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
    args = authenticateUser_args()
    args.login = login
    args.user = user
    args.properties = properties
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_authenticateUser(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = authenticateUser_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");

  def changeUserAuthorizations(self, login, user, authorizations):
    """
    Parameters:
     - login
     - user
     - authorizations
    """
    self.send_changeUserAuthorizations(login, user, authorizations)
    self.recv_changeUserAuthorizations()

  def send_changeUserAuthorizations(self, login, user, authorizations):
    self._oprot.writeMessageBegin('changeUserAuthorizations', TMessageType.CALL, self._seqid)
    args = changeUserAuthorizations_args()
    args.login = login
    args.user = user
    args.authorizations = authorizations
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_changeUserAuthorizations(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = changeUserAuthorizations_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def changeLocalUserPassword(self, login, user, password):
    """
    Parameters:
     - login
     - user
     - password
    """
    self.send_changeLocalUserPassword(login, user, password)
    self.recv_changeLocalUserPassword()

  def send_changeLocalUserPassword(self, login, user, password):
    self._oprot.writeMessageBegin('changeLocalUserPassword', TMessageType.CALL, self._seqid)
    args = changeLocalUserPassword_args()
    args.login = login
    args.user = user
    args.password = password
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_changeLocalUserPassword(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = changeLocalUserPassword_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def createLocalUser(self, login, user, password):
    """
    Parameters:
     - login
     - user
     - password
    """
    self.send_createLocalUser(login, user, password)
    self.recv_createLocalUser()

  def send_createLocalUser(self, login, user, password):
    self._oprot.writeMessageBegin('createLocalUser', TMessageType.CALL, self._seqid)
    args = createLocalUser_args()
    args.login = login
    args.user = user
    args.password = password
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createLocalUser(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createLocalUser_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def dropLocalUser(self, login, user):
    """
    Parameters:
     - login
     - user
    """
    self.send_dropLocalUser(login, user)
    self.recv_dropLocalUser()

  def send_dropLocalUser(self, login, user):
    self._oprot.writeMessageBegin('dropLocalUser', TMessageType.CALL, self._seqid)
    args = dropLocalUser_args()
    args.login = login
    args.user = user
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_dropLocalUser(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = dropLocalUser_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def getUserAuthorizations(self, login, user):
    """
    Parameters:
     - login
     - user
    """
    self.send_getUserAuthorizations(login, user)
    return self.recv_getUserAuthorizations()

  def send_getUserAuthorizations(self, login, user):
    self._oprot.writeMessageBegin('getUserAuthorizations', TMessageType.CALL, self._seqid)
    args = getUserAuthorizations_args()
    args.login = login
    args.user = user
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getUserAuthorizations(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getUserAuthorizations_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserAuthorizations failed: unknown result");

  def grantSystemPermission(self, login, user, perm):
    """
    Parameters:
     - login
     - user
     - perm
    """
    self.send_grantSystemPermission(login, user, perm)
    self.recv_grantSystemPermission()

  def send_grantSystemPermission(self, login, user, perm):
    self._oprot.writeMessageBegin('grantSystemPermission', TMessageType.CALL, self._seqid)
    args = grantSystemPermission_args()
    args.login = login
    args.user = user
    args.perm = perm
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_grantSystemPermission(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = grantSystemPermission_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def grantTablePermission(self, login, user, table, perm):
    """
    Parameters:
     - login
     - user
     - table
     - perm
    """
    self.send_grantTablePermission(login, user, table, perm)
    self.recv_grantTablePermission()

  def send_grantTablePermission(self, login, user, table, perm):
    self._oprot.writeMessageBegin('grantTablePermission', TMessageType.CALL, self._seqid)
    args = grantTablePermission_args()
    args.login = login
    args.user = user
    args.table = table
    args.perm = perm
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_grantTablePermission(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = grantTablePermission_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def hasSystemPermission(self, login, user, perm):
    """
    Parameters:
     - login
     - user
     - perm
    """
    self.send_hasSystemPermission(login, user, perm)
    return self.recv_hasSystemPermission()

  def send_hasSystemPermission(self, login, user, perm):
    self._oprot.writeMessageBegin('hasSystemPermission', TMessageType.CALL, self._seqid)
    args = hasSystemPermission_args()
    args.login = login
    args.user = user
    args.perm = perm
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_hasSystemPermission(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = hasSystemPermission_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "hasSystemPermission failed: unknown result");

  def hasTablePermission(self, login, user, table, perm):
    """
    Parameters:
     - login
     - user
     - table
     - perm
    """
    self.send_hasTablePermission(login, user, table, perm)
    return self.recv_hasTablePermission()

  def send_hasTablePermission(self, login, user, table, perm):
    self._oprot.writeMessageBegin('hasTablePermission', TMessageType.CALL, self._seqid)
    args = hasTablePermission_args()
    args.login = login
    args.user = user
    args.table = table
    args.perm = perm
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_hasTablePermission(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = hasTablePermission_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "hasTablePermission failed: unknown result");

  def listLocalUsers(self, login):
    """
    Parameters:
     - login
    """
    self.send_listLocalUsers(login)
    return self.recv_listLocalUsers()

  def send_listLocalUsers(self, login):
    self._oprot.writeMessageBegin('listLocalUsers', TMessageType.CALL, self._seqid)
    args = listLocalUsers_args()
    args.login = login
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_listLocalUsers(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = listLocalUsers_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "listLocalUsers failed: unknown result");

  def revokeSystemPermission(self, login, user, perm):
    """
    Parameters:
     - login
     - user
     - perm
    """
    self.send_revokeSystemPermission(login, user, perm)
    self.recv_revokeSystemPermission()

  def send_revokeSystemPermission(self, login, user, perm):
    self._oprot.writeMessageBegin('revokeSystemPermission', TMessageType.CALL, self._seqid)
    args = revokeSystemPermission_args()
    args.login = login
    args.user = user
    args.perm = perm
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_revokeSystemPermission(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = revokeSystemPermission_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def revokeTablePermission(self, login, user, table, perm):
    """
    Parameters:
     - login
     - user
     - table
     - perm
    """
    self.send_revokeTablePermission(login, user, table, perm)
    self.recv_revokeTablePermission()

  def send_revokeTablePermission(self, login, user, table, perm):
    self._oprot.writeMessageBegin('revokeTablePermission', TMessageType.CALL, self._seqid)
    args = revokeTablePermission_args()
    args.login = login
    args.user = user
    args.table = table
    args.perm = perm
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_revokeTablePermission(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = revokeTablePermission_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def createBatchScanner(self, login, tableName, options):
    """
    Parameters:
     - login
     - tableName
     - options
    """
    self.send_createBatchScanner(login, tableName, options)
    return self.recv_createBatchScanner()

  def send_createBatchScanner(self, login, tableName, options):
    self._oprot.writeMessageBegin('createBatchScanner', TMessageType.CALL, self._seqid)
    args = createBatchScanner_args()
    args.login = login
    args.tableName = tableName
    args.options = options
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createBatchScanner(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createBatchScanner_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createBatchScanner failed: unknown result");

  def createScanner(self, login, tableName, options):
    """
    Parameters:
     - login
     - tableName
     - options
    """
    self.send_createScanner(login, tableName, options)
    return self.recv_createScanner()

  def send_createScanner(self, login, tableName, options):
    self._oprot.writeMessageBegin('createScanner', TMessageType.CALL, self._seqid)
    args = createScanner_args()
    args.login = login
    args.tableName = tableName
    args.options = options
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createScanner(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createScanner_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createScanner failed: unknown result");

  def hasNext(self, scanner):
    """
    Parameters:
     - scanner
    """
    self.send_hasNext(scanner)
    return self.recv_hasNext()

  def send_hasNext(self, scanner):
    self._oprot.writeMessageBegin('hasNext', TMessageType.CALL, self._seqid)
    args = hasNext_args()
    args.scanner = scanner
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_hasNext(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = hasNext_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    raise TApplicationException(TApplicationException.MISSING_RESULT, "hasNext failed: unknown result");

  def nextEntry(self, scanner):
    """
    Parameters:
     - scanner
    """
    self.send_nextEntry(scanner)
    return self.recv_nextEntry()

  def send_nextEntry(self, scanner):
    self._oprot.writeMessageBegin('nextEntry', TMessageType.CALL, self._seqid)
    args = nextEntry_args()
    args.scanner = scanner
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_nextEntry(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = nextEntry_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    raise TApplicationException(TApplicationException.MISSING_RESULT, "nextEntry failed: unknown result");

  def nextK(self, scanner, k):
    """
    Parameters:
     - scanner
     - k
    """
    self.send_nextK(scanner, k)
    return self.recv_nextK()

  def send_nextK(self, scanner, k):
    self._oprot.writeMessageBegin('nextK', TMessageType.CALL, self._seqid)
    args = nextK_args()
    args.scanner = scanner
    args.k = k
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_nextK(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = nextK_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    if result.ouch3 is not None:
      raise result.ouch3
    raise TApplicationException(TApplicationException.MISSING_RESULT, "nextK failed: unknown result");

  def closeScanner(self, scanner):
    """
    Parameters:
     - scanner
    """
    self.send_closeScanner(scanner)
    self.recv_closeScanner()

  def send_closeScanner(self, scanner):
    self._oprot.writeMessageBegin('closeScanner', TMessageType.CALL, self._seqid)
    args = closeScanner_args()
    args.scanner = scanner
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_closeScanner(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = closeScanner_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    return

  def updateAndFlush(self, login, tableName, cells):
    """
    Parameters:
     - login
     - tableName
     - cells
    """
    self.send_updateAndFlush(login, tableName, cells)
    self.recv_updateAndFlush()

  def send_updateAndFlush(self, login, tableName, cells):
    self._oprot.writeMessageBegin('updateAndFlush', TMessageType.CALL, self._seqid)
    args = updateAndFlush_args()
    args.login = login
    args.tableName = tableName
    args.cells = cells
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_updateAndFlush(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = updateAndFlush_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.outch1 is not None:
      raise result.outch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def createWriter(self, login, tableName, opts):
    """
    Parameters:
     - login
     - tableName
     - opts
    """
    self.send_createWriter(login, tableName, opts)
    return self.recv_createWriter()

  def send_createWriter(self, login, tableName, opts):
    self._oprot.writeMessageBegin('createWriter', TMessageType.CALL, self._seqid)
    args = createWriter_args()
    args.login = login
    args.tableName = tableName
    args.opts = opts
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createWriter(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createWriter_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.outch1 is not None:
      raise result.outch1
    if result.ouch2 is not None:
      raise result.ouch2
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createWriter failed: unknown result");

  def update(self, writer, cells):
    """
    Parameters:
     - writer
     - cells
    """
    self.send_update(writer, cells)

  def send_update(self, writer, cells):
    self._oprot.writeMessageBegin('update', TMessageType.CALL, self._seqid)
    args = update_args()
    args.writer = writer
    args.cells = cells
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()
  def flush(self, writer):
    """
    Parameters:
     - writer
    """
    self.send_flush(writer)
    self.recv_flush()

  def send_flush(self, writer):
    self._oprot.writeMessageBegin('flush', TMessageType.CALL, self._seqid)
    args = flush_args()
    args.writer = writer
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_flush(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = flush_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def closeWriter(self, writer):
    """
    Parameters:
     - writer
    """
    self.send_closeWriter(writer)
    self.recv_closeWriter()

  def send_closeWriter(self, writer):
    self._oprot.writeMessageBegin('closeWriter', TMessageType.CALL, self._seqid)
    args = closeWriter_args()
    args.writer = writer
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_closeWriter(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = closeWriter_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ouch1 is not None:
      raise result.ouch1
    if result.ouch2 is not None:
      raise result.ouch2
    return

  def getRowRange(self, row):
    """
    Parameters:
     - row
    """
    self.send_getRowRange(row)
    return self.recv_getRowRange()

  def send_getRowRange(self, row):
    self._oprot.writeMessageBegin('getRowRange', TMessageType.CALL, self._seqid)
    args = getRowRange_args()
    args.row = row
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getRowRange(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getRowRange_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowRange failed: unknown result");

  def getFollowing(self, key, part):
    """
    Parameters:
     - key
     - part
    """
    self.send_getFollowing(key, part)
    return self.recv_getFollowing()

  def send_getFollowing(self, key, part):
    self._oprot.writeMessageBegin('getFollowing', TMessageType.CALL, self._seqid)
    args = getFollowing_args()
    args.key = key
    args.part = part
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getFollowing(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getFollowing_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFollowing failed: unknown result");


class Processor(Iface, TProcessor):
  def __init__(self, handler):
    self._handler = handler
    self._processMap = {}
    self._processMap["login"] = Processor.process_login
    self._processMap["addConstraint"] = Processor.process_addConstraint
    self._processMap["addSplits"] = Processor.process_addSplits
    self._processMap["attachIterator"] = Processor.process_attachIterator
    self._processMap["checkIteratorConflicts"] = Processor.process_checkIteratorConflicts
    self._processMap["clearLocatorCache"] = Processor.process_clearLocatorCache
    self._processMap["cloneTable"] = Processor.process_cloneTable
    self._processMap["compactTable"] = Processor.process_compactTable
    self._processMap["cancelCompaction"] = Processor.process_cancelCompaction
    self._processMap["createTable"] = Processor.process_createTable
    self._processMap["deleteTable"] = Processor.process_deleteTable
    self._processMap["deleteRows"] = Processor.process_deleteRows
    self._processMap["exportTable"] = Processor.process_exportTable
    self._processMap["flushTable"] = Processor.process_flushTable
    self._processMap["getLocalityGroups"] = Processor.process_getLocalityGroups
    self._processMap["getIteratorSetting"] = Processor.process_getIteratorSetting
    self._processMap["getMaxRow"] = Processor.process_getMaxRow
    self._processMap["getTableProperties"] = Processor.process_getTableProperties
    self._processMap["getSplits"] = Processor.process_getSplits
    self._processMap["importDirectory"] = Processor.process_importDirectory
    self._processMap["importTable"] = Processor.process_importTable
    self._processMap["listTables"] = Processor.process_listTables
    self._processMap["listIterators"] = Processor.process_listIterators
    self._processMap["listConstraints"] = Processor.process_listConstraints
    self._processMap["mergeTablets"] = Processor.process_mergeTablets
    self._processMap["offlineTable"] = Processor.process_offlineTable
    self._processMap["onlineTable"] = Processor.process_onlineTable
    self._processMap["removeConstraint"] = Processor.process_removeConstraint
    self._processMap["removeIterator"] = Processor.process_removeIterator
    self._processMap["removeTableProperty"] = Processor.process_removeTableProperty
    self._processMap["renameTable"] = Processor.process_renameTable
    self._processMap["setLocalityGroups"] = Processor.process_setLocalityGroups
    self._processMap["setTableProperty"] = Processor.process_setTableProperty
    self._processMap["splitRangeByTablets"] = Processor.process_splitRangeByTablets
    self._processMap["tableExists"] = Processor.process_tableExists
    self._processMap["tableIdMap"] = Processor.process_tableIdMap
    self._processMap["pingTabletServer"] = Processor.process_pingTabletServer
    self._processMap["getActiveScans"] = Processor.process_getActiveScans
    self._processMap["getActiveCompactions"] = Processor.process_getActiveCompactions
    self._processMap["getSiteConfiguration"] = Processor.process_getSiteConfiguration
    self._processMap["getSystemConfiguration"] = Processor.process_getSystemConfiguration
    self._processMap["getTabletServers"] = Processor.process_getTabletServers
    self._processMap["removeProperty"] = Processor.process_removeProperty
    self._processMap["setProperty"] = Processor.process_setProperty
    self._processMap["testClassLoad"] = Processor.process_testClassLoad
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
    self._processMap["changeUserAuthorizations"] = Processor.process_changeUserAuthorizations
    self._processMap["changeLocalUserPassword"] = Processor.process_changeLocalUserPassword
    self._processMap["createLocalUser"] = Processor.process_createLocalUser
    self._processMap["dropLocalUser"] = Processor.process_dropLocalUser
    self._processMap["getUserAuthorizations"] = Processor.process_getUserAuthorizations
    self._processMap["grantSystemPermission"] = Processor.process_grantSystemPermission
    self._processMap["grantTablePermission"] = Processor.process_grantTablePermission
    self._processMap["hasSystemPermission"] = Processor.process_hasSystemPermission
    self._processMap["hasTablePermission"] = Processor.process_hasTablePermission
    self._processMap["listLocalUsers"] = Processor.process_listLocalUsers
    self._processMap["revokeSystemPermission"] = Processor.process_revokeSystemPermission
    self._processMap["revokeTablePermission"] = Processor.process_revokeTablePermission
    self._processMap["createBatchScanner"] = Processor.process_createBatchScanner
    self._processMap["createScanner"] = Processor.process_createScanner
    self._processMap["hasNext"] = Processor.process_hasNext
    self._processMap["nextEntry"] = Processor.process_nextEntry
    self._processMap["nextK"] = Processor.process_nextK
    self._processMap["closeScanner"] = Processor.process_closeScanner
    self._processMap["updateAndFlush"] = Processor.process_updateAndFlush
    self._processMap["createWriter"] = Processor.process_createWriter
    self._processMap["update"] = Processor.process_update
    self._processMap["flush"] = Processor.process_flush
    self._processMap["closeWriter"] = Processor.process_closeWriter
    self._processMap["getRowRange"] = Processor.process_getRowRange
    self._processMap["getFollowing"] = Processor.process_getFollowing

  def process(self, iprot, oprot):
    (name, type, seqid) = iprot.readMessageBegin()
    if name not in self._processMap:
      iprot.skip(TType.STRUCT)
      iprot.readMessageEnd()
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
      x.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
      return
    else:
      self._processMap[name](self, seqid, iprot, oprot)
    return True

  def process_login(self, seqid, iprot, oprot):
    args = login_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = login_result()
    try:
      result.success = self._handler.login(args.principal, args.loginProperties)
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("login", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_addConstraint(self, seqid, iprot, oprot):
    args = addConstraint_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = addConstraint_result()
    try:
      result.success = self._handler.addConstraint(args.login, args.tableName, args.constraintClassName)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("addConstraint", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_addSplits(self, seqid, iprot, oprot):
    args = addSplits_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = addSplits_result()
    try:
      self._handler.addSplits(args.login, args.tableName, args.splits)
    except TableNotFoundException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("addSplits", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_attachIterator(self, seqid, iprot, oprot):
    args = attachIterator_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = attachIterator_result()
    try:
      self._handler.attachIterator(args.login, args.tableName, args.setting, args.scopes)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("attachIterator", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_checkIteratorConflicts(self, seqid, iprot, oprot):
    args = checkIteratorConflicts_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = checkIteratorConflicts_result()
    try:
      self._handler.checkIteratorConflicts(args.login, args.tableName, args.setting, args.scopes)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("checkIteratorConflicts", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_clearLocatorCache(self, seqid, iprot, oprot):
    args = clearLocatorCache_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = clearLocatorCache_result()
    try:
      self._handler.clearLocatorCache(args.login, args.tableName)
    except TableNotFoundException as ouch1:
      result.ouch1 = ouch1
    oprot.writeMessageBegin("clearLocatorCache", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_cloneTable(self, seqid, iprot, oprot):
    args = cloneTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = cloneTable_result()
    try:
      self._handler.cloneTable(args.login, args.tableName, args.newTableName, args.flush, args.propertiesToSet, args.propertiesToExclude)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    except TableExistsException as ouch4:
      result.ouch4 = ouch4
    oprot.writeMessageBegin("cloneTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_compactTable(self, seqid, iprot, oprot):
    args = compactTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = compactTable_result()
    try:
      self._handler.compactTable(args.login, args.tableName, args.startRow, args.endRow, args.iterators, args.flush, args.wait)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException as ouch2:
      result.ouch2 = ouch2
    except AccumuloException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("compactTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_cancelCompaction(self, seqid, iprot, oprot):
    args = cancelCompaction_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = cancelCompaction_result()
    try:
      self._handler.cancelCompaction(args.login, args.tableName)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException as ouch2:
      result.ouch2 = ouch2
    except AccumuloException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("cancelCompaction", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createTable(self, seqid, iprot, oprot):
    args = createTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createTable_result()
    try:
      self._handler.createTable(args.login, args.tableName, args.versioningIter, args.type)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    except TableExistsException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("createTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_deleteTable(self, seqid, iprot, oprot):
    args = deleteTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = deleteTable_result()
    try:
      self._handler.deleteTable(args.login, args.tableName)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("deleteTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_deleteRows(self, seqid, iprot, oprot):
    args = deleteRows_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = deleteRows_result()
    try:
      self._handler.deleteRows(args.login, args.tableName, args.startRow, args.endRow)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("deleteRows", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_exportTable(self, seqid, iprot, oprot):
    args = exportTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = exportTable_result()
    try:
      self._handler.exportTable(args.login, args.tableName, args.exportDir)
    except TableNotFoundException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("exportTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_flushTable(self, seqid, iprot, oprot):
    args = flushTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = flushTable_result()
    try:
      self._handler.flushTable(args.login, args.tableName, args.startRow, args.endRow, args.wait)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("flushTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getLocalityGroups(self, seqid, iprot, oprot):
    args = getLocalityGroups_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getLocalityGroups_result()
    try:
      result.success = self._handler.getLocalityGroups(args.login, args.tableName)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("getLocalityGroups", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getIteratorSetting(self, seqid, iprot, oprot):
    args = getIteratorSetting_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getIteratorSetting_result()
    try:
      result.success = self._handler.getIteratorSetting(args.login, args.tableName, args.iteratorName, args.scope)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("getIteratorSetting", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getMaxRow(self, seqid, iprot, oprot):
    args = getMaxRow_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getMaxRow_result()
    try:
      result.success = self._handler.getMaxRow(args.login, args.tableName, args.auths, args.startRow, args.startInclusive, args.endRow, args.endInclusive)
    except TableNotFoundException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("getMaxRow", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getTableProperties(self, seqid, iprot, oprot):
    args = getTableProperties_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getTableProperties_result()
    try:
      result.success = self._handler.getTableProperties(args.login, args.tableName)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("getTableProperties", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getSplits(self, seqid, iprot, oprot):
    args = getSplits_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getSplits_result()
    try:
      result.success = self._handler.getSplits(args.login, args.tableName, args.maxSplits)
    except TableNotFoundException as ouch1:
      result.ouch1 = ouch1
    oprot.writeMessageBegin("getSplits", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_importDirectory(self, seqid, iprot, oprot):
    args = importDirectory_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = importDirectory_result()
    try:
      self._handler.importDirectory(args.login, args.tableName, args.importDir, args.failureDir, args.setTime)
    except TableNotFoundException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch3:
      result.ouch3 = ouch3
    except AccumuloSecurityException as ouch4:
      result.ouch4 = ouch4
    oprot.writeMessageBegin("importDirectory", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_importTable(self, seqid, iprot, oprot):
    args = importTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = importTable_result()
    try:
      self._handler.importTable(args.login, args.tableName, args.importDir)
    except TableExistsException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("importTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_listTables(self, seqid, iprot, oprot):
    args = listTables_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = listTables_result()
    result.success = self._handler.listTables(args.login)
    oprot.writeMessageBegin("listTables", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_listIterators(self, seqid, iprot, oprot):
    args = listIterators_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = listIterators_result()
    try:
      result.success = self._handler.listIterators(args.login, args.tableName)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("listIterators", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_listConstraints(self, seqid, iprot, oprot):
    args = listConstraints_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = listConstraints_result()
    try:
      result.success = self._handler.listConstraints(args.login, args.tableName)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("listConstraints", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_mergeTablets(self, seqid, iprot, oprot):
    args = mergeTablets_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = mergeTablets_result()
    try:
      self._handler.mergeTablets(args.login, args.tableName, args.startRow, args.endRow)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("mergeTablets", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_offlineTable(self, seqid, iprot, oprot):
    args = offlineTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = offlineTable_result()
    try:
      self._handler.offlineTable(args.login, args.tableName)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("offlineTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_onlineTable(self, seqid, iprot, oprot):
    args = onlineTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = onlineTable_result()
    try:
      self._handler.onlineTable(args.login, args.tableName)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("onlineTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_removeConstraint(self, seqid, iprot, oprot):
    args = removeConstraint_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = removeConstraint_result()
    try:
      self._handler.removeConstraint(args.login, args.tableName, args.constraint)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("removeConstraint", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_removeIterator(self, seqid, iprot, oprot):
    args = removeIterator_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = removeIterator_result()
    try:
      self._handler.removeIterator(args.login, args.tableName, args.iterName, args.scopes)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except AccumuloException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("removeIterator", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_removeTableProperty(self, seqid, iprot, oprot):
    args = removeTableProperty_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = removeTableProperty_result()
    try:
      self._handler.removeTableProperty(args.login, args.tableName, args.property)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("removeTableProperty", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_renameTable(self, seqid, iprot, oprot):
    args = renameTable_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = renameTable_result()
    try:
      self._handler.renameTable(args.login, args.oldTableName, args.newTableName)
    except AccumuloSecurityException as ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException as ouch2:
      result.ouch2 = ouch2
    except AccumuloException as ouch3:
      result.ouch3 = ouch3
    except TableExistsException as ouch4:
      result.ouch4 = ouch4
    oprot.writeMessageBegin("renameTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_setLocalityGroups(self, seqid, iprot, oprot):
    args = setLocalityGroups_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = setLocalityGroups_result()
    try:
      self._handler.setLocalityGroups(args.login, args.tableName, args.groups)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("setLocalityGroups", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_setTableProperty(self, seqid, iprot, oprot):
    args = setTableProperty_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = setTableProperty_result()
    try:
      self._handler.setTableProperty(args.login, args.tableName, args.property, args.value)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("setTableProperty", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_splitRangeByTablets(self, seqid, iprot, oprot):
    args = splitRangeByTablets_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = splitRangeByTablets_result()
    try:
      result.success = self._handler.splitRangeByTablets(args.login, args.tableName, args.range, args.maxSplits)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("splitRangeByTablets", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_tableExists(self, seqid, iprot, oprot):
    args = tableExists_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = tableExists_result()
    result.success = self._handler.tableExists(args.login, args.tableName)
    oprot.writeMessageBegin("tableExists", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_tableIdMap(self, seqid, iprot, oprot):
    args = tableIdMap_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = tableIdMap_result()
    result.success = self._handler.tableIdMap(args.login)
    oprot.writeMessageBegin("tableIdMap", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_pingTabletServer(self, seqid, iprot, oprot):
    args = pingTabletServer_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = pingTabletServer_result()
    try:
      self._handler.pingTabletServer(args.login, args.tserver)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("pingTabletServer", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getActiveScans(self, seqid, iprot, oprot):
    args = getActiveScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getActiveScans_result()
    try:
      result.success = self._handler.getActiveScans(args.login, args.tserver)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("getActiveScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getActiveCompactions(self, seqid, iprot, oprot):
    args = getActiveCompactions_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getActiveCompactions_result()
    try:
      result.success = self._handler.getActiveCompactions(args.login, args.tserver)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("getActiveCompactions", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getSiteConfiguration(self, seqid, iprot, oprot):
    args = getSiteConfiguration_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getSiteConfiguration_result()
    try:
      result.success = self._handler.getSiteConfiguration(args.login)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("getSiteConfiguration", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getSystemConfiguration(self, seqid, iprot, oprot):
    args = getSystemConfiguration_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getSystemConfiguration_result()
    try:
      result.success = self._handler.getSystemConfiguration(args.login)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("getSystemConfiguration", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getTabletServers(self, seqid, iprot, oprot):
    args = getTabletServers_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getTabletServers_result()
    result.success = self._handler.getTabletServers(args.login)
    oprot.writeMessageBegin("getTabletServers", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_removeProperty(self, seqid, iprot, oprot):
    args = removeProperty_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = removeProperty_result()
    try:
      self._handler.removeProperty(args.login, args.property)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("removeProperty", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_setProperty(self, seqid, iprot, oprot):
    args = setProperty_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = setProperty_result()
    try:
      self._handler.setProperty(args.login, args.property, args.value)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("setProperty", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_testClassLoad(self, seqid, iprot, oprot):
    args = testClassLoad_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = testClassLoad_result()
    try:
      result.success = self._handler.testClassLoad(args.login, args.className, args.asTypeName)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("testClassLoad", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_authenticateUser(self, seqid, iprot, oprot):
    args = authenticateUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = authenticateUser_result()
    try:
      result.success = self._handler.authenticateUser(args.login, args.user, args.properties)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_changeUserAuthorizations(self, seqid, iprot, oprot):
    args = changeUserAuthorizations_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = changeUserAuthorizations_result()
    try:
      self._handler.changeUserAuthorizations(args.login, args.user, args.authorizations)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("changeUserAuthorizations", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_changeLocalUserPassword(self, seqid, iprot, oprot):
    args = changeLocalUserPassword_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = changeLocalUserPassword_result()
    try:
      self._handler.changeLocalUserPassword(args.login, args.user, args.password)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("changeLocalUserPassword", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createLocalUser(self, seqid, iprot, oprot):
    args = createLocalUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createLocalUser_result()
    try:
      self._handler.createLocalUser(args.login, args.user, args.password)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("createLocalUser", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_dropLocalUser(self, seqid, iprot, oprot):
    args = dropLocalUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = dropLocalUser_result()
    try:
      self._handler.dropLocalUser(args.login, args.user)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("dropLocalUser", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getUserAuthorizations(self, seqid, iprot, oprot):
    args = getUserAuthorizations_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getUserAuthorizations_result()
    try:
      result.success = self._handler.getUserAuthorizations(args.login, args.user)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("getUserAuthorizations", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_grantSystemPermission(self, seqid, iprot, oprot):
    args = grantSystemPermission_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = grantSystemPermission_result()
    try:
      self._handler.grantSystemPermission(args.login, args.user, args.perm)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("grantSystemPermission", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_grantTablePermission(self, seqid, iprot, oprot):
    args = grantTablePermission_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = grantTablePermission_result()
    try:
      self._handler.grantTablePermission(args.login, args.user, args.table, args.perm)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("grantTablePermission", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_hasSystemPermission(self, seqid, iprot, oprot):
    args = hasSystemPermission_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = hasSystemPermission_result()
    try:
      result.success = self._handler.hasSystemPermission(args.login, args.user, args.perm)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("hasSystemPermission", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_hasTablePermission(self, seqid, iprot, oprot):
    args = hasTablePermission_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = hasTablePermission_result()
    try:
      result.success = self._handler.hasTablePermission(args.login, args.user, args.table, args.perm)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("hasTablePermission", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_listLocalUsers(self, seqid, iprot, oprot):
    args = listLocalUsers_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = listLocalUsers_result()
    try:
      result.success = self._handler.listLocalUsers(args.login)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("listLocalUsers", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_revokeSystemPermission(self, seqid, iprot, oprot):
    args = revokeSystemPermission_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = revokeSystemPermission_result()
    try:
      self._handler.revokeSystemPermission(args.login, args.user, args.perm)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("revokeSystemPermission", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_revokeTablePermission(self, seqid, iprot, oprot):
    args = revokeTablePermission_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = revokeTablePermission_result()
    try:
      self._handler.revokeTablePermission(args.login, args.user, args.table, args.perm)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("revokeTablePermission", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createBatchScanner(self, seqid, iprot, oprot):
    args = createBatchScanner_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createBatchScanner_result()
    try:
      result.success = self._handler.createBatchScanner(args.login, args.tableName, args.options)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("createBatchScanner", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createScanner(self, seqid, iprot, oprot):
    args = createScanner_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createScanner_result()
    try:
      result.success = self._handler.createScanner(args.login, args.tableName, args.options)
    except AccumuloException as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("createScanner", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_hasNext(self, seqid, iprot, oprot):
    args = hasNext_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = hasNext_result()
    try:
      result.success = self._handler.hasNext(args.scanner)
    except UnknownScanner as ouch1:
      result.ouch1 = ouch1
    oprot.writeMessageBegin("hasNext", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_nextEntry(self, seqid, iprot, oprot):
    args = nextEntry_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = nextEntry_result()
    try:
      result.success = self._handler.nextEntry(args.scanner)
    except NoMoreEntriesException as ouch1:
      result.ouch1 = ouch1
    except UnknownScanner as ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("nextEntry", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_nextK(self, seqid, iprot, oprot):
    args = nextK_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = nextK_result()
    try:
      result.success = self._handler.nextK(args.scanner, args.k)
    except NoMoreEntriesException as ouch1:
      result.ouch1 = ouch1
    except UnknownScanner as ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException as ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("nextK", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_closeScanner(self, seqid, iprot, oprot):
    args = closeScanner_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = closeScanner_result()
    try:
      self._handler.closeScanner(args.scanner)
    except UnknownScanner as ouch1:
      result.ouch1 = ouch1
    oprot.writeMessageBegin("closeScanner", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_updateAndFlush(self, seqid, iprot, oprot):
    args = updateAndFlush_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = updateAndFlush_result()
    try:
      self._handler.updateAndFlush(args.login, args.tableName, args.cells)
    except AccumuloException as outch1:
      result.outch1 = outch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("updateAndFlush", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createWriter(self, seqid, iprot, oprot):
    args = createWriter_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createWriter_result()
    try:
      result.success = self._handler.createWriter(args.login, args.tableName, args.opts)
    except AccumuloException as outch1:
      result.outch1 = outch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("createWriter", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_update(self, seqid, iprot, oprot):
    args = update_args()
    args.read(iprot)
    iprot.readMessageEnd()
    self._handler.update(args.writer, args.cells)
    return

  def process_flush(self, seqid, iprot, oprot):
    args = flush_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = flush_result()
    try:
      self._handler.flush(args.writer)
    except UnknownWriter as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("flush", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_closeWriter(self, seqid, iprot, oprot):
    args = closeWriter_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = closeWriter_result()
    try:
      self._handler.closeWriter(args.writer)
    except UnknownWriter as ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException as ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("closeWriter", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getRowRange(self, seqid, iprot, oprot):
    args = getRowRange_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getRowRange_result()
    result.success = self._handler.getRowRange(args.row)
    oprot.writeMessageBegin("getRowRange", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getFollowing(self, seqid, iprot, oprot):
    args = getFollowing_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getFollowing_result()
    result.success = self._handler.getFollowing(args.key, args.part)
    oprot.writeMessageBegin("getFollowing", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()


# HELPER FUNCTIONS AND STRUCTURES

class login_args:
  """
  Attributes:
   - principal
   - loginProperties
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'principal', None, None, ), # 1
    (2, TType.MAP, 'loginProperties', (TType.STRING,None,TType.STRING,None), None, ), # 2
  )

  def __init__(self, principal=None, loginProperties=None,):
    self.principal = principal
    self.loginProperties = loginProperties

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.principal = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.MAP:
          self.loginProperties = {}
          (_ktype101, _vtype102, _size100 ) = iprot.readMapBegin() 
          for _i104 in xrange(_size100):
            _key105 = iprot.readString();
            _val106 = iprot.readString();
            self.loginProperties[_key105] = _val106
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('login_args')
    if self.principal is not None:
      oprot.writeFieldBegin('principal', TType.STRING, 1)
      oprot.writeString(self.principal)
      oprot.writeFieldEnd()
    if self.loginProperties is not None:
      oprot.writeFieldBegin('loginProperties', TType.MAP, 2)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.loginProperties))
      for kiter107,viter108 in self.loginProperties.items():
        oprot.writeString(kiter107)
        oprot.writeString(viter108)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class login_result:
  """
  Attributes:
   - success
   - ouch2
  """

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, ouch2=None,):
    self.success = success
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRING:
          self.success = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('login_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRING, 0)
      oprot.writeString(self.success)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 1)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class addConstraint_args:
  """
  Attributes:
   - login
   - tableName
   - constraintClassName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'constraintClassName', None, None, ), # 3
  )

  def __init__(self, login=None, tableName=None, constraintClassName=None,):
    self.login = login
    self.tableName = tableName
    self.constraintClassName = constraintClassName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.constraintClassName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('addConstraint_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.constraintClassName is not None:
      oprot.writeFieldBegin('constraintClassName', TType.STRING, 3)
      oprot.writeString(self.constraintClassName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class addConstraint_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.I32, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.I32:
          self.success = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('addConstraint_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I32, 0)
      oprot.writeI32(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class addSplits_args:
  """
  Attributes:
   - login
   - tableName
   - splits
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.SET, 'splits', (TType.STRING,None), None, ), # 3
  )

  def __init__(self, login=None, tableName=None, splits=None,):
    self.login = login
    self.tableName = tableName
    self.splits = splits

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.SET:
          self.splits = set()
          (_etype112, _size109) = iprot.readSetBegin()
          for _i113 in xrange(_size109):
            _elem114 = iprot.readString();
            self.splits.add(_elem114)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('addSplits_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.splits is not None:
      oprot.writeFieldBegin('splits', TType.SET, 3)
      oprot.writeSetBegin(TType.STRING, len(self.splits))
      for iter115 in self.splits:
        oprot.writeString(iter115)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class addSplits_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = TableNotFoundException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloSecurityException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('addSplits_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class attachIterator_args:
  """
  Attributes:
   - login
   - tableName
   - setting
   - scopes
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRUCT, 'setting', (IteratorSetting, IteratorSetting.thrift_spec), None, ), # 3
    (4, TType.SET, 'scopes', (TType.I32,None), None, ), # 4
  )

  def __init__(self, login=None, tableName=None, setting=None, scopes=None,):
    self.login = login
    self.tableName = tableName
    self.setting = setting
    self.scopes = scopes

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.setting = IteratorSetting()
          self.setting.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.SET:
          self.scopes = set()
          (_etype119, _size116) = iprot.readSetBegin()
          for _i120 in xrange(_size116):
            _elem121 = iprot.readI32();
            self.scopes.add(_elem121)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('attachIterator_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.setting is not None:
      oprot.writeFieldBegin('setting', TType.STRUCT, 3)
      self.setting.write(oprot)
      oprot.writeFieldEnd()
    if self.scopes is not None:
      oprot.writeFieldBegin('scopes', TType.SET, 4)
      oprot.writeSetBegin(TType.I32, len(self.scopes))
      for iter122 in self.scopes:
        oprot.writeI32(iter122)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class attachIterator_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('attachIterator_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class checkIteratorConflicts_args:
  """
  Attributes:
   - login
   - tableName
   - setting
   - scopes
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRUCT, 'setting', (IteratorSetting, IteratorSetting.thrift_spec), None, ), # 3
    (4, TType.SET, 'scopes', (TType.I32,None), None, ), # 4
  )

  def __init__(self, login=None, tableName=None, setting=None, scopes=None,):
    self.login = login
    self.tableName = tableName
    self.setting = setting
    self.scopes = scopes

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.setting = IteratorSetting()
          self.setting.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.SET:
          self.scopes = set()
          (_etype126, _size123) = iprot.readSetBegin()
          for _i127 in xrange(_size123):
            _elem128 = iprot.readI32();
            self.scopes.add(_elem128)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('checkIteratorConflicts_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.setting is not None:
      oprot.writeFieldBegin('setting', TType.STRUCT, 3)
      self.setting.write(oprot)
      oprot.writeFieldEnd()
    if self.scopes is not None:
      oprot.writeFieldBegin('scopes', TType.SET, 4)
      oprot.writeSetBegin(TType.I32, len(self.scopes))
      for iter129 in self.scopes:
        oprot.writeI32(iter129)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class checkIteratorConflicts_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = TableNotFoundException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('checkIteratorConflicts_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class clearLocatorCache_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('clearLocatorCache_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class clearLocatorCache_result:
  """
  Attributes:
   - ouch1
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 1
  )

  def __init__(self, ouch1=None,):
    self.ouch1 = ouch1

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = TableNotFoundException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('clearLocatorCache_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class cloneTable_args:
  """
  Attributes:
   - login
   - tableName
   - newTableName
   - flush
   - propertiesToSet
   - propertiesToExclude
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'newTableName', None, None, ), # 3
    (4, TType.BOOL, 'flush', None, None, ), # 4
    (5, TType.MAP, 'propertiesToSet', (TType.STRING,None,TType.STRING,None), None, ), # 5
    (6, TType.SET, 'propertiesToExclude', (TType.STRING,None), None, ), # 6
  )

  def __init__(self, login=None, tableName=None, newTableName=None, flush=None, propertiesToSet=None, propertiesToExclude=None,):
    self.login = login
    self.tableName = tableName
    self.newTableName = newTableName
    self.flush = flush
    self.propertiesToSet = propertiesToSet
    self.propertiesToExclude = propertiesToExclude

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.newTableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.BOOL:
          self.flush = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.MAP:
          self.propertiesToSet = {}
          (_ktype131, _vtype132, _size130 ) = iprot.readMapBegin() 
          for _i134 in xrange(_size130):
            _key135 = iprot.readString();
            _val136 = iprot.readString();
            self.propertiesToSet[_key135] = _val136
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.SET:
          self.propertiesToExclude = set()
          (_etype140, _size137) = iprot.readSetBegin()
          for _i141 in xrange(_size137):
            _elem142 = iprot.readString();
            self.propertiesToExclude.add(_elem142)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('cloneTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.newTableName is not None:
      oprot.writeFieldBegin('newTableName', TType.STRING, 3)
      oprot.writeString(self.newTableName)
      oprot.writeFieldEnd()
    if self.flush is not None:
      oprot.writeFieldBegin('flush', TType.BOOL, 4)
      oprot.writeBool(self.flush)
      oprot.writeFieldEnd()
    if self.propertiesToSet is not None:
      oprot.writeFieldBegin('propertiesToSet', TType.MAP, 5)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.propertiesToSet))
      for kiter143,viter144 in self.propertiesToSet.items():
        oprot.writeString(kiter143)
        oprot.writeString(viter144)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.propertiesToExclude is not None:
      oprot.writeFieldBegin('propertiesToExclude', TType.SET, 6)
      oprot.writeSetBegin(TType.STRING, len(self.propertiesToExclude))
      for iter145 in self.propertiesToExclude:
        oprot.writeString(iter145)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class cloneTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
   - ouch4
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
    (4, TType.STRUCT, 'ouch4', (TableExistsException, TableExistsException.thrift_spec), None, ), # 4
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None, ouch4=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3
    self.ouch4 = ouch4

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRUCT:
          self.ouch4 = TableExistsException()
          self.ouch4.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('cloneTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch4 is not None:
      oprot.writeFieldBegin('ouch4', TType.STRUCT, 4)
      self.ouch4.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class compactTable_args:
  """
  Attributes:
   - login
   - tableName
   - startRow
   - endRow
   - iterators
   - flush
   - wait
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'startRow', None, None, ), # 3
    (4, TType.STRING, 'endRow', None, None, ), # 4
    (5, TType.LIST, 'iterators', (TType.STRUCT,(IteratorSetting, IteratorSetting.thrift_spec)), None, ), # 5
    (6, TType.BOOL, 'flush', None, None, ), # 6
    (7, TType.BOOL, 'wait', None, None, ), # 7
  )

  def __init__(self, login=None, tableName=None, startRow=None, endRow=None, iterators=None, flush=None, wait=None,):
    self.login = login
    self.tableName = tableName
    self.startRow = startRow
    self.endRow = endRow
    self.iterators = iterators
    self.flush = flush
    self.wait = wait

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.startRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.endRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.LIST:
          self.iterators = []
          (_etype149, _size146) = iprot.readListBegin()
          for _i150 in xrange(_size146):
            _elem151 = IteratorSetting()
            _elem151.read(iprot)
            self.iterators.append(_elem151)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.BOOL:
          self.flush = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.BOOL:
          self.wait = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('compactTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.startRow is not None:
      oprot.writeFieldBegin('startRow', TType.STRING, 3)
      oprot.writeString(self.startRow)
      oprot.writeFieldEnd()
    if self.endRow is not None:
      oprot.writeFieldBegin('endRow', TType.STRING, 4)
      oprot.writeString(self.endRow)
      oprot.writeFieldEnd()
    if self.iterators is not None:
      oprot.writeFieldBegin('iterators', TType.LIST, 5)
      oprot.writeListBegin(TType.STRUCT, len(self.iterators))
      for iter152 in self.iterators:
        iter152.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.flush is not None:
      oprot.writeFieldBegin('flush', TType.BOOL, 6)
      oprot.writeBool(self.flush)
      oprot.writeFieldEnd()
    if self.wait is not None:
      oprot.writeFieldBegin('wait', TType.BOOL, 7)
      oprot.writeBool(self.wait)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class compactTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloException, AccumuloException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = TableNotFoundException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('compactTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class cancelCompaction_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('cancelCompaction_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class cancelCompaction_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloException, AccumuloException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = TableNotFoundException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('cancelCompaction_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createTable_args:
  """
  Attributes:
   - login
   - tableName
   - versioningIter
   - type
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.BOOL, 'versioningIter', None, None, ), # 3
    (4, TType.I32, 'type', None, None, ), # 4
  )

  def __init__(self, login=None, tableName=None, versioningIter=None, type=None,):
    self.login = login
    self.tableName = tableName
    self.versioningIter = versioningIter
    self.type = type

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.BOOL:
          self.versioningIter = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.versioningIter is not None:
      oprot.writeFieldBegin('versioningIter', TType.BOOL, 3)
      oprot.writeBool(self.versioningIter)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 4)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableExistsException, TableExistsException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableExistsException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class deleteTable_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('deleteTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class deleteTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('deleteTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class deleteRows_args:
  """
  Attributes:
   - login
   - tableName
   - startRow
   - endRow
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'startRow', None, None, ), # 3
    (4, TType.STRING, 'endRow', None, None, ), # 4
  )

  def __init__(self, login=None, tableName=None, startRow=None, endRow=None,):
    self.login = login
    self.tableName = tableName
    self.startRow = startRow
    self.endRow = endRow

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.startRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.endRow = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('deleteRows_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.startRow is not None:
      oprot.writeFieldBegin('startRow', TType.STRING, 3)
      oprot.writeString(self.startRow)
      oprot.writeFieldEnd()
    if self.endRow is not None:
      oprot.writeFieldBegin('endRow', TType.STRING, 4)
      oprot.writeString(self.endRow)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class deleteRows_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('deleteRows_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class exportTable_args:
  """
  Attributes:
   - login
   - tableName
   - exportDir
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'exportDir', None, None, ), # 3
  )

  def __init__(self, login=None, tableName=None, exportDir=None,):
    self.login = login
    self.tableName = tableName
    self.exportDir = exportDir

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.exportDir = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('exportTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.exportDir is not None:
      oprot.writeFieldBegin('exportDir', TType.STRING, 3)
      oprot.writeString(self.exportDir)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class exportTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = TableNotFoundException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloSecurityException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('exportTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class flushTable_args:
  """
  Attributes:
   - login
   - tableName
   - startRow
   - endRow
   - wait
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'startRow', None, None, ), # 3
    (4, TType.STRING, 'endRow', None, None, ), # 4
    (5, TType.BOOL, 'wait', None, None, ), # 5
  )

  def __init__(self, login=None, tableName=None, startRow=None, endRow=None, wait=None,):
    self.login = login
    self.tableName = tableName
    self.startRow = startRow
    self.endRow = endRow
    self.wait = wait

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.startRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.endRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.BOOL:
          self.wait = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('flushTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.startRow is not None:
      oprot.writeFieldBegin('startRow', TType.STRING, 3)
      oprot.writeString(self.startRow)
      oprot.writeFieldEnd()
    if self.endRow is not None:
      oprot.writeFieldBegin('endRow', TType.STRING, 4)
      oprot.writeString(self.endRow)
      oprot.writeFieldEnd()
    if self.wait is not None:
      oprot.writeFieldBegin('wait', TType.BOOL, 5)
      oprot.writeBool(self.wait)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class flushTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('flushTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getLocalityGroups_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getLocalityGroups_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getLocalityGroups_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.SET,(TType.STRING,None)), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.MAP:
          self.success = {}
          (_ktype154, _vtype155, _size153 ) = iprot.readMapBegin() 
          for _i157 in xrange(_size153):
            _key158 = iprot.readString();
            _val159 = set()
            (_etype163, _size160) = iprot.readSetBegin()
            for _i164 in xrange(_size160):
              _elem165 = iprot.readString();
              _val159.add(_elem165)
            iprot.readSetEnd()
            self.success[_key158] = _val159
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = TableNotFoundException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getLocalityGroups_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.SET, len(self.success))
      for kiter166,viter167 in self.success.items():
        oprot.writeString(kiter166)
        oprot.writeSetBegin(TType.STRING, len(viter167))
        for iter168 in viter167:
          oprot.writeString(iter168)
        oprot.writeSetEnd()
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getIteratorSetting_args:
  """
  Attributes:
   - login
   - tableName
   - iteratorName
   - scope
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'iteratorName', None, None, ), # 3
    (4, TType.I32, 'scope', None, None, ), # 4
  )

  def __init__(self, login=None, tableName=None, iteratorName=None, scope=None,):
    self.login = login
    self.tableName = tableName
    self.iteratorName = iteratorName
    self.scope = scope

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.iteratorName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.scope = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getIteratorSetting_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.iteratorName is not None:
      oprot.writeFieldBegin('iteratorName', TType.STRING, 3)
      oprot.writeString(self.iteratorName)
      oprot.writeFieldEnd()
    if self.scope is not None:
      oprot.writeFieldBegin('scope', TType.I32, 4)
      oprot.writeI32(self.scope)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getIteratorSetting_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (IteratorSetting, IteratorSetting.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = IteratorSetting()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getIteratorSetting_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getMaxRow_args:
  """
  Attributes:
   - login
   - tableName
   - auths
   - startRow
   - startInclusive
   - endRow
   - endInclusive
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.SET, 'auths', (TType.STRING,None), None, ), # 3
    (4, TType.STRING, 'startRow', None, None, ), # 4
    (5, TType.BOOL, 'startInclusive', None, None, ), # 5
    (6, TType.STRING, 'endRow', None, None, ), # 6
    (7, TType.BOOL, 'endInclusive', None, None, ), # 7
  )

  def __init__(self, login=None, tableName=None, auths=None, startRow=None, startInclusive=None, endRow=None, endInclusive=None,):
    self.login = login
    self.tableName = tableName
    self.auths = auths
    self.startRow = startRow
    self.startInclusive = startInclusive
    self.endRow = endRow
    self.endInclusive = endInclusive

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.SET:
          self.auths = set()
          (_etype172, _size169) = iprot.readSetBegin()
          for _i173 in xrange(_size169):
            _elem174 = iprot.readString();
            self.auths.add(_elem174)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.startRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.BOOL:
          self.startInclusive = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.STRING:
          self.endRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.BOOL:
          self.endInclusive = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getMaxRow_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.auths is not None:
      oprot.writeFieldBegin('auths', TType.SET, 3)
      oprot.writeSetBegin(TType.STRING, len(self.auths))
      for iter175 in self.auths:
        oprot.writeString(iter175)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    if self.startRow is not None:
      oprot.writeFieldBegin('startRow', TType.STRING, 4)
      oprot.writeString(self.startRow)
      oprot.writeFieldEnd()
    if self.startInclusive is not None:
      oprot.writeFieldBegin('startInclusive', TType.BOOL, 5)
      oprot.writeBool(self.startInclusive)
      oprot.writeFieldEnd()
    if self.endRow is not None:
      oprot.writeFieldBegin('endRow', TType.STRING, 6)
      oprot.writeString(self.endRow)
      oprot.writeFieldEnd()
    if self.endInclusive is not None:
      oprot.writeFieldBegin('endInclusive', TType.BOOL, 7)
      oprot.writeBool(self.endInclusive)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getMaxRow_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 3
  )

  def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRING:
          self.success = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = TableNotFoundException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloSecurityException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getMaxRow_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRING, 0)
      oprot.writeString(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getTableProperties_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getTableProperties_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getTableProperties_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.MAP:
          self.success = {}
          (_ktype177, _vtype178, _size176 ) = iprot.readMapBegin() 
          for _i180 in xrange(_size176):
            _key181 = iprot.readString();
            _val182 = iprot.readString();
            self.success[_key181] = _val182
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = TableNotFoundException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getTableProperties_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
      for kiter183,viter184 in self.success.items():
        oprot.writeString(kiter183)
        oprot.writeString(viter184)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getSplits_args:
  """
  Attributes:
   - login
   - tableName
   - maxSplits
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.I32, 'maxSplits', None, None, ), # 3
  )

  def __init__(self, login=None, tableName=None, maxSplits=None,):
    self.login = login
    self.tableName = tableName
    self.maxSplits = maxSplits

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.maxSplits = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getSplits_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.maxSplits is not None:
      oprot.writeFieldBegin('maxSplits', TType.I32, 3)
      oprot.writeI32(self.maxSplits)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getSplits_result:
  """
  Attributes:
   - success
   - ouch1
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, ouch1=None,):
    self.success = success
    self.ouch1 = ouch1

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.LIST:
          self.success = []
          (_etype188, _size185) = iprot.readListBegin()
          for _i189 in xrange(_size185):
            _elem190 = iprot.readString();
            self.success.append(_elem190)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = TableNotFoundException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getSplits_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRING, len(self.success))
      for iter191 in self.success:
        oprot.writeString(iter191)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class importDirectory_args:
  """
  Attributes:
   - login
   - tableName
   - importDir
   - failureDir
   - setTime
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'importDir', None, None, ), # 3
    (4, TType.STRING, 'failureDir', None, None, ), # 4
    (5, TType.BOOL, 'setTime', None, None, ), # 5
  )

  def __init__(self, login=None, tableName=None, importDir=None, failureDir=None, setTime=None,):
    self.login = login
    self.tableName = tableName
    self.importDir = importDir
    self.failureDir = failureDir
    self.setTime = setTime

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.importDir = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.failureDir = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.BOOL:
          self.setTime = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('importDirectory_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.importDir is not None:
      oprot.writeFieldBegin('importDir', TType.STRING, 3)
      oprot.writeString(self.importDir)
      oprot.writeFieldEnd()
    if self.failureDir is not None:
      oprot.writeFieldBegin('failureDir', TType.STRING, 4)
      oprot.writeString(self.failureDir)
      oprot.writeFieldEnd()
    if self.setTime is not None:
      oprot.writeFieldBegin('setTime', TType.BOOL, 5)
      oprot.writeBool(self.setTime)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class importDirectory_result:
  """
  Attributes:
   - ouch1
   - ouch3
   - ouch4
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch3', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch4', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch3=None, ouch4=None,):
    self.ouch1 = ouch1
    self.ouch3 = ouch3
    self.ouch4 = ouch4

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = TableNotFoundException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch4 = AccumuloSecurityException()
          self.ouch4.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('importDirectory_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 2)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch4 is not None:
      oprot.writeFieldBegin('ouch4', TType.STRUCT, 3)
      self.ouch4.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class importTable_args:
  """
  Attributes:
   - login
   - tableName
   - importDir
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'importDir', None, None, ), # 3
  )

  def __init__(self, login=None, tableName=None, importDir=None,):
    self.login = login
    self.tableName = tableName
    self.importDir = importDir

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.importDir = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('importTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.importDir is not None:
      oprot.writeFieldBegin('importDir', TType.STRING, 3)
      oprot.writeString(self.importDir)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class importTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (TableExistsException, TableExistsException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = TableExistsException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloSecurityException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('importTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class listTables_args:
  """
  Attributes:
   - login
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
  )

  def __init__(self, login=None,):
    self.login = login

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('listTables_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class listTables_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.SET, 'success', (TType.STRING,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.SET:
          self.success = set()
          (_etype195, _size192) = iprot.readSetBegin()
          for _i196 in xrange(_size192):
            _elem197 = iprot.readString();
            self.success.add(_elem197)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('listTables_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.SET, 0)
      oprot.writeSetBegin(TType.STRING, len(self.success))
      for iter198 in self.success:
        oprot.writeString(iter198)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class listIterators_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('listIterators_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class listIterators_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.SET,(TType.I32,None)), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.MAP:
          self.success = {}
          (_ktype200, _vtype201, _size199 ) = iprot.readMapBegin() 
          for _i203 in xrange(_size199):
            _key204 = iprot.readString();
            _val205 = set()
            (_etype209, _size206) = iprot.readSetBegin()
            for _i210 in xrange(_size206):
              _elem211 = iprot.readI32();
              _val205.add(_elem211)
            iprot.readSetEnd()
            self.success[_key204] = _val205
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('listIterators_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.SET, len(self.success))
      for kiter212,viter213 in self.success.items():
        oprot.writeString(kiter212)
        oprot.writeSetBegin(TType.I32, len(viter213))
        for iter214 in viter213:
          oprot.writeI32(iter214)
        oprot.writeSetEnd()
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class listConstraints_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('listConstraints_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class listConstraints_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.I32,None), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.MAP:
          self.success = {}
          (_ktype216, _vtype217, _size215 ) = iprot.readMapBegin() 
          for _i219 in xrange(_size215):
            _key220 = iprot.readString();
            _val221 = iprot.readI32();
            self.success[_key220] = _val221
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = TableNotFoundException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('listConstraints_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.I32, len(self.success))
      for kiter222,viter223 in self.success.items():
        oprot.writeString(kiter222)
        oprot.writeI32(viter223)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class mergeTablets_args:
  """
  Attributes:
   - login
   - tableName
   - startRow
   - endRow
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'startRow', None, None, ), # 3
    (4, TType.STRING, 'endRow', None, None, ), # 4
  )

  def __init__(self, login=None, tableName=None, startRow=None, endRow=None,):
    self.login = login
    self.tableName = tableName
    self.startRow = startRow
    self.endRow = endRow

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.startRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.endRow = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('mergeTablets_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.startRow is not None:
      oprot.writeFieldBegin('startRow', TType.STRING, 3)
      oprot.writeString(self.startRow)
      oprot.writeFieldEnd()
    if self.endRow is not None:
      oprot.writeFieldBegin('endRow', TType.STRING, 4)
      oprot.writeString(self.endRow)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class mergeTablets_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('mergeTablets_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class offlineTable_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('offlineTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class offlineTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('offlineTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class onlineTable_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('onlineTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class onlineTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('onlineTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeConstraint_args:
  """
  Attributes:
   - login
   - tableName
   - constraint
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.I32, 'constraint', None, None, ), # 3
  )

  def __init__(self, login=None, tableName=None, constraint=None,):
    self.login = login
    self.tableName = tableName
    self.constraint = constraint

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.constraint = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeConstraint_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.constraint is not None:
      oprot.writeFieldBegin('constraint', TType.I32, 3)
      oprot.writeI32(self.constraint)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeConstraint_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeConstraint_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeIterator_args:
  """
  Attributes:
   - login
   - tableName
   - iterName
   - scopes
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'iterName', None, None, ), # 3
    (4, TType.SET, 'scopes', (TType.I32,None), None, ), # 4
  )

  def __init__(self, login=None, tableName=None, iterName=None, scopes=None,):
    self.login = login
    self.tableName = tableName
    self.iterName = iterName
    self.scopes = scopes

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.iterName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.SET:
          self.scopes = set()
          (_etype227, _size224) = iprot.readSetBegin()
          for _i228 in xrange(_size224):
            _elem229 = iprot.readI32();
            self.scopes.add(_elem229)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeIterator_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.iterName is not None:
      oprot.writeFieldBegin('iterName', TType.STRING, 3)
      oprot.writeString(self.iterName)
      oprot.writeFieldEnd()
    if self.scopes is not None:
      oprot.writeFieldBegin('scopes', TType.SET, 4)
      oprot.writeSetBegin(TType.I32, len(self.scopes))
      for iter230 in self.scopes:
        oprot.writeI32(iter230)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeIterator_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloException, AccumuloException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeIterator_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeTableProperty_args:
  """
  Attributes:
   - login
   - tableName
   - property
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'property', None, None, ), # 3
  )

  def __init__(self, login=None, tableName=None, property=None,):
    self.login = login
    self.tableName = tableName
    self.property = property

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.property = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeTableProperty_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.property is not None:
      oprot.writeFieldBegin('property', TType.STRING, 3)
      oprot.writeString(self.property)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeTableProperty_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeTableProperty_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class renameTable_args:
  """
  Attributes:
   - login
   - oldTableName
   - newTableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'oldTableName', None, None, ), # 2
    (3, TType.STRING, 'newTableName', None, None, ), # 3
  )

  def __init__(self, login=None, oldTableName=None, newTableName=None,):
    self.login = login
    self.oldTableName = oldTableName
    self.newTableName = newTableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.oldTableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.newTableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('renameTable_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.oldTableName is not None:
      oprot.writeFieldBegin('oldTableName', TType.STRING, 2)
      oprot.writeString(self.oldTableName)
      oprot.writeFieldEnd()
    if self.newTableName is not None:
      oprot.writeFieldBegin('newTableName', TType.STRING, 3)
      oprot.writeString(self.newTableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class renameTable_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
   - ouch4
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloException, AccumuloException.thrift_spec), None, ), # 3
    (4, TType.STRUCT, 'ouch4', (TableExistsException, TableExistsException.thrift_spec), None, ), # 4
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None, ouch4=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3
    self.ouch4 = ouch4

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloSecurityException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = TableNotFoundException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRUCT:
          self.ouch4 = TableExistsException()
          self.ouch4.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('renameTable_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch4 is not None:
      oprot.writeFieldBegin('ouch4', TType.STRUCT, 4)
      self.ouch4.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class setLocalityGroups_args:
  """
  Attributes:
   - login
   - tableName
   - groups
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.MAP, 'groups', (TType.STRING,None,TType.SET,(TType.STRING,None)), None, ), # 3
  )

  def __init__(self, login=None, tableName=None, groups=None,):
    self.login = login
    self.tableName = tableName
    self.groups = groups

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.MAP:
          self.groups = {}
          (_ktype232, _vtype233, _size231 ) = iprot.readMapBegin() 
          for _i235 in xrange(_size231):
            _key236 = iprot.readString();
            _val237 = set()
            (_etype241, _size238) = iprot.readSetBegin()
            for _i242 in xrange(_size238):
              _elem243 = iprot.readString();
              _val237.add(_elem243)
            iprot.readSetEnd()
            self.groups[_key236] = _val237
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('setLocalityGroups_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.groups is not None:
      oprot.writeFieldBegin('groups', TType.MAP, 3)
      oprot.writeMapBegin(TType.STRING, TType.SET, len(self.groups))
      for kiter244,viter245 in self.groups.items():
        oprot.writeString(kiter244)
        oprot.writeSetBegin(TType.STRING, len(viter245))
        for iter246 in viter245:
          oprot.writeString(iter246)
        oprot.writeSetEnd()
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class setLocalityGroups_result:
  """
  Attributes:
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, ouch1=None, ouch2=None, ouch3=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('setLocalityGroups_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class setTableProperty_args:
  """
  Attributes:
   - login
   - tableName
   - property
   - value
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'property', None, None, ), # 3
    (4, TType.STRING, 'value', None, None, ), # 4
  )

  def __init__(self, login=None, tableName=None, property=None, value=None,):
    self.login = login
    self.tableName = tableName
    self.property = property
    self.value = value

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.property = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.value = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('setTableProperty_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.property is not None:
      oprot.writeFieldBegin('property', TType.STRING, 3)
      oprot.writeString(self.property)
      oprot.writeFieldEnd()
    if self.value is not None:
      oprot.writeFieldBegin('value', TType.STRING, 4)
      oprot.writeString(self.value)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class setTableProperty_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('setTableProperty_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class splitRangeByTablets_args:
  """
  Attributes:
   - login
   - tableName
   - range
   - maxSplits
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRUCT, 'range', (Range, Range.thrift_spec), None, ), # 3
    (4, TType.I32, 'maxSplits', None, None, ), # 4
  )

  def __init__(self, login=None, tableName=None, range=None, maxSplits=None,):
    self.login = login
    self.tableName = tableName
    self.range = range
    self.maxSplits = maxSplits

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.range = Range()
          self.range.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.maxSplits = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('splitRangeByTablets_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.range is not None:
      oprot.writeFieldBegin('range', TType.STRUCT, 3)
      self.range.write(oprot)
      oprot.writeFieldEnd()
    if self.maxSplits is not None:
      oprot.writeFieldBegin('maxSplits', TType.I32, 4)
      oprot.writeI32(self.maxSplits)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class splitRangeByTablets_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.SET, 'success', (TType.STRUCT,(Range, Range.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.SET:
          self.success = set()
          (_etype250, _size247) = iprot.readSetBegin()
          for _i251 in xrange(_size247):
            _elem252 = Range()
            _elem252.read(iprot)
            self.success.add(_elem252)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = TableNotFoundException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('splitRangeByTablets_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.SET, 0)
      oprot.writeSetBegin(TType.STRUCT, len(self.success))
      for iter253 in self.success:
        iter253.write(oprot)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class tableExists_args:
  """
  Attributes:
   - login
   - tableName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
  )

  def __init__(self, login=None, tableName=None,):
    self.login = login
    self.tableName = tableName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('tableExists_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class tableExists_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.BOOL:
          self.success = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('tableExists_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class tableIdMap_args:
  """
  Attributes:
   - login
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
  )

  def __init__(self, login=None,):
    self.login = login

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('tableIdMap_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class tableIdMap_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.MAP:
          self.success = {}
          (_ktype255, _vtype256, _size254 ) = iprot.readMapBegin() 
          for _i258 in xrange(_size254):
            _key259 = iprot.readString();
            _val260 = iprot.readString();
            self.success[_key259] = _val260
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('tableIdMap_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
      for kiter261,viter262 in self.success.items():
        oprot.writeString(kiter261)
        oprot.writeString(viter262)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class pingTabletServer_args:
  """
  Attributes:
   - login
   - tserver
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tserver', None, None, ), # 2
  )

  def __init__(self, login=None, tserver=None,):
    self.login = login
    self.tserver = tserver

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tserver = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('pingTabletServer_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tserver is not None:
      oprot.writeFieldBegin('tserver', TType.STRING, 2)
      oprot.writeString(self.tserver)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class pingTabletServer_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('pingTabletServer_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getActiveScans_args:
  """
  Attributes:
   - login
   - tserver
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tserver', None, None, ), # 2
  )

  def __init__(self, login=None, tserver=None,):
    self.login = login
    self.tserver = tserver

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tserver = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getActiveScans_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tserver is not None:
      oprot.writeFieldBegin('tserver', TType.STRING, 2)
      oprot.writeString(self.tserver)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getActiveScans_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(ActiveScan, ActiveScan.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.LIST:
          self.success = []
          (_etype266, _size263) = iprot.readListBegin()
          for _i267 in xrange(_size263):
            _elem268 = ActiveScan()
            _elem268.read(iprot)
            self.success.append(_elem268)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getActiveScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter269 in self.success:
        iter269.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getActiveCompactions_args:
  """
  Attributes:
   - login
   - tserver
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tserver', None, None, ), # 2
  )

  def __init__(self, login=None, tserver=None,):
    self.login = login
    self.tserver = tserver

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tserver = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getActiveCompactions_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tserver is not None:
      oprot.writeFieldBegin('tserver', TType.STRING, 2)
      oprot.writeString(self.tserver)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getActiveCompactions_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(ActiveCompaction, ActiveCompaction.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.LIST:
          self.success = []
          (_etype273, _size270) = iprot.readListBegin()
          for _i274 in xrange(_size270):
            _elem275 = ActiveCompaction()
            _elem275.read(iprot)
            self.success.append(_elem275)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getActiveCompactions_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter276 in self.success:
        iter276.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getSiteConfiguration_args:
  """
  Attributes:
   - login
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
  )

  def __init__(self, login=None,):
    self.login = login

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getSiteConfiguration_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getSiteConfiguration_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.MAP:
          self.success = {}
          (_ktype278, _vtype279, _size277 ) = iprot.readMapBegin() 
          for _i281 in xrange(_size277):
            _key282 = iprot.readString();
            _val283 = iprot.readString();
            self.success[_key282] = _val283
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getSiteConfiguration_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
      for kiter284,viter285 in self.success.items():
        oprot.writeString(kiter284)
        oprot.writeString(viter285)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getSystemConfiguration_args:
  """
  Attributes:
   - login
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
  )

  def __init__(self, login=None,):
    self.login = login

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getSystemConfiguration_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getSystemConfiguration_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.MAP:
          self.success = {}
          (_ktype287, _vtype288, _size286 ) = iprot.readMapBegin() 
          for _i290 in xrange(_size286):
            _key291 = iprot.readString();
            _val292 = iprot.readString();
            self.success[_key291] = _val292
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getSystemConfiguration_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
      for kiter293,viter294 in self.success.items():
        oprot.writeString(kiter293)
        oprot.writeString(viter294)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getTabletServers_args:
  """
  Attributes:
   - login
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
  )

  def __init__(self, login=None,):
    self.login = login

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getTabletServers_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getTabletServers_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.LIST:
          self.success = []
          (_etype298, _size295) = iprot.readListBegin()
          for _i299 in xrange(_size295):
            _elem300 = iprot.readString();
            self.success.append(_elem300)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getTabletServers_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRING, len(self.success))
      for iter301 in self.success:
        oprot.writeString(iter301)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeProperty_args:
  """
  Attributes:
   - login
   - property
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'property', None, None, ), # 2
  )

  def __init__(self, login=None, property=None,):
    self.login = login
    self.property = property

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.property = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeProperty_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.property is not None:
      oprot.writeFieldBegin('property', TType.STRING, 2)
      oprot.writeString(self.property)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeProperty_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeProperty_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class setProperty_args:
  """
  Attributes:
   - login
   - property
   - value
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'property', None, None, ), # 2
    (3, TType.STRING, 'value', None, None, ), # 3
  )

  def __init__(self, login=None, property=None, value=None,):
    self.login = login
    self.property = property
    self.value = value

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.property = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.value = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('setProperty_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.property is not None:
      oprot.writeFieldBegin('property', TType.STRING, 2)
      oprot.writeString(self.property)
      oprot.writeFieldEnd()
    if self.value is not None:
      oprot.writeFieldBegin('value', TType.STRING, 3)
      oprot.writeString(self.value)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class setProperty_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('setProperty_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class testClassLoad_args:
  """
  Attributes:
   - login
   - className
   - asTypeName
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'className', None, None, ), # 2
    (3, TType.STRING, 'asTypeName', None, None, ), # 3
  )

  def __init__(self, login=None, className=None, asTypeName=None,):
    self.login = login
    self.className = className
    self.asTypeName = asTypeName

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.className = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.asTypeName = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('testClassLoad_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.className is not None:
      oprot.writeFieldBegin('className', TType.STRING, 2)
      oprot.writeString(self.className)
      oprot.writeFieldEnd()
    if self.asTypeName is not None:
      oprot.writeFieldBegin('asTypeName', TType.STRING, 3)
      oprot.writeString(self.asTypeName)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class testClassLoad_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.BOOL:
          self.success = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('testClassLoad_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class authenticateUser_args:
  """
  Attributes:
   - login
   - user
   - properties
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.MAP, 'properties', (TType.STRING,None,TType.STRING,None), None, ), # 3
  )

  def __init__(self, login=None, user=None, properties=None,):
    self.login = login
    self.user = user
    self.properties = properties

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.MAP:
          self.properties = {}
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin() 
          for _i306 in xrange(_size302):
            _key307 = iprot.readString();
            _val308 = iprot.readString();
            self.properties[_key307] = _val308
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('authenticateUser_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.properties is not None:
      oprot.writeFieldBegin('properties', TType.MAP, 3)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties))
      for kiter309,viter310 in self.properties.items():
        oprot.writeString(kiter309)
        oprot.writeString(viter310)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class authenticateUser_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.BOOL:
          self.success = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('authenticateUser_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class changeUserAuthorizations_args:
  """
  Attributes:
   - login
   - user
   - authorizations
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.SET, 'authorizations', (TType.STRING,None), None, ), # 3
  )

  def __init__(self, login=None, user=None, authorizations=None,):
    self.login = login
    self.user = user
    self.authorizations = authorizations

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.SET:
          self.authorizations = set()
          (_etype314, _size311) = iprot.readSetBegin()
          for _i315 in xrange(_size311):
            _elem316 = iprot.readString();
            self.authorizations.add(_elem316)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('changeUserAuthorizations_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.authorizations is not None:
      oprot.writeFieldBegin('authorizations', TType.SET, 3)
      oprot.writeSetBegin(TType.STRING, len(self.authorizations))
      for iter317 in self.authorizations:
        oprot.writeString(iter317)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class changeUserAuthorizations_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('changeUserAuthorizations_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class changeLocalUserPassword_args:
  """
  Attributes:
   - login
   - user
   - password
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.STRING, 'password', None, None, ), # 3
  )

  def __init__(self, login=None, user=None, password=None,):
    self.login = login
    self.user = user
    self.password = password

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.password = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('changeLocalUserPassword_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.password is not None:
      oprot.writeFieldBegin('password', TType.STRING, 3)
      oprot.writeString(self.password)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class changeLocalUserPassword_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('changeLocalUserPassword_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createLocalUser_args:
  """
  Attributes:
   - login
   - user
   - password
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.STRING, 'password', None, None, ), # 3
  )

  def __init__(self, login=None, user=None, password=None,):
    self.login = login
    self.user = user
    self.password = password

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.password = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createLocalUser_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.password is not None:
      oprot.writeFieldBegin('password', TType.STRING, 3)
      oprot.writeString(self.password)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createLocalUser_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createLocalUser_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class dropLocalUser_args:
  """
  Attributes:
   - login
   - user
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
  )

  def __init__(self, login=None, user=None,):
    self.login = login
    self.user = user

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('dropLocalUser_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class dropLocalUser_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('dropLocalUser_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getUserAuthorizations_args:
  """
  Attributes:
   - login
   - user
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
  )

  def __init__(self, login=None, user=None,):
    self.login = login
    self.user = user

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getUserAuthorizations_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getUserAuthorizations_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.LIST:
          self.success = []
          (_etype321, _size318) = iprot.readListBegin()
          for _i322 in xrange(_size318):
            _elem323 = iprot.readString();
            self.success.append(_elem323)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getUserAuthorizations_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRING, len(self.success))
      for iter324 in self.success:
        oprot.writeString(iter324)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class grantSystemPermission_args:
  """
  Attributes:
   - login
   - user
   - perm
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.I32, 'perm', None, None, ), # 3
  )

  def __init__(self, login=None, user=None, perm=None,):
    self.login = login
    self.user = user
    self.perm = perm

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.perm = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('grantSystemPermission_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.perm is not None:
      oprot.writeFieldBegin('perm', TType.I32, 3)
      oprot.writeI32(self.perm)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class grantSystemPermission_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('grantSystemPermission_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class grantTablePermission_args:
  """
  Attributes:
   - login
   - user
   - table
   - perm
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.STRING, 'table', None, None, ), # 3
    (4, TType.I32, 'perm', None, None, ), # 4
  )

  def __init__(self, login=None, user=None, table=None, perm=None,):
    self.login = login
    self.user = user
    self.table = table
    self.perm = perm

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.table = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.perm = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('grantTablePermission_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.table is not None:
      oprot.writeFieldBegin('table', TType.STRING, 3)
      oprot.writeString(self.table)
      oprot.writeFieldEnd()
    if self.perm is not None:
      oprot.writeFieldBegin('perm', TType.I32, 4)
      oprot.writeI32(self.perm)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class grantTablePermission_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('grantTablePermission_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class hasSystemPermission_args:
  """
  Attributes:
   - login
   - user
   - perm
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.I32, 'perm', None, None, ), # 3
  )

  def __init__(self, login=None, user=None, perm=None,):
    self.login = login
    self.user = user
    self.perm = perm

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.perm = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('hasSystemPermission_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.perm is not None:
      oprot.writeFieldBegin('perm', TType.I32, 3)
      oprot.writeI32(self.perm)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class hasSystemPermission_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.BOOL:
          self.success = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('hasSystemPermission_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class hasTablePermission_args:
  """
  Attributes:
   - login
   - user
   - table
   - perm
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.STRING, 'table', None, None, ), # 3
    (4, TType.I32, 'perm', None, None, ), # 4
  )

  def __init__(self, login=None, user=None, table=None, perm=None,):
    self.login = login
    self.user = user
    self.table = table
    self.perm = perm

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.table = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.perm = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('hasTablePermission_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.table is not None:
      oprot.writeFieldBegin('table', TType.STRING, 3)
      oprot.writeString(self.table)
      oprot.writeFieldEnd()
    if self.perm is not None:
      oprot.writeFieldBegin('perm', TType.I32, 4)
      oprot.writeI32(self.perm)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class hasTablePermission_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.BOOL:
          self.success = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('hasTablePermission_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class listLocalUsers_args:
  """
  Attributes:
   - login
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
  )

  def __init__(self, login=None,):
    self.login = login

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('listLocalUsers_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class listLocalUsers_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.SET, 'success', (TType.STRING,None), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.SET:
          self.success = set()
          (_etype328, _size325) = iprot.readSetBegin()
          for _i329 in xrange(_size325):
            _elem330 = iprot.readString();
            self.success.add(_elem330)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('listLocalUsers_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.SET, 0)
      oprot.writeSetBegin(TType.STRING, len(self.success))
      for iter331 in self.success:
        oprot.writeString(iter331)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class revokeSystemPermission_args:
  """
  Attributes:
   - login
   - user
   - perm
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.I32, 'perm', None, None, ), # 3
  )

  def __init__(self, login=None, user=None, perm=None,):
    self.login = login
    self.user = user
    self.perm = perm

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.perm = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('revokeSystemPermission_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.perm is not None:
      oprot.writeFieldBegin('perm', TType.I32, 3)
      oprot.writeI32(self.perm)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class revokeSystemPermission_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('revokeSystemPermission_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class revokeTablePermission_args:
  """
  Attributes:
   - login
   - user
   - table
   - perm
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.STRING, 'table', None, None, ), # 3
    (4, TType.I32, 'perm', None, None, ), # 4
  )

  def __init__(self, login=None, user=None, table=None, perm=None,):
    self.login = login
    self.user = user
    self.table = table
    self.perm = perm

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.table = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.perm = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('revokeTablePermission_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.table is not None:
      oprot.writeFieldBegin('table', TType.STRING, 3)
      oprot.writeString(self.table)
      oprot.writeFieldEnd()
    if self.perm is not None:
      oprot.writeFieldBegin('perm', TType.I32, 4)
      oprot.writeI32(self.perm)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class revokeTablePermission_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('revokeTablePermission_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createBatchScanner_args:
  """
  Attributes:
   - login
   - tableName
   - options
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRUCT, 'options', (BatchScanOptions, BatchScanOptions.thrift_spec), None, ), # 3
  )

  def __init__(self, login=None, tableName=None, options=None,):
    self.login = login
    self.tableName = tableName
    self.options = options

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.options = BatchScanOptions()
          self.options.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createBatchScanner_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.options is not None:
      oprot.writeFieldBegin('options', TType.STRUCT, 3)
      self.options.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createBatchScanner_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRING:
          self.success = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createBatchScanner_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRING, 0)
      oprot.writeString(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createScanner_args:
  """
  Attributes:
   - login
   - tableName
   - options
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRUCT, 'options', (ScanOptions, ScanOptions.thrift_spec), None, ), # 3
  )

  def __init__(self, login=None, tableName=None, options=None,):
    self.login = login
    self.tableName = tableName
    self.options = options

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.options = ScanOptions()
          self.options.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createScanner_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.options is not None:
      oprot.writeFieldBegin('options', TType.STRUCT, 3)
      self.options.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createScanner_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, ouch1=None, ouch2=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRING:
          self.success = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = AccumuloException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createScanner_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRING, 0)
      oprot.writeString(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class hasNext_args:
  """
  Attributes:
   - scanner
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'scanner', None, None, ), # 1
  )

  def __init__(self, scanner=None,):
    self.scanner = scanner

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.scanner = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('hasNext_args')
    if self.scanner is not None:
      oprot.writeFieldBegin('scanner', TType.STRING, 1)
      oprot.writeString(self.scanner)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class hasNext_result:
  """
  Attributes:
   - success
   - ouch1
  """

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ouch1', (UnknownScanner, UnknownScanner.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, ouch1=None,):
    self.success = success
    self.ouch1 = ouch1

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.BOOL:
          self.success = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = UnknownScanner()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('hasNext_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class nextEntry_args:
  """
  Attributes:
   - scanner
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'scanner', None, None, ), # 1
  )

  def __init__(self, scanner=None,):
    self.scanner = scanner

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.scanner = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('nextEntry_args')
    if self.scanner is not None:
      oprot.writeFieldBegin('scanner', TType.STRING, 1)
      oprot.writeString(self.scanner)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class nextEntry_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (KeyValueAndPeek, KeyValueAndPeek.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (NoMoreEntriesException, NoMoreEntriesException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (UnknownScanner, UnknownScanner.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 3
  )

  def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = KeyValueAndPeek()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = NoMoreEntriesException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = UnknownScanner()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloSecurityException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('nextEntry_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class nextK_args:
  """
  Attributes:
   - scanner
   - k
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'scanner', None, None, ), # 1
    (2, TType.I32, 'k', None, None, ), # 2
  )

  def __init__(self, scanner=None, k=None,):
    self.scanner = scanner
    self.k = k

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.scanner = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.k = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('nextK_args')
    if self.scanner is not None:
      oprot.writeFieldBegin('scanner', TType.STRING, 1)
      oprot.writeString(self.scanner)
      oprot.writeFieldEnd()
    if self.k is not None:
      oprot.writeFieldBegin('k', TType.I32, 2)
      oprot.writeI32(self.k)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class nextK_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (ScanResult, ScanResult.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (NoMoreEntriesException, NoMoreEntriesException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (UnknownScanner, UnknownScanner.thrift_spec), None, ), # 2
    (3, TType.STRUCT, 'ouch3', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 3
  )

  def __init__(self, success=None, ouch1=None, ouch2=None, ouch3=None,):
    self.success = success
    self.ouch1 = ouch1
    self.ouch2 = ouch2
    self.ouch3 = ouch3

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = ScanResult()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = NoMoreEntriesException()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = UnknownScanner()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.ouch3 = AccumuloSecurityException()
          self.ouch3.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('nextK_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch3 is not None:
      oprot.writeFieldBegin('ouch3', TType.STRUCT, 3)
      self.ouch3.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class closeScanner_args:
  """
  Attributes:
   - scanner
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'scanner', None, None, ), # 1
  )

  def __init__(self, scanner=None,):
    self.scanner = scanner

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.scanner = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('closeScanner_args')
    if self.scanner is not None:
      oprot.writeFieldBegin('scanner', TType.STRING, 1)
      oprot.writeString(self.scanner)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class closeScanner_result:
  """
  Attributes:
   - ouch1
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (UnknownScanner, UnknownScanner.thrift_spec), None, ), # 1
  )

  def __init__(self, ouch1=None,):
    self.ouch1 = ouch1

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = UnknownScanner()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('closeScanner_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class updateAndFlush_args:
  """
  Attributes:
   - login
   - tableName
   - cells
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.MAP, 'cells', (TType.STRING,None,TType.LIST,(TType.STRUCT,(ColumnUpdate, ColumnUpdate.thrift_spec))), None, ), # 3
  )

  def __init__(self, login=None, tableName=None, cells=None,):
    self.login = login
    self.tableName = tableName
    self.cells = cells

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.MAP:
          self.cells = {}
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin() 
          for _i336 in xrange(_size332):
            _key337 = iprot.readString();
            _val338 = []
            (_etype342, _size339) = iprot.readListBegin()
            for _i343 in xrange(_size339):
              _elem344 = ColumnUpdate()
              _elem344.read(iprot)
              _val338.append(_elem344)
            iprot.readListEnd()
            self.cells[_key337] = _val338
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('updateAndFlush_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.cells is not None:
      oprot.writeFieldBegin('cells', TType.MAP, 3)
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.cells))
      for kiter345,viter346 in self.cells.items():
        oprot.writeString(kiter345)
        oprot.writeListBegin(TType.STRUCT, len(viter346))
        for iter347 in viter346:
          iter347.write(oprot)
        oprot.writeListEnd()
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class updateAndFlush_result:
  """
  Attributes:
   - outch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'outch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, outch1=None, ouch2=None,):
    self.outch1 = outch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.outch1 = AccumuloException()
          self.outch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('updateAndFlush_result')
    if self.outch1 is not None:
      oprot.writeFieldBegin('outch1', TType.STRUCT, 1)
      self.outch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createWriter_args:
  """
  Attributes:
   - login
   - tableName
   - opts
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRUCT, 'opts', (WriterOptions, WriterOptions.thrift_spec), None, ), # 3
  )

  def __init__(self, login=None, tableName=None, opts=None,):
    self.login = login
    self.tableName = tableName
    self.opts = opts

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.login = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.opts = WriterOptions()
          self.opts.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createWriter_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.opts is not None:
      oprot.writeFieldBegin('opts', TType.STRUCT, 3)
      self.opts.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createWriter_result:
  """
  Attributes:
   - success
   - outch1
   - ouch2
  """

  thrift_spec = (
    (0, TType.STRING, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'outch1', (AccumuloException, AccumuloException.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, success=None, outch1=None, ouch2=None,):
    self.success = success
    self.outch1 = outch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRING:
          self.success = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.outch1 = AccumuloException()
          self.outch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createWriter_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRING, 0)
      oprot.writeString(self.success)
      oprot.writeFieldEnd()
    if self.outch1 is not None:
      oprot.writeFieldBegin('outch1', TType.STRUCT, 1)
      self.outch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class update_args:
  """
  Attributes:
   - writer
   - cells
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'writer', None, None, ), # 1
    (2, TType.MAP, 'cells', (TType.STRING,None,TType.LIST,(TType.STRUCT,(ColumnUpdate, ColumnUpdate.thrift_spec))), None, ), # 2
  )

  def __init__(self, writer=None, cells=None,):
    self.writer = writer
    self.cells = cells

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.writer = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.MAP:
          self.cells = {}
          (_ktype349, _vtype350, _size348 ) = iprot.readMapBegin() 
          for _i352 in xrange(_size348):
            _key353 = iprot.readString();
            _val354 = []
            (_etype358, _size355) = iprot.readListBegin()
            for _i359 in xrange(_size355):
              _elem360 = ColumnUpdate()
              _elem360.read(iprot)
              _val354.append(_elem360)
            iprot.readListEnd()
            self.cells[_key353] = _val354
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('update_args')
    if self.writer is not None:
      oprot.writeFieldBegin('writer', TType.STRING, 1)
      oprot.writeString(self.writer)
      oprot.writeFieldEnd()
    if self.cells is not None:
      oprot.writeFieldBegin('cells', TType.MAP, 2)
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.cells))
      for kiter361,viter362 in self.cells.items():
        oprot.writeString(kiter361)
        oprot.writeListBegin(TType.STRUCT, len(viter362))
        for iter363 in viter362:
          iter363.write(oprot)
        oprot.writeListEnd()
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class flush_args:
  """
  Attributes:
   - writer
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'writer', None, None, ), # 1
  )

  def __init__(self, writer=None,):
    self.writer = writer

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.writer = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('flush_args')
    if self.writer is not None:
      oprot.writeFieldBegin('writer', TType.STRING, 1)
      oprot.writeString(self.writer)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class flush_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (UnknownWriter, UnknownWriter.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = UnknownWriter()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('flush_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class closeWriter_args:
  """
  Attributes:
   - writer
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'writer', None, None, ), # 1
  )

  def __init__(self, writer=None,):
    self.writer = writer

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.writer = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('closeWriter_args')
    if self.writer is not None:
      oprot.writeFieldBegin('writer', TType.STRING, 1)
      oprot.writeString(self.writer)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class closeWriter_result:
  """
  Attributes:
   - ouch1
   - ouch2
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ouch1', (UnknownWriter, UnknownWriter.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'ouch2', (AccumuloSecurityException, AccumuloSecurityException.thrift_spec), None, ), # 2
  )

  def __init__(self, ouch1=None, ouch2=None,):
    self.ouch1 = ouch1
    self.ouch2 = ouch2

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.ouch1 = UnknownWriter()
          self.ouch1.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.ouch2 = AccumuloSecurityException()
          self.ouch2.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('closeWriter_result')
    if self.ouch1 is not None:
      oprot.writeFieldBegin('ouch1', TType.STRUCT, 1)
      self.ouch1.write(oprot)
      oprot.writeFieldEnd()
    if self.ouch2 is not None:
      oprot.writeFieldBegin('ouch2', TType.STRUCT, 2)
      self.ouch2.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getRowRange_args:
  """
  Attributes:
   - row
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
  )

  def __init__(self, row=None,):
    self.row = row

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.row = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getRowRange_args')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getRowRange_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Range, Range.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Range()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getRowRange_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getFollowing_args:
  """
  Attributes:
   - key
   - part
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'key', (Key, Key.thrift_spec), None, ), # 1
    (2, TType.I32, 'part', None, None, ), # 2
  )

  def __init__(self, key=None, part=None,):
    self.key = key
    self.part = part

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.key = Key()
          self.key.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.part = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getFollowing_args')
    if self.key is not None:
      oprot.writeFieldBegin('key', TType.STRUCT, 1)
      self.key.write(oprot)
      oprot.writeFieldEnd()
    if self.part is not None:
      oprot.writeFieldBegin('part', TType.I32, 2)
      oprot.writeI32(self.part)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getFollowing_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Key, Key.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Key()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getFollowing_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)
