jalhyd

import { CalculatorType, ComputeNode } from "../internal_modules"; import { LinkedValue } from "../internal_modules"; import { Nub } from "../internal_modules"; import { Interval } from "../internal_modules"; import { IObservable, Observer } from "../internal_modules"; import { ParamDomain, ParamDomainValue } from "../internal_modules"; import { INamedIterableValues, INumberIterator } from "../internal_modules"; import { ParamValueMode } from "../internal_modules"; import { ParamValues } from "../internal_modules"; import { ParamsEquation } from "../internal_modules"; /** * Calculabilité du paramètre */ export declare enum ParamCalculability { /** parameter may have any value, may not vary, may not be calculated */ FIXED = 0, /** parameter may have any value, may vary, may not be calculated */ FREE = 1, /** parameter may have any value, may vary, may be calculated analytically */ EQUATION = 2, /** parameter may have any value, may vary, may be calculated using numerical method */ DICHO = 3 } /** * Parameter family: defines linkability with other parameters/results */ export declare enum ParamFamily { ANY = 0, LENGTHS = 1, WIDTHS = 2, SLOPES = 3, HEIGHTS = 4, BASINFALLS = 5, TOTALFALLS = 6, ELEVATIONS = 7, VOLUMES = 8, FLOWS = 9, DIAMETERS = 10, SPEEDS = 11, STRICKLERS = 12, BLOCKCONCENTRATION = 13 } /** * Strategy to apply when multiple parameters are variating, and * values series have to be extended for sizes to match */ export declare enum ExtensionStrategy { REPEAT_LAST = 0, RECYCLE = 1 } /** * Paramètre avec symbole, famille, domaine de définition, calculabilité, * pointant éventuellement vers un autre paramètre / résultat */ export declare class ParamDefinition implements INamedIterableValues, IObservable { /** le paramètre doit-il être exposé (par ex: affiché par l'interface graphique) ? */ visible: boolean; /** sandbox value used during calculation */ v: number; /** value used to initialize "DICHO" calculation, never supposed to be undefined */ private _initValue; /** extension strategy, when multiple parameters vary */ private _extensionStrategy; /** symbole */ private _symbol; /** unité */ private _unit; /** related parameters groups; indirectly gives access to the Nub using this parameter */ private _parent; /** domaine de définition */ private _domain; /** calculabilité */ private _calc; /** valeur(s) prise(s) */ private _paramValues; /** parameters family, for linking */ private _family; /** pointer to another Parameter / Result, in case of LINK mode */ private _referencedValue; /** implémentation par délégation de IObservable */ private _observable; /** * @param nullParams true if provided value must be ignored (@see nghyd/enableEmptyFieldsOnFormInit) */ constructor(parent: ParamsEquation, symb: string, d: ParamDomain | ParamDomainValue, unit?: string, val?: number, family?: ParamFamily, visible?: boolean, nullParams?: boolean); /** * set parent a-posteriori; used by nghyd when populating forms */ /** * identifiant unique de la forme * (uid du JalhydObject (en général un Nub) + "_" + symbole du paramètre) * ex: 123_Q */ get uid(): string; get unit(): string; setUnit(u: string): void; get initValue(): number; /** * Make sure that this value is never undefined, null or NaN, so that * there is always an initial value for "DICHO" calculations, even * when param value was set to undefined before */ set initValue(v: number); /** * @see getParentComputeNode() */ get parentComputeNode(): ComputeNode; /** * pointer to the ComputeNode (usually Nub) that uses the ParamsEquation that * uses this ParamDefinition; for Section params, if returnEnclosingNubForSections * is true, this will return the Nub enclosing the Section, otherwise the section itself */ getParentComputeNode(returnEnclosingNubForSections?: boolean): ComputeNode; /** * Returns the parent compute node as Nub if it is a Nub; returns * undefined otherwise */ get parentNub(): Nub; /** * Identifiant unique du Nub parent */ get nubUid(): string; /** * Type de module du Nub parent */ get nubCalcType(): CalculatorType; get symbol(): string; setDomain(d: any): void; get domain(): ParamDomain; get interval(): Interval; get extensionStrategy(): ExtensionStrategy; set extensionStrategy(strategy: ExtensionStrategy); get valueMode(): ParamValueMode; /** * Easy setter that propagates the change to other parameters * (default behaviour); use setValueMode(..., false) to prevent * possible infinite loops */ set valueMode(newMode: ParamValueMode); /** * Sets the value mode and asks the Nub to ensure there is only one parameter * in CALC mode * * If propagateToCalculatedParam is true, any param that goes from CALC mode * to any other mode will trigger a reset of the default calculated param at * Nub level * * Propagates modes other than CALC and LINK to the underlying * ParamValues (local instance) */ setValueMode(newMode: ParamValueMode, propagateToCalculatedParam?: boolean): void; private propagateValueMode; /** * Returns true if this parameter is the calculatedParam of * its parent Nub */ get isCalculated(): boolean; /** * Sets this parameter as the one to be calculated */ setCalculated(): void; /** * Current values set associated to this parameter; in LINK mode, points * to a remote set of values. */ get paramValues(): ParamValues; get referencedValue(): LinkedValue; get family(): ParamFamily; get calculability(): ParamCalculability; set calculability(c: ParamCalculability); /** * Returns true if current value (not singleValue !) is defined */ get hasCurrentValue(): boolean; /** * Returns true if held value (not currentValue !) is defined, * depending on the value mode */ get isDefined(): boolean; get singleValue(): number; set singleValue(v: number); get min(): number; set min(v: number); get max(): number; set max(v: number); get step(): number; set step(v: number); /** * Generates a reference step value, given the current (local) values for min / max */ get stepRefValue(): Interval; get valueList(): number[]; set valueList(l: number[]); count(): number; /** * Copies values of p into the current parameter, whatever the valueMode is; if * p has linked values, the target values will be copied and the links won't be kept * @param p a reference ParamDefinition or ParamValues to copy values from */ copyValuesFrom(p: ParamDefinition | ParamValues): void; get currentValue(): number; /** * Get single value */ getValue(): number; /** * Returns values as a number list, for LISTE and MINMAX modes; * in MINMAX mode, infers the list from min/max/step values * @param extendTo if given, will extend the values list to this number of values */ getInferredValuesList(extendTo?: number): number[]; /** * Magic method to define current values into Paramvalues set; defines the mode * accordingly by detecting values nature */ setValues(o: number | any, max?: number, step?: number): void; /** * Sets the current value of the parameter's own values set, then * notifies all observers */ setValue(val: number, sender?: any): void; /** * Same as setValue() but does not force SINGLE value mode; used for * updating initial value of a DICHO calculated parameter */ setInitValue(val: number, sender?: any): void; /** * Validates the given numeric value against the definition domain; throws * an error if value is outside the domain */ checkValueAgainstDomain(v: number): void; checkMin(min: number): boolean; checkMax(max: number): boolean; checkMinMaxStep(step: number): boolean; /** * Return true if single value is valid regarding the domain constraints */ get isValueValid(): boolean; get isMinMaxValid(): boolean; /** * Return true if current value is valid regarding the range constraints : min / max / step */ get isRangeValid(): boolean; /** * Root method to determine if a field value is valid, regarding the model constraints. * * Does not take care of input validation (ie: valid number, not empty...) because an * invalid input should never be set as a value; input validation is up to the GUI. * * In LINK mode : * - if target is a parameter, checks validity of the target value against the local model constraints * - if target is a result : * - is result is already computed, checks validity of the target result against the local model constraints * - if it is not, checks the "computability" of the target Nub (ie. validity of the Nub) to allow * triggering chain computation */ get isValid(): boolean; /** * Sets the current parameter to LINK mode, pointing to the given * symbol (might be a Parameter (computed or not) or an ExtraResult) * of the given Nub * * Prefer @see defineReferenceFromLinkedValue() whenever possible * * @param nub * @param symbol */ defineReference(nub: Nub, symbol: string): void; /** * Asks the Session for available linkabke values for the current parameter, * and returns true if given { nub / symbol } pair is part of them */ isAcceptableReference(nub: Nub, symbol: string): boolean; defineReferenceFromLinkedValue(target: LinkedValue): void; undefineReference(): void; isReferenceDefined(): boolean; /** * Returns an object representation of the Parameter's current state * @param nubUidsInSession UIDs of Nubs that will be saved in session along with this one; * useful to determine if linked parameters must be kept as links or have their value * copied (if target is not in UIDs list); if undefined, wil consider all Nubs as * available (ie. will not break links) */ objectRepresentation(nubUidsInSession?: string[]): { symbol: string; mode: string; }; /** * Fills the current Parameter, provided an object representation * @param obj object representation of a Parameter state * @returns object { * calculated: boolean true if loaded parameter is in CALC mode * hasErrors: boolean true if errors were encountered during loading * } */ loadObjectRepresentation(obj: any, setCalcMode?: boolean): { calculated: boolean; hasErrors: boolean; }; /** * Returns true if both the Nub UID and the symbol are identical */ equals(p: ParamDefinition): boolean; /** * Returns true if this parameter's value can safely be linked to the * given parameter "src" (ie. without leading to circular dependencies) */ isLinkableTo(src: ParamDefinition): boolean; /** * Returns true if this parameter is ultimately (after followink links chain) linked * to a result or extra result of any of the given nubs. * If followLinksChain is false, will limit theexploration to the first target level only */ isLinkedToResultOfNubs(nubs: Nub[], followLinksChain?: boolean): boolean; /** * Returns true if the current parameter is directly linked to the * Nub having UID "uid", its parent or any of its children * @param uid * @param symbol symbol of the target parameter whose value change triggered this method; * if current Parameter targets this symbol, Nub will be considered dependent * @param includeValuesLinks if true, even if this Parameter targets a non-calculated non-modified * parameter, Nub will be considered dependent @see jalhyd#98 */ dependsOnNubFamily(uid: string, symbol?: string, includeValuesLinks?: boolean): boolean; /** * Transparent proxy to own values iterator or targetted values iterator (in LINK mode) */ get valuesIterator(): INumberIterator; getExtendedValuesIterator(size: number): INumberIterator; /** * Returns true if there are more than 1 value associated to this parameter; * might be its own values (MINMAX / LISTE mode), or targetted values (LINK mode) */ get hasMultipleValues(): boolean; initValuesIterator(reverse?: boolean): INumberIterator; get hasNext(): boolean; next(): IteratorResult<number>; /** trick method - use .next() instead, unless you are explicitely in jalhyd#222 case */ nextValue(): IteratorResult<number>; [Symbol.iterator](): IterableIterator<number>; /** * ajoute un observateur à la liste */ addObserver(o: Observer): void; /** * supprime un observateur de la liste */ removeObserver(o: Observer): void; /** * notifie un événement aux observateurs */ notifyObservers(data: any, sender?: any): void; /** * variable calculable par l'équation ? */ isAnalytical(): boolean; /** * Get the highest nub in the child nub hierarchy */ get originNub(): Nub; /** * Renvoie la valeur actuelle du paramètre (valeur courante ou résultat si calculé) */ get V(): number; clone(): ParamDefinition; /** * notification envoyée après la modification de la valeur du paramètre */ private notifyValueModified; /** * vérifie si un min/max est valide par rapport au domaine de définition */ private isMinMaxDomainValid; private checkMinMax; private get isListValid(); /** * Throws an error if this.paramValues._valueMode is not the expected value mode. * In LINK mode, the tested valueMode is the mode of the ultimately targetted * set of values (may never be LINK) */ private checkValueMode; } //# sourceMappingURL=param-definition.d.ts.map