doubly-linked-list-typed/dist/data-structures/base/iterable-element-base.d.ts

Doubly Linked List

import { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
export declare abstract class IterableElementBase<E, R> {
    /**
     * The protected constructor initializes the options for the IterableElementBase class, including the
     * toElementFn function.
     * @param [options] - An optional object that contains the following properties:
     */
    protected constructor(options?: IterableElementBaseOptions<E, R>);
    protected _toElementFn?: (rawElement: R) => E;
    get toElementFn(): ((rawElement: R) => E) | undefined;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(1)
     *
     * The function is an implementation of the Symbol.iterator method that returns an IterableIterator.
     * @param {any[]} args - The `args` parameter in the code snippet represents a rest parameter. It
     * allows the function to accept any number of arguments as an array. In this case, the `args`
     * parameter is used to pass any number of arguments to the `_getIterator` method.
     */
    [Symbol.iterator](...args: any[]): IterableIterator<E>;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(n)
     *
     * The function returns an iterator that yields all the values in the object.
     */
    values(): IterableIterator<E>;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(1)
     *
     * The `every` function checks if every element in the array satisfies a given predicate.
     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
     * the current element being processed, its index, and the array it belongs to. It should return a
     * boolean value indicating whether the element satisfies a certain condition or not.
     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
     * passed as the `this` value to the `predicate` function. If `thisArg` is
     * @returns The `every` method is returning a boolean value. It returns `true` if every element in
     * the array satisfies the provided predicate function, and `false` otherwise.
     */
    every(predicate: ElementCallback<E, R, boolean>, thisArg?: any): boolean;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(1)
     *
     * The "some" function checks if at least one element in a collection satisfies a given predicate.
     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
     * `value`, `index`, and `array`. It should return a boolean value indicating whether the current
     * element satisfies the condition.
     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
     * it will be passed as the `this` value to the `predicate` function. If `thisArg
     * @returns a boolean value. It returns true if the predicate function returns true for any element
     * in the collection, and false otherwise.
     */
    some(predicate: ElementCallback<E, R, boolean>, thisArg?: any): boolean;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(1)
     *
     * The `forEach` function iterates over each element in an array-like object and calls a callback
     * function for each element.
     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
     * the array. It takes three arguments: the current element being processed, the index of the current
     * element, and the array that forEach was called upon.
     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
     * be passed as the `this` value to the `callbackfn` function. If `thisArg
     */
    forEach(callbackfn: ElementCallback<E, R, void>, thisArg?: any): void;
    find<S extends E>(predicate: ElementCallback<E, R, S>, thisArg?: any): S | undefined;
    find(predicate: ElementCallback<E, R, unknown>, thisArg?: any): E | undefined;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(1)
     *
     * The function checks if a given element exists in a collection.
     * @param {E} element - The parameter "element" is of type E, which means it can be any type. It
     * represents the element that we want to check for existence in the collection.
     * @returns a boolean value. It returns true if the element is found in the collection, and false
     * otherwise.
     */
    has(element: E): boolean;
    reduce(callbackfn: ReduceElementCallback<E, R>): E;
    reduce(callbackfn: ReduceElementCallback<E, R>, initialValue: E): E;
    reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue: U): U;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(n)
     *
     * The `toArray` function converts a linked list into an array.
     * @returns The `toArray()` method is returning an array of type `E[]`.
     */
    toArray(): E[];
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(n)
     *
     * The print function logs the elements of an array to the console.
     */
    toVisual(): E[];
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(n)
     *
     * The print function logs the elements of an array to the console.
     */
    print(): void;
    abstract isEmpty(): boolean;
    abstract clear(): void;
    abstract clone(): IterableElementBase<E, R>;
    abstract map(...args: any[]): any;
    abstract filter(...args: any[]): any;
    protected abstract _getIterator(...args: any[]): IterableIterator<E>;
}