@theia/core/lib/common/message-rpc/rpc-protocol.d.ts

import { CancellationTokenSource } from '../cancellation';
import { DisposableCollection } from '../disposable';
import { Emitter, Event } from '../event';
import { Deferred } from '../promise-util';
import { Channel } from './channel';
import { RpcMessage, RpcMessageDecoder, RpcMessageEncoder } from './rpc-message-encoder';
/**
 * Handles request messages received by the {@link RpcServer}.
 */
export declare type RequestHandler = (method: string, args: any[]) => Promise<any>;
/**
 * Initialization options for a {@link RpcProtocol}.
 */
export interface RpcProtocolOptions {
    /**
     * The message encoder that should be used. If `undefined` the default {@link RpcMessageEncoder} will be used.
     */
    encoder?: RpcMessageEncoder;
    /**
     * The message decoder that should be used. If `undefined` the default {@link RpcMessageDecoder} will be used.
     */
    decoder?: RpcMessageDecoder;
}
/**
 * Establish a bi-directional RPC protocol on top of a given channel. Bi-directional means to send
 * sends requests and notifications to the remote side as well as receiving requests and notifications from the remote side.
 * Clients can get a promise for a remote request result that will be either resolved or
 * rejected depending on the success of the request. Keeps track of outstanding requests and matches replies to the appropriate request
 * Currently, there is no timeout handling for long running requests implemented.
 */
export declare class RpcProtocol {
    readonly channel: Channel;
    readonly requestHandler: RequestHandler;
    static readonly CANCELLATION_TOKEN_KEY = "add.cancellation.token";
    protected readonly pendingRequests: Map<number, Deferred<any>>;
    protected nextMessageId: number;
    protected readonly encoder: RpcMessageEncoder;
    protected readonly decoder: RpcMessageDecoder;
    protected readonly onNotificationEmitter: Emitter<{
        method: string;
        args: any[];
    }>;
    protected readonly cancellationTokenSources: Map<number, CancellationTokenSource>;
    get onNotification(): Event<{
        method: string;
        args: any[];
    }>;
    protected toDispose: DisposableCollection;
    constructor(channel: Channel, requestHandler: RequestHandler, options?: RpcProtocolOptions);
    handleMessage(message: RpcMessage): void;
    protected handleReply(id: number, value: any): void;
    protected handleReplyErr(id: number, error: any): void;
    sendRequest<T>(method: string, args: any[]): Promise<T>;
    sendNotification(method: string, args: any[]): void;
    sendCancel(requestId: number): void;
    protected handleCancel(id: number): void;
    protected handleRequest(id: number, method: string, args: any[]): Promise<void>;
    protected handleNotify(id: number, method: string, args: any[]): Promise<void>;
}
//# sourceMappingURL=rpc-protocol.d.ts.map