# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Autogenerated by Thrift Compiler (0.9.1)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  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, compactionStrategy):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
     - iterators
     - flush
     - wait
     - compactionStrategy
    """
    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 getDiskUsage(self, login, tables):
    """
    Parameters:
     - login
     - tables
    """
    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 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 listSplits(self, login, tableName, maxSplits):
    """
    Parameters:
     - login
     - tableName
     - maxSplits
    """
    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, wait):
    """
    Parameters:
     - login
     - tableName
     - wait
    """
    pass

  def onlineTable(self, login, tableName, wait):
    """
    Parameters:
     - login
     - tableName
     - wait
    """
    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 testTableClassLoad(self, login, tableName, className, asTypeName):
    """
    Parameters:
     - login
     - tableName
     - className
     - asTypeName
    """
    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 updateRowConditionally(self, login, tableName, row, updates):
    """
    Parameters:
     - login
     - tableName
     - row
     - updates
    """
    pass

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

  def updateRowsConditionally(self, conditionalWriter, updates):
    """
    Parameters:
     - conditionalWriter
     - updates
    """
    pass

  def closeConditionalWriter(self, conditionalWriter):
    """
    Parameters:
     - conditionalWriter
    """
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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, compactionStrategy):
    """
    Parameters:
     - login
     - tableName
     - startRow
     - endRow
     - iterators
     - flush
     - wait
     - compactionStrategy
    """
    self.send_compactTable(login, tableName, startRow, endRow, iterators, flush, wait, compactionStrategy)
    self.recv_compactTable()

  def send_compactTable(self, login, tableName, startRow, endRow, iterators, flush, wait, compactionStrategy):
    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.compactionStrategy = compactionStrategy
    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
    if result.ouch3 is not None:
      raise result.ouch3
    return

  def getDiskUsage(self, login, tables):
    """
    Parameters:
     - login
     - tables
    """
    self.send_getDiskUsage(login, tables)
    return self.recv_getDiskUsage()

  def send_getDiskUsage(self, login, tables):
    self._oprot.writeMessageBegin('getDiskUsage', TMessageType.CALL, self._seqid)
    args = getDiskUsage_args()
    args.login = login
    args.tables = tables
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getDiskUsage(self):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getDiskUsage_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, "getDiskUsage failed: unknown result");

  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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableProperties 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 listSplits(self, login, tableName, maxSplits):
    """
    Parameters:
     - login
     - tableName
     - maxSplits
    """
    self.send_listSplits(login, tableName, maxSplits)
    return self.recv_listSplits()

  def send_listSplits(self, login, tableName, maxSplits):
    self._oprot.writeMessageBegin('listSplits', TMessageType.CALL, self._seqid)
    args = listSplits_args()
    args.login = login
    args.tableName = tableName
    args.maxSplits = maxSplits
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_listSplits(self):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = listSplits_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, "listSplits failed: unknown result");

  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
    if result.ouch3 is not None:
      raise result.ouch3
    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, wait):
    """
    Parameters:
     - login
     - tableName
     - wait
    """
    self.send_offlineTable(login, tableName, wait)
    self.recv_offlineTable()

  def send_offlineTable(self, login, tableName, wait):
    self._oprot.writeMessageBegin('offlineTable', TMessageType.CALL, self._seqid)
    args = offlineTable_args()
    args.login = login
    args.tableName = tableName
    args.wait = wait
    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, wait):
    """
    Parameters:
     - login
     - tableName
     - wait
    """
    self.send_onlineTable(login, tableName, wait)
    self.recv_onlineTable()

  def send_onlineTable(self, login, tableName, wait):
    self._oprot.writeMessageBegin('onlineTable', TMessageType.CALL, self._seqid)
    args = onlineTable_args()
    args.login = login
    args.tableName = tableName
    args.wait = wait
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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 testTableClassLoad(self, login, tableName, className, asTypeName):
    """
    Parameters:
     - login
     - tableName
     - className
     - asTypeName
    """
    self.send_testTableClassLoad(login, tableName, className, asTypeName)
    return self.recv_testTableClassLoad()

  def send_testTableClassLoad(self, login, tableName, className, asTypeName):
    self._oprot.writeMessageBegin('testTableClassLoad', TMessageType.CALL, self._seqid)
    args = testTableClassLoad_args()
    args.login = login
    args.tableName = tableName
    args.className = className
    args.asTypeName = asTypeName
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_testTableClassLoad(self):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = testTableClassLoad_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, "testTableClassLoad 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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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
    if result.ouch3 is not None:
      raise result.ouch3
    if result.ouch4 is not None:
      raise result.ouch4
    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
    if result.ouch3 is not None:
      raise result.ouch3
    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 updateRowConditionally(self, login, tableName, row, updates):
    """
    Parameters:
     - login
     - tableName
     - row
     - updates
    """
    self.send_updateRowConditionally(login, tableName, row, updates)
    return self.recv_updateRowConditionally()

  def send_updateRowConditionally(self, login, tableName, row, updates):
    self._oprot.writeMessageBegin('updateRowConditionally', TMessageType.CALL, self._seqid)
    args = updateRowConditionally_args()
    args.login = login
    args.tableName = tableName
    args.row = row
    args.updates = updates
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_updateRowConditionally(self):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = updateRowConditionally_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, "updateRowConditionally failed: unknown result");

  def createConditionalWriter(self, login, tableName, options):
    """
    Parameters:
     - login
     - tableName
     - options
    """
    self.send_createConditionalWriter(login, tableName, options)
    return self.recv_createConditionalWriter()

  def send_createConditionalWriter(self, login, tableName, options):
    self._oprot.writeMessageBegin('createConditionalWriter', TMessageType.CALL, self._seqid)
    args = createConditionalWriter_args()
    args.login = login
    args.tableName = tableName
    args.options = options
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createConditionalWriter(self):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createConditionalWriter_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, "createConditionalWriter failed: unknown result");

  def updateRowsConditionally(self, conditionalWriter, updates):
    """
    Parameters:
     - conditionalWriter
     - updates
    """
    self.send_updateRowsConditionally(conditionalWriter, updates)
    return self.recv_updateRowsConditionally()

  def send_updateRowsConditionally(self, conditionalWriter, updates):
    self._oprot.writeMessageBegin('updateRowsConditionally', TMessageType.CALL, self._seqid)
    args = updateRowsConditionally_args()
    args.conditionalWriter = conditionalWriter
    args.updates = updates
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_updateRowsConditionally(self):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = updateRowsConditionally_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, "updateRowsConditionally failed: unknown result");

  def closeConditionalWriter(self, conditionalWriter):
    """
    Parameters:
     - conditionalWriter
    """
    self.send_closeConditionalWriter(conditionalWriter)
    self.recv_closeConditionalWriter()

  def send_closeConditionalWriter(self, conditionalWriter):
    self._oprot.writeMessageBegin('closeConditionalWriter', TMessageType.CALL, self._seqid)
    args = closeConditionalWriter_args()
    args.conditionalWriter = conditionalWriter
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_closeConditionalWriter(self):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = closeConditionalWriter_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    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["getDiskUsage"] = Processor.process_getDiskUsage
    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["importDirectory"] = Processor.process_importDirectory
    self._processMap["importTable"] = Processor.process_importTable
    self._processMap["listSplits"] = Processor.process_listSplits
    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["testTableClassLoad"] = Processor.process_testTableClassLoad
    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["updateRowConditionally"] = Processor.process_updateRowConditionally
    self._processMap["createConditionalWriter"] = Processor.process_createConditionalWriter
    self._processMap["updateRowsConditionally"] = Processor.process_updateRowsConditionally
    self._processMap["closeConditionalWriter"] = Processor.process_closeConditionalWriter
    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, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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 AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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 AccumuloSecurityException, ouch1:
      result.ouch1 = ouch1
    except AccumuloException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    except TableExistsException, 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, args.compactionStrategy)
    except AccumuloSecurityException, ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException, ouch2:
      result.ouch2 = ouch2
    except AccumuloException, 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, ouch1:
      result.ouch1 = ouch1
    except TableNotFoundException, ouch2:
      result.ouch2 = ouch2
    except AccumuloException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableExistsException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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 AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("flushTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getDiskUsage(self, seqid, iprot, oprot):
    args = getDiskUsage_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getDiskUsage_result()
    try:
      result.success = self._handler.getDiskUsage(args.login, args.tables)
    except AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("getDiskUsage", 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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 AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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 AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("getTableProperties", 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloException, ouch3:
      result.ouch3 = ouch3
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloException, ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("importTable", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_listSplits(self, seqid, iprot, oprot):
    args = listSplits_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = listSplits_result()
    try:
      result.success = self._handler.listSplits(args.login, args.tableName, args.maxSplits)
    except AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("listSplits", 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 AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, args.wait)
    except AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, args.wait)
    except AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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 AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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 AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    except TableExistsException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, 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_testTableClassLoad(self, seqid, iprot, oprot):
    args = testTableClassLoad_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = testTableClassLoad_result()
    try:
      result.success = self._handler.testTableClassLoad(args.login, args.tableName, args.className, args.asTypeName)
    except AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("testTableClassLoad", 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, 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, ouch1:
      result.ouch1 = ouch1
    except UnknownScanner, ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException, 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, ouch1:
      result.ouch1 = ouch1
    except UnknownScanner, ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException, 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, 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, outch1:
      result.outch1 = outch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    except MutationsRejectedException, ouch4:
      result.ouch4 = ouch4
    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, outch1:
      result.outch1 = outch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    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, ouch1:
      result.ouch1 = ouch1
    except MutationsRejectedException, 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, ouch1:
      result.ouch1 = ouch1
    except MutationsRejectedException, ouch2:
      result.ouch2 = ouch2
    oprot.writeMessageBegin("closeWriter", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_updateRowConditionally(self, seqid, iprot, oprot):
    args = updateRowConditionally_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = updateRowConditionally_result()
    try:
      result.success = self._handler.updateRowConditionally(args.login, args.tableName, args.row, args.updates)
    except AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("updateRowConditionally", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createConditionalWriter(self, seqid, iprot, oprot):
    args = createConditionalWriter_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createConditionalWriter_result()
    try:
      result.success = self._handler.createConditionalWriter(args.login, args.tableName, args.options)
    except AccumuloException, ouch1:
      result.ouch1 = ouch1
    except AccumuloSecurityException, ouch2:
      result.ouch2 = ouch2
    except TableNotFoundException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("createConditionalWriter", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_updateRowsConditionally(self, seqid, iprot, oprot):
    args = updateRowsConditionally_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = updateRowsConditionally_result()
    try:
      result.success = self._handler.updateRowsConditionally(args.conditionalWriter, args.updates)
    except UnknownWriter, ouch1:
      result.ouch1 = ouch1
    except AccumuloException, ouch2:
      result.ouch2 = ouch2
    except AccumuloSecurityException, ouch3:
      result.ouch3 = ouch3
    oprot.writeMessageBegin("updateRowsConditionally", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_closeConditionalWriter(self, seqid, iprot, oprot):
    args = closeConditionalWriter_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = closeConditionalWriter_result()
    self._handler.closeConditionalWriter(args.conditionalWriter)
    oprot.writeMessageBegin("closeConditionalWriter", 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 = {}
          (_ktype145, _vtype146, _size144 ) = iprot.readMapBegin()
          for _i148 in xrange(_size144):
            _key149 = iprot.readString();
            _val150 = iprot.readString();
            self.loginProperties[_key149] = _val150
          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 kiter151,viter152 in self.loginProperties.items():
        oprot.writeString(kiter151)
        oprot.writeString(viter152)
      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()
          (_etype156, _size153) = iprot.readSetBegin()
          for _i157 in xrange(_size153):
            _elem158 = iprot.readString();
            self.splits.add(_elem158)
          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 iter159 in self.splits:
        oprot.writeString(iter159)
      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', (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('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()
          (_etype163, _size160) = iprot.readSetBegin()
          for _i164 in xrange(_size160):
            _elem165 = iprot.readI32();
            self.scopes.add(_elem165)
          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 iter166 in self.scopes:
        oprot.writeI32(iter166)
      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()
          (_etype170, _size167) = iprot.readSetBegin()
          for _i171 in xrange(_size167):
            _elem172 = iprot.readI32();
            self.scopes.add(_elem172)
          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 iter173 in self.scopes:
        oprot.writeI32(iter173)
      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
   - 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('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()
    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 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 = {}
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
          for _i178 in xrange(_size174):
            _key179 = iprot.readString();
            _val180 = iprot.readString();
            self.propertiesToSet[_key179] = _val180
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.SET:
          self.propertiesToExclude = set()
          (_etype184, _size181) = iprot.readSetBegin()
          for _i185 in xrange(_size181):
            _elem186 = iprot.readString();
            self.propertiesToExclude.add(_elem186)
          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 kiter187,viter188 in self.propertiesToSet.items():
        oprot.writeString(kiter187)
        oprot.writeString(viter188)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.propertiesToExclude is not None:
      oprot.writeFieldBegin('propertiesToExclude', TType.SET, 6)
      oprot.writeSetBegin(TType.STRING, len(self.propertiesToExclude))
      for iter189 in self.propertiesToExclude:
        oprot.writeString(iter189)
      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
   - compactionStrategy
  """

  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
    (8, TType.STRUCT, 'compactionStrategy', (CompactionStrategyConfig, CompactionStrategyConfig.thrift_spec), None, ), # 8
  )

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

  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 = []
          (_etype193, _size190) = iprot.readListBegin()
          for _i194 in xrange(_size190):
            _elem195 = IteratorSetting()
            _elem195.read(iprot)
            self.iterators.append(_elem195)
          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)
      elif fid == 8:
        if ftype == TType.STRUCT:
          self.compactionStrategy = CompactionStrategyConfig()
          self.compactionStrategy.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_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 iter196 in self.iterators:
        iter196.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()
    if self.compactionStrategy is not None:
      oprot.writeFieldBegin('compactionStrategy', TType.STRUCT, 8)
      self.compactionStrategy.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_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', (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('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
   - 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('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()
    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 getDiskUsage_args:
  """
  Attributes:
   - login
   - tables
  """

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

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

  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.SET:
          self.tables = set()
          (_etype200, _size197) = iprot.readSetBegin()
          for _i201 in xrange(_size197):
            _elem202 = iprot.readString();
            self.tables.add(_elem202)
          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('getDiskUsage_args')
    if self.login is not None:
      oprot.writeFieldBegin('login', TType.STRING, 1)
      oprot.writeString(self.login)
      oprot.writeFieldEnd()
    if self.tables is not None:
      oprot.writeFieldBegin('tables', TType.SET, 2)
      oprot.writeSetBegin(TType.STRING, len(self.tables))
      for iter203 in self.tables:
        oprot.writeString(iter203)
      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 getDiskUsage_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(DiskUsage, DiskUsage.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.LIST:
          self.success = []
          (_etype207, _size204) = iprot.readListBegin()
          for _i208 in xrange(_size204):
            _elem209 = DiskUsage()
            _elem209.read(iprot)
            self.success.append(_elem209)
          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)
      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('getDiskUsage_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter210 in self.success:
        iter210.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()
    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 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
   - ouch3
  """

  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', (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.MAP:
          self.success = {}
          (_ktype212, _vtype213, _size211 ) = iprot.readMapBegin()
          for _i215 in xrange(_size211):
            _key216 = iprot.readString();
            _val217 = set()
            (_etype221, _size218) = iprot.readSetBegin()
            for _i222 in xrange(_size218):
              _elem223 = iprot.readString();
              _val217.add(_elem223)
            iprot.readSetEnd()
            self.success[_key216] = _val217
          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)
      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('getLocalityGroups_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.SET, len(self.success))
      for kiter224,viter225 in self.success.items():
        oprot.writeString(kiter224)
        oprot.writeSetBegin(TType.STRING, len(viter225))
        for iter226 in viter225:
          oprot.writeString(iter226)
        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 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', (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.STRUCT:
          self.success = IteratorSetting()
          self.success.read(iprot)
        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('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()
          (_etype230, _size227) = iprot.readSetBegin()
          for _i231 in xrange(_size227):
            _elem232 = iprot.readString();
            self.auths.add(_elem232)
          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 iter233 in self.auths:
        oprot.writeString(iter233)
      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', (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.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)
      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('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
   - ouch3
  """

  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
    (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 = {}
          (_ktype235, _vtype236, _size234 ) = iprot.readMapBegin()
          for _i238 in xrange(_size234):
            _key239 = iprot.readString();
            _val240 = iprot.readString();
            self.success[_key239] = _val240
          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)
      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('getTableProperties_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
      for kiter241,viter242 in self.success.items():
        oprot.writeString(kiter241)
        oprot.writeString(viter242)
      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 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 listSplits_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('listSplits_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 listSplits_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  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
    (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.LIST:
          self.success = []
          (_etype246, _size243) = iprot.readListBegin()
          for _i247 in xrange(_size243):
            _elem248 = iprot.readString();
            self.success.append(_elem248)
          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)
      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('listSplits_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRING, len(self.success))
      for iter249 in self.success:
        oprot.writeString(iter249)
      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()
    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()
          (_etype253, _size250) = iprot.readSetBegin()
          for _i254 in xrange(_size250):
            _elem255 = iprot.readString();
            self.success.add(_elem255)
          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 iter256 in self.success:
        oprot.writeString(iter256)
      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', (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.MAP:
          self.success = {}
          (_ktype258, _vtype259, _size257 ) = iprot.readMapBegin()
          for _i261 in xrange(_size257):
            _key262 = iprot.readString();
            _val263 = set()
            (_etype267, _size264) = iprot.readSetBegin()
            for _i268 in xrange(_size264):
              _elem269 = iprot.readI32();
              _val263.add(_elem269)
            iprot.readSetEnd()
            self.success[_key262] = _val263
          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)
      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 kiter270,viter271 in self.success.items():
        oprot.writeString(kiter270)
        oprot.writeSetBegin(TType.I32, len(viter271))
        for iter272 in viter271:
          oprot.writeI32(iter272)
        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
   - ouch3
  """

  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', (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.MAP:
          self.success = {}
          (_ktype274, _vtype275, _size273 ) = iprot.readMapBegin()
          for _i277 in xrange(_size273):
            _key278 = iprot.readString();
            _val279 = iprot.readI32();
            self.success[_key278] = _val279
          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)
      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('listConstraints_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.I32, len(self.success))
      for kiter280,viter281 in self.success.items():
        oprot.writeString(kiter280)
        oprot.writeI32(viter281)
      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 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
   - wait
  """

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

  def __init__(self, login=None, tableName=None, wait=thrift_spec[3][4],):
    self.login = login
    self.tableName = tableName
    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.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('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()
    if self.wait is not None:
      oprot.writeFieldBegin('wait', TType.BOOL, 3)
      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 offlineTable_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('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
   - wait
  """

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

  def __init__(self, login=None, tableName=None, wait=thrift_spec[3][4],):
    self.login = login
    self.tableName = tableName
    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.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('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()
    if self.wait is not None:
      oprot.writeFieldBegin('wait', TType.BOOL, 3)
      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 onlineTable_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('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
   - 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('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()
    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 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()
          (_etype285, _size282) = iprot.readSetBegin()
          for _i286 in xrange(_size282):
            _elem287 = iprot.readI32();
            self.scopes.add(_elem287)
          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 iter288 in self.scopes:
        oprot.writeI32(iter288)
      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', (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('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
   - 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('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()
    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 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', (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('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 = {}
          (_ktype290, _vtype291, _size289 ) = iprot.readMapBegin()
          for _i293 in xrange(_size289):
            _key294 = iprot.readString();
            _val295 = set()
            (_etype299, _size296) = iprot.readSetBegin()
            for _i300 in xrange(_size296):
              _elem301 = iprot.readString();
              _val295.add(_elem301)
            iprot.readSetEnd()
            self.groups[_key294] = _val295
          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 kiter302,viter303 in self.groups.items():
        oprot.writeString(kiter302)
        oprot.writeSetBegin(TType.STRING, len(viter303))
        for iter304 in viter303:
          oprot.writeString(iter304)
        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
   - 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('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()
    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 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()
          (_etype308, _size305) = iprot.readSetBegin()
          for _i309 in xrange(_size305):
            _elem310 = Range()
            _elem310.read(iprot)
            self.success.add(_elem310)
          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 iter311 in self.success:
        iter311.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 = {}
          (_ktype313, _vtype314, _size312 ) = iprot.readMapBegin()
          for _i316 in xrange(_size312):
            _key317 = iprot.readString();
            _val318 = iprot.readString();
            self.success[_key317] = _val318
          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 kiter319,viter320 in self.success.items():
        oprot.writeString(kiter319)
        oprot.writeString(viter320)
      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 testTableClassLoad_args:
  """
  Attributes:
   - login
   - tableName
   - className
   - asTypeName
  """

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

  def __init__(self, login=None, tableName=None, className=None, asTypeName=None,):
    self.login = login
    self.tableName = tableName
    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.tableName = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.className = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        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('testTableClassLoad_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.className is not None:
      oprot.writeFieldBegin('className', TType.STRING, 3)
      oprot.writeString(self.className)
      oprot.writeFieldEnd()
    if self.asTypeName is not None:
      oprot.writeFieldBegin('asTypeName', TType.STRING, 4)
      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 testTableClassLoad_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  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
    (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.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)
      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('testTableClassLoad_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()
    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 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 = []
          (_etype324, _size321) = iprot.readListBegin()
          for _i325 in xrange(_size321):
            _elem326 = ActiveScan()
            _elem326.read(iprot)
            self.success.append(_elem326)
          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 iter327 in self.success:
        iter327.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 = []
          (_etype331, _size328) = iprot.readListBegin()
          for _i332 in xrange(_size328):
            _elem333 = ActiveCompaction()
            _elem333.read(iprot)
            self.success.append(_elem333)
          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 iter334 in self.success:
        iter334.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 = {}
          (_ktype336, _vtype337, _size335 ) = iprot.readMapBegin()
          for _i339 in xrange(_size335):
            _key340 = iprot.readString();
            _val341 = iprot.readString();
            self.success[_key340] = _val341
          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 kiter342,viter343 in self.success.items():
        oprot.writeString(kiter342)
        oprot.writeString(viter343)
      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 = {}
          (_ktype345, _vtype346, _size344 ) = iprot.readMapBegin()
          for _i348 in xrange(_size344):
            _key349 = iprot.readString();
            _val350 = iprot.readString();
            self.success[_key349] = _val350
          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 kiter351,viter352 in self.success.items():
        oprot.writeString(kiter351)
        oprot.writeString(viter352)
      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 = []
          (_etype356, _size353) = iprot.readListBegin()
          for _i357 in xrange(_size353):
            _elem358 = iprot.readString();
            self.success.append(_elem358)
          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 iter359 in self.success:
        oprot.writeString(iter359)
      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 = {}
          (_ktype361, _vtype362, _size360 ) = iprot.readMapBegin()
          for _i364 in xrange(_size360):
            _key365 = iprot.readString();
            _val366 = iprot.readString();
            self.properties[_key365] = _val366
          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 kiter367,viter368 in self.properties.items():
        oprot.writeString(kiter367)
        oprot.writeString(viter368)
      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()
          (_etype372, _size369) = iprot.readSetBegin()
          for _i373 in xrange(_size369):
            _elem374 = iprot.readString();
            self.authorizations.add(_elem374)
          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 iter375 in self.authorizations:
        oprot.writeString(iter375)
      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 = []
          (_etype379, _size376) = iprot.readListBegin()
          for _i380 in xrange(_size376):
            _elem381 = iprot.readString();
            self.success.append(_elem381)
          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 iter382 in self.success:
        oprot.writeString(iter382)
      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
   - 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('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()
    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 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
   - ouch3
  """

  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
    (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.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)
      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('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()
    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 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
   - ouch3
  """

  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
    (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()
          (_etype386, _size383) = iprot.readSetBegin()
          for _i387 in xrange(_size383):
            _elem388 = iprot.readString();
            self.success.add(_elem388)
          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('listLocalUsers_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.SET, 0)
      oprot.writeSetBegin(TType.STRING, len(self.success))
      for iter389 in self.success:
        oprot.writeString(iter389)
      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 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
   - 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('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()
    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 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
   - ouch3
  """

  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
    (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.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)
      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('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()
    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 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
   - ouch3
  """

  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
    (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.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)
      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('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()
    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 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 = {}
          (_ktype391, _vtype392, _size390 ) = iprot.readMapBegin()
          for _i394 in xrange(_size390):
            _key395 = iprot.readString();
            _val396 = []
            (_etype400, _size397) = iprot.readListBegin()
            for _i401 in xrange(_size397):
              _elem402 = ColumnUpdate()
              _elem402.read(iprot)
              _val396.append(_elem402)
            iprot.readListEnd()
            self.cells[_key395] = _val396
          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 kiter403,viter404 in self.cells.items():
        oprot.writeString(kiter403)
        oprot.writeListBegin(TType.STRUCT, len(viter404))
        for iter405 in viter404:
          iter405.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
   - ouch3
   - ouch4
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'outch1', (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', (MutationsRejectedException, MutationsRejectedException.thrift_spec), None, ), # 4
  )

  def __init__(self, outch1=None, ouch2=None, ouch3=None, ouch4=None,):
    self.outch1 = outch1
    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.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)
      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 = MutationsRejectedException()
          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('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()
    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 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
   - ouch3
  """

  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
    (3, TType.STRUCT, 'ouch3', (TableNotFoundException, TableNotFoundException.thrift_spec), None, ), # 3
  )

  def __init__(self, success=None, outch1=None, ouch2=None, ouch3=None,):
    self.success = success
    self.outch1 = outch1
    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.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)
      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('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()
    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 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 = {}
          (_ktype407, _vtype408, _size406 ) = iprot.readMapBegin()
          for _i410 in xrange(_size406):
            _key411 = iprot.readString();
            _val412 = []
            (_etype416, _size413) = iprot.readListBegin()
            for _i417 in xrange(_size413):
              _elem418 = ColumnUpdate()
              _elem418.read(iprot)
              _val412.append(_elem418)
            iprot.readListEnd()
            self.cells[_key411] = _val412
          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 kiter419,viter420 in self.cells.items():
        oprot.writeString(kiter419)
        oprot.writeListBegin(TType.STRUCT, len(viter420))
        for iter421 in viter420:
          iter421.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', (MutationsRejectedException, MutationsRejectedException.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 = MutationsRejectedException()
          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', (MutationsRejectedException, MutationsRejectedException.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 = MutationsRejectedException()
          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 updateRowConditionally_args:
  """
  Attributes:
   - login
   - tableName
   - row
   - updates
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'login', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'row', None, None, ), # 3
    (4, TType.STRUCT, 'updates', (ConditionalUpdates, ConditionalUpdates.thrift_spec), None, ), # 4
  )

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

  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.row = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRUCT:
          self.updates = ConditionalUpdates()
          self.updates.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('updateRowConditionally_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.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 3)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.updates is not None:
      oprot.writeFieldBegin('updates', TType.STRUCT, 4)
      self.updates.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 updateRowConditionally_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('updateRowConditionally_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 createConditionalWriter_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', (ConditionalWriterOptions, ConditionalWriterOptions.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 = ConditionalWriterOptions()
          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('createConditionalWriter_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 createConditionalWriter_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  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
    (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.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)
      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('createConditionalWriter_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 updateRowsConditionally_args:
  """
  Attributes:
   - conditionalWriter
   - updates
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'conditionalWriter', None, None, ), # 1
    (2, TType.MAP, 'updates', (TType.STRING,None,TType.STRUCT,(ConditionalUpdates, ConditionalUpdates.thrift_spec)), None, ), # 2
  )

  def __init__(self, conditionalWriter=None, updates=None,):
    self.conditionalWriter = conditionalWriter
    self.updates = updates

  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.conditionalWriter = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.MAP:
          self.updates = {}
          (_ktype423, _vtype424, _size422 ) = iprot.readMapBegin()
          for _i426 in xrange(_size422):
            _key427 = iprot.readString();
            _val428 = ConditionalUpdates()
            _val428.read(iprot)
            self.updates[_key427] = _val428
          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('updateRowsConditionally_args')
    if self.conditionalWriter is not None:
      oprot.writeFieldBegin('conditionalWriter', TType.STRING, 1)
      oprot.writeString(self.conditionalWriter)
      oprot.writeFieldEnd()
    if self.updates is not None:
      oprot.writeFieldBegin('updates', TType.MAP, 2)
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.updates))
      for kiter429,viter430 in self.updates.items():
        oprot.writeString(kiter429)
        viter430.write(oprot)
      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 updateRowsConditionally_result:
  """
  Attributes:
   - success
   - ouch1
   - ouch2
   - ouch3
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.STRING,None,TType.I32,None), None, ), # 0
    (1, TType.STRUCT, 'ouch1', (UnknownWriter, UnknownWriter.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.MAP:
          self.success = {}
          (_ktype432, _vtype433, _size431 ) = iprot.readMapBegin()
          for _i435 in xrange(_size431):
            _key436 = iprot.readString();
            _val437 = iprot.readI32();
            self.success[_key436] = _val437
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif 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 = 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('updateRowsConditionally_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.STRING, TType.I32, len(self.success))
      for kiter438,viter439 in self.success.items():
        oprot.writeString(kiter438)
        oprot.writeI32(viter439)
      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 closeConditionalWriter_args:
  """
  Attributes:
   - conditionalWriter
  """

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

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

  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.conditionalWriter = 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('closeConditionalWriter_args')
    if self.conditionalWriter is not None:
      oprot.writeFieldBegin('conditionalWriter', TType.STRING, 1)
      oprot.writeString(self.conditionalWriter)
      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 closeConditionalWriter_result:

  thrift_spec = (
  )

  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
      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('closeConditionalWriter_result')
    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)