jalhyd/build/param/param-value-iterator.d.ts

JaLHyd, a Javascript Library for Hydraulics

import { INamedObject, IObjectWithFamily } from "../internal_modules";
import { ParamValues } from "../internal_modules";
/**
 * itérateur sur des nombres
 */
export interface INumberIterator extends IterableIterator<number> {
    /**
     * @return true si il reste des valeurs à parcourir
     */
    readonly hasNext: boolean;
    /**
     * valeur courante cad résultat du précédent appel à next().
     * contrairement à next(), on peut l'appeler plusieurs fois sans modifier l'état de l'itérateur
     */
    readonly currentValue: number;
    /**
     * prochaine valeur
     */
    next(): IteratorResult<number>;
    nextValue(): IteratorResult<number>;
    count(): number;
}
/**
 * interface implémentée par les objets pouvant posséder/renvoyer un itérateur sur une série de valeurs numériques
 */
export interface IterableValues extends INumberIterator {
    /**
     * crée un nouvel itérateur sur les valeurs
     */
    readonly valuesIterator: INumberIterator;
    /**
     * true si la série de valeurs a plus d'une valeur
     */
    readonly hasMultipleValues: boolean;
    /**
     * initialise un itérateur interne sur les valeurs implicitement utilisé par hasNext() et next()
     */
    initValuesIterator(reverse: boolean): INumberIterator;
}
/**
 * objets pouvant avoir un nom et un itérateur sur une série de valeurs numériques
 */
export interface INamedIterableValues extends INamedObject, IObjectWithFamily, IterableValues {
}
/**
 * itérateur sur les (ou la) valeurs prises par un ParamValues
 */
export declare class ParamValueIterator implements INumberIterator {
    /** paramètre à itérer */
    private _param;
    /**
     * true si les valeurs sont fournies de max à min (ParamValueMode.MINMAX);
     * utilisé uniquement par Remous
     */
    private _reverse;
    /** length to extend the values series to, depending on _param ExtensionStrategy */
    private _extendTo;
    /**
     * if true, in MINMAX mode ensures that max value is returned,
     * even if (max - min) is not a multiple of step
     */
    private _addLastStep;
    /** valeur courante */
    private _current;
    /**
     * index sur les valeurs définies (et non sur les valeurs étendues): en mode LISTE,
     * nombre de valeurs actuellement produites; en mode MINMAX, valeur courante (!)
     */
    private _index;
    /**
     * index sur les valeurs étendues (lorsque plusieurs paramètres varient): en mode MINMAX,
     * nombre de valeurs actuellement produites, à comparer à this._extendTo; en mode LISTE,
     * index de la valeur courante à répéter (!)
     */
    private _xindex;
    /**
     * itérateur local pour étendre les valeurs en mode MINMAX
     */
    private _locExIt;
    /**
     * indicates that the MINMAX iterator has already run once until
     * the last value (whether it is aligned or not) was reached
     */
    private _minMaxLastValueReached;
    constructor(prm: ParamValues, reverse: boolean, extendTo: number, addLastStep?: boolean);
    get currentValue(): number;
    /**
     * Returns the number of elements in the iterator without altering it,
     * by counting a copy of the iterator
     */
    count(): number;
    /**
     * Reinits the value iterator
     * @param reverse if true, will iterate starting at the end
     * @param extendTo if defined, will extend values list until this boundary
     * @param addLastStep if true, if (max - min) is not a multiple of step, one more
     *                    iteration will be done return last value (max)
     */
    reset(reverse: boolean, extendTo?: number, addLastStep?: boolean): void;
    /**
     * Same as next(), but sets _currentValue on attached ParamValues; to be
     * used with dedicated iterators, for params having multiple links on them
     * @see jalhyd#222
     */
    nextValue(): IteratorResult<number>;
    next(): IteratorResult<number>;
    [Symbol.iterator](): IterableIterator<number>;
    get hasNext(): boolean;
    protected get hasNextWithoutExtension(): boolean;
    /**
     * Returns true if iterator has at least one more value
     * @param ignoreExtension if true, will consider only real values (those that were
     *      set up), including the possible extraStep, and ignore extended values
     */
    protected hasNextValue(ignoreExtension?: boolean): boolean;
    /**
     * Returns true if last value that is a multiple of step was reached;
     * it might still miss the lastStep if required
     */
    protected minMaxLastAlignedValueReached(): boolean;
    /**
     * Returns true if last value was reached in MINMAX mode
     */
    protected minMaxLastValueReached(): boolean;
}
//# sourceMappingURL=param-value-iterator.d.ts.map