TypeScript BinaryStream.readUInt8方法代码示例

export function readMessageHeader(stream: BinaryStream): MessageHeader {

    const msgType = String.fromCharCode(stream.readUInt8()) +
        String.fromCharCode(stream.readUInt8()) +
        String.fromCharCode(stream.readUInt8());

    const isFinal = String.fromCharCode(stream.readUInt8());
    const length = stream.readUInt32();
    return {msgType, isFinal, length};
}

function _decodeNodeId(encodingByte: number, stream: BinaryStream): NodeId {
    let value;
    let namespace;
    let nodeIdType;
    /*jslint bitwise: true */
    encodingByte &= 0x3f; // 1 to 5

    switch (encodingByte) {
        case EnumNodeIdEncoding.TwoBytes:
            value = stream.readUInt8();
            nodeIdType = NodeIdType.NUMERIC;
            break;
        case EnumNodeIdEncoding.FourBytes:
            namespace = stream.readUInt8();
            value = stream.readUInt16();
            nodeIdType = NodeIdType.NUMERIC;
            break;
        case EnumNodeIdEncoding.Numeric:
            namespace = stream.readUInt16();
            value = stream.readUInt32();
            nodeIdType = NodeIdType.NUMERIC;
            break;
        case EnumNodeIdEncoding.String:
            namespace = stream.readUInt16();
            value = decodeString(stream);
            nodeIdType = NodeIdType.STRING;
            break;
        case EnumNodeIdEncoding.ByteString:
            namespace = stream.readUInt16();
            value = decodeByteString(stream);
            nodeIdType = NodeIdType.BYTESTRING;
            break;
        default:
            if (encodingByte !== EnumNodeIdEncoding.Guid) {
                /*jslint bitwise: true */
                // console.log(" encoding_byte = 0x" + encodingByte.toString(16),
                //     " bin=", ("0000000000000000" + encodingByte.toString(2)).substr(-16),
                //     encodingByte, encodingByte & 0x3f);

                throw new Error(" encoding_byte = " + encodingByte.toString(16));
            }
            namespace = stream.readUInt16();
            value = decodeGuid(stream);
            nodeIdType = NodeIdType.GUID;
            assert(isValidGuid(value));
            break;
    }
    return new NodeId(nodeIdType, value, namespace);
}

export function decodeExtensionObject(stream: BinaryStream): ExtensionObject | null {

    const nodeId = decodeNodeId(stream);
    const encodingType = stream.readUInt8();

    if (encodingType === 0) {
        return null;
    }

    const length = stream.readUInt32();

    /* istanbul ignore next */
    if (nodeId.value === 0 || encodingType === 0) {
        return {} as ExtensionObject;
    }

    // let verify that  decode will use the expected number of bytes
    const streamLengthBefore = stream.length;

    let object: any;
    if (nodeId.namespace !== 0) {
        // this is a extension object define in a other namespace
        // we can only threat it as an opaque object for the time being
        // the caller that may now more about the namespace Array and type
        // definition will be able to turn the opaque object into a meaningful
        // structure
        // lets rewind before the length
        stream.length -= 4;
        object = new OpaqueStructure(nodeId, stream.readByteStream()!);

    } else {
        object = constructEmptyExtensionObject(nodeId);
        /* istanbul ignore next */
        if (object === null) {
            // this object is unknown to us ..
            stream.length += length;
            object = {} as ExtensionObject;
        } else {
            try {
                object.decode(stream);
            } catch (err) {
                debugLog("Cannot decode object ", err.message);
            }
        }
    }

    if (streamLengthBefore + length !== stream.length) {
        // this may happen if the server or client do have a different OPCUA version
        // for instance SubscriptionDiagnostics structure has been changed between OPCUA version 1.01 and 1.04
        // causing 2 extra member to be added.
        debugLog(chalk.bgWhiteBright.red("========================================="));

        // tslint:disable-next-line:no-console
        console.warn("WARNING => Extension object decoding error on ",
          object.constructor.name, " expected size was", length,
          "but only this amount of bytes have been read :", stream.length - streamLengthBefore);
        stream.length = streamLengthBefore + length;
    }
    return object;
}

export function decodeExpandedNodeId(stream: BinaryStream): ExpandedNodeId {
    const encodingByte = stream.readUInt8();
    const expandedNodeId = _decodeNodeId(encodingByte, stream) as ExpandedNodeId;
    expandedNodeId.namespaceUri = null;
    expandedNodeId.serverIndex = 0;

    if (encodingByte & EnumNodeIdEncoding.NamespaceUriFlag) {
        expandedNodeId.namespaceUri = decodeString(stream);
    }
    if (encodingByte & EnumNodeIdEncoding.ServerIndexFlag) {
        expandedNodeId.serverIndex = decodeUInt32(stream);
    }
    const e: ExpandedNodeId = expandedNodeId;
    return new ExpandedNodeId(e.identifierType, e.value, e.namespace, e.namespaceUri, e.serverIndex);
}

 function read_UInt8() {
     return toHex(stream.readUInt8(), 2);
 }

 decode: (stream: BinaryStream): AccessLevelFlag => {
     const code = stream.readUInt8();
     return (code ? AccessLevelFlag[code] : AccessLevelFlag.NONE) as AccessLevelFlag;
 },

export function decodeBoolean(stream: BinaryStream): boolean {
    return !!stream.readUInt8();
}

export function decodeNodeId(stream: BinaryStream): NodeId {
    const encodingByte = stream.readUInt8();
    return _decodeNodeId(encodingByte, stream);
}

export function decodeUInt8(stream: BinaryStream): UInt8 {
    return stream.readUInt8();
}