TypeScript OutputBinaryStream.writeUInt8方法代碼示例

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;
    }
}

 function write_UInt8(starts: number[]) {
     const n = starts.length;
     for (let i = 0; i < n; i++) {
         const start = starts[i];
         stream.writeUInt8(parseInt(guid.substr(start, 2), 16));
     }
 }

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 encodeBoolean(value: boolean, stream: OutputBinaryStream): void {
    assert(isValidBoolean(value));
    stream.writeUInt8(value ? 1 : 0);
}

export function encodeUInt8(value: UInt8, stream: OutputBinaryStream): void {
    stream.writeUInt8(value);
}