An error occurred while loading the file. Please try again.
-
Mathias Chouet authored0fad80c0
import { ExtensionStrategy } from "./param-definition";
import { INumberIterator, IterableValues, ParamValueIterator } from "./param-value-iterator";
import { ParamValueMode } from "./param-value-mode";
/**
* Represents the value(s) taken by a Parameter, along with and depending on
* the value mode; linked values are not managed here, only the LINK value
* mode is defined here
*/
export class ParamValues implements IterableValues {
/** usually set by enclosing ParamDefinition */
public valueMode: ParamValueMode;
/** usually set by enclosing ParamDefinition */
public extensionStrategy: ExtensionStrategy;
/** valeur min dans le cas ParamValueMode.MINMAX */
public min: number;
/** valeur max dans le cas ParamValueMode.MINMAX */
public max: number;
/** pas de progression dans le cas ParamValueMode.MINMAX */
public step: number;
/** liste de valeurs dans le cas ParamValueMode.LISTE */
public valueList: number[];
/** valeur numérique (éventuellement non définie) dans le mode "valeur unique" (ParamValueMode.SINGLE) */
private _singleValue: number;
/** valeur courante (éventuellement non définie) indépendemment du mode */
private _currentValue: number;
/**
* itérateur courant
*/
private _iterator: INumberIterator;
public get singleValue(): number {
return this._singleValue;
}
public set singleValue(v: number) {
this._singleValue = v;
this._currentValue = v;
}
public get currentValue() {
return this._currentValue;
}
public count() {
return this._iterator.count();
}
public setValues(o: number | any, max?: number, step?: number) {
if (typeof (o) === "number") {
if (max === undefined) {
this.valueMode = ParamValueMode.SINGLE;
this.singleValue = o;
} else {
this.valueMode = ParamValueMode.MINMAX;
this.min = o;
this.max = max;
this.step = step;
}
} else if (Array.isArray(o)) {
this.valueMode = ParamValueMode.LISTE;
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
this.valueList = o;
} else {
throw new Error(`ParamValues.setValues() : appel invalide`);
}
}
public check() {
switch (this.valueMode) {
case ParamValueMode.SINGLE:
if (this.singleValue === undefined) {
throw new Error(`ParamValues : valeur fixe non définie`);
}
break;
case ParamValueMode.MINMAX:
if (this.min === undefined) {
throw new Error(`ParamValues : valeur min non définie`);
}
if (this.max === undefined) {
throw new Error(`ParamValues : valeur max non définie`);
}
if (this.step === undefined) {
throw new Error(`ParamValues : valeur du pas non définie`);
}
if (this.min > this.max) {
throw new Error(`ParamValues : min > max`);
}
break;
case ParamValueMode.LISTE:
if (this.valueList === undefined) {
throw new Error(`ParamValues : liste de valeurs non définie`);
}
break;
case ParamValueMode.LINK:
case ParamValueMode.CALCUL:
default:
break;
}
}
/**
* Returns values as a number list by running through the iterator,
* taking in account reverse, extendTo and addLastStep if defined
*/
public getInferredValuesList(reverse: boolean = false, extendTo?: number, addLastStep: boolean = false) {
if ([ ParamValueMode.MINMAX, ParamValueMode.LISTE ].includes(this.valueMode)) {
// protection against infinite loops
if (
this.step !== undefined && this.step > 0
&& this.min !== undefined && this.min !== null
&& this.max !== undefined && this.max !== null
) {
const it = this.initValuesIterator(reverse, extendTo, addLastStep);
const values: number[] = [];
for (const v of it) {
values.push(v);
}
return values;
} else {
return [];
}
}
throw new Error("ParamValues.getInferredValuesList() : incorrect value mode" + ParamValueMode[this.valueMode]);
}
// -- iterator-related methods
/**
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
* Returns a ParamValueIterator over the current values
* @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)
*/
public getValuesIterator(
reverse: boolean = false,
extendTo?: number,
addLastStep: boolean = false
): INumberIterator {
return new ParamValueIterator(this, reverse, extendTo, addLastStep);
}
// interface IterableValues
public get valuesIterator(): INumberIterator {
return this.getValuesIterator(false, undefined, true);
}
public get hasMultipleValues(): boolean {
try {
// will throw an error if no value is defined at all
this.check();
} catch (e) {
return false;
}
const it = this.getValuesIterator();
if (it) {
let n = 0;
for (const v of it) {
n++;
if (n > 1) {
break;
}
}
return n > 1;
} else {
return false;
}
}
/**
* Checks that values are in LIST or MINMAX mode, then retrieves an 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)
*/
public initValuesIterator(
reverse: boolean = false,
extendTo?: number,
addLastStep: boolean = false
): INumberIterator {
switch (this.valueMode) {
case ParamValueMode.LISTE:
case ParamValueMode.MINMAX:
this._iterator = this.getValuesIterator(reverse, extendTo, addLastStep);
break;
default:
throw new Error(`ParamValues : mode de valeurs ${ParamValueMode[this.valueMode]} incorrect`);
}
return this._iterator;
}
/**
* @return true si il reste des valeurs à parcourir par l'itérateur courant
*/
211212213214215216217218219220221222223224225226227228229230231232
public get hasNext(): boolean {
return this._iterator.hasNext;
}
/**
* fixe la valeur courante à la prochaine valeur à parcourir par l'itérateur courant
* @return prochaine valeur à parcourir par l'itérateur courant
*/
public next(): IteratorResult<number> {
let res;
res = this._iterator.next();
if (!res.done) {
this._currentValue = res.value;
}
return res;
}
public [Symbol.iterator](): IterableIterator<number> {
return this;
}
}