pddl-workspace/dist/PddlWorkspace.d.ts

PDDL Workspace

/// <reference types="node" />
import { URI } from 'vscode-uri';
import { EventEmitter } from 'events';
import { ProblemInfo } from './ProblemInfo';
import { FileInfo } from './FileInfo';
import { HappeningsInfo } from "./HappeningsInfo";
import { PddlExtensionContext } from './PddlExtensionContext';
import { DocumentPositionResolver } from './DocumentPositionResolver';
import { DomainInfo } from './DomainInfo';
import { PlanInfo } from './PlanInfo';
import { PddlLanguage, FileStatus } from './language';
import { PddlFileParser, PddlParserOptions } from './parser/index';
import { PddlWorkspaceExtension } from './PddlWorkspaceExtension';
import { PlannerRegistrar } from './planner/PlannerRegistrar';
export declare class Folder {
    readonly folderPath: string;
    files: Map<string, FileInfo>;
    private readonly folderUri;
    constructor(folderPath: string);
    getFolderUri(): URI;
    hasFile(fileUri: URI): boolean;
    get(fileUri: URI): FileInfo | undefined;
    add(fileInfo: FileInfo): void;
    remove(fileInfo: FileInfo): boolean;
    removeByUri(fileUri: URI): boolean;
    getProblemFileWithName(problemName: string): ProblemInfo | undefined;
    getProblemFilesFor(domainInfo: DomainInfo): ProblemInfo[];
    getDomainFilesFor(problemInfo: ProblemInfo): DomainInfo[];
}
/**
 * Enumeration of file types. The types `File` and `Directory` can also be
 * a symbolic links, in that case use `FileType.File | FileType.SymbolicLink` and
 * `FileType.Directory | FileType.SymbolicLink`.
 */
export declare enum FileType {
    /**
     * The file type is unknown.
     */
    Unknown = 0,
    /**
     * A regular file.
     */
    File = 1,
    /**
     * A directory.
     */
    Directory = 2,
    /**
     * A symbolic link to a file.
     */
    SymbolicLink = 64
}
export interface PddlFileSystem {
    /**
     * Retrieve all entries of a [directory](#FileType.Directory).
     *
     * @param uri The uri of the folder.
     * @return An array of name/type-tuples or a thenable that resolves to such.
     */
    readDirectory(uri: URI): Promise<[string, FileType][]>;
    /**
     * Read the entire contents of a file.
     *
     * @param uri The uri of the file.
     * @return An array of bytes or a thenable that resolves to such.
     */
    readFile(uri: URI): Promise<Uint8Array>;
}
export interface PddlWorkspaceOptions {
    epsilon: number;
    context?: PddlExtensionContext;
    parserOptions?: PddlParserOptions;
    fileLoader?: PddlFileSystem;
}
export declare class PddlWorkspace extends EventEmitter {
    readonly folders: Map<string, Folder>;
    private parsingTimeout;
    private defaultTimerDelayInSeconds;
    private pddlFileParsers;
    private plannerRegistrar;
    private _epsilon;
    private readonly fileLoader?;
    static INSERTED: symbol;
    static UPDATED: symbol;
    static REMOVING: symbol;
    static MAX_FILES_PER_FOLDER: number;
    constructor(options: PddlWorkspaceOptions);
    get epsilon(): number;
    set epsilon(value: number);
    getPlannerRegistrar(): PlannerRegistrar;
    addExtension(extension: PddlWorkspaceExtension): void;
    addPddlFileParser(parsers: PddlFileParser<FileInfo>[]): void;
    static getFolderPath(documentUri: URI): string;
    static getFileName(documentUri: URI): string;
    static getFileInfoName(fileInfo: FileInfo): string;
    upsertAndParseFile(fileUri: URI, language: PddlLanguage, fileVersion: number, fileText: string, positionResolver: DocumentPositionResolver): Promise<FileInfo>;
    upsertFile(fileUri: URI, language: PddlLanguage, fileVersion: number, fileText: string, positionResolver: DocumentPositionResolver, force?: boolean): Promise<FileInfo>;
    private insertFile;
    private loadFolder;
    invalidateDiagnostics(fileInfo: FileInfo, fileStatus?: FileStatus): void;
    markProblemsAsDirty(domainInfo: DomainInfo): void;
    markPlansAsDirty(problemInfo: ProblemInfo): void;
    scheduleParsing(): void;
    private cancelScheduledParsing;
    private parseAllDirty;
    reParseFile(fileInfo: FileInfo): Promise<FileInfo>;
    private lastVersionUpdateEmitted;
    /**
     * Emit event, unless it is stale
     * @param fileInfo file concerned
     */
    private emitIfNew;
    private parseFile;
    private appendOffendingTokenToParsingProblems;
    upsertAndParseFolder(folderUri: URI): Promise<Folder>;
    getFolder(folderUri: URI): Folder | undefined;
    private upsertFolder;
    removeFile(documentUri: URI, options: FileRemovalOptions): boolean;
    hasExplicitAssociations(documentUri: URI): boolean;
    getFileInfo<T extends FileInfo>(fileUri: URI): T | undefined;
    getProblemFiles(domainInfo: DomainInfo): ProblemInfo[];
    getPlanFiles(problemInfo: ProblemInfo): PlanInfo[];
    getHappeningsFiles(problemInfo: ProblemInfo): HappeningsInfo[];
    getAllFilesIf<T extends FileInfo>(predicate: (fileInfo: T) => boolean): T[];
    getAllFiles(): FileInfo[];
    /**
     * Finds a corresponding domain file
     * @param fileInfo a PDDL file info
     * @returns corresponding domain file if fileInfo is a problem file,
     * or `fileInfo` itself if the `fileInfo` is a domain file, or `null` otherwise.
     */
    asDomain(fileInfo: FileInfo): DomainInfo | undefined;
    /** Explicit associations between problem files and domain files. */
    private problemToDomainMap;
    associateProblemToDomain(problemInfo: ProblemInfo, domainInfo: DomainInfo): void;
    /**
     * Finds the matching domain files.
     * @param problemFile problem file info
     * @returns matching domain files (zero, one or many)
     */
    getDomainFilesFor(problemFile: ProblemInfo): DomainInfo[];
    /**
     * Finds the matching domain file in the same folder.
     * @param problemFile problem file info
     * @returns matching domain file, if exactly one exists in the same folder. `null` otherwise
     */
    getDomainFileFor(problemFile: ProblemInfo): DomainInfo | undefined;
    /** Explicit associations between plan files and problem files. */
    private planToProblemMap;
    associatePlanToProblem(planUri: URI, problemFileInfo: ProblemInfo): void;
    getProblemFileForPlan(planInfo: PlanInfo): ProblemInfo | undefined;
    getProblemFileForHappenings(happeningsInfo: HappeningsInfo): ProblemInfo | undefined;
    getFolderOf(fileInfo: FileInfo): Folder | undefined;
}
export interface FileRemovalOptions {
    removeAllReferences: boolean;
}