incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [1/6] Adding some javascript thrift code, so Blur ajax calls can now be made.
Date Wed, 17 Apr 2013 01:26:56 GMT
Updated Branches:
  refs/heads/0.1.5 4266a40fc -> 39c899d29


http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/39c899d2/src/distribution/src/main/scripts/interface/gen-js/Blur_types.js
----------------------------------------------------------------------
diff --git a/src/distribution/src/main/scripts/interface/gen-js/Blur_types.js b/src/distribution/src/main/scripts/interface/gen-js/Blur_types.js
new file mode 100644
index 0000000..1c96301
--- /dev/null
+++ b/src/distribution/src/main/scripts/interface/gen-js/Blur_types.js
@@ -0,0 +1,3099 @@
+//
+// Autogenerated by Thrift Compiler (0.9.0)
+//
+// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+//
+
+ScoreType = {
+'SUPER' : 0,
+'AGGREGATE' : 1,
+'BEST' : 2,
+'CONSTANT' : 3
+};
+QueryState = {
+'RUNNING' : 0,
+'INTERRUPTED' : 1,
+'COMPLETE' : 2
+};
+RowMutationType = {
+'DELETE_ROW' : 0,
+'REPLACE_ROW' : 1,
+'UPDATE_ROW' : 2
+};
+RecordMutationType = {
+'DELETE_ENTIRE_RECORD' : 0,
+'REPLACE_ENTIRE_RECORD' : 1,
+'REPLACE_COLUMNS' : 2,
+'APPEND_COLUMN_VALUES' : 3
+};
+BlurException = function(args) {
+  this.message = null;
+  this.stackTraceStr = null;
+  if (args) {
+    if (args.message !== undefined) {
+      this.message = args.message;
+    }
+    if (args.stackTraceStr !== undefined) {
+      this.stackTraceStr = args.stackTraceStr;
+    }
+  }
+};
+Thrift.inherits(BlurException, Thrift.TException);
+BlurException.prototype.name = 'BlurException';
+BlurException.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.message = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.stackTraceStr = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurException.prototype.write = function(output) {
+  output.writeStructBegin('BlurException');
+  if (this.message !== null && this.message !== undefined) {
+    output.writeFieldBegin('message', Thrift.Type.STRING, 1);
+    output.writeString(this.message);
+    output.writeFieldEnd();
+  }
+  if (this.stackTraceStr !== null && this.stackTraceStr !== undefined) {
+    output.writeFieldBegin('stackTraceStr', Thrift.Type.STRING, 2);
+    output.writeString(this.stackTraceStr);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Column = function(args) {
+  this.name = null;
+  this.value = null;
+  if (args) {
+    if (args.name !== undefined) {
+      this.name = args.name;
+    }
+    if (args.value !== undefined) {
+      this.value = args.value;
+    }
+  }
+};
+Column.prototype = {};
+Column.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.name = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.value = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Column.prototype.write = function(output) {
+  output.writeStructBegin('Column');
+  if (this.name !== null && this.name !== undefined) {
+    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
+    output.writeString(this.name);
+    output.writeFieldEnd();
+  }
+  if (this.value !== null && this.value !== undefined) {
+    output.writeFieldBegin('value', Thrift.Type.STRING, 2);
+    output.writeString(this.value);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Record = function(args) {
+  this.recordId = null;
+  this.family = null;
+  this.columns = null;
+  if (args) {
+    if (args.recordId !== undefined) {
+      this.recordId = args.recordId;
+    }
+    if (args.family !== undefined) {
+      this.family = args.family;
+    }
+    if (args.columns !== undefined) {
+      this.columns = args.columns;
+    }
+  }
+};
+Record.prototype = {};
+Record.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.recordId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.family = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.LIST) {
+        var _size0 = 0;
+        var _rtmp34;
+        this.columns = [];
+        var _etype3 = 0;
+        _rtmp34 = input.readListBegin();
+        _etype3 = _rtmp34.etype;
+        _size0 = _rtmp34.size;
+        for (var _i5 = 0; _i5 < _size0; ++_i5)
+        {
+          var elem6 = null;
+          elem6 = new Column();
+          elem6.read(input);
+          this.columns.push(elem6);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Record.prototype.write = function(output) {
+  output.writeStructBegin('Record');
+  if (this.recordId !== null && this.recordId !== undefined) {
+    output.writeFieldBegin('recordId', Thrift.Type.STRING, 1);
+    output.writeString(this.recordId);
+    output.writeFieldEnd();
+  }
+  if (this.family !== null && this.family !== undefined) {
+    output.writeFieldBegin('family', Thrift.Type.STRING, 2);
+    output.writeString(this.family);
+    output.writeFieldEnd();
+  }
+  if (this.columns !== null && this.columns !== undefined) {
+    output.writeFieldBegin('columns', Thrift.Type.LIST, 3);
+    output.writeListBegin(Thrift.Type.STRUCT, this.columns.length);
+    for (var iter7 in this.columns)
+    {
+      if (this.columns.hasOwnProperty(iter7))
+      {
+        iter7 = this.columns[iter7];
+        iter7.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Row = function(args) {
+  this.id = null;
+  this.records = null;
+  this.recordCount = null;
+  if (args) {
+    if (args.id !== undefined) {
+      this.id = args.id;
+    }
+    if (args.records !== undefined) {
+      this.records = args.records;
+    }
+    if (args.recordCount !== undefined) {
+      this.recordCount = args.recordCount;
+    }
+  }
+};
+Row.prototype = {};
+Row.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.id = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.LIST) {
+        var _size8 = 0;
+        var _rtmp312;
+        this.records = [];
+        var _etype11 = 0;
+        _rtmp312 = input.readListBegin();
+        _etype11 = _rtmp312.etype;
+        _size8 = _rtmp312.size;
+        for (var _i13 = 0; _i13 < _size8; ++_i13)
+        {
+          var elem14 = null;
+          elem14 = new Record();
+          elem14.read(input);
+          this.records.push(elem14);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.recordCount = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Row.prototype.write = function(output) {
+  output.writeStructBegin('Row');
+  if (this.id !== null && this.id !== undefined) {
+    output.writeFieldBegin('id', Thrift.Type.STRING, 1);
+    output.writeString(this.id);
+    output.writeFieldEnd();
+  }
+  if (this.records !== null && this.records !== undefined) {
+    output.writeFieldBegin('records', Thrift.Type.LIST, 2);
+    output.writeListBegin(Thrift.Type.STRUCT, this.records.length);
+    for (var iter15 in this.records)
+    {
+      if (this.records.hasOwnProperty(iter15))
+      {
+        iter15 = this.records[iter15];
+        iter15.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.recordCount !== null && this.recordCount !== undefined) {
+    output.writeFieldBegin('recordCount', Thrift.Type.I32, 3);
+    output.writeI32(this.recordCount);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Selector = function(args) {
+  this.recordOnly = null;
+  this.locationId = null;
+  this.rowId = null;
+  this.recordId = null;
+  this.columnFamiliesToFetch = null;
+  this.columnsToFetch = null;
+  this.allowStaleData = null;
+  if (args) {
+    if (args.recordOnly !== undefined) {
+      this.recordOnly = args.recordOnly;
+    }
+    if (args.locationId !== undefined) {
+      this.locationId = args.locationId;
+    }
+    if (args.rowId !== undefined) {
+      this.rowId = args.rowId;
+    }
+    if (args.recordId !== undefined) {
+      this.recordId = args.recordId;
+    }
+    if (args.columnFamiliesToFetch !== undefined) {
+      this.columnFamiliesToFetch = args.columnFamiliesToFetch;
+    }
+    if (args.columnsToFetch !== undefined) {
+      this.columnsToFetch = args.columnsToFetch;
+    }
+    if (args.allowStaleData !== undefined) {
+      this.allowStaleData = args.allowStaleData;
+    }
+  }
+};
+Selector.prototype = {};
+Selector.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.BOOL) {
+        this.recordOnly = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.locationId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRING) {
+        this.rowId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRING) {
+        this.recordId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.SET) {
+        var _size16 = 0;
+        var _rtmp320;
+        this.columnFamiliesToFetch = [];
+        var _etype19 = 0;
+        _rtmp320 = input.readSetBegin();
+        _etype19 = _rtmp320.etype;
+        _size16 = _rtmp320.size;
+        for (var _i21 = 0; _i21 < _size16; ++_i21)
+        {
+          var elem22 = null;
+          elem22 = input.readString().value;
+          this.columnFamiliesToFetch.push(elem22);
+        }
+        input.readSetEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.MAP) {
+        var _size23 = 0;
+        var _rtmp327;
+        this.columnsToFetch = {};
+        var _ktype24 = 0;
+        var _vtype25 = 0;
+        _rtmp327 = input.readMapBegin();
+        _ktype24 = _rtmp327.ktype;
+        _vtype25 = _rtmp327.vtype;
+        _size23 = _rtmp327.size;
+        for (var _i28 = 0; _i28 < _size23; ++_i28)
+        {
+          if (_i28 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key29 = null;
+          var val30 = null;
+          key29 = input.readString().value;
+          var _size31 = 0;
+          var _rtmp335;
+          val30 = [];
+          var _etype34 = 0;
+          _rtmp335 = input.readSetBegin();
+          _etype34 = _rtmp335.etype;
+          _size31 = _rtmp335.size;
+          for (var _i36 = 0; _i36 < _size31; ++_i36)
+          {
+            var elem37 = null;
+            elem37 = input.readString().value;
+            val30.push(elem37);
+          }
+          input.readSetEnd();
+          this.columnsToFetch[key29] = val30;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 7:
+      if (ftype == Thrift.Type.BOOL) {
+        this.allowStaleData = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Selector.prototype.write = function(output) {
+  output.writeStructBegin('Selector');
+  if (this.recordOnly !== null && this.recordOnly !== undefined) {
+    output.writeFieldBegin('recordOnly', Thrift.Type.BOOL, 1);
+    output.writeBool(this.recordOnly);
+    output.writeFieldEnd();
+  }
+  if (this.locationId !== null && this.locationId !== undefined) {
+    output.writeFieldBegin('locationId', Thrift.Type.STRING, 2);
+    output.writeString(this.locationId);
+    output.writeFieldEnd();
+  }
+  if (this.rowId !== null && this.rowId !== undefined) {
+    output.writeFieldBegin('rowId', Thrift.Type.STRING, 3);
+    output.writeString(this.rowId);
+    output.writeFieldEnd();
+  }
+  if (this.recordId !== null && this.recordId !== undefined) {
+    output.writeFieldBegin('recordId', Thrift.Type.STRING, 4);
+    output.writeString(this.recordId);
+    output.writeFieldEnd();
+  }
+  if (this.columnFamiliesToFetch !== null && this.columnFamiliesToFetch !== undefined) {
+    output.writeFieldBegin('columnFamiliesToFetch', Thrift.Type.SET, 5);
+    output.writeSetBegin(Thrift.Type.STRING, this.columnFamiliesToFetch.length);
+    for (var iter38 in this.columnFamiliesToFetch)
+    {
+      if (this.columnFamiliesToFetch.hasOwnProperty(iter38))
+      {
+        iter38 = this.columnFamiliesToFetch[iter38];
+        output.writeString(iter38);
+      }
+    }
+    output.writeSetEnd();
+    output.writeFieldEnd();
+  }
+  if (this.columnsToFetch !== null && this.columnsToFetch !== undefined) {
+    output.writeFieldBegin('columnsToFetch', Thrift.Type.MAP, 6);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.SET, Thrift.objectLength(this.columnsToFetch));
+    for (var kiter39 in this.columnsToFetch)
+    {
+      if (this.columnsToFetch.hasOwnProperty(kiter39))
+      {
+        var viter40 = this.columnsToFetch[kiter39];
+        output.writeString(kiter39);
+        output.writeSetBegin(Thrift.Type.STRING, viter40.length);
+        for (var iter41 in viter40)
+        {
+          if (viter40.hasOwnProperty(iter41))
+          {
+            iter41 = viter40[iter41];
+            output.writeString(iter41);
+          }
+        }
+        output.writeSetEnd();
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  if (this.allowStaleData !== null && this.allowStaleData !== undefined) {
+    output.writeFieldBegin('allowStaleData', Thrift.Type.BOOL, 7);
+    output.writeBool(this.allowStaleData);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+FetchRowResult = function(args) {
+  this.row = null;
+  if (args) {
+    if (args.row !== undefined) {
+      this.row = args.row;
+    }
+  }
+};
+FetchRowResult.prototype = {};
+FetchRowResult.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.row = new Row();
+        this.row.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+FetchRowResult.prototype.write = function(output) {
+  output.writeStructBegin('FetchRowResult');
+  if (this.row !== null && this.row !== undefined) {
+    output.writeFieldBegin('row', Thrift.Type.STRUCT, 1);
+    this.row.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+FetchRecordResult = function(args) {
+  this.rowid = null;
+  this.record = null;
+  if (args) {
+    if (args.rowid !== undefined) {
+      this.rowid = args.rowid;
+    }
+    if (args.record !== undefined) {
+      this.record = args.record;
+    }
+  }
+};
+FetchRecordResult.prototype = {};
+FetchRecordResult.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.rowid = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.record = new Record();
+        this.record.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+FetchRecordResult.prototype.write = function(output) {
+  output.writeStructBegin('FetchRecordResult');
+  if (this.rowid !== null && this.rowid !== undefined) {
+    output.writeFieldBegin('rowid', Thrift.Type.STRING, 1);
+    output.writeString(this.rowid);
+    output.writeFieldEnd();
+  }
+  if (this.record !== null && this.record !== undefined) {
+    output.writeFieldBegin('record', Thrift.Type.STRUCT, 2);
+    this.record.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+FetchResult = function(args) {
+  this.exists = null;
+  this.deleted = null;
+  this.table = null;
+  this.rowResult = null;
+  this.recordResult = null;
+  if (args) {
+    if (args.exists !== undefined) {
+      this.exists = args.exists;
+    }
+    if (args.deleted !== undefined) {
+      this.deleted = args.deleted;
+    }
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.rowResult !== undefined) {
+      this.rowResult = args.rowResult;
+    }
+    if (args.recordResult !== undefined) {
+      this.recordResult = args.recordResult;
+    }
+  }
+};
+FetchResult.prototype = {};
+FetchResult.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.BOOL) {
+        this.exists = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.BOOL) {
+        this.deleted = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRING) {
+        this.table = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.rowResult = new FetchRowResult();
+        this.rowResult.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.recordResult = new FetchRecordResult();
+        this.recordResult.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+FetchResult.prototype.write = function(output) {
+  output.writeStructBegin('FetchResult');
+  if (this.exists !== null && this.exists !== undefined) {
+    output.writeFieldBegin('exists', Thrift.Type.BOOL, 1);
+    output.writeBool(this.exists);
+    output.writeFieldEnd();
+  }
+  if (this.deleted !== null && this.deleted !== undefined) {
+    output.writeFieldBegin('deleted', Thrift.Type.BOOL, 2);
+    output.writeBool(this.deleted);
+    output.writeFieldEnd();
+  }
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 3);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.rowResult !== null && this.rowResult !== undefined) {
+    output.writeFieldBegin('rowResult', Thrift.Type.STRUCT, 4);
+    this.rowResult.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.recordResult !== null && this.recordResult !== undefined) {
+    output.writeFieldBegin('recordResult', Thrift.Type.STRUCT, 5);
+    this.recordResult.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+SimpleQuery = function(args) {
+  this.queryStr = null;
+  this.superQueryOn = true;
+  this.type = 0;
+  this.postSuperFilter = null;
+  this.preSuperFilter = null;
+  if (args) {
+    if (args.queryStr !== undefined) {
+      this.queryStr = args.queryStr;
+    }
+    if (args.superQueryOn !== undefined) {
+      this.superQueryOn = args.superQueryOn;
+    }
+    if (args.type !== undefined) {
+      this.type = args.type;
+    }
+    if (args.postSuperFilter !== undefined) {
+      this.postSuperFilter = args.postSuperFilter;
+    }
+    if (args.preSuperFilter !== undefined) {
+      this.preSuperFilter = args.preSuperFilter;
+    }
+  }
+};
+SimpleQuery.prototype = {};
+SimpleQuery.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.queryStr = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.BOOL) {
+        this.superQueryOn = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.type = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRING) {
+        this.postSuperFilter = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.STRING) {
+        this.preSuperFilter = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+SimpleQuery.prototype.write = function(output) {
+  output.writeStructBegin('SimpleQuery');
+  if (this.queryStr !== null && this.queryStr !== undefined) {
+    output.writeFieldBegin('queryStr', Thrift.Type.STRING, 1);
+    output.writeString(this.queryStr);
+    output.writeFieldEnd();
+  }
+  if (this.superQueryOn !== null && this.superQueryOn !== undefined) {
+    output.writeFieldBegin('superQueryOn', Thrift.Type.BOOL, 2);
+    output.writeBool(this.superQueryOn);
+    output.writeFieldEnd();
+  }
+  if (this.type !== null && this.type !== undefined) {
+    output.writeFieldBegin('type', Thrift.Type.I32, 3);
+    output.writeI32(this.type);
+    output.writeFieldEnd();
+  }
+  if (this.postSuperFilter !== null && this.postSuperFilter !== undefined) {
+    output.writeFieldBegin('postSuperFilter', Thrift.Type.STRING, 4);
+    output.writeString(this.postSuperFilter);
+    output.writeFieldEnd();
+  }
+  if (this.preSuperFilter !== null && this.preSuperFilter !== undefined) {
+    output.writeFieldBegin('preSuperFilter', Thrift.Type.STRING, 5);
+    output.writeString(this.preSuperFilter);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+ExpertQuery = function(args) {
+  this.query = null;
+  this.filter = null;
+  if (args) {
+    if (args.query !== undefined) {
+      this.query = args.query;
+    }
+    if (args.filter !== undefined) {
+      this.filter = args.filter;
+    }
+  }
+};
+ExpertQuery.prototype = {};
+ExpertQuery.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.query = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.filter = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+ExpertQuery.prototype.write = function(output) {
+  output.writeStructBegin('ExpertQuery');
+  if (this.query !== null && this.query !== undefined) {
+    output.writeFieldBegin('query', Thrift.Type.STRING, 1);
+    output.writeString(this.query);
+    output.writeFieldEnd();
+  }
+  if (this.filter !== null && this.filter !== undefined) {
+    output.writeFieldBegin('filter', Thrift.Type.STRING, 2);
+    output.writeString(this.filter);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Facet = function(args) {
+  this.queryStr = null;
+  this.minimumNumberOfBlurResults = 9223372036854775807;
+  if (args) {
+    if (args.queryStr !== undefined) {
+      this.queryStr = args.queryStr;
+    }
+    if (args.minimumNumberOfBlurResults !== undefined) {
+      this.minimumNumberOfBlurResults = args.minimumNumberOfBlurResults;
+    }
+  }
+};
+Facet.prototype = {};
+Facet.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.queryStr = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.I64) {
+        this.minimumNumberOfBlurResults = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Facet.prototype.write = function(output) {
+  output.writeStructBegin('Facet');
+  if (this.queryStr !== null && this.queryStr !== undefined) {
+    output.writeFieldBegin('queryStr', Thrift.Type.STRING, 1);
+    output.writeString(this.queryStr);
+    output.writeFieldEnd();
+  }
+  if (this.minimumNumberOfBlurResults !== null && this.minimumNumberOfBlurResults !== undefined) {
+    output.writeFieldBegin('minimumNumberOfBlurResults', Thrift.Type.I64, 2);
+    output.writeI64(this.minimumNumberOfBlurResults);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+BlurQuery = function(args) {
+  this.simpleQuery = null;
+  this.expertQuery = null;
+  this.facets = null;
+  this.selector = null;
+  this.allowStaleData = false;
+  this.useCacheIfPresent = true;
+  this.start = 0;
+  this.fetch = 10;
+  this.minimumNumberOfResults = 9223372036854775807;
+  this.maxQueryTime = 9223372036854775807;
+  this.uuid = null;
+  this.userContext = null;
+  this.cacheResult = true;
+  this.startTime = 0;
+  this.modifyFileCaches = true;
+  if (args) {
+    if (args.simpleQuery !== undefined) {
+      this.simpleQuery = args.simpleQuery;
+    }
+    if (args.expertQuery !== undefined) {
+      this.expertQuery = args.expertQuery;
+    }
+    if (args.facets !== undefined) {
+      this.facets = args.facets;
+    }
+    if (args.selector !== undefined) {
+      this.selector = args.selector;
+    }
+    if (args.allowStaleData !== undefined) {
+      this.allowStaleData = args.allowStaleData;
+    }
+    if (args.useCacheIfPresent !== undefined) {
+      this.useCacheIfPresent = args.useCacheIfPresent;
+    }
+    if (args.start !== undefined) {
+      this.start = args.start;
+    }
+    if (args.fetch !== undefined) {
+      this.fetch = args.fetch;
+    }
+    if (args.minimumNumberOfResults !== undefined) {
+      this.minimumNumberOfResults = args.minimumNumberOfResults;
+    }
+    if (args.maxQueryTime !== undefined) {
+      this.maxQueryTime = args.maxQueryTime;
+    }
+    if (args.uuid !== undefined) {
+      this.uuid = args.uuid;
+    }
+    if (args.userContext !== undefined) {
+      this.userContext = args.userContext;
+    }
+    if (args.cacheResult !== undefined) {
+      this.cacheResult = args.cacheResult;
+    }
+    if (args.startTime !== undefined) {
+      this.startTime = args.startTime;
+    }
+    if (args.modifyFileCaches !== undefined) {
+      this.modifyFileCaches = args.modifyFileCaches;
+    }
+  }
+};
+BlurQuery.prototype = {};
+BlurQuery.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.simpleQuery = new SimpleQuery();
+        this.simpleQuery.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.expertQuery = new ExpertQuery();
+        this.expertQuery.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.LIST) {
+        var _size42 = 0;
+        var _rtmp346;
+        this.facets = [];
+        var _etype45 = 0;
+        _rtmp346 = input.readListBegin();
+        _etype45 = _rtmp346.etype;
+        _size42 = _rtmp346.size;
+        for (var _i47 = 0; _i47 < _size42; ++_i47)
+        {
+          var elem48 = null;
+          elem48 = new Facet();
+          elem48.read(input);
+          this.facets.push(elem48);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.selector = new Selector();
+        this.selector.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.BOOL) {
+        this.allowStaleData = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.BOOL) {
+        this.useCacheIfPresent = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 7:
+      if (ftype == Thrift.Type.I64) {
+        this.start = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 8:
+      if (ftype == Thrift.Type.I32) {
+        this.fetch = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 9:
+      if (ftype == Thrift.Type.I64) {
+        this.minimumNumberOfResults = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 10:
+      if (ftype == Thrift.Type.I64) {
+        this.maxQueryTime = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 11:
+      if (ftype == Thrift.Type.I64) {
+        this.uuid = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 12:
+      if (ftype == Thrift.Type.STRING) {
+        this.userContext = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 13:
+      if (ftype == Thrift.Type.BOOL) {
+        this.cacheResult = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 14:
+      if (ftype == Thrift.Type.I64) {
+        this.startTime = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 15:
+      if (ftype == Thrift.Type.BOOL) {
+        this.modifyFileCaches = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurQuery.prototype.write = function(output) {
+  output.writeStructBegin('BlurQuery');
+  if (this.simpleQuery !== null && this.simpleQuery !== undefined) {
+    output.writeFieldBegin('simpleQuery', Thrift.Type.STRUCT, 1);
+    this.simpleQuery.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.expertQuery !== null && this.expertQuery !== undefined) {
+    output.writeFieldBegin('expertQuery', Thrift.Type.STRUCT, 2);
+    this.expertQuery.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.facets !== null && this.facets !== undefined) {
+    output.writeFieldBegin('facets', Thrift.Type.LIST, 3);
+    output.writeListBegin(Thrift.Type.STRUCT, this.facets.length);
+    for (var iter49 in this.facets)
+    {
+      if (this.facets.hasOwnProperty(iter49))
+      {
+        iter49 = this.facets[iter49];
+        iter49.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.selector !== null && this.selector !== undefined) {
+    output.writeFieldBegin('selector', Thrift.Type.STRUCT, 4);
+    this.selector.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.allowStaleData !== null && this.allowStaleData !== undefined) {
+    output.writeFieldBegin('allowStaleData', Thrift.Type.BOOL, 5);
+    output.writeBool(this.allowStaleData);
+    output.writeFieldEnd();
+  }
+  if (this.useCacheIfPresent !== null && this.useCacheIfPresent !== undefined) {
+    output.writeFieldBegin('useCacheIfPresent', Thrift.Type.BOOL, 6);
+    output.writeBool(this.useCacheIfPresent);
+    output.writeFieldEnd();
+  }
+  if (this.start !== null && this.start !== undefined) {
+    output.writeFieldBegin('start', Thrift.Type.I64, 7);
+    output.writeI64(this.start);
+    output.writeFieldEnd();
+  }
+  if (this.fetch !== null && this.fetch !== undefined) {
+    output.writeFieldBegin('fetch', Thrift.Type.I32, 8);
+    output.writeI32(this.fetch);
+    output.writeFieldEnd();
+  }
+  if (this.minimumNumberOfResults !== null && this.minimumNumberOfResults !== undefined) {
+    output.writeFieldBegin('minimumNumberOfResults', Thrift.Type.I64, 9);
+    output.writeI64(this.minimumNumberOfResults);
+    output.writeFieldEnd();
+  }
+  if (this.maxQueryTime !== null && this.maxQueryTime !== undefined) {
+    output.writeFieldBegin('maxQueryTime', Thrift.Type.I64, 10);
+    output.writeI64(this.maxQueryTime);
+    output.writeFieldEnd();
+  }
+  if (this.uuid !== null && this.uuid !== undefined) {
+    output.writeFieldBegin('uuid', Thrift.Type.I64, 11);
+    output.writeI64(this.uuid);
+    output.writeFieldEnd();
+  }
+  if (this.userContext !== null && this.userContext !== undefined) {
+    output.writeFieldBegin('userContext', Thrift.Type.STRING, 12);
+    output.writeString(this.userContext);
+    output.writeFieldEnd();
+  }
+  if (this.cacheResult !== null && this.cacheResult !== undefined) {
+    output.writeFieldBegin('cacheResult', Thrift.Type.BOOL, 13);
+    output.writeBool(this.cacheResult);
+    output.writeFieldEnd();
+  }
+  if (this.startTime !== null && this.startTime !== undefined) {
+    output.writeFieldBegin('startTime', Thrift.Type.I64, 14);
+    output.writeI64(this.startTime);
+    output.writeFieldEnd();
+  }
+  if (this.modifyFileCaches !== null && this.modifyFileCaches !== undefined) {
+    output.writeFieldBegin('modifyFileCaches', Thrift.Type.BOOL, 15);
+    output.writeBool(this.modifyFileCaches);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+BlurResult = function(args) {
+  this.locationId = null;
+  this.score = null;
+  this.fetchResult = null;
+  if (args) {
+    if (args.locationId !== undefined) {
+      this.locationId = args.locationId;
+    }
+    if (args.score !== undefined) {
+      this.score = args.score;
+    }
+    if (args.fetchResult !== undefined) {
+      this.fetchResult = args.fetchResult;
+    }
+  }
+};
+BlurResult.prototype = {};
+BlurResult.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.locationId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.DOUBLE) {
+        this.score = input.readDouble().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.fetchResult = new FetchResult();
+        this.fetchResult.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurResult.prototype.write = function(output) {
+  output.writeStructBegin('BlurResult');
+  if (this.locationId !== null && this.locationId !== undefined) {
+    output.writeFieldBegin('locationId', Thrift.Type.STRING, 1);
+    output.writeString(this.locationId);
+    output.writeFieldEnd();
+  }
+  if (this.score !== null && this.score !== undefined) {
+    output.writeFieldBegin('score', Thrift.Type.DOUBLE, 2);
+    output.writeDouble(this.score);
+    output.writeFieldEnd();
+  }
+  if (this.fetchResult !== null && this.fetchResult !== undefined) {
+    output.writeFieldBegin('fetchResult', Thrift.Type.STRUCT, 3);
+    this.fetchResult.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+BlurResults = function(args) {
+  this.totalResults = 0;
+  this.shardInfo = null;
+  this.results = null;
+  this.facetCounts = null;
+  this.exceptions = null;
+  this.query = null;
+  if (args) {
+    if (args.totalResults !== undefined) {
+      this.totalResults = args.totalResults;
+    }
+    if (args.shardInfo !== undefined) {
+      this.shardInfo = args.shardInfo;
+    }
+    if (args.results !== undefined) {
+      this.results = args.results;
+    }
+    if (args.facetCounts !== undefined) {
+      this.facetCounts = args.facetCounts;
+    }
+    if (args.exceptions !== undefined) {
+      this.exceptions = args.exceptions;
+    }
+    if (args.query !== undefined) {
+      this.query = args.query;
+    }
+  }
+};
+BlurResults.prototype = {};
+BlurResults.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.I64) {
+        this.totalResults = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.MAP) {
+        var _size50 = 0;
+        var _rtmp354;
+        this.shardInfo = {};
+        var _ktype51 = 0;
+        var _vtype52 = 0;
+        _rtmp354 = input.readMapBegin();
+        _ktype51 = _rtmp354.ktype;
+        _vtype52 = _rtmp354.vtype;
+        _size50 = _rtmp354.size;
+        for (var _i55 = 0; _i55 < _size50; ++_i55)
+        {
+          if (_i55 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key56 = null;
+          var val57 = null;
+          key56 = input.readString().value;
+          val57 = input.readI64().value;
+          this.shardInfo[key56] = val57;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.LIST) {
+        var _size58 = 0;
+        var _rtmp362;
+        this.results = [];
+        var _etype61 = 0;
+        _rtmp362 = input.readListBegin();
+        _etype61 = _rtmp362.etype;
+        _size58 = _rtmp362.size;
+        for (var _i63 = 0; _i63 < _size58; ++_i63)
+        {
+          var elem64 = null;
+          elem64 = new BlurResult();
+          elem64.read(input);
+          this.results.push(elem64);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.LIST) {
+        var _size65 = 0;
+        var _rtmp369;
+        this.facetCounts = [];
+        var _etype68 = 0;
+        _rtmp369 = input.readListBegin();
+        _etype68 = _rtmp369.etype;
+        _size65 = _rtmp369.size;
+        for (var _i70 = 0; _i70 < _size65; ++_i70)
+        {
+          var elem71 = null;
+          elem71 = input.readI64().value;
+          this.facetCounts.push(elem71);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.LIST) {
+        var _size72 = 0;
+        var _rtmp376;
+        this.exceptions = [];
+        var _etype75 = 0;
+        _rtmp376 = input.readListBegin();
+        _etype75 = _rtmp376.etype;
+        _size72 = _rtmp376.size;
+        for (var _i77 = 0; _i77 < _size72; ++_i77)
+        {
+          var elem78 = null;
+          elem78 = new BlurException();
+          elem78.read(input);
+          this.exceptions.push(elem78);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.query = new BlurQuery();
+        this.query.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurResults.prototype.write = function(output) {
+  output.writeStructBegin('BlurResults');
+  if (this.totalResults !== null && this.totalResults !== undefined) {
+    output.writeFieldBegin('totalResults', Thrift.Type.I64, 1);
+    output.writeI64(this.totalResults);
+    output.writeFieldEnd();
+  }
+  if (this.shardInfo !== null && this.shardInfo !== undefined) {
+    output.writeFieldBegin('shardInfo', Thrift.Type.MAP, 2);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.I64, Thrift.objectLength(this.shardInfo));
+    for (var kiter79 in this.shardInfo)
+    {
+      if (this.shardInfo.hasOwnProperty(kiter79))
+      {
+        var viter80 = this.shardInfo[kiter79];
+        output.writeString(kiter79);
+        output.writeI64(viter80);
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  if (this.results !== null && this.results !== undefined) {
+    output.writeFieldBegin('results', Thrift.Type.LIST, 3);
+    output.writeListBegin(Thrift.Type.STRUCT, this.results.length);
+    for (var iter81 in this.results)
+    {
+      if (this.results.hasOwnProperty(iter81))
+      {
+        iter81 = this.results[iter81];
+        iter81.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.facetCounts !== null && this.facetCounts !== undefined) {
+    output.writeFieldBegin('facetCounts', Thrift.Type.LIST, 4);
+    output.writeListBegin(Thrift.Type.I64, this.facetCounts.length);
+    for (var iter82 in this.facetCounts)
+    {
+      if (this.facetCounts.hasOwnProperty(iter82))
+      {
+        iter82 = this.facetCounts[iter82];
+        output.writeI64(iter82);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.exceptions !== null && this.exceptions !== undefined) {
+    output.writeFieldBegin('exceptions', Thrift.Type.LIST, 5);
+    output.writeListBegin(Thrift.Type.STRUCT, this.exceptions.length);
+    for (var iter83 in this.exceptions)
+    {
+      if (this.exceptions.hasOwnProperty(iter83))
+      {
+        iter83 = this.exceptions[iter83];
+        iter83.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.query !== null && this.query !== undefined) {
+    output.writeFieldBegin('query', Thrift.Type.STRUCT, 6);
+    this.query.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+RecordMutation = function(args) {
+  this.recordMutationType = null;
+  this.record = null;
+  if (args) {
+    if (args.recordMutationType !== undefined) {
+      this.recordMutationType = args.recordMutationType;
+    }
+    if (args.record !== undefined) {
+      this.record = args.record;
+    }
+  }
+};
+RecordMutation.prototype = {};
+RecordMutation.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.I32) {
+        this.recordMutationType = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.record = new Record();
+        this.record.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+RecordMutation.prototype.write = function(output) {
+  output.writeStructBegin('RecordMutation');
+  if (this.recordMutationType !== null && this.recordMutationType !== undefined) {
+    output.writeFieldBegin('recordMutationType', Thrift.Type.I32, 1);
+    output.writeI32(this.recordMutationType);
+    output.writeFieldEnd();
+  }
+  if (this.record !== null && this.record !== undefined) {
+    output.writeFieldBegin('record', Thrift.Type.STRUCT, 2);
+    this.record.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+RowMutation = function(args) {
+  this.table = null;
+  this.rowId = null;
+  this.wal = true;
+  this.rowMutationType = null;
+  this.recordMutations = null;
+  this.waitToBeVisible = false;
+  if (args) {
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.rowId !== undefined) {
+      this.rowId = args.rowId;
+    }
+    if (args.wal !== undefined) {
+      this.wal = args.wal;
+    }
+    if (args.rowMutationType !== undefined) {
+      this.rowMutationType = args.rowMutationType;
+    }
+    if (args.recordMutations !== undefined) {
+      this.recordMutations = args.recordMutations;
+    }
+    if (args.waitToBeVisible !== undefined) {
+      this.waitToBeVisible = args.waitToBeVisible;
+    }
+  }
+};
+RowMutation.prototype = {};
+RowMutation.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    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.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.rowId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.BOOL) {
+        this.wal = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.I32) {
+        this.rowMutationType = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.LIST) {
+        var _size84 = 0;
+        var _rtmp388;
+        this.recordMutations = [];
+        var _etype87 = 0;
+        _rtmp388 = input.readListBegin();
+        _etype87 = _rtmp388.etype;
+        _size84 = _rtmp388.size;
+        for (var _i89 = 0; _i89 < _size84; ++_i89)
+        {
+          var elem90 = null;
+          elem90 = new RecordMutation();
+          elem90.read(input);
+          this.recordMutations.push(elem90);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.BOOL) {
+        this.waitToBeVisible = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+RowMutation.prototype.write = function(output) {
+  output.writeStructBegin('RowMutation');
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.rowId !== null && this.rowId !== undefined) {
+    output.writeFieldBegin('rowId', Thrift.Type.STRING, 2);
+    output.writeString(this.rowId);
+    output.writeFieldEnd();
+  }
+  if (this.wal !== null && this.wal !== undefined) {
+    output.writeFieldBegin('wal', Thrift.Type.BOOL, 3);
+    output.writeBool(this.wal);
+    output.writeFieldEnd();
+  }
+  if (this.rowMutationType !== null && this.rowMutationType !== undefined) {
+    output.writeFieldBegin('rowMutationType', Thrift.Type.I32, 4);
+    output.writeI32(this.rowMutationType);
+    output.writeFieldEnd();
+  }
+  if (this.recordMutations !== null && this.recordMutations !== undefined) {
+    output.writeFieldBegin('recordMutations', Thrift.Type.LIST, 5);
+    output.writeListBegin(Thrift.Type.STRUCT, this.recordMutations.length);
+    for (var iter91 in this.recordMutations)
+    {
+      if (this.recordMutations.hasOwnProperty(iter91))
+      {
+        iter91 = this.recordMutations[iter91];
+        iter91.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.waitToBeVisible !== null && this.waitToBeVisible !== undefined) {
+    output.writeFieldBegin('waitToBeVisible', Thrift.Type.BOOL, 6);
+    output.writeBool(this.waitToBeVisible);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+CpuTime = function(args) {
+  this.cpuTime = null;
+  this.realTime = null;
+  if (args) {
+    if (args.cpuTime !== undefined) {
+      this.cpuTime = args.cpuTime;
+    }
+    if (args.realTime !== undefined) {
+      this.realTime = args.realTime;
+    }
+  }
+};
+CpuTime.prototype = {};
+CpuTime.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.I64) {
+        this.cpuTime = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.I64) {
+        this.realTime = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+CpuTime.prototype.write = function(output) {
+  output.writeStructBegin('CpuTime');
+  if (this.cpuTime !== null && this.cpuTime !== undefined) {
+    output.writeFieldBegin('cpuTime', Thrift.Type.I64, 1);
+    output.writeI64(this.cpuTime);
+    output.writeFieldEnd();
+  }
+  if (this.realTime !== null && this.realTime !== undefined) {
+    output.writeFieldBegin('realTime', Thrift.Type.I64, 2);
+    output.writeI64(this.realTime);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+BlurQueryStatus = function(args) {
+  this.query = null;
+  this.cpuTimes = null;
+  this.completeShards = null;
+  this.totalShards = null;
+  this.state = null;
+  this.uuid = null;
+  if (args) {
+    if (args.query !== undefined) {
+      this.query = args.query;
+    }
+    if (args.cpuTimes !== undefined) {
+      this.cpuTimes = args.cpuTimes;
+    }
+    if (args.completeShards !== undefined) {
+      this.completeShards = args.completeShards;
+    }
+    if (args.totalShards !== undefined) {
+      this.totalShards = args.totalShards;
+    }
+    if (args.state !== undefined) {
+      this.state = args.state;
+    }
+    if (args.uuid !== undefined) {
+      this.uuid = args.uuid;
+    }
+  }
+};
+BlurQueryStatus.prototype = {};
+BlurQueryStatus.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.query = new BlurQuery();
+        this.query.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.MAP) {
+        var _size92 = 0;
+        var _rtmp396;
+        this.cpuTimes = {};
+        var _ktype93 = 0;
+        var _vtype94 = 0;
+        _rtmp396 = input.readMapBegin();
+        _ktype93 = _rtmp396.ktype;
+        _vtype94 = _rtmp396.vtype;
+        _size92 = _rtmp396.size;
+        for (var _i97 = 0; _i97 < _size92; ++_i97)
+        {
+          if (_i97 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key98 = null;
+          var val99 = null;
+          key98 = input.readString().value;
+          val99 = new CpuTime();
+          val99.read(input);
+          this.cpuTimes[key98] = val99;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.completeShards = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.I32) {
+        this.totalShards = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.I32) {
+        this.state = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.I64) {
+        this.uuid = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurQueryStatus.prototype.write = function(output) {
+  output.writeStructBegin('BlurQueryStatus');
+  if (this.query !== null && this.query !== undefined) {
+    output.writeFieldBegin('query', Thrift.Type.STRUCT, 1);
+    this.query.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.cpuTimes !== null && this.cpuTimes !== undefined) {
+    output.writeFieldBegin('cpuTimes', Thrift.Type.MAP, 2);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(this.cpuTimes));
+    for (var kiter100 in this.cpuTimes)
+    {
+      if (this.cpuTimes.hasOwnProperty(kiter100))
+      {
+        var viter101 = this.cpuTimes[kiter100];
+        output.writeString(kiter100);
+        viter101.write(output);
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  if (this.completeShards !== null && this.completeShards !== undefined) {
+    output.writeFieldBegin('completeShards', Thrift.Type.I32, 3);
+    output.writeI32(this.completeShards);
+    output.writeFieldEnd();
+  }
+  if (this.totalShards !== null && this.totalShards !== undefined) {
+    output.writeFieldBegin('totalShards', Thrift.Type.I32, 4);
+    output.writeI32(this.totalShards);
+    output.writeFieldEnd();
+  }
+  if (this.state !== null && this.state !== undefined) {
+    output.writeFieldBegin('state', Thrift.Type.I32, 5);
+    output.writeI32(this.state);
+    output.writeFieldEnd();
+  }
+  if (this.uuid !== null && this.uuid !== undefined) {
+    output.writeFieldBegin('uuid', Thrift.Type.I64, 6);
+    output.writeI64(this.uuid);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+TableStats = function(args) {
+  this.tableName = null;
+  this.bytes = null;
+  this.recordCount = null;
+  this.rowCount = null;
+  this.queries = null;
+  if (args) {
+    if (args.tableName !== undefined) {
+      this.tableName = args.tableName;
+    }
+    if (args.bytes !== undefined) {
+      this.bytes = args.bytes;
+    }
+    if (args.recordCount !== undefined) {
+      this.recordCount = args.recordCount;
+    }
+    if (args.rowCount !== undefined) {
+      this.rowCount = args.rowCount;
+    }
+    if (args.queries !== undefined) {
+      this.queries = args.queries;
+    }
+  }
+};
+TableStats.prototype = {};
+TableStats.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.tableName = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.I64) {
+        this.bytes = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I64) {
+        this.recordCount = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.I64) {
+        this.rowCount = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.I64) {
+        this.queries = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+TableStats.prototype.write = function(output) {
+  output.writeStructBegin('TableStats');
+  if (this.tableName !== null && this.tableName !== undefined) {
+    output.writeFieldBegin('tableName', Thrift.Type.STRING, 1);
+    output.writeString(this.tableName);
+    output.writeFieldEnd();
+  }
+  if (this.bytes !== null && this.bytes !== undefined) {
+    output.writeFieldBegin('bytes', Thrift.Type.I64, 2);
+    output.writeI64(this.bytes);
+    output.writeFieldEnd();
+  }
+  if (this.recordCount !== null && this.recordCount !== undefined) {
+    output.writeFieldBegin('recordCount', Thrift.Type.I64, 3);
+    output.writeI64(this.recordCount);
+    output.writeFieldEnd();
+  }
+  if (this.rowCount !== null && this.rowCount !== undefined) {
+    output.writeFieldBegin('rowCount', Thrift.Type.I64, 4);
+    output.writeI64(this.rowCount);
+    output.writeFieldEnd();
+  }
+  if (this.queries !== null && this.queries !== undefined) {
+    output.writeFieldBegin('queries', Thrift.Type.I64, 5);
+    output.writeI64(this.queries);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Schema = function(args) {
+  this.table = null;
+  this.columnFamilies = null;
+  if (args) {
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.columnFamilies !== undefined) {
+      this.columnFamilies = args.columnFamilies;
+    }
+  }
+};
+Schema.prototype = {};
+Schema.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    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.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.MAP) {
+        var _size102 = 0;
+        var _rtmp3106;
+        this.columnFamilies = {};
+        var _ktype103 = 0;
+        var _vtype104 = 0;
+        _rtmp3106 = input.readMapBegin();
+        _ktype103 = _rtmp3106.ktype;
+        _vtype104 = _rtmp3106.vtype;
+        _size102 = _rtmp3106.size;
+        for (var _i107 = 0; _i107 < _size102; ++_i107)
+        {
+          if (_i107 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key108 = null;
+          var val109 = null;
+          key108 = input.readString().value;
+          var _size110 = 0;
+          var _rtmp3114;
+          val109 = [];
+          var _etype113 = 0;
+          _rtmp3114 = input.readSetBegin();
+          _etype113 = _rtmp3114.etype;
+          _size110 = _rtmp3114.size;
+          for (var _i115 = 0; _i115 < _size110; ++_i115)
+          {
+            var elem116 = null;
+            elem116 = input.readString().value;
+            val109.push(elem116);
+          }
+          input.readSetEnd();
+          this.columnFamilies[key108] = val109;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Schema.prototype.write = function(output) {
+  output.writeStructBegin('Schema');
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.columnFamilies !== null && this.columnFamilies !== undefined) {
+    output.writeFieldBegin('columnFamilies', Thrift.Type.MAP, 2);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.SET, Thrift.objectLength(this.columnFamilies));
+    for (var kiter117 in this.columnFamilies)
+    {
+      if (this.columnFamilies.hasOwnProperty(kiter117))
+      {
+        var viter118 = this.columnFamilies[kiter117];
+        output.writeString(kiter117);
+        output.writeSetBegin(Thrift.Type.STRING, viter118.length);
+        for (var iter119 in viter118)
+        {
+          if (viter118.hasOwnProperty(iter119))
+          {
+            iter119 = viter118[iter119];
+            output.writeString(iter119);
+          }
+        }
+        output.writeSetEnd();
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+AlternateColumnDefinition = function(args) {
+  this.analyzerClassName = null;
+  if (args) {
+    if (args.analyzerClassName !== undefined) {
+      this.analyzerClassName = args.analyzerClassName;
+    }
+  }
+};
+AlternateColumnDefinition.prototype = {};
+AlternateColumnDefinition.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.analyzerClassName = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+AlternateColumnDefinition.prototype.write = function(output) {
+  output.writeStructBegin('AlternateColumnDefinition');
+  if (this.analyzerClassName !== null && this.analyzerClassName !== undefined) {
+    output.writeFieldBegin('analyzerClassName', Thrift.Type.STRING, 1);
+    output.writeString(this.analyzerClassName);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+ColumnDefinition = function(args) {
+  this.analyzerClassName = 'org.apache.lucene.analysis.standard.StandardAnalyzer';
+  this.fullTextIndex = null;
+  this.alternateColumnDefinitions = null;
+  if (args) {
+    if (args.analyzerClassName !== undefined) {
+      this.analyzerClassName = args.analyzerClassName;
+    }
+    if (args.fullTextIndex !== undefined) {
+      this.fullTextIndex = args.fullTextIndex;
+    }
+    if (args.alternateColumnDefinitions !== undefined) {
+      this.alternateColumnDefinitions = args.alternateColumnDefinitions;
+    }
+  }
+};
+ColumnDefinition.prototype = {};
+ColumnDefinition.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRING) {
+        this.analyzerClassName = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.BOOL) {
+        this.fullTextIndex = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.MAP) {
+        var _size120 = 0;
+        var _rtmp3124;
+        this.alternateColumnDefinitions = {};
+        var _ktype121 = 0;
+        var _vtype122 = 0;
+        _rtmp3124 = input.readMapBegin();
+        _ktype121 = _rtmp3124.ktype;
+        _vtype122 = _rtmp3124.vtype;
+        _size120 = _rtmp3124.size;
+        for (var _i125 = 0; _i125 < _size120; ++_i125)
+        {
+          if (_i125 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key126 = null;
+          var val127 = null;
+          key126 = input.readString().value;
+          val127 = new AlternateColumnDefinition();
+          val127.read(input);
+          this.alternateColumnDefinitions[key126] = val127;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+ColumnDefinition.prototype.write = function(output) {
+  output.writeStructBegin('ColumnDefinition');
+  if (this.analyzerClassName !== null && this.analyzerClassName !== undefined) {
+    output.writeFieldBegin('analyzerClassName', Thrift.Type.STRING, 1);
+    output.writeString(this.analyzerClassName);
+    output.writeFieldEnd();
+  }
+  if (this.fullTextIndex !== null && this.fullTextIndex !== undefined) {
+    output.writeFieldBegin('fullTextIndex', Thrift.Type.BOOL, 2);
+    output.writeBool(this.fullTextIndex);
+    output.writeFieldEnd();
+  }
+  if (this.alternateColumnDefinitions !== null && this.alternateColumnDefinitions !== undefined) {
+    output.writeFieldBegin('alternateColumnDefinitions', Thrift.Type.MAP, 3);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(this.alternateColumnDefinitions));
+    for (var kiter128 in this.alternateColumnDefinitions)
+    {
+      if (this.alternateColumnDefinitions.hasOwnProperty(kiter128))
+      {
+        var viter129 = this.alternateColumnDefinitions[kiter128];
+        output.writeString(kiter128);
+        viter129.write(output);
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+ColumnFamilyDefinition = function(args) {
+  this.defaultDefinition = null;
+  this.columnDefinitions = null;
+  if (args) {
+    if (args.defaultDefinition !== undefined) {
+      this.defaultDefinition = args.defaultDefinition;
+    }
+    if (args.columnDefinitions !== undefined) {
+      this.columnDefinitions = args.columnDefinitions;
+    }
+  }
+};
+ColumnFamilyDefinition.prototype = {};
+ColumnFamilyDefinition.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.defaultDefinition = new ColumnDefinition();
+        this.defaultDefinition.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.MAP) {
+        var _size130 = 0;
+        var _rtmp3134;
+        this.columnDefinitions = {};
+        var _ktype131 = 0;
+        var _vtype132 = 0;
+        _rtmp3134 = input.readMapBegin();
+        _ktype131 = _rtmp3134.ktype;
+        _vtype132 = _rtmp3134.vtype;
+        _size130 = _rtmp3134.size;
+        for (var _i135 = 0; _i135 < _size130; ++_i135)
+        {
+          if (_i135 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key136 = null;
+          var val137 = null;
+          key136 = input.readString().value;
+          val137 = new ColumnDefinition();
+          val137.read(input);
+          this.columnDefinitions[key136] = val137;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+ColumnFamilyDefinition.prototype.write = function(output) {
+  output.writeStructBegin('ColumnFamilyDefinition');
+  if (this.defaultDefinition !== null && this.defaultDefinition !== undefined) {
+    output.writeFieldBegin('defaultDefinition', Thrift.Type.STRUCT, 1);
+    this.defaultDefinition.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.columnDefinitions !== null && this.columnDefinitions !== undefined) {
+    output.writeFieldBegin('columnDefinitions', Thrift.Type.MAP, 2);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(this.columnDefinitions));
+    for (var kiter138 in this.columnDefinitions)
+    {
+      if (this.columnDefinitions.hasOwnProperty(kiter138))
+      {
+        var viter139 = this.columnDefinitions[kiter138];
+        output.writeString(kiter138);
+        viter139.write(output);
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+AnalyzerDefinition = function(args) {
+  this.defaultDefinition = null;
+  this.fullTextAnalyzerClassName = 'org.apache.lucene.analysis.standard.StandardAnalyzer';
+  this.columnFamilyDefinitions = null;
+  if (args) {
+    if (args.defaultDefinition !== undefined) {
+      this.defaultDefinition = args.defaultDefinition;
+    }
+    if (args.fullTextAnalyzerClassName !== undefined) {
+      this.fullTextAnalyzerClassName = args.fullTextAnalyzerClassName;
+    }
+    if (args.columnFamilyDefinitions !== undefined) {
+      this.columnFamilyDefinitions = args.columnFamilyDefinitions;
+    }
+  }
+};
+AnalyzerDefinition.prototype = {};
+AnalyzerDefinition.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.defaultDefinition = new ColumnDefinition();
+        this.defaultDefinition.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.fullTextAnalyzerClassName = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.MAP) {
+        var _size140 = 0;
+        var _rtmp3144;
+        this.columnFamilyDefinitions = {};
+        var _ktype141 = 0;
+        var _vtype142 = 0;
+        _rtmp3144 = input.readMapBegin();
+        _ktype141 = _rtmp3144.ktype;
+        _vtype142 = _rtmp3144.vtype;
+        _size140 = _rtmp3144.size;
+        for (var _i145 = 0; _i145 < _size140; ++_i145)
+        {
+          if (_i145 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key146 = null;
+          var val147 = null;
+          key146 = input.readString().value;
+          val147 = new ColumnFamilyDefinition();
+          val147.read(input);
+          this.columnFamilyDefinitions[key146] = val147;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+AnalyzerDefinition.prototype.write = function(output) {
+  output.writeStructBegin('AnalyzerDefinition');
+  if (this.defaultDefinition !== null && this.defaultDefinition !== undefined) {
+    output.writeFieldBegin('defaultDefinition', Thrift.Type.STRUCT, 1);
+    this.defaultDefinition.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.fullTextAnalyzerClassName !== null && this.fullTextAnalyzerClassName !== undefined) {
+    output.writeFieldBegin('fullTextAnalyzerClassName', Thrift.Type.STRING, 2);
+    output.writeString(this.fullTextAnalyzerClassName);
+    output.writeFieldEnd();
+  }
+  if (this.columnFamilyDefinitions !== null && this.columnFamilyDefinitions !== undefined) {
+    output.writeFieldBegin('columnFamilyDefinitions', Thrift.Type.MAP, 3);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(this.columnFamilyDefinitions));
+    for (var kiter148 in this.columnFamilyDefinitions)
+    {
+      if (this.columnFamilyDefinitions.hasOwnProperty(kiter148))
+      {
+        var viter149 = this.columnFamilyDefinitions[kiter148];
+        output.writeString(kiter148);
+        viter149.write(output);
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+ColumnPreCache = function(args) {
+  this.preCacheCols = null;
+  if (args) {
+    if (args.preCacheCols !== undefined) {
+      this.preCacheCols = args.preCacheCols;
+    }
+  }
+};
+ColumnPreCache.prototype = {};
+ColumnPreCache.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.LIST) {
+        var _size150 = 0;
+        var _rtmp3154;
+        this.preCacheCols = [];
+        var _etype153 = 0;
+        _rtmp3154 = input.readListBegin();
+        _etype153 = _rtmp3154.etype;
+        _size150 = _rtmp3154.size;
+        for (var _i155 = 0; _i155 < _size150; ++_i155)
+        {
+          var elem156 = null;
+          elem156 = input.readString().value;
+          this.preCacheCols.push(elem156);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+ColumnPreCache.prototype.write = function(output) {
+  output.writeStructBegin('ColumnPreCache');
+  if (this.preCacheCols !== null && this.preCacheCols !== undefined) {
+    output.writeFieldBegin('preCacheCols', Thrift.Type.LIST, 1);
+    output.writeListBegin(Thrift.Type.STRING, this.preCacheCols.length);
+    for (var iter157 in this.preCacheCols)
+    {
+      if (this.preCacheCols.hasOwnProperty(iter157))
+      {
+        iter157 = this.preCacheCols[iter157];
+        output.writeString(iter157);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+TableDescriptor = function(args) {
+  this.isEnabled = true;
+  this.analyzerDefinition = null;
+  this.shardCount = 1;
+  this.tableUri = null;
+  this.compressionClass = 'org.apache.hadoop.io.compress.DefaultCodec';
+  this.compressionBlockSize = 32768;
+  this.cluster = 'default';
+  this.name = null;
+  this.similarityClass = null;
+  this.blockCaching = true;
+  this.blockCachingFileTypes = null;
+  this.readOnly = false;
+  this.columnPreCache = null;
+  if (args) {
+    if (args.isEnabled !== undefined) {
+      this.isEnabled = args.isEnabled;
+    }
+    if (args.analyzerDefinition !== undefined) {
+      this.analyzerDefinition = args.analyzerDefinition;
+    }
+    if (args.shardCount !== undefined) {
+      this.shardCount = args.shardCount;
+    }
+    if (args.tableUri !== undefined) {
+      this.tableUri = args.tableUri;
+    }
+    if (args.compressionClass !== undefined) {
+      this.compressionClass = args.compressionClass;
+    }
+    if (args.compressionBlockSize !== undefined) {
+      this.compressionBlockSize = args.compressionBlockSize;
+    }
+    if (args.cluster !== undefined) {
+      this.cluster = args.cluster;
+    }
+    if (args.name !== undefined) {
+      this.name = args.name;
+    }
+    if (args.similarityClass !== undefined) {
+      this.similarityClass = args.similarityClass;
+    }
+    if (args.blockCaching !== undefined) {
+      this.blockCaching = args.blockCaching;
+    }
+    if (args.blockCachingFileTypes !== undefined) {
+      this.blockCachingFileTypes = args.blockCachingFileTypes;
+    }
+    if (args.readOnly !== undefined) {
+      this.readOnly = args.readOnly;
+    }
+    if (args.columnPreCache !== undefined) {
+      this.columnPreCache = args.columnPreCache;
+    }
+  }
+};
+TableDescriptor.prototype = {};
+TableDescriptor.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.BOOL) {
+        this.isEnabled = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.analyzerDefinition = new AnalyzerDefinition();
+        this.analyzerDefinition.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.shardCount = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRING) {
+        this.tableUri = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.STRING) {
+        this.compressionClass = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.I32) {
+        this.compressionBlockSize = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 7:
+      if (ftype == Thrift.Type.STRING) {
+        this.cluster = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 8:
+      if (ftype == Thrift.Type.STRING) {
+        this.name = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 9:
+      if (ftype == Thrift.Type.STRING) {
+        this.similarityClass = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 10:
+      if (ftype == Thrift.Type.BOOL) {
+        this.blockCaching = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 11:
+      if (ftype == Thrift.Type.SET) {
+        var _size158 = 0;
+        var _rtmp3162;
+        this.blockCachingFileTypes = [];
+        var _etype161 = 0;
+        _rtmp3162 = input.readSetBegin();
+        _etype161 = _rtmp3162.etype;
+        _size158 = _rtmp3162.size;
+        for (var _i163 = 0; _i163 < _size158; ++_i163)
+        {
+          var elem164 = null;
+          elem164 = input.readString().value;
+          this.blockCachingFileTypes.push(elem164);
+        }
+        input.readSetEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 12:
+      if (ftype == Thrift.Type.BOOL) {
+        this.readOnly = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 13:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.columnPreCache = new ColumnPreCache();
+        this.columnPreCache.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+TableDescriptor.prototype.write = function(output) {
+  output.writeStructBegin('TableDescriptor');
+  if (this.isEnabled !== null && this.isEnabled !== undefined) {
+    output.writeFieldBegin('isEnabled', Thrift.Type.BOOL, 1);
+    output.writeBool(this.isEnabled);
+    output.writeFieldEnd();
+  }
+  if (this.analyzerDefinition !== null && this.analyzerDefinition !== undefined) {
+    output.writeFieldBegin('analyzerDefinition', Thrift.Type.STRUCT, 2);
+    this.analyzerDefinition.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.shardCount !== null && this.shardCount !== undefined) {
+    output.writeFieldBegin('shardCount', Thrift.Type.I32, 3);
+    output.writeI32(this.shardCount);
+    output.writeFieldEnd();
+  }
+  if (this.tableUri !== null && this.tableUri !== undefined) {
+    output.writeFieldBegin('tableUri', Thrift.Type.STRING, 4);
+    output.writeString(this.tableUri);
+    output.writeFieldEnd();
+  }
+  if (this.compressionClass !== null && this.compressionClass !== undefined) {
+    output.writeFieldBegin('compressionClass', Thrift.Type.STRING, 5);
+    output.writeString(this.compressionClass);
+    output.writeFieldEnd();
+  }
+  if (this.compressionBlockSize !== null && this.compressionBlockSize !== undefined) {
+    output.writeFieldBegin('compressionBlockSize', Thrift.Type.I32, 6);
+    output.writeI32(this.compressionBlockSize);
+    output.writeFieldEnd();
+  }
+  if (this.cluster !== null && this.cluster !== undefined) {
+    output.writeFieldBegin('cluster', Thrift.Type.STRING, 7);
+    output.writeString(this.cluster);
+    output.writeFieldEnd();
+  }
+  if (this.name !== null && this.name !== undefined) {
+    output.writeFieldBegin('name', Thrift.Type.STRING, 8);
+    output.writeString(this.name);
+    output.writeFieldEnd();
+  }
+  if (this.similarityClass !== null && this.similarityClass !== undefined) {
+    output.writeFieldBegin('similarityClass', Thrift.Type.STRING, 9);
+    output.writeString(this.similarityClass);
+    output.writeFieldEnd();
+  }
+  if (this.blockCaching !== null && this.blockCaching !== undefined) {
+    output.writeFieldBegin('blockCaching', Thrift.Type.BOOL, 10);
+    output.writeBool(this.blockCaching);
+    output.writeFieldEnd();
+  }
+  if (this.blockCachingFileTypes !== null && this.blockCachingFileTypes !== undefined) {
+    output.writeFieldBegin('blockCachingFileTypes', Thrift.Type.SET, 11);
+    output.writeSetBegin(Thrift.Type.STRING, this.blockCachingFileTypes.length);
+    for (var iter165 in this.blockCachingFileTypes)
+    {
+      if (this.blockCachingFileTypes.hasOwnProperty(iter165))
+      {
+        iter165 = this.blockCachingFileTypes[iter165];
+        output.writeString(iter165);
+      }
+    }
+    output.writeSetEnd();
+    output.writeFieldEnd();
+  }
+  if (this.readOnly !== null && this.readOnly !== undefined) {
+    output.writeFieldBegin('readOnly', Thrift.Type.BOOL, 12);
+    output.writeBool(this.readOnly);
+    output.writeFieldEnd();
+  }
+  if (this.columnPreCache !== null && this.columnPreCache !== undefined) {
+    output.writeFieldBegin('columnPreCache', Thrift.Type.STRUCT, 13);
+    this.columnPreCache.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/39c899d2/src/distribution/src/main/scripts/interface/genAndReplace.sh
----------------------------------------------------------------------
diff --git a/src/distribution/src/main/scripts/interface/genAndReplace.sh b/src/distribution/src/main/scripts/interface/genAndReplace.sh
index 860716c..b387bdc 100755
--- a/src/distribution/src/main/scripts/interface/genAndReplace.sh
+++ b/src/distribution/src/main/scripts/interface/genAndReplace.sh
@@ -19,7 +19,7 @@
 
 rm ../../../../../../src/blur-thrift/src/main/java/org/apache/blur/thrift/generated/*
 rm -r gen-java/ gen-perl/ gen-rb/ gen-html/
-thrift --gen html --gen perl --gen java --gen rb Blur.thrift
+thrift --gen html --gen perl --gen java --gen rb --gen js Blur.thrift
 for f in gen-java/org/apache/blur/thrift/generated/*.java; do
   awk -v f="apache.header" 'BEGIN {while (getline < f) txt=txt $0 "\n"} /package org\.apache\.blur\.thrift\.generated;/ {sub("package org.apache.blur.thrift.generated;", txt)} 1' $f > $f.new
   rm $f


Mime
View raw message