netkitty/dist/lib/codec/abstracts/BaseHeader.d.ts

Network tools kit

import { ProtocolJSONSchema } from '../../schema/ProtocolJSONSchema';
import { CodecModule } from '../types/CodecModule';
import { ProtocolFieldJSONSchema } from '../../schema/ProtocolFieldJSONSchema';
import { CodecErrorInfo } from '../types/CodecErrorInfo';
import { PostHandlerItem } from '../types/PostHandlerItem';
import { CodecData } from '../types/CodecData';
import { FlexibleObject } from '../lib/FlexibleObject';
import { HeaderTreeNode } from '../types/HeaderTreeNode';
export declare abstract class BaseHeader {
    #private;
    protected static get CODEC_INSTANCE(): CodecModule;
    protected static CREATE_CODEC_INSTANCE_WITCH_CODEC_MODULES(codecData: CodecData, codecModules: CodecModule[]): CodecModule;
    static get PROTOCOL_ID(): string;
    static get PROTOCOL_NAME(): string;
    static get PROTOCOL_SCHEMA(): ProtocolJSONSchema;
    static MATCH(codecData: CodecData, codecModules: CodecModule[]): boolean;
    static CREATE_INSTANCE(codecData: CodecData, codecModules: CodecModule[]): CodecModule;
    /**
     * Protocol schema definition
     */
    abstract readonly SCHEMA: ProtocolJSONSchema;
    /**
     * Program used header id
     */
    abstract readonly id: string;
    /**
     * Human-readable header name
     */
    abstract readonly name: string;
    /**
     * Human-readable header nickname
     */
    abstract readonly nickname: string;
    /**
     * Current header is a protocol or not
     */
    readonly isProtocol: boolean;
    /**
     * Encode/Decode error info objects
     */
    errors: CodecErrorInfo[];
    /**
     * Header schema instance
     */
    instance: FlexibleObject;
    /**
     * Entire packet buffer data getter
     */
    get packet(): Buffer;
    /**
     * Entire packet buffer data setter
     * @param packet
     */
    set packet(packet: Buffer);
    /**
     * The start position of this header in the entire packet's buffer
     */
    startPos: number;
    /**
     * The end position of this header in the entire packet's buffer
     */
    get endPos(): number;
    /**
     * Readonly Header length
     */
    get length(): number;
    /**
     * Header length
     * @protected
     */
    protected headerLength: number;
    /**
     * Previous Codec module
     * @protected
     */
    protected readonly prevCodecModule: CodecModule;
    /**
     * Codec modules
     * @protected
     */
    protected readonly codecModules: CodecModule[];
    /**
     * Previous codec modules
     * @protected
     */
    protected readonly prevCodecModules: CodecModule[];
    /**
     * Current header index in packet headers
     * @protected
     */
    protected readonly headerIndex: number;
    /**
     * Post packet handlers
     * @protected
     */
    protected get postPacketHandlers(): PostHandlerItem[];
    /**
     * Registered post encode handlers (CodecModule)
     * @protected
     */
    protected readonly postSelfEncodeHandlers: PostHandlerItem[];
    /**
     * Registered post decode handlers (CodecModule)
     * @protected
     */
    protected readonly postSelfDecodeHandlers: PostHandlerItem[];
    /**
     * Codec data
     * @protected
     */
    protected readonly codecData: CodecData;
    constructor(codecData: CodecData, codecModules: CodecModule[]);
    /**
     * Get packet data offset
     * @param offset
     * @protected
     */
    protected getPacketOffset(offset: number): number;
    /**
     * Is data buffer fits current header codec
     */
    abstract match(): boolean;
    /**
     * Read bytes from buffer
     * @param offset
     * @param length
     * @param dryRun
     * @protected
     */
    protected readBytes(offset: number, length: number, dryRun?: boolean): Buffer;
    /**
     * Write bytes to buffer
     * @param offset
     * @param buffer
     * @protected
     */
    protected writeBytes(offset: number, buffer: Buffer): void;
    /**
     * Read bits from buffer
     * @param offset
     * @param length
     * @param bitOffset
     * @param bitLength
     * @protected
     */
    protected readBits(offset: number, length: number, bitOffset: number, bitLength: number): number;
    /**
     * Write bits to buffer
     * @param offset
     * @param length
     * @param bitOffset
     * @param bitLength
     * @param value
     * @protected
     */
    protected writeBits(offset: number, length: number, bitOffset: number, bitLength: number, value: number): void;
    /**
     * Get field codecs from schema tree
     * @param schema
     * @param codecName
     * @param execBeforeSubCodecs
     * @param codecs
     * @protected
     */
    protected getFieldCodecs(schema: ProtocolFieldJSONSchema, codecName: string, execBeforeSubCodecs: boolean, codecs?: (() => Promise<void>)[]): (() => Promise<void>)[];
    /**
     * Record encode/decode error
     * @param path
     * @param message
     * @protected
     */
    protected recordError(path: string, message: string): void;
    /**
     * Register post encode handler for current codec
     * @param handler
     * @param priority
     * @protected
     */
    protected addPostSelfEncodeHandler(handler: () => void | Promise<void>, priority?: number): void;
    /**
     * Register post decode handler for current codec
     * @param handler
     * @param priority
     * @protected
     */
    protected addPostSelfDecodeHandler(handler: () => void | Promise<void>, priority?: number): void;
    /**
     * Register post encode handler for packet
     * @description Registered handler call sequence: LIFO (Last In First Out)
     * @param handler
     * @param priority
     * @protected
     */
    protected addPostPacketEncodeHandler(handler: () => void | Promise<void>, priority?: number): void;
    /**
     * Register post decode handler for packet
     * @description Registered handler call sequence: FIFO (First In First Out)
     * @param handler
     * @param priority
     * @protected
     */
    protected addPostPacketDecodeHandler(handler: () => void | Promise<void>, priority?: number): void;
    /**
     * Validate input json node is valid
     * @param headerTreeNode
     */
    validate(headerTreeNode: HeaderTreeNode): HeaderTreeNode;
    /**
     * Decode packet header field by field
     */
    decode(): Promise<void>;
    /**
     * Encode packet header field by field
     */
    encode(): Promise<void>;
}
//# sourceMappingURL=BaseHeader.d.ts.map