kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-06-01 19:45:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

flatbuffers: Fix lint (#20960)

Browse Source
This commit is contained in:
Andy
2017-10-24 11:25:17 -07:00
committed by Sheetal Nandi
parent 20f37c2c8d
commit 768e798aa4
1 changed files with 16 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

372
types/flatbuffers/index.d.ts vendored
View File

@@ -7,122 +7,39 @@ export { flatbuffers };
declare global {
namespace flatbuffers {
/**
* @typedef {number}
*/
type Offset = number;
/**
* @typedef {{
* bb: flatbuffers.ByteBuffer,
* bb_pos: number
* }}
*/
interface Table {
bb: ByteBuffer;
bb_pos: number;
}
/**
* @type {number}
* @const
*/
const SIZEOF_SHORT: number;
/**
* @type {number}
* @const
*/
const SIZEOF_INT: number;
/**
* @type {number}
* @const
*/
const FILE_IDENTIFIER_LENGTH: number;
/**
* @enum {number}
*/
enum Encoding { UTF8_BYTES, UTF16_STRING }
/**
* @type {Int32Array}
* @const
*/
const int32: Int32Array;
/**
* @type {Float32Array}
* @const
*/
const float32: Float32Array;
/**
* @type {Float64Array}
* @const
*/
const float64: Float64Array;
/**
* @type {boolean}
* @const
*/
const isLittleEndian: boolean;
////////////////////////////////////////////////////////////////////////////////
class Long {
/**
* @type {number}
* @const
*/
low: number;
/**
* @type {number}
* @const
*/
high: number;
/**
* @type {flatbuffers.Long}
* @const
*/
static ZERO: Long;
/**
* @constructor
* @param {number} high
* @param {number} low
*/
constructor(low: number, high: number);
/**
* @returns {number}
*/
toFloat64(): number;
/**
* @param {flatbuffers.Long} other
* @returns {boolean}
*/
equals(other: any): boolean;
/**
* @param {number} low
* @param {number} high
*/
static create(low: number, high: number): Long;
}
////////////////////////////////////////////////////////////////////////////////
class Builder {
/**
* @constructor
* @param {number=} initial_size
*/
constructor(initial_size?: number);
/**
@@ -130,7 +47,7 @@ declare global {
* don't get serialized into the buffer. Forcing defaults provides a
* way to manually disable this optimization.
*
* @param {boolean} forceDefaults true always serializes default values
* @param forceDefaults true always serializes default values
*/
forceDefaults(forceDefaults: boolean): void;
@@ -138,8 +55,6 @@ declare global {
* Get the ByteBuffer representing the FlatBuffer. Only call this after you've
* called finish(). The actual data starts at the ByteBuffer's current position,
* not necessarily at 0.
*
* @returns {flatbuffers.ByteBuffer}
*/
dataBuffer(): ByteBuffer;
@@ -147,8 +62,6 @@ declare global {
* Get the ByteBuffer representing the FlatBuffer. Only call this after you've
* called finish(). The actual data starts at the ByteBuffer's current position,
* not necessarily at 0.
*
* @returns {Uint8Array}
*/
asUint8Array(): Uint8Array;
@@ -158,131 +71,37 @@ declare global {
* field is aligned to 4 bytes, and the string data follows it directly. If all
* you need to do is alignment, `additional_bytes` will be 0.
*
* @param {number} size This is the of the new element to write
* @param {number} additional_bytes The padding size
* @param size This is the of the new element to write
* @param additional_bytes The padding size
*/
prep(size: number, additional_bytes: number): void;
/**
* @param {number} byte_size
*/
pad(byte_size: number): void;
/**
* @param {number} value
*/
writeInt8(value: number): void;
/**
* @param {number} value
*/
writeInt16(value: number): void;
/**
* @param {number} value
*/
writeInt32(value: number): void;
/**
* @param {flatbuffers.Long} value
*/
writeInt64(value: Long): void;
/**
* @param {number} value
*/
writeFloat32(value: number): void;
/**
* @param {number} value
*/
writeFloat64(value: number): void;
/**
* @param {number} value
*/
addInt8(value: number): void;
/**
* @param {number} value
*/
addInt16(value: number): void;
/**
* @param {number} value
*/
addInt32(value: number): void;
/**
* @param {flatbuffers.Long} value
*/
addInt64(value: Long): void;
/**
* @param {number} value
*/
addFloat32(value: number): void;
/**
* @param {number} value
*/
addFloat64(value: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt8(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt16(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt32(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} voffset
* @param {flatbuffers.Long} value
* @param {flatbuffers.Long} defaultValue
*/
addFieldInt64(voffset: number, value: Long, defaultValue: Long): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldFloat32(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldFloat64(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} voffset
* @param {flatbuffers.Offset} value
* @param {flatbuffers.Offset} defaultValue
*/
addFieldOffset(voffset: number, value: Offset, defaultValue: Offset): void;
/**
* Structs are stored inline, so nothing additional is being added. `d` is always 0.
*
* @param {number} voffset
* @param {flatbuffers.Offset} value
* @param {flatbuffers.Offset} defaultValue
*/
addFieldStruct(voffset: number, value: Offset, defaultValue: Offset): void;
@@ -291,7 +110,7 @@ declare global {
* where they're used. You'll get this assertion failure if you
* created it elsewhere.
*
* @param {flatbuffers.Offset} obj The offset of the created object
* @param obj The offset of the created object
*/
nested(obj: Offset): void;
@@ -303,13 +122,11 @@ declare global {
/**
* Set the current vtable at `voffset` to the current location in the buffer.
*
* @param {number} voffset
*/
slot(voffset: number): void;
/**
* @returns {flatbuffers.Offset} Offset relative to the end of the buffer.
* @returns Offset relative to the end of the buffer.
*/
offset(): Offset;
@@ -317,8 +134,8 @@ declare global {
* Doubles the size of the backing ByteBuffer and copies the old data towards
* the end of the new buffer (since we build the buffer backwards).
*
* @param {flatbuffers.ByteBuffer} bb The current buffer with the existing data
* @returns {flatbuffers.ByteBuffer} A new byte buffer with the old data copied
* @param bb The current buffer with the existing data
* @returns A new byte buffer with the old data copied
* to it. The data is located at the end of the buffer.
*/
static growByteBuffer(bb: ByteBuffer): ByteBuffer;
@@ -326,7 +143,7 @@ declare global {
/**
* Adds on offset, relative to where it will be written.
*
* @param {flatbuffers.Offset} offset The offset to add
* @param offset The offset to add
*/
addOffset(offset: Offset): void;
@@ -334,30 +151,21 @@ declare global {
* Start encoding a new object in the buffer. Users will not usually need to
* call this directly. The FlatBuffers compiler will generate helper methods
* that call this method internally.
*
* @param {number} numfields
*/
startObject(numfields: number): void;
/**
* Finish off writing the object that is under construction.
*
* @returns {flatbuffers.Offset} The offset to the object inside `dataBuffer`
* @returns The offset to the object inside `dataBuffer`
*/
endObject(): Offset;
/**
* @param {flatbuffers.Offset} root_table
* @param {string=} file_identifier
*/
finish(root_table: Offset, file_identifier?: string): void;
/**
* This checks a required field has been set in a given table that has
* just been constructed.
*
* @param {flatbuffers.Offset} table
* @param {number} field
*/
requiredField(table: Offset, field: number): void;
@@ -366,9 +174,9 @@ declare global {
* this directly. The FlatBuffers compiler will create a start/end
* method for vector types in generated code.
*
* @param {number} elem_size The size of each element in the array
* @param {number} num_elems The number of elements in the array
* @param {number} alignment The alignment of the array
* @param elem_size The size of each element in the array
* @param num_elems The number of elements in the array
* @param alignment The alignment of the array
*/
startVector(elem_size: number, num_elems: number, alignment: number): void;
@@ -376,7 +184,7 @@ declare global {
* Finish off the creation of an array and all its elements. The array must be
* created with `startVector`.
*
* @returns {flatbuffers.Offset} The offset at which the newly created array
* @returns The offset at which the newly created array
* starts.
*/
endVector(): Offset;
@@ -385,17 +193,13 @@ declare global {
* Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
* instead of a string, it is assumed to contain valid UTF-8 encoded data.
*
* @param {string|Uint8Array} s The string to encode
* @return {flatbuffers.Offset} The offset in the buffer where the encoded string starts
* @param s The string to encode
* @return The offset in the buffer where the encoded string starts
*/
createString(s: string|Uint8Array): Offset;
/**
* Conveniance function for creating Long objects.
*
* @param {number} low
* @param {number} high
* @returns {Long}
*/
createLong(low: number, high: number): Long;
}
@@ -403,174 +207,48 @@ declare global {
////////////////////////////////////////////////////////////////////////////////
class ByteBuffer {
/**
* @constructor
* @param {Uint8Array} bytes
*/
constructor(bytes: Uint8Array);
/**
* @param {number} byte_size
* @returns {flatbuffers.ByteBuffer}
*/
static allocate(byte_size: number): ByteBuffer;
/**
* @returns {Uint8Array}
*/
bytes(): Uint8Array;
/**
* @returns {number}
*/
position(): number;
/**
* @param {number} position
*/
setPosition(position: number): void;
/**
* @returns {number}
*/
capacity(): number;
/**
* @param {number} offset
* @returns {number}
*/
readInt8(offset: number): number;
/**
* @param {number} offset
* @returns {number}
*/
readUint8(offset: number): number;
/**
* @param {number} offset
* @returns {number}
*/
readInt16(offset: number): number;
/**
* @param {number} offset
* @returns {number}
*/
readUint16(offset: number): number;
/**
* @param {number} offset
* @returns {number}
*/
readInt32(offset: number): number;
/**
* @param {number} offset
* @returns {number}
*/
readUint32(offset: number): number;
/**
* @param {number} offset
* @returns {flatbuffers.Long}
*/
readInt64(offset: number): Long;
/**
* @param {number} offset
* @returns {flatbuffers.Long}
*/
readUint64(offset: number): Long;
/**
* @param {number} offset
* @returns {number}
*/
readFloat32(offset: number): number;
/**
* @param {number} offset
* @returns {number}
*/
readFloat64(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeInt8(offset: number, value: number): void;
/**
* @param {number} offset
* @param {number} value
*/
writeUint8(offset: number, value: number): void;
/**
* @param {number} offset
* @param {number} value
*/
writeInt16(offset: number, value: number): void;
/**
* @param {number} offset
* @param {number} value
*/
writeUint16(offset: number, value: number): void;
/**
* @param {number} offset
* @param {number} value
*/
writeInt32(offset: number, value: number): void;
/**
* @param {number} offset
* @param {number} value
*/
writeUint32(offset: number, value: number): void;
/**
* @param {number} offset
* @param {flatbuffers.Long} value
*/
writeInt64(offset: number, value: Long): void;
/**
* @param {number} offset
* @param {flatbuffers.Long} value
*/
writeUint64(offset: number, value: Long): void;
/**
* @param {number} offset
* @param {number} value
*/
writeFloat32(offset: number, value: number): void;
/**
* @param {number} offset
* @param {number} value
*/
writeFloat64(offset: number, value: number): void;
/**
* Look up a field in the vtable, return an offset into the object, or 0 if the
* field is not present.
*
* @param {number} bb_pos
* @param {number} vtable_offset
* @returns {number}
*/
__offset(bb_pos: number, vtable_offset: number): number;
/**
* Initialize any Table-derived type to point to the union at the given offset.
*
* @param {flatbuffers.Table} t
* @param {number} offset
* @returns {flatbuffers.Table}
*/
__union<T extends Table>(t: T, offset: number): T;
@@ -583,47 +261,29 @@ declare global {
* and from UTF-16 when the data will just be packaged back up in another
* FlatBuffer later on.
*
* @param {number} offset
* @param {flatbuffers.Encoding=} optionalEncoding Defaults to UTF16_STRING
* @returns {string|Uint8Array}
* @param optionalEncoding Defaults to UTF16_STRING
*/
__string(offset: number, optionalEncoding?: Encoding): string|Uint8Array;
/**
* Retrieve the relative offset stored at "offset"
* @param {number} offset
* @returns {number}
*/
__indirect(offset: number): number;
/**
* Get the start of data of a vector whose offset is stored at "offset" in this object.
*
* @param {number} offset
* @returns {number}
*/
__vector(offset: number): number;
/**
* Get the length of a vector whose offset is stored at "offset" in this object.
*
* @param {number} offset
* @returns {number}
*/
__vector_len(offset: number): number;
/**
* @param {string} ident
* @returns {boolean}
*/
__has_identifier(ident: string): boolean;
/**
* Conveniance function for creating Long objects.
*
* @param {number} low
* @param {number} high
* @returns {Long}
*/
createLong(low: number, high: number): Long;
}