@hazae41/box/dist/types/mods/move/index.d.ts

Rust-like Box and similar objects for TypeScript

import { Nullable } from '../../libs/nullable/index.js';
import { Wrap } from '../wrap/index.js';

declare class MovedError extends Error {
    #private;
    readonly name: string;
    constructor();
}
interface Movable<T> {
    readonly moved: boolean;
    get(): T;
    getOrNull(): Nullable<T>;
    getOrThrow(): T;
    checkOrNull(): Nullable<this>;
    checkOrThrow(): this;
    unwrapOrNull(): Nullable<T>;
    unwrapOrThrow(): T;
    moveOrNull(): Nullable<Move<T>>;
    moveOrThrow(): Move<T>;
}
/**
 * A movable reference
 */
declare class Move<T> implements Disposable, Movable<T> {
    #private;
    readonly value: T;
    readonly clean: Disposable;
    /**
     * An movable reference
     * @param value
     */
    constructor(value: T, clean: Disposable);
    static wrap<T extends Disposable>(value: T): Move<T>;
    static from<T>(value: Wrap<T>): Move<T>;
    static with<T>(value: T, clean: (value: T) => void): Move<T>;
    [Symbol.dispose](): void;
    [Symbol.asyncDispose](): Promise<void>;
    get moved(): boolean;
    /**
     * Get the value
     * @returns T
     */
    get(): T;
    /**
     * Get the value or null-like if not owned
     * @returns T or null-like if not owned
     */
    getOrNull(): Nullable<T>;
    /**
     * Get the value or throw if not owned
     * @returns T
     * @throws NotOwnedError if not owned
     */
    getOrThrow(): T;
    checkOrNull(): Nullable<this>;
    checkOrThrow(): this;
    /**
     * Get the value and set this as moved or null-like if not owned
     * @returns T or null-like if not owned
     */
    unwrapOrNull(): Nullable<T>;
    /**
     * Get the value and set this as moved or throw if not owned
     * @returns T
     * @throws DroppedError if not owned
     */
    unwrapOrThrow(): T;
    /**
     * Move the value to a new Unpin and set this one as moved or null-like if already moved
     * @returns Unpin<T> or null-like if moved
     */
    moveOrNull(): Nullable<Move<T>>;
    /**
     * Move the value to a new Unpin and set this one as moved or throw if already moved
     * @returns Unpin<T>
     * @throws DroppedError if already moved
     */
    moveOrThrow(): Move<T>;
}

export { type Movable, Move, MovedError };