#45

- simplification de IReferencedObject
- ParamValues implémente IObjectReference

spec/value_ref/value_ref.spec.ts

@@ -195,7 +195,7 @@ describe("référence d'un paramètre à un autre : ", () => {
 
             let n = 0;
             let i = min;
-            for (const v of prm2.A.referencedValues) {
+            for (const v of prm2.A.paramValues.getValuesIterator()) {
                 expect(v).toEqual(i);
                 n++;
                 i += step;

src/nub.ts

@@ -148,37 +148,14 @@ export abstract class Nub extends ComputeNode implements IReferencedObject {
 
     // interface IReferencedObject
 
-    /**
-     * getter de la (des) valeurs référencées
-     */
-    public getReferencedValues(desc: string): number[] {
-        const p: ParamDefinition = this.getParameter(desc);
-        if (p !== undefined) {
-            switch (p.valueMode) {
-                case ParamValueMode.CALCUL:
-                    {
-                        this.CalcSerie(0.001, 0.1, p.symbol);
-                        const res: number[] = [];
-                        for (const re of this._result.resultElements)
-                            res.push(re.vCalc);
-                        return res;
-                    }
-
-                case ParamValueMode.LINK:
-                    return p.referencedValues;
-
-                default:
-                    const res: number[] = [];
-                    for (const v of p.paramValues.getValuesIterator())
-                        res.push(v);
-                    return res;
-            }
-        }
-
-        throw new Error(`Nub : appel à IReferencedObject.getReferencedValues('${desc}') invalide`);
+    public getReferencedParamValues(desc: string): ParamValues {
+        return this.getParameter(desc).paramValues;
     }
 
-    public getReferencedValueMode(desc: string): ParamValueMode {
-        return this.getParameter(desc).paramValues.valueMode;
+    public getReferencedResult(desc: string): Result {
+        if (this._result !== undefined && this._result.name === desc)
+            return this._result;
+
+        return this.CalcSerie(0.001, 0.1, desc);
     }
 }

src/param/param-base.ts

@@ -5,7 +5,8 @@ import { Message, MessageCode } from "../util/message";
 import { JalhydObject } from "../jalhyd_object"
 import { ParamDomain, ParamDomainValue } from "./param-domain";
 import { ParamValues, ParamValueMode } from "./param-values";
-import { IReferencedObject, IObjectReference, ObjectReference } from "../value_ref/object_ref";
+import { IReferencedObject, IObjectReference } from "../value_ref/object_ref";
+import { Result } from "..";
 
 /**
  * paramètre avec symbole et domaine de définition
@@ -27,15 +28,9 @@ export class BaseParam extends JalhydObject implements IObjectReference {
      */
     private _paramValues: ParamValues;
 
-    /**
-     * implémentation par délégation de IObjectReference
-     */
-    private _valueRef: ObjectReference;
-
     constructor(symb: string, d: ParamDomain | ParamDomainValue, val?: number) {
         super();
         this._symbol = symb;
-        this._valueRef = new ObjectReference();
 
         this._paramValues = new ParamValues();
         this._paramValues.setSingleValue(val);
@@ -64,6 +59,8 @@ export class BaseParam extends JalhydObject implements IObjectReference {
     }
 
     public get paramValues(): ParamValues {
+        if (this.isReferenceDefined)
+            return this.referencedParamValues;
         return this._paramValues;
     }
 
@@ -82,16 +79,7 @@ export class BaseParam extends JalhydObject implements IObjectReference {
             throw e;
         }
 
-        if (this.isReferenceDefined)
-            return this._valueRef.referencedValues[0];
-        else
-            switch (this.valueMode) {
-                case ParamValueMode.SINGLE:
-                    return this._paramValues.singleValue;
-
-                default:
-                    throw new Error(`mode de valeur ${ParamValueMode[this.valueMode]} invalide`);
-            }
+        return this._paramValues.singleValue;
     }
 
     public setValue(val: number) {
@@ -158,37 +146,24 @@ export class BaseParam extends JalhydObject implements IObjectReference {
     }
 
     public get valueMode() {
-        switch (this._paramValues.valueMode) {
-            case ParamValueMode.LINK:
-                return this.referencedValueMode;
-
-            default:
-                return this._paramValues.valueMode;
-        }
+        return this._paramValues.valueMode;
     }
 
     // interface IObjectReference
 
     public defineReference(target: IReferencedObject, desc: string) {
-        this.paramValues.valueMode = ParamValueMode.LINK;
-        this._valueRef.defineReference(target, desc);
+        this._paramValues.defineReference(target, desc);
     }
 
     public get isReferenceDefined(): boolean {
-        return this._valueRef.isReferenceDefined;
+        return this._paramValues.isReferenceDefined;
     }
 
-    /**
-     * valeurs de l'objet IReferencedObject référencé
-     */
-    public get referencedValues(): number[] {
-        return this._valueRef.referencedValues;
+    public get referencedParamValues(): ParamValues {
+        return this._paramValues.referencedParamValues;
     }
 
-    /**
-     * mode de valeur dans l'objet référencé
-     */
-    public get referencedValueMode(): ParamValueMode {
-        return this._valueRef.referencedValueMode;
+    public get referencedResult(): Result {
+        return this._paramValues.referencedResult;
     }
 }

src/param/param-values.ts

 import { Pair } from "../util/pair"
 import { DefinedNumber } from "../util/definedvalue";
+import { IReferencedObject, IObjectReference, ObjectReference } from "../value_ref/object_ref";
+import { Result } from "..";
 
 /**
  * mode de génération des valeurs
@@ -178,7 +180,7 @@ export class ParamValueIterator implements IterableIterator<number> {
     }
 }
 
-export class ParamValues {
+export class ParamValues implements IObjectReference {
     /**
      * mode de génération des valeurs : min/max, liste, ...
      */
@@ -214,8 +216,14 @@ export class ParamValues {
      */
     private _iterator: ParamValueIterator;
 
+    /**
+     * implémentation par délégation de IObjectReference
+     */
+    private _valueRef: ObjectReference;
+
     constructor() {
         this._singleValue = new DefinedNumber();
+        this._valueRef = new ObjectReference();
     }
 
     public setValues(o: number | any, max?: number, step?: number) {
@@ -239,7 +247,13 @@ export class ParamValues {
     }
 
     public get valueMode() {
-        return this._valueMode;
+        switch (this._valueMode) {
+            case ParamValueMode.LINK:
+                return this.referencedParamValues.valueMode;
+
+            default:
+                return this._valueMode;
+        }
     }
 
     public set valueMode(m: ParamValueMode) {
@@ -283,7 +297,9 @@ export class ParamValues {
         }
     }
 
-    public get singleValue() {
+    public get singleValue(): number {
+        if (this.isReferenceDefined)
+            return this._valueRef.referencedParamValues.singleValue;
         return this._singleValue.value;
     }
 
@@ -301,7 +317,17 @@ export class ParamValues {
     }
 
     public get min() {
-        return this._minValue;
+        switch (this._valueMode) {
+            case ParamValueMode.MINMAX:
+                return this._minValue;
+
+            case ParamValueMode.LINK:
+                return this._valueRef.referencedParamValues.min;
+
+            default:
+                this.checkValueMode(ParamValueMode.MINMAX); // pour générer une erreur
+                return undefined; // pour le compilo
+        }
     }
 
     public set min(v: number) {
@@ -310,7 +336,17 @@ export class ParamValues {
     }
 
     public get max() {
-        return this._maxValue;
+        switch (this._valueMode) {
+            case ParamValueMode.MINMAX:
+                return this._maxValue;
+
+            case ParamValueMode.LINK:
+                return this._valueRef.referencedParamValues.max;
+
+            default:
+                this.checkValueMode(ParamValueMode.MINMAX);
+                return undefined; // pour le compilo
+        }
     }
 
     public set max(v: number) {
@@ -324,8 +360,17 @@ export class ParamValues {
     }
 
     public get step() {
-        this.checkValueMode(ParamValueMode.MINMAX);
-        return this._stepValue;
+        switch (this._valueMode) {
+            case ParamValueMode.MINMAX:
+                return this._stepValue;
+
+            case ParamValueMode.LINK:
+                return this._valueRef.referencedParamValues.step;
+
+            default:
+                this.checkValueMode(ParamValueMode.MINMAX); // pour générer une erreur
+                return undefined; // pour le compilo
+        }
     }
 
     public set step(v: number) {
@@ -359,13 +404,16 @@ export class ParamValues {
         switch (this._valueMode) {
             case ParamValueMode.LISTE:
             case ParamValueMode.MINMAX:
+                this._iterator = this.getValuesIterator(reverse);
+                break;
+
+            case ParamValueMode.LINK:
+                this._iterator = this._valueRef.referencedParamValues.getValuesIterator(reverse);
                 break;
 
             default:
                 throw new Error(`ParamValues : mode de valeurs ${ParamValueMode[this._valueMode]} incorrect`);
         }
-
-        this._iterator = this.getValuesIterator(reverse);
     }
 
     /**
@@ -383,4 +431,23 @@ export class ParamValues {
         this._singleValue.value = this._iterator.next().value;
         return this._singleValue.value;
     }
+
+    // interface IObjectReference
+
+    public defineReference(target: IReferencedObject, desc: string) {
+        this.valueMode = ParamValueMode.LINK;
+        this._valueRef.defineReference(target, desc);
+    }
+
+    public get isReferenceDefined(): boolean {
+        return this._valueRef.isReferenceDefined;
+    }
+
+    public get referencedParamValues(): ParamValues {
+        return this._valueRef.referencedParamValues;
+    }
+
+    public get referencedResult(): Result {
+        return this._valueRef.referencedResult;
+    }
 }

src/value_ref/object_ref.ts

-import { ParamValueMode } from "../param/param-values";
+import { ParamValueMode, ParamValueIterator, ParamValues } from "../param/param-values";
+import { Result } from "..";
 
 /**
  * objet (paramètre ou résultat) dont les valeurs sont référençables pour réutilisation
@@ -6,15 +7,16 @@ import { ParamValueMode } from "../param/param-values";
  */
 export interface IReferencedObject {
     /**
-     * getter de la (des) valeurs
+     * getter des valeurs
+     * @param desc : description sous forme symbolique
      */
-    getReferencedValues(desc: string): number[];
-
+    getReferencedParamValues(desc: string): ParamValues;
 
     /**
-     * getter du mode de valeur
+     * getter du résultat
+     * @param desc : description sous forme symbolique
      */
-    getReferencedValueMode(desc: string): ParamValueMode;
+    getReferencedResult(desc: string): Result;
 }
 
 /**
@@ -34,14 +36,14 @@ export interface IObjectReference {
     readonly isReferenceDefined: boolean;
 
     /**
-     * valeurs de l'objet IReferencedObject référencé
+     * instance de ParamValues référencée
      */
-    readonly referencedValues: number[];
+    readonly referencedParamValues: ParamValues;
 
     /**
-     * mode de valeur dans l'objet référencé
+     * instance de Result référencée
      */
-    readonly referencedValueMode: ParamValueMode;
+    readonly referencedResult: Result;
 }
 
 /**
@@ -69,16 +71,16 @@ export class ObjectReference implements IObjectReference {
     }
 
     /**
-     * valeurs dans l'objet référencé
+     * instance de ParamValues référencée
      */
-    public get referencedValues(): number[] {
-        return this._referencedObject.getReferencedValues(this._refDefinition);
+    public get referencedParamValues(): ParamValues {
+        return this._referencedObject.getReferencedParamValues(this._refDefinition);
     }
 
     /**
-     * mode de valeur dans l'objet référencé
+     * instance de Result référencée
      */
-    public get referencedValueMode(): ParamValueMode {
-        return this._referencedObject.getReferencedValueMode(this._refDefinition);
+    public get referencedResult(): Result {
+        return this._referencedObject.getReferencedResult(this._refDefinition);
     }
 }