async _read()

in src/BinaryObject.ts [410:451]
42 lines of code
8 McCabe index (conditional complexity)

    async _read(communicator) {
        await this._readHeader(communicator);
        if (this._hasSchema) {
            this._buffer.position = this._startPos + this._schemaOffset;
            const fieldOffsets = [];
            const fieldIds = this._typeBuilder.schema.fieldIds;
            let index = 0;
            let fieldId;
            let schemaEndOffset = this._startPos + this._length;
            if (this._hasRawData) {
                schemaEndOffset -= BinaryUtils.getSize(BinaryUtils.TYPE_CODE.INTEGER);
            }
            while (this._buffer.position < schemaEndOffset) {
                if (!this._compactFooter) {
                    fieldId = this._buffer.readInteger();
                    this._typeBuilder.schema.addField(fieldId);
                }
                else {
                    if (index >= fieldIds.length) {
                        throw IgniteClientError.serializationError(
                            false, 'wrong number of fields in schema');
                    }
                    fieldId = fieldIds[index];
                    index++;
                }
                fieldOffsets.push([fieldId, this._buffer.readNumber(this._offsetType, false)]);
            }
            fieldOffsets.sort((val1, val2) => val1[1] - val2[1]);
            let offset;
            let nextOffset;
            let field;
            for (let i = 0; i < fieldOffsets.length; i++) {
                fieldId = fieldOffsets[i][0];
                offset = fieldOffsets[i][1];
                nextOffset = i + 1 < fieldOffsets.length ? fieldOffsets[i + 1][1] : this._schemaOffset;
                field = BinaryObjectField._fromBuffer(
                    communicator,this._buffer, this._startPos + offset, nextOffset - offset, fieldId);
                this._fields.set(field.id, field);
            }
        }
        this._buffer.position = this._startPos + this._length;
    }