@ccmaymay/concrete 4.15.0

package/ex_types.js

@@ -0,0 +1,82 @@
+//
+// Autogenerated by Thrift Compiler (0.15.0)
+//
+// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+//
+"use strict";
+
+const thrift = require('thrift');
+const Thrift = thrift.Thrift;
+const Int64 = require('node-int64');
+
+
+const ttypes = module.exports = {};
+const ConcreteThriftException = module.exports.ConcreteThriftException = class extends Thrift.TException {
+  constructor(args) {
+    super(args);
+    this.name = "ConcreteThriftException";
+    this.message = null;
+    this.serEx = null;
+    if (args) {
+      if (args.message !== undefined && args.message !== null) {
+        this.message = args.message;
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field message is unset!');
+      }
+      if (args.serEx !== undefined && args.serEx !== null) {
+        this.serEx = args.serEx;
+      }
+    }
+  }
+
+  read (input) {
+    input.readStructBegin();
+    while (true) {
+      const ret = input.readFieldBegin();
+      const ftype = ret.ftype;
+      const fid = ret.fid;
+      if (ftype == Thrift.Type.STOP) {
+        break;
+      }
+      switch (fid) {
+        case 1:
+        if (ftype == Thrift.Type.STRING) {
+          this.message = input.readString();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 2:
+        if (ftype == Thrift.Type.STRING) {
+          this.serEx = input.readBinary();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        default:
+          input.skip(ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return;
+  }
+
+  write (output) {
+    output.writeStructBegin('ConcreteThriftException');
+    if (this.message !== null && this.message !== undefined) {
+      output.writeFieldBegin('message', Thrift.Type.STRING, 1);
+      output.writeString(this.message);
+      output.writeFieldEnd();
+    }
+    if (this.serEx !== null && this.serEx !== undefined) {
+      output.writeFieldBegin('serEx', Thrift.Type.STRING, 2);
+      output.writeBinary(this.serEx);
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+    return;
+  }
+
+};

package/language_types.js

@@ -0,0 +1,123 @@
+//
+// Autogenerated by Thrift Compiler (0.15.0)
+//
+// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+//
+"use strict";
+
+const thrift = require('thrift');
+const Thrift = thrift.Thrift;
+const Int64 = require('node-int64');
+
+const metadata_ttypes = require('./metadata_types');
+const uuid_ttypes = require('./uuid_types');
+
+
+const ttypes = module.exports = {};
+const LanguageIdentification = module.exports.LanguageIdentification = class {
+  constructor(args) {
+    this.uuid = null;
+    this.metadata = null;
+    this.languageToProbabilityMap = null;
+    if (args) {
+      if (args.uuid !== undefined && args.uuid !== null) {
+        this.uuid = new uuid_ttypes.UUID(args.uuid);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field uuid is unset!');
+      }
+      if (args.metadata !== undefined && args.metadata !== null) {
+        this.metadata = new metadata_ttypes.AnnotationMetadata(args.metadata);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field metadata is unset!');
+      }
+      if (args.languageToProbabilityMap !== undefined && args.languageToProbabilityMap !== null) {
+        this.languageToProbabilityMap = Thrift.copyMap(args.languageToProbabilityMap, [null]);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field languageToProbabilityMap is unset!');
+      }
+    }
+  }
+
+  read (input) {
+    input.readStructBegin();
+    while (true) {
+      const ret = input.readFieldBegin();
+      const ftype = ret.ftype;
+      const fid = ret.fid;
+      if (ftype == Thrift.Type.STOP) {
+        break;
+      }
+      switch (fid) {
+        case 1:
+        if (ftype == Thrift.Type.STRUCT) {
+          this.uuid = new uuid_ttypes.UUID();
+          this.uuid.read(input);
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 2:
+        if (ftype == Thrift.Type.STRUCT) {
+          this.metadata = new metadata_ttypes.AnnotationMetadata();
+          this.metadata.read(input);
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 3:
+        if (ftype == Thrift.Type.MAP) {
+          this.languageToProbabilityMap = {};
+          const _rtmp31 = input.readMapBegin();
+          const _size0 = _rtmp31.size || 0;
+          for (let _i2 = 0; _i2 < _size0; ++_i2) {
+            let key3 = null;
+            let val4 = null;
+            key3 = input.readString();
+            val4 = input.readDouble();
+            this.languageToProbabilityMap[key3] = val4;
+          }
+          input.readMapEnd();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        default:
+          input.skip(ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return;
+  }
+
+  write (output) {
+    output.writeStructBegin('LanguageIdentification');
+    if (this.uuid !== null && this.uuid !== undefined) {
+      output.writeFieldBegin('uuid', Thrift.Type.STRUCT, 1);
+      this.uuid.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.metadata !== null && this.metadata !== undefined) {
+      output.writeFieldBegin('metadata', Thrift.Type.STRUCT, 2);
+      this.metadata.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.languageToProbabilityMap !== null && this.languageToProbabilityMap !== undefined) {
+      output.writeFieldBegin('languageToProbabilityMap', Thrift.Type.MAP, 3);
+      output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.DOUBLE, Thrift.objectLength(this.languageToProbabilityMap));
+      for (let kiter5 in this.languageToProbabilityMap) {
+        if (this.languageToProbabilityMap.hasOwnProperty(kiter5)) {
+          let viter6 = this.languageToProbabilityMap[kiter5];
+          output.writeString(kiter5);
+          output.writeDouble(viter6);
+        }
+      }
+      output.writeMapEnd();
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+    return;
+  }
+
+};

package/learn_types.js

@@ -0,0 +1,207 @@
+//
+// Autogenerated by Thrift Compiler (0.15.0)
+//
+// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+//
+"use strict";
+
+const thrift = require('thrift');
+const Thrift = thrift.Thrift;
+const Int64 = require('node-int64');
+
+const services_ttypes = require('./services_types');
+const uuid_ttypes = require('./uuid_types');
+const communication_ttypes = require('./communication_types');
+
+
+const ttypes = module.exports = {};
+const AnnotationTask = module.exports.AnnotationTask = class {
+  constructor(args) {
+    this.type = null;
+    this.language = null;
+    this.unitType = null;
+    this.units = null;
+    if (args) {
+      if (args.type !== undefined && args.type !== null) {
+        this.type = args.type;
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field type is unset!');
+      }
+      if (args.language !== undefined && args.language !== null) {
+        this.language = args.language;
+      }
+      if (args.unitType !== undefined && args.unitType !== null) {
+        this.unitType = args.unitType;
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field unitType is unset!');
+      }
+      if (args.units !== undefined && args.units !== null) {
+        this.units = Thrift.copyList(args.units, [services_ttypes.AnnotationUnitIdentifier]);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field units is unset!');
+      }
+    }
+  }
+
+  read (input) {
+    input.readStructBegin();
+    while (true) {
+      const ret = input.readFieldBegin();
+      const ftype = ret.ftype;
+      const fid = ret.fid;
+      if (ftype == Thrift.Type.STOP) {
+        break;
+      }
+      switch (fid) {
+        case 1:
+        if (ftype == Thrift.Type.I32) {
+          this.type = input.readI32();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 2:
+        if (ftype == Thrift.Type.STRING) {
+          this.language = input.readString();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 3:
+        if (ftype == Thrift.Type.I32) {
+          this.unitType = input.readI32();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 4:
+        if (ftype == Thrift.Type.LIST) {
+          this.units = [];
+          const _rtmp31 = input.readListBegin();
+          const _size0 = _rtmp31.size || 0;
+          for (let _i2 = 0; _i2 < _size0; ++_i2) {
+            let elem3 = null;
+            elem3 = new services_ttypes.AnnotationUnitIdentifier();
+            elem3.read(input);
+            this.units.push(elem3);
+          }
+          input.readListEnd();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        default:
+          input.skip(ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return;
+  }
+
+  write (output) {
+    output.writeStructBegin('AnnotationTask');
+    if (this.type !== null && this.type !== undefined) {
+      output.writeFieldBegin('type', Thrift.Type.I32, 1);
+      output.writeI32(this.type);
+      output.writeFieldEnd();
+    }
+    if (this.language !== null && this.language !== undefined) {
+      output.writeFieldBegin('language', Thrift.Type.STRING, 2);
+      output.writeString(this.language);
+      output.writeFieldEnd();
+    }
+    if (this.unitType !== null && this.unitType !== undefined) {
+      output.writeFieldBegin('unitType', Thrift.Type.I32, 3);
+      output.writeI32(this.unitType);
+      output.writeFieldEnd();
+    }
+    if (this.units !== null && this.units !== undefined) {
+      output.writeFieldBegin('units', Thrift.Type.LIST, 4);
+      output.writeListBegin(Thrift.Type.STRUCT, this.units.length);
+      for (let iter4 in this.units) {
+        if (this.units.hasOwnProperty(iter4)) {
+          iter4 = this.units[iter4];
+          iter4.write(output);
+        }
+      }
+      output.writeListEnd();
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+    return;
+  }
+
+};
+const Annotation = module.exports.Annotation = class {
+  constructor(args) {
+    this.id = null;
+    this.communication = null;
+    if (args) {
+      if (args.id !== undefined && args.id !== null) {
+        this.id = new services_ttypes.AnnotationUnitIdentifier(args.id);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field id is unset!');
+      }
+      if (args.communication !== undefined && args.communication !== null) {
+        this.communication = new communication_ttypes.Communication(args.communication);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field communication is unset!');
+      }
+    }
+  }
+
+  read (input) {
+    input.readStructBegin();
+    while (true) {
+      const ret = input.readFieldBegin();
+      const ftype = ret.ftype;
+      const fid = ret.fid;
+      if (ftype == Thrift.Type.STOP) {
+        break;
+      }
+      switch (fid) {
+        case 1:
+        if (ftype == Thrift.Type.STRUCT) {
+          this.id = new services_ttypes.AnnotationUnitIdentifier();
+          this.id.read(input);
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 2:
+        if (ftype == Thrift.Type.STRUCT) {
+          this.communication = new communication_ttypes.Communication();
+          this.communication.read(input);
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        default:
+          input.skip(ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return;
+  }
+
+  write (output) {
+    output.writeStructBegin('Annotation');
+    if (this.id !== null && this.id !== undefined) {
+      output.writeFieldBegin('id', Thrift.Type.STRUCT, 1);
+      this.id.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.communication !== null && this.communication !== undefined) {
+      output.writeFieldBegin('communication', Thrift.Type.STRUCT, 2);
+      this.communication.write(output);
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+    return;
+  }
+
+};

package/linking_types.js

@@ -0,0 +1,286 @@
+//
+// Autogenerated by Thrift Compiler (0.15.0)
+//
+// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+//
+"use strict";
+
+const thrift = require('thrift');
+const Thrift = thrift.Thrift;
+const Int64 = require('node-int64');
+
+const uuid_ttypes = require('./uuid_types');
+const metadata_ttypes = require('./metadata_types');
+
+
+const ttypes = module.exports = {};
+const LinkTarget = module.exports.LinkTarget = class {
+  constructor(args) {
+    this.confidence = null;
+    this.targetId = null;
+    this.dbId = null;
+    this.dbName = null;
+    if (args) {
+      if (args.confidence !== undefined && args.confidence !== null) {
+        this.confidence = args.confidence;
+      }
+      if (args.targetId !== undefined && args.targetId !== null) {
+        this.targetId = new uuid_ttypes.UUID(args.targetId);
+      }
+      if (args.dbId !== undefined && args.dbId !== null) {
+        this.dbId = args.dbId;
+      }
+      if (args.dbName !== undefined && args.dbName !== null) {
+        this.dbName = args.dbName;
+      }
+    }
+  }
+
+  read (input) {
+    input.readStructBegin();
+    while (true) {
+      const ret = input.readFieldBegin();
+      const ftype = ret.ftype;
+      const fid = ret.fid;
+      if (ftype == Thrift.Type.STOP) {
+        break;
+      }
+      switch (fid) {
+        case 1:
+        if (ftype == Thrift.Type.DOUBLE) {
+          this.confidence = input.readDouble();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 2:
+        if (ftype == Thrift.Type.STRUCT) {
+          this.targetId = new uuid_ttypes.UUID();
+          this.targetId.read(input);
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 3:
+        if (ftype == Thrift.Type.STRING) {
+          this.dbId = input.readString();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 4:
+        if (ftype == Thrift.Type.STRING) {
+          this.dbName = input.readString();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        default:
+          input.skip(ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return;
+  }
+
+  write (output) {
+    output.writeStructBegin('LinkTarget');
+    if (this.confidence !== null && this.confidence !== undefined) {
+      output.writeFieldBegin('confidence', Thrift.Type.DOUBLE, 1);
+      output.writeDouble(this.confidence);
+      output.writeFieldEnd();
+    }
+    if (this.targetId !== null && this.targetId !== undefined) {
+      output.writeFieldBegin('targetId', Thrift.Type.STRUCT, 2);
+      this.targetId.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.dbId !== null && this.dbId !== undefined) {
+      output.writeFieldBegin('dbId', Thrift.Type.STRING, 3);
+      output.writeString(this.dbId);
+      output.writeFieldEnd();
+    }
+    if (this.dbName !== null && this.dbName !== undefined) {
+      output.writeFieldBegin('dbName', Thrift.Type.STRING, 4);
+      output.writeString(this.dbName);
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+    return;
+  }
+
+};
+const Link = module.exports.Link = class {
+  constructor(args) {
+    this.sourceId = null;
+    this.linkTargetList = null;
+    if (args) {
+      if (args.sourceId !== undefined && args.sourceId !== null) {
+        this.sourceId = new uuid_ttypes.UUID(args.sourceId);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field sourceId is unset!');
+      }
+      if (args.linkTargetList !== undefined && args.linkTargetList !== null) {
+        this.linkTargetList = Thrift.copyList(args.linkTargetList, [ttypes.LinkTarget]);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field linkTargetList is unset!');
+      }
+    }
+  }
+
+  read (input) {
+    input.readStructBegin();
+    while (true) {
+      const ret = input.readFieldBegin();
+      const ftype = ret.ftype;
+      const fid = ret.fid;
+      if (ftype == Thrift.Type.STOP) {
+        break;
+      }
+      switch (fid) {
+        case 1:
+        if (ftype == Thrift.Type.STRUCT) {
+          this.sourceId = new uuid_ttypes.UUID();
+          this.sourceId.read(input);
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 2:
+        if (ftype == Thrift.Type.LIST) {
+          this.linkTargetList = [];
+          const _rtmp31 = input.readListBegin();
+          const _size0 = _rtmp31.size || 0;
+          for (let _i2 = 0; _i2 < _size0; ++_i2) {
+            let elem3 = null;
+            elem3 = new ttypes.LinkTarget();
+            elem3.read(input);
+            this.linkTargetList.push(elem3);
+          }
+          input.readListEnd();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        default:
+          input.skip(ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return;
+  }
+
+  write (output) {
+    output.writeStructBegin('Link');
+    if (this.sourceId !== null && this.sourceId !== undefined) {
+      output.writeFieldBegin('sourceId', Thrift.Type.STRUCT, 1);
+      this.sourceId.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.linkTargetList !== null && this.linkTargetList !== undefined) {
+      output.writeFieldBegin('linkTargetList', Thrift.Type.LIST, 2);
+      output.writeListBegin(Thrift.Type.STRUCT, this.linkTargetList.length);
+      for (let iter4 in this.linkTargetList) {
+        if (this.linkTargetList.hasOwnProperty(iter4)) {
+          iter4 = this.linkTargetList[iter4];
+          iter4.write(output);
+        }
+      }
+      output.writeListEnd();
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+    return;
+  }
+
+};
+const Linking = module.exports.Linking = class {
+  constructor(args) {
+    this.metadata = null;
+    this.linkList = null;
+    if (args) {
+      if (args.metadata !== undefined && args.metadata !== null) {
+        this.metadata = new metadata_ttypes.AnnotationMetadata(args.metadata);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field metadata is unset!');
+      }
+      if (args.linkList !== undefined && args.linkList !== null) {
+        this.linkList = Thrift.copyList(args.linkList, [ttypes.Link]);
+      } else {
+        throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field linkList is unset!');
+      }
+    }
+  }
+
+  read (input) {
+    input.readStructBegin();
+    while (true) {
+      const ret = input.readFieldBegin();
+      const ftype = ret.ftype;
+      const fid = ret.fid;
+      if (ftype == Thrift.Type.STOP) {
+        break;
+      }
+      switch (fid) {
+        case 1:
+        if (ftype == Thrift.Type.STRUCT) {
+          this.metadata = new metadata_ttypes.AnnotationMetadata();
+          this.metadata.read(input);
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        case 2:
+        if (ftype == Thrift.Type.LIST) {
+          this.linkList = [];
+          const _rtmp36 = input.readListBegin();
+          const _size5 = _rtmp36.size || 0;
+          for (let _i7 = 0; _i7 < _size5; ++_i7) {
+            let elem8 = null;
+            elem8 = new ttypes.Link();
+            elem8.read(input);
+            this.linkList.push(elem8);
+          }
+          input.readListEnd();
+        } else {
+          input.skip(ftype);
+        }
+        break;
+        default:
+          input.skip(ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return;
+  }
+
+  write (output) {
+    output.writeStructBegin('Linking');
+    if (this.metadata !== null && this.metadata !== undefined) {
+      output.writeFieldBegin('metadata', Thrift.Type.STRUCT, 1);
+      this.metadata.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.linkList !== null && this.linkList !== undefined) {
+      output.writeFieldBegin('linkList', Thrift.Type.LIST, 2);
+      output.writeListBegin(Thrift.Type.STRUCT, this.linkList.length);
+      for (let iter9 in this.linkList) {
+        if (this.linkList.hasOwnProperty(iter9)) {
+          iter9 = this.linkList[iter9];
+          iter9.write(output);
+        }
+      }
+      output.writeListEnd();
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+    return;
+  }
+
+};