node-thrift2-hbase/gen-nodejs/THBaseService.js

Easy to CRUD for hbase by node-thrift-hbase

//
// Autogenerated by Thrift Compiler (0.13.0)
//
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
//
"use strict";

var thrift = require('thrift');
var Thrift = thrift.Thrift;
var Q = thrift.Q;
var Int64 = require('node-int64');


var ttypes = require('./hbase_types');
//HELPER FUNCTIONS AND STRUCTURES

var THBaseService_exists_args = function(args) {
  this.table = null;
  this.tget = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tget !== undefined && args.tget !== null) {
      this.tget = new ttypes.TGet(args.tget);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tget is unset!');
    }
  }
};
THBaseService_exists_args.prototype = {};
THBaseService_exists_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.tget = new ttypes.TGet();
        this.tget.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_exists_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_exists_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tget !== null && this.tget !== undefined) {
    output.writeFieldBegin('tget', Thrift.Type.STRUCT, 2);
    this.tget.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_exists_result = function(args) {
  this.success = null;
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.success !== undefined && args.success !== null) {
      this.success = args.success;
    }
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_exists_result.prototype = {};
THBaseService_exists_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 0:
      if (ftype == Thrift.Type.BOOL) {
        this.success = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_exists_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_exists_result');
  if (this.success !== null && this.success !== undefined) {
    output.writeFieldBegin('success', Thrift.Type.BOOL, 0);
    output.writeBool(this.success);
    output.writeFieldEnd();
  }
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_get_args = function(args) {
  this.table = null;
  this.tget = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tget !== undefined && args.tget !== null) {
      this.tget = new ttypes.TGet(args.tget);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tget is unset!');
    }
  }
};
THBaseService_get_args.prototype = {};
THBaseService_get_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.tget = new ttypes.TGet();
        this.tget.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_get_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_get_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tget !== null && this.tget !== undefined) {
    output.writeFieldBegin('tget', Thrift.Type.STRUCT, 2);
    this.tget.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_get_result = function(args) {
  this.success = null;
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.success !== undefined && args.success !== null) {
      this.success = new ttypes.TResult(args.success);
    }
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_get_result.prototype = {};
THBaseService_get_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 0:
      if (ftype == Thrift.Type.STRUCT) {
        this.success = new ttypes.TResult();
        this.success.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_get_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_get_result');
  if (this.success !== null && this.success !== undefined) {
    output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
    this.success.write(output);
    output.writeFieldEnd();
  }
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_getMultiple_args = function(args) {
  this.table = null;
  this.tgets = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tgets !== undefined && args.tgets !== null) {
      this.tgets = Thrift.copyList(args.tgets, [ttypes.TGet]);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tgets is unset!');
    }
  }
};
THBaseService_getMultiple_args.prototype = {};
THBaseService_getMultiple_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        this.tgets = [];
        var _rtmp388 = input.readListBegin();
        var _size87 = _rtmp388.size || 0;
        for (var _i89 = 0; _i89 < _size87; ++_i89) {
          var elem90 = null;
          elem90 = new ttypes.TGet();
          elem90.read(input);
          this.tgets.push(elem90);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_getMultiple_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_getMultiple_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tgets !== null && this.tgets !== undefined) {
    output.writeFieldBegin('tgets', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.tgets.length);
    for (var iter91 in this.tgets) {
      if (this.tgets.hasOwnProperty(iter91)) {
        iter91 = this.tgets[iter91];
        iter91.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_getMultiple_result = function(args) {
  this.success = null;
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.success !== undefined && args.success !== null) {
      this.success = Thrift.copyList(args.success, [ttypes.TResult]);
    }
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_getMultiple_result.prototype = {};
THBaseService_getMultiple_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 0:
      if (ftype == Thrift.Type.LIST) {
        this.success = [];
        var _rtmp393 = input.readListBegin();
        var _size92 = _rtmp393.size || 0;
        for (var _i94 = 0; _i94 < _size92; ++_i94) {
          var elem95 = null;
          elem95 = new ttypes.TResult();
          elem95.read(input);
          this.success.push(elem95);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_getMultiple_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_getMultiple_result');
  if (this.success !== null && this.success !== undefined) {
    output.writeFieldBegin('success', Thrift.Type.LIST, 0);
    output.writeListBegin(Thrift.Type.STRUCT, this.success.length);
    for (var iter96 in this.success) {
      if (this.success.hasOwnProperty(iter96)) {
        iter96 = this.success[iter96];
        iter96.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_put_args = function(args) {
  this.table = null;
  this.tput = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tput !== undefined && args.tput !== null) {
      this.tput = new ttypes.TPut(args.tput);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tput is unset!');
    }
  }
};
THBaseService_put_args.prototype = {};
THBaseService_put_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.tput = new ttypes.TPut();
        this.tput.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_put_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_put_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tput !== null && this.tput !== undefined) {
    output.writeFieldBegin('tput', Thrift.Type.STRUCT, 2);
    this.tput.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_put_result = function(args) {
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_put_result.prototype = {};
THBaseService_put_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_put_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_put_result');
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_checkAndPut_args = function(args) {
  this.table = null;
  this.row = null;
  this.family = null;
  this.qualifier = null;
  this.value = null;
  this.tput = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.row !== undefined && args.row !== null) {
      this.row = args.row;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field row is unset!');
    }
    if (args.family !== undefined && args.family !== null) {
      this.family = args.family;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field family is unset!');
    }
    if (args.qualifier !== undefined && args.qualifier !== null) {
      this.qualifier = args.qualifier;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field qualifier is unset!');
    }
    if (args.value !== undefined && args.value !== null) {
      this.value = args.value;
    }
    if (args.tput !== undefined && args.tput !== null) {
      this.tput = new ttypes.TPut(args.tput);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tput is unset!');
    }
  }
};
THBaseService_checkAndPut_args.prototype = {};
THBaseService_checkAndPut_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.row = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.family = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.qualifier = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRING) {
        this.value = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRUCT) {
        this.tput = new ttypes.TPut();
        this.tput.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_checkAndPut_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_checkAndPut_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.row !== null && this.row !== undefined) {
    output.writeFieldBegin('row', Thrift.Type.STRING, 2);
    output.writeBinary(this.row);
    output.writeFieldEnd();
  }
  if (this.family !== null && this.family !== undefined) {
    output.writeFieldBegin('family', Thrift.Type.STRING, 3);
    output.writeBinary(this.family);
    output.writeFieldEnd();
  }
  if (this.qualifier !== null && this.qualifier !== undefined) {
    output.writeFieldBegin('qualifier', Thrift.Type.STRING, 4);
    output.writeBinary(this.qualifier);
    output.writeFieldEnd();
  }
  if (this.value !== null && this.value !== undefined) {
    output.writeFieldBegin('value', Thrift.Type.STRING, 5);
    output.writeBinary(this.value);
    output.writeFieldEnd();
  }
  if (this.tput !== null && this.tput !== undefined) {
    output.writeFieldBegin('tput', Thrift.Type.STRUCT, 6);
    this.tput.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_checkAndPut_result = function(args) {
  this.success = null;
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.success !== undefined && args.success !== null) {
      this.success = args.success;
    }
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_checkAndPut_result.prototype = {};
THBaseService_checkAndPut_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 0:
      if (ftype == Thrift.Type.BOOL) {
        this.success = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_checkAndPut_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_checkAndPut_result');
  if (this.success !== null && this.success !== undefined) {
    output.writeFieldBegin('success', Thrift.Type.BOOL, 0);
    output.writeBool(this.success);
    output.writeFieldEnd();
  }
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_putMultiple_args = function(args) {
  this.table = null;
  this.tputs = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tputs !== undefined && args.tputs !== null) {
      this.tputs = Thrift.copyList(args.tputs, [ttypes.TPut]);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tputs is unset!');
    }
  }
};
THBaseService_putMultiple_args.prototype = {};
THBaseService_putMultiple_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        this.tputs = [];
        var _rtmp398 = input.readListBegin();
        var _size97 = _rtmp398.size || 0;
        for (var _i99 = 0; _i99 < _size97; ++_i99) {
          var elem100 = null;
          elem100 = new ttypes.TPut();
          elem100.read(input);
          this.tputs.push(elem100);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_putMultiple_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_putMultiple_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tputs !== null && this.tputs !== undefined) {
    output.writeFieldBegin('tputs', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.tputs.length);
    for (var iter101 in this.tputs) {
      if (this.tputs.hasOwnProperty(iter101)) {
        iter101 = this.tputs[iter101];
        iter101.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_putMultiple_result = function(args) {
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_putMultiple_result.prototype = {};
THBaseService_putMultiple_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_putMultiple_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_putMultiple_result');
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_deleteSingle_args = function(args) {
  this.table = null;
  this.tdelete = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tdelete !== undefined && args.tdelete !== null) {
      this.tdelete = new ttypes.TDelete(args.tdelete);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tdelete is unset!');
    }
  }
};
THBaseService_deleteSingle_args.prototype = {};
THBaseService_deleteSingle_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.tdelete = new ttypes.TDelete();
        this.tdelete.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_deleteSingle_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_deleteSingle_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tdelete !== null && this.tdelete !== undefined) {
    output.writeFieldBegin('tdelete', Thrift.Type.STRUCT, 2);
    this.tdelete.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_deleteSingle_result = function(args) {
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_deleteSingle_result.prototype = {};
THBaseService_deleteSingle_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_deleteSingle_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_deleteSingle_result');
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_deleteMultiple_args = function(args) {
  this.table = null;
  this.tdeletes = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tdeletes !== undefined && args.tdeletes !== null) {
      this.tdeletes = Thrift.copyList(args.tdeletes, [ttypes.TDelete]);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tdeletes is unset!');
    }
  }
};
THBaseService_deleteMultiple_args.prototype = {};
THBaseService_deleteMultiple_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        this.tdeletes = [];
        var _rtmp3103 = input.readListBegin();
        var _size102 = _rtmp3103.size || 0;
        for (var _i104 = 0; _i104 < _size102; ++_i104) {
          var elem105 = null;
          elem105 = new ttypes.TDelete();
          elem105.read(input);
          this.tdeletes.push(elem105);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_deleteMultiple_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_deleteMultiple_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tdeletes !== null && this.tdeletes !== undefined) {
    output.writeFieldBegin('tdeletes', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.tdeletes.length);
    for (var iter106 in this.tdeletes) {
      if (this.tdeletes.hasOwnProperty(iter106)) {
        iter106 = this.tdeletes[iter106];
        iter106.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_deleteMultiple_result = function(args) {
  this.success = null;
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.success !== undefined && args.success !== null) {
      this.success = Thrift.copyList(args.success, [ttypes.TDelete]);
    }
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_deleteMultiple_result.prototype = {};
THBaseService_deleteMultiple_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 0:
      if (ftype == Thrift.Type.LIST) {
        this.success = [];
        var _rtmp3108 = input.readListBegin();
        var _size107 = _rtmp3108.size || 0;
        for (var _i109 = 0; _i109 < _size107; ++_i109) {
          var elem110 = null;
          elem110 = new ttypes.TDelete();
          elem110.read(input);
          this.success.push(elem110);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_deleteMultiple_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_deleteMultiple_result');
  if (this.success !== null && this.success !== undefined) {
    output.writeFieldBegin('success', Thrift.Type.LIST, 0);
    output.writeListBegin(Thrift.Type.STRUCT, this.success.length);
    for (var iter111 in this.success) {
      if (this.success.hasOwnProperty(iter111)) {
        iter111 = this.success[iter111];
        iter111.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_checkAndDelete_args = function(args) {
  this.table = null;
  this.row = null;
  this.family = null;
  this.qualifier = null;
  this.value = null;
  this.tdelete = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.row !== undefined && args.row !== null) {
      this.row = args.row;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field row is unset!');
    }
    if (args.family !== undefined && args.family !== null) {
      this.family = args.family;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field family is unset!');
    }
    if (args.qualifier !== undefined && args.qualifier !== null) {
      this.qualifier = args.qualifier;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field qualifier is unset!');
    }
    if (args.value !== undefined && args.value !== null) {
      this.value = args.value;
    }
    if (args.tdelete !== undefined && args.tdelete !== null) {
      this.tdelete = new ttypes.TDelete(args.tdelete);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tdelete is unset!');
    }
  }
};
THBaseService_checkAndDelete_args.prototype = {};
THBaseService_checkAndDelete_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.row = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.family = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.qualifier = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRING) {
        this.value = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRUCT) {
        this.tdelete = new ttypes.TDelete();
        this.tdelete.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_checkAndDelete_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_checkAndDelete_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.row !== null && this.row !== undefined) {
    output.writeFieldBegin('row', Thrift.Type.STRING, 2);
    output.writeBinary(this.row);
    output.writeFieldEnd();
  }
  if (this.family !== null && this.family !== undefined) {
    output.writeFieldBegin('family', Thrift.Type.STRING, 3);
    output.writeBinary(this.family);
    output.writeFieldEnd();
  }
  if (this.qualifier !== null && this.qualifier !== undefined) {
    output.writeFieldBegin('qualifier', Thrift.Type.STRING, 4);
    output.writeBinary(this.qualifier);
    output.writeFieldEnd();
  }
  if (this.value !== null && this.value !== undefined) {
    output.writeFieldBegin('value', Thrift.Type.STRING, 5);
    output.writeBinary(this.value);
    output.writeFieldEnd();
  }
  if (this.tdelete !== null && this.tdelete !== undefined) {
    output.writeFieldBegin('tdelete', Thrift.Type.STRUCT, 6);
    this.tdelete.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_checkAndDelete_result = function(args) {
  this.success = null;
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.success !== undefined && args.success !== null) {
      this.success = args.success;
    }
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_checkAndDelete_result.prototype = {};
THBaseService_checkAndDelete_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 0:
      if (ftype == Thrift.Type.BOOL) {
        this.success = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_checkAndDelete_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_checkAndDelete_result');
  if (this.success !== null && this.success !== undefined) {
    output.writeFieldBegin('success', Thrift.Type.BOOL, 0);
    output.writeBool(this.success);
    output.writeFieldEnd();
  }
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_increment_args = function(args) {
  this.table = null;
  this.tincrement = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tincrement !== undefined && args.tincrement !== null) {
      this.tincrement = new ttypes.TIncrement(args.tincrement);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tincrement is unset!');
    }
  }
};
THBaseService_increment_args.prototype = {};
THBaseService_increment_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.tincrement = new ttypes.TIncrement();
        this.tincrement.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_increment_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_increment_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tincrement !== null && this.tincrement !== undefined) {
    output.writeFieldBegin('tincrement', Thrift.Type.STRUCT, 2);
    this.tincrement.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_increment_result = function(args) {
  this.success = null;
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.success !== undefined && args.success !== null) {
      this.success = new ttypes.TResult(args.success);
    }
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_increment_result.prototype = {};
THBaseService_increment_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 0:
      if (ftype == Thrift.Type.STRUCT) {
        this.success = new ttypes.TResult();
        this.success.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_increment_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_increment_result');
  if (this.success !== null && this.success !== undefined) {
    output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
    this.success.write(output);
    output.writeFieldEnd();
  }
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_append_args = function(args) {
  this.table = null;
  this.tappend = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tappend !== undefined && args.tappend !== null) {
      this.tappend = new ttypes.TAppend(args.tappend);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tappend is unset!');
    }
  }
};
THBaseService_append_args.prototype = {};
THBaseService_append_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.tappend = new ttypes.TAppend();
        this.tappend.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_append_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_append_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
    output.writeBinary(this.table);
    output.writeFieldEnd();
  }
  if (this.tappend !== null && this.tappend !== undefined) {
    output.writeFieldBegin('tappend', Thrift.Type.STRUCT, 2);
    this.tappend.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_append_result = function(args) {
  this.success = null;
  this.io = null;
  if (args instanceof ttypes.TIOError) {
    this.io = args;
    return;
  }
  if (args) {
    if (args.success !== undefined && args.success !== null) {
      this.success = new ttypes.TResult(args.success);
    }
    if (args.io !== undefined && args.io !== null) {
      this.io = args.io;
    }
  }
};
THBaseService_append_result.prototype = {};
THBaseService_append_result.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 0:
      if (ftype == Thrift.Type.STRUCT) {
        this.success = new ttypes.TResult();
        this.success.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.io = new ttypes.TIOError();
        this.io.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_append_result.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_append_result');
  if (this.success !== null && this.success !== undefined) {
    output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
    this.success.write(output);
    output.writeFieldEnd();
  }
  if (this.io !== null && this.io !== undefined) {
    output.writeFieldBegin('io', Thrift.Type.STRUCT, 1);
    this.io.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var THBaseService_openScanner_args = function(args) {
  this.table = null;
  this.tscan = null;
  if (args) {
    if (args.table !== undefined && args.table !== null) {
      this.table = args.table;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field table is unset!');
    }
    if (args.tscan !== undefined && args.tscan !== null) {
      this.tscan = new ttypes.TScan(args.tscan);
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field tscan is unset!');
    }
  }
};
THBaseService_openScanner_args.prototype = {};
THBaseService_openScanner_args.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.table = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.tscan = new ttypes.TScan();
        this.tscan.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

THBaseService_openScanner_args.prototype.write = function(output) {
  output.writeStructBegin('THBaseService_openScanner_args');
  if (this.table !== null && this.table !== undefined) {
    output.writeFieldBegin('table', Thrift.Type