TypeScript OutputBinaryStream.writeUInt32方法代碼示例

export function encodeUInt64(value: UInt64 | number, stream: OutputBinaryStream) {
    if (_.isNumber(value)) {
        const arr = coerceUInt64(value);
        stream.writeUInt32(arr[1]);
        stream.writeUInt32(arr[0]);
    } else {
        stream.writeUInt32((value as number[])[1]);
        stream.writeUInt32((value as number[])[0]);
    }
}

export function encodeArray(
    arr: any[] | null,
    stream: OutputBinaryStream,
    encodeElementFunc: (value: any, stream: OutputBinaryStream) => void): void {
    if (arr === null) {
        stream.writeUInt32(0xffffffff);
        return;
    }
    assert(_.isArray(arr));
    stream.writeUInt32(arr.length);
    for (const value of arr) {
        encodeElementFunc(value, stream);
    }
}

 //           1         2         3
 // 012345678901234567890123456789012345
 // |        |    |    | |  | | | | | |
 // 12345678-1234-1234-ABCD-0123456789AB
 // 00000000-0000-0000-0000-000000000000";
 function write_UInt32(starts: number[]) {
     const n = starts.length;
     for (let i = 0; i < n; i++) {
         const start = starts[i];
         stream.writeUInt32(parseInt(guid.substr(start, 8), 16));
     }
 }

function _encodeNodeId(encodingByte: number, nodeId: NodeId, stream: OutputBinaryStream) {

    stream.writeUInt8(encodingByte); // encoding byte

    /*jslint bitwise: true */
    encodingByte &= 0x3f;

    switch (encodingByte) {
        case EnumNodeIdEncoding.TwoBytes:
            stream.writeUInt8(nodeId ? nodeId.value as number : 0);
            break;
        case EnumNodeIdEncoding.FourBytes:
            stream.writeUInt8(nodeId.namespace);
            stream.writeUInt16(nodeId.value as number);
            break;
        case EnumNodeIdEncoding.Numeric:
            stream.writeUInt16(nodeId.namespace);
            stream.writeUInt32(nodeId.value as number);
            break;
        case EnumNodeIdEncoding.String:
            stream.writeUInt16(nodeId.namespace);
            encodeString(nodeId.value as string, stream);
            break;
        case EnumNodeIdEncoding.ByteString:
            stream.writeUInt16(nodeId.namespace);
            encodeByteString(nodeId.value as Buffer, stream);
            break;
        default:
            assert(encodingByte === EnumNodeIdEncoding.Guid);
            stream.writeUInt16(nodeId.namespace);
            encodeGuid(nodeId.value as Guid, stream);
            break;
    }
}

export function encodeHighAccuracyDateTime(date: Date | null, picoseconds: number, stream: OutputBinaryStream) {

    if (date === null) {
        stream.writeUInt32(0);
        stream.writeUInt32(picoseconds % 100000);
        return;
    }
    if (!(date instanceof Date)) {
        throw new Error("Expecting a Date : but got a " + typeof(date) + " " + (date as any).toString());
    }
    assert(date instanceof Date);
    const hl = bn_dateToHundredNanoSecondFrom1601(date, picoseconds);
    const hi = hl[0];
    const lo = hl[1];

    stream.writeInteger(lo);
    stream.writeInteger(hi);
}

export function writeTCPMessageHeader(msgType: string, chunkType: string, totalLength: number, stream: OutputBinaryStream) {

    if (stream instanceof Buffer) {
        stream = new BinaryStream(stream);
    }
    assert(is_valid_msg_type(msgType));
    assert(["A", "F", "C"].indexOf(chunkType) !== -1);

    stream.writeUInt8(msgType.charCodeAt(0));
    stream.writeUInt8(msgType.charCodeAt(1));
    stream.writeUInt8(msgType.charCodeAt(2));
    // Chunk type
    stream.writeUInt8(chunkType.charCodeAt(0)); // reserved

    stream.writeUInt32(totalLength);
}

export function encodeExtensionObject(object: ExtensionObject | null, stream: OutputBinaryStream): void {

    if (!object) {
        encodeNodeId(makeNodeId(0), stream);
        stream.writeUInt8(0x00); // no body is encoded
        // note : Length shall not hbe specified, end of the job!
    } else {
        /* istanbul ignore next */
        if (!((object as any) instanceof ExtensionObject)) {
            throw new Error("Expecting a extension object");
        }
        // ensure we have a valid encoding Default Binary ID !!!
        /* istanbul ignore next */
        if (!object.schema) {
            debugLog(" object = ", object);
            throw new Error("object has no schema " + object.constructor.name);
        }
        const encodingDefaultBinary = object.schema.encodingDefaultBinary;
        /* istanbul ignore next */
        if (!encodingDefaultBinary) {
            debugLog(chalk.yellow("xxxxxxxxx encoding ExtObj "), object);
            throw new Error("Cannot find encodingDefaultBinary for this object");
        }
        /* istanbul ignore next */
        if (encodingDefaultBinary.isEmpty()) {
            debugLog(chalk.yellow("xxxxxxxxx encoding ExtObj "), (object.constructor as any).encodingDefaultBinary.toString());
            throw new Error("Cannot find encodingDefaultBinary for this object");
        }
        /* istanbul ignore next */
        if (is_internal_id(encodingDefaultBinary.value)) {
            debugLog(chalk.yellow("xxxxxxxxx encoding ExtObj "),
              (object.constructor as any).encodingDefaultBinary.toString(), object.schema.name);
            throw new Error("Cannot find valid OPCUA encodingDefaultBinary for this object");
        }

        encodeNodeId(encodingDefaultBinary, stream);
        stream.writeUInt8(0x01); // 0x01 The body is encoded as a ByteString.
        stream.writeUInt32(object.binaryStoreSize());
        object.encode(stream);
    }
}

export function encodeTimestampsToReturn(value: TimestampsToReturn, stream: OutputBinaryStream) {
    stream.writeUInt32(value);
}

export function encodeUInt32(value: UInt32, stream: OutputBinaryStream) {
    stream.writeUInt32(value);
}

export function encodeBrowseDirection(value: BrowseDirection, stream: OutputBinaryStream) {
    stream.writeUInt32(value);
}