node-storm/lib/gen-nodejs/Nimbus.js

Node.js multilang protocol implementation for Storm

//
// Autogenerated by Thrift Compiler (0.9.1)
//
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
//
var Thrift = require('thrift').Thrift;

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

Nimbus_submitTopology_args = function(args) {
  this.name = null;
  this.uploadedJarLocation = null;
  this.jsonConf = null;
  this.topology = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.uploadedJarLocation !== undefined) {
      this.uploadedJarLocation = args.uploadedJarLocation;
    }
    if (args.jsonConf !== undefined) {
      this.jsonConf = args.jsonConf;
    }
    if (args.topology !== undefined) {
      this.topology = args.topology;
    }
  }
};
Nimbus_submitTopology_args.prototype = {};
Nimbus_submitTopology_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.uploadedJarLocation = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.jsonConf = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRUCT) {
        this.topology = new ttypes.StormTopology();
        this.topology.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_submitTopology_args.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_submitTopology_args');
  if (this.name !== null && this.name !== undefined) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.uploadedJarLocation !== null && this.uploadedJarLocation !== undefined) {
    output.writeFieldBegin('uploadedJarLocation', Thrift.Type.STRING, 2);
    output.writeString(this.uploadedJarLocation);
    output.writeFieldEnd();
  }
  if (this.jsonConf !== null && this.jsonConf !== undefined) {
    output.writeFieldBegin('jsonConf', Thrift.Type.STRING, 3);
    output.writeString(this.jsonConf);
    output.writeFieldEnd();
  }
  if (this.topology !== null && this.topology !== undefined) {
    output.writeFieldBegin('topology', Thrift.Type.STRUCT, 4);
    this.topology.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_submitTopology_result = function(args) {
  this.e = null;
  this.ite = null;
  if (args instanceof ttypes.AlreadyAliveException) {
    this.e = args;
    return;
  }
  if (args instanceof ttypes.InvalidTopologyException) {
    this.ite = args;
    return;
  }
  if (args) {
    if (args.e !== undefined) {
      this.e = args.e;
    }
    if (args.ite !== undefined) {
      this.ite = args.ite;
    }
  }
};
Nimbus_submitTopology_result.prototype = {};
Nimbus_submitTopology_result.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.e = new ttypes.AlreadyAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.ite = new ttypes.InvalidTopologyException();
        this.ite.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_submitTopologyWithOpts_args = function(args) {
  this.name = null;
  this.uploadedJarLocation = null;
  this.jsonConf = null;
  this.topology = null;
  this.options = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.uploadedJarLocation !== undefined) {
      this.uploadedJarLocation = args.uploadedJarLocation;
    }
    if (args.jsonConf !== undefined) {
      this.jsonConf = args.jsonConf;
    }
    if (args.topology !== undefined) {
      this.topology = args.topology;
    }
    if (args.options !== undefined) {
      this.options = args.options;
    }
  }
};
Nimbus_submitTopologyWithOpts_args.prototype = {};
Nimbus_submitTopologyWithOpts_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.uploadedJarLocation = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.jsonConf = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRUCT) {
        this.topology = new ttypes.StormTopology();
        this.topology.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRUCT) {
        this.options = new ttypes.SubmitOptions();
        this.options.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_submitTopologyWithOpts_args.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_submitTopologyWithOpts_args');
  if (this.name !== null && this.name !== undefined) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.uploadedJarLocation !== null && this.uploadedJarLocation !== undefined) {
    output.writeFieldBegin('uploadedJarLocation', Thrift.Type.STRING, 2);
    output.writeString(this.uploadedJarLocation);
    output.writeFieldEnd();
  }
  if (this.jsonConf !== null && this.jsonConf !== undefined) {
    output.writeFieldBegin('jsonConf', Thrift.Type.STRING, 3);
    output.writeString(this.jsonConf);
    output.writeFieldEnd();
  }
  if (this.topology !== null && this.topology !== undefined) {
    output.writeFieldBegin('topology', Thrift.Type.STRUCT, 4);
    this.topology.write(output);
    output.writeFieldEnd();
  }
  if (this.options !== null && this.options !== undefined) {
    output.writeFieldBegin('options', Thrift.Type.STRUCT, 5);
    this.options.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_submitTopologyWithOpts_result = function(args) {
  this.e = null;
  this.ite = null;
  if (args instanceof ttypes.AlreadyAliveException) {
    this.e = args;
    return;
  }
  if (args instanceof ttypes.InvalidTopologyException) {
    this.ite = args;
    return;
  }
  if (args) {
    if (args.e !== undefined) {
      this.e = args.e;
    }
    if (args.ite !== undefined) {
      this.ite = args.ite;
    }
  }
};
Nimbus_submitTopologyWithOpts_result.prototype = {};
Nimbus_submitTopologyWithOpts_result.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.e = new ttypes.AlreadyAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.ite = new ttypes.InvalidTopologyException();
        this.ite.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_killTopology_args = function(args) {
  this.name = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
  }
};
Nimbus_killTopology_args.prototype = {};
Nimbus_killTopology_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_killTopology_result = function(args) {
  this.e = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args) {
    if (args.e !== undefined) {
      this.e = args.e;
    }
  }
};
Nimbus_killTopology_result.prototype = {};
Nimbus_killTopology_result.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.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_killTopologyWithOpts_args = function(args) {
  this.name = null;
  this.options = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.options !== undefined) {
      this.options = args.options;
    }
  }
};
Nimbus_killTopologyWithOpts_args.prototype = {};
Nimbus_killTopologyWithOpts_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.options = new ttypes.KillOptions();
        this.options.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_killTopologyWithOpts_args.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_killTopologyWithOpts_args');
  if (this.name !== null && this.name !== undefined) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.options !== null && this.options !== undefined) {
    output.writeFieldBegin('options', Thrift.Type.STRUCT, 2);
    this.options.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_killTopologyWithOpts_result = function(args) {
  this.e = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args) {
    if (args.e !== undefined) {
      this.e = args.e;
    }
  }
};
Nimbus_killTopologyWithOpts_result.prototype = {};
Nimbus_killTopologyWithOpts_result.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.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_activate_args = function(args) {
  this.name = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
  }
};
Nimbus_activate_args.prototype = {};
Nimbus_activate_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_activate_result = function(args) {
  this.e = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args) {
    if (args.e !== undefined) {
      this.e = args.e;
    }
  }
};
Nimbus_activate_result.prototype = {};
Nimbus_activate_result.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.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_deactivate_args = function(args) {
  this.name = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
  }
};
Nimbus_deactivate_args.prototype = {};
Nimbus_deactivate_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_deactivate_result = function(args) {
  this.e = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args) {
    if (args.e !== undefined) {
      this.e = args.e;
    }
  }
};
Nimbus_deactivate_result.prototype = {};
Nimbus_deactivate_result.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.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_rebalance_args = function(args) {
  this.name = null;
  this.options = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.options !== undefined) {
      this.options = args.options;
    }
  }
};
Nimbus_rebalance_args.prototype = {};
Nimbus_rebalance_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.options = new ttypes.RebalanceOptions();
        this.options.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_rebalance_args.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_rebalance_args');
  if (this.name !== null && this.name !== undefined) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.options !== null && this.options !== undefined) {
    output.writeFieldBegin('options', Thrift.Type.STRUCT, 2);
    this.options.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_rebalance_result = function(args) {
  this.e = null;
  this.ite = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args instanceof ttypes.InvalidTopologyException) {
    this.ite = args;
    return;
  }
  if (args) {
    if (args.e !== undefined) {
      this.e = args.e;
    }
    if (args.ite !== undefined) {
      this.ite = args.ite;
    }
  }
};
Nimbus_rebalance_result.prototype = {};
Nimbus_rebalance_result.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.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.ite = new ttypes.InvalidTopologyException();
        this.ite.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_beginFileUpload_args = function(args) {
};
Nimbus_beginFileUpload_args.prototype = {};
Nimbus_beginFileUpload_args.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;
    }
    input.skip(ftype);
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_beginFileUpload_args.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_beginFileUpload_args');
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_beginFileUpload_result = function(args) {
  this.success = null;
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
  }
};
Nimbus_beginFileUpload_result.prototype = {};
Nimbus_beginFileUpload_result.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 0:
      if (ftype == Thrift.Type.STRING) {
        this.success = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_uploadChunk_args = function(args) {
  this.location = null;
  this.chunk = null;
  if (args) {
    if (args.location !== undefined) {
      this.location = args.location;
    }
    if (args.chunk !== undefined) {
      this.chunk = args.chunk;
    }
  }
};
Nimbus_uploadChunk_args.prototype = {};
Nimbus_uploadChunk_args.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.location = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.chunk = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_uploadChunk_args.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_uploadChunk_args');
  if (this.location !== null && this.location !== undefined) {
    output.writeFieldBegin('location', Thrift.Type.STRING, 1);
    output.writeString(this.location);
    output.writeFieldEnd();
  }
  if (this.chunk !== null && this.chunk !== undefined) {
    output.writeFieldBegin('chunk', Thrift.Type.STRING, 2);
    output.writeString(this.chunk);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_uploadChunk_result = function(args) {
};
Nimbus_uploadChunk_result.prototype = {};
Nimbus_uploadChunk_result.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;
    }
    input.skip(ftype);
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_uploadChunk_result.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_uploadChunk_result');
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_finishFileUpload_args = function(args) {
  this.location = null;
  if (args) {
    if (args.location !== undefined) {
      this.location = args.location;
    }
  }
};
Nimbus_finishFileUpload_args.prototype = {};
Nimbus_finishFileUpload_args.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.location = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_finishFileUpload_result = function(args) {
};
Nimbus_finishFileUpload_result.prototype = {};
Nimbus_finishFileUpload_result.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;
    }
    input.skip(ftype);
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_finishFileUpload_result.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_finishFileUpload_result');
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_beginFileDownload_args = function(args) {
  this.file = null;
  if (args) {
    if (args.file !== undefined) {
      this.file = args.file;
    }
  }
};
Nimbus_beginFileDownload_args.prototype = {};
Nimbus_beginFileDownload_args.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.file = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_beginFileDownload_result = function(args) {
  this.success = null;
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
  }
};
Nimbus_beginFileDownload_result.prototype = {};
Nimbus_beginFileDownload_result.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 0:
      if (ftype == Thrift.Type.STRING) {
        this.success = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_downloadChunk_args = function(args) {
  this.id = null;
  if (args) {
    if (args.id !== undefined) {
      this.id = args.id;
    }
  }
};
Nimbus_downloadChunk_args.prototype = {};
Nimbus_downloadChunk_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_downloadChunk_result = function(args) {
  this.success = null;
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
  }
};
Nimbus_downloadChunk_result.prototype = {};
Nimbus_downloadChunk_result.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 0:
      if (ftype == Thrift.Type.STRING) {
        this.success = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getNimbusConf_args = function(args) {
};
Nimbus_getNimbusConf_args.prototype = {};
Nimbus_getNimbusConf_args.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;
    }
    input.skip(ftype);
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_getNimbusConf_args.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_getNimbusConf_args');
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_getNimbusConf_result = function(args) {
  this.success = null;
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
  }
};
Nimbus_getNimbusConf_result.prototype = {};
Nimbus_getNimbusConf_result.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 0:
      if (ftype == Thrift.Type.STRING) {
        this.success = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getClusterInfo_args = function(args) {
};
Nimbus_getClusterInfo_args.prototype = {};
Nimbus_getClusterInfo_args.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;
    }
    input.skip(ftype);
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Nimbus_getClusterInfo_args.prototype.write = function(output) {
  output.writeStructBegin('Nimbus_getClusterInfo_args');
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

Nimbus_getClusterInfo_result = function(args) {
  this.success = null;
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
  }
};
Nimbus_getClusterInfo_result.prototype = {};
Nimbus_getClusterInfo_result.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 0:
      if (ftype == Thrift.Type.STRUCT) {
        this.success = new ttypes.ClusterSummary();
        this.success.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getTopologyInfo_args = function(args) {
  this.id = null;
  if (args) {
    if (args.id !== undefined) {
      this.id = args.id;
    }
  }
};
Nimbus_getTopologyInfo_args.prototype = {};
Nimbus_getTopologyInfo_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getTopologyInfo_result = function(args) {
  this.success = null;
  this.e = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
    if (args.e !== undefined) {
      this.e = args.e;
    }
  }
};
Nimbus_getTopologyInfo_result.prototype = {};
Nimbus_getTopologyInfo_result.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 0:
      if (ftype == Thrift.Type.STRUCT) {
        this.success = new ttypes.TopologyInfo();
        this.success.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getTopologyConf_args = function(args) {
  this.id = null;
  if (args) {
    if (args.id !== undefined) {
      this.id = args.id;
    }
  }
};
Nimbus_getTopologyConf_args.prototype = {};
Nimbus_getTopologyConf_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getTopologyConf_result = function(args) {
  this.success = null;
  this.e = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
    if (args.e !== undefined) {
      this.e = args.e;
    }
  }
};
Nimbus_getTopologyConf_result.prototype = {};
Nimbus_getTopologyConf_result.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 0:
      if (ftype == Thrift.Type.STRING) {
        this.success = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getTopology_args = function(args) {
  this.id = null;
  if (args) {
    if (args.id !== undefined) {
      this.id = args.id;
    }
  }
};
Nimbus_getTopology_args.prototype = {};
Nimbus_getTopology_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getTopology_result = function(args) {
  this.success = null;
  this.e = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
    if (args.e !== undefined) {
      this.e = args.e;
    }
  }
};
Nimbus_getTopology_result.prototype = {};
Nimbus_getTopology_result.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 0:
      if (ftype == Thrift.Type.STRUCT) {
        this.success = new ttypes.StormTopology();
        this.success.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getUserTopology_args = function(args) {
  this.id = null;
  if (args) {
    if (args.id !== undefined) {
      this.id = args.id;
    }
  }
};
Nimbus_getUserTopology_args.prototype = {};
Nimbus_getUserTopology_args.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();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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

Nimbus_getUserTopology_result = function(args) {
  this.success = null;
  this.e = null;
  if (args instanceof ttypes.NotAliveException) {
    this.e = args;
    return;
  }
  if (args) {
    if (args.success !== undefined) {
      this.success = args.success;
    }
    if (args.e !== undefined) {
      this.e = args.e;
    }
  }
};
Nimbus_getUserTopology_result.prototype = {};
Nimbus_getUserTopology_result.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 0:
      if (ftype == Thrift.Type.STRUCT) {
        this.success = new ttypes.StormTopology();
        this.success.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.e = new ttypes.NotAliveException();
        this.e.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

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