biner/lib/decode.js

Declarative binary data encoder / decoder.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const util_1 = require("./util");
const bs_1 = require("./bs");
const symbols = require("./internal/symbols");
const meta_1 = require("./internal/meta");
function decode(rstream, typeOrSchema) {
    let decodeStream;
    if (Buffer.isBuffer(rstream)) {
        const bs = new bs_1.BinaryStream();
        bs.append(rstream);
        decodeStream = bs;
    }
    else {
        decodeStream = rstream;
    }
    const meta = new meta_1.Metadata();
    const value = decodeCommon(decodeStream, typeOrSchema, meta);
    meta_1.Metadata.clean(meta);
    return [value, meta.bytes];
}
exports.decode = decode;
function decodeCommon(rstream, typeOrSchema, meta) {
    if (util_1.isType(typeOrSchema)) {
        const [value, bytes] = typeOrSchema.decode.call(meta, rstream);
        meta[symbols.bytes] += bytes;
        return value;
    }
    return decodeSchema(rstream, typeOrSchema, meta);
}
exports.decodeCommon = decodeCommon;
function decodeSchema(rstream, schema, meta) {
    assertSchema(schema);
    const node = Object.create(null);
    if (meta.node === undefined) {
        meta.node = node;
        meta.current = node;
    }
    else {
        meta.current = node;
    }
    const keys = Object.keys(schema);
    for (let i = 0; i < keys.length; i += 1) {
        const key = keys[i];
        const type = schema[key];
        if (!util_1.isDecodeType(type)) {
            node[key] = decodeSchema(rstream, type, meta);
            meta.current = node;
            continue;
        }
        const [value, bytes] = type.decode.call(meta, rstream);
        meta[symbols.bytes] += bytes;
        if (type[symbols.skip] === true) {
            continue;
        }
        node[key] = value;
    }
    return node;
}
function assertSchema(schema) {
    if (!util_1.isUserType(schema)) {
        throw new TypeError('Argument #2 should be a plain object.');
    }
}
//# sourceMappingURL=decode.js.map