ticket #36 : suppression de BaseResult, Result hérite de CalcResult

spec/remous/remous_rect_euler_pentefaible.spec.ts

@@ -4,7 +4,7 @@ import { cLog } from "../../src/util/log";
 import { Message, MessageCode } from "../../src/util/message";
 import { compareArray, compareLog, compareObject } from "../test_func";
 import { precDist } from "../test_config";
-import { CalcResult } from "../../src/util/result";
+import { CalcResult } from "../../src/util/calcresult";
 
 describe("Class Remous / section rectangulaire :", () => {
     describe("méthode Euler explicite :", () => {

spec/remous/test-remous-fenetre.ts

@@ -2,7 +2,8 @@
 import { CourbeRemous, CourbeRemousParams, MethodeResolution } from "../../src/remous";
 import { cSnRectang, ParamsSectionRectang } from "../../src/section/section_rectang";
 import { equalEpsilon, compareArray } from "../test_func";
-import { Result, CalcResult } from "../../src/util/result";
+import { Result } from "../../src/util/result";
+import { CalcResult } from "../../src/util/calcresult";
 
 /*
    Tentative de validation automatique du calcul des courbes de remous.

src/index.ts

-export * from './base';
-export * from './param';
-export * from './parameters';
-export * from './nub';
-export * from './cond_distri';
-export * from './dichotomie';
-export * from './lechaptcalmon';
-export * from './regime_uniforme';
-export * from './remous';
-export * from './section/section_type';
-export * from './section/section_trapez';
-export * from './section/section_rectang';
-export * from './section/section_circulaire';
-export * from './section/section_puissance';
-export * from './util/definedvalue';
-export * from './util/numericalstring';
-export * from './util/message';
-export * from './util/log';
-export * from './util/result';
-export * from './util/pair';
-export * from './util/interval';
-export * from './pab/pab_dimension';
-export * from './pab/pab_puissance';
+export * from "./base";
+export * from "./param";
+export * from "./parameters";
+export * from "./nub";
+export * from "./cond_distri";
+export * from "./dichotomie";
+export * from "./lechaptcalmon";
+export * from "./regime_uniforme";
+export * from "./remous";
+export * from "./section/section_type";
+export * from "./section/section_trapez";
+export * from "./section/section_rectang";
+export * from "./section/section_circulaire";
+export * from "./section/section_puissance";
+export * from "./util/definedvalue";
+export * from "./util/numericalstring";
+export * from "./util/message";
+export * from "./util/log";
+export * from "./util/result";
+export * from "./util/calcresult";
+export * from "./util/pair";
+export * from "./util/interval";
+export * from "./pab/pab_dimension";
+export * from "./pab/pab_puissance";

src/remous.ts

 import { ParamsSection, acSection } from "./section/section_type";
 import { XOR, round } from "./base";
-import { Result, CalcResult } from "./util/result";
+import { Result } from "./util/result";
+import { CalcResult } from "./util/calcresult";
 import { ParamsEquation, ParamDefinition, ParamCalculability, ComputeNodeType, ParamDomainValue } from "./param";
 import { Dichotomie } from "./dichotomie";
 import { Nub } from "./nub";

src/util/calcresult.ts

+import { cLog } from "./log";
+import { Result } from "./result";
+import { MessageSeverity, Message } from "./message";
+
+/**
+ * Résultat global d'un calcul
+ * Peut comporter un ou plusieurs Result.
+ */
+// tslint:disable-next-line:max-classes-per-file
+export class CalcResult {
+    /**
+     * Messages (erreurs, infos, ...)
+     */
+    private _log: cLog;
+
+    private _results: Result[];
+
+    constructor() {
+        this._log = new cLog();
+        this._results = [];
+    }
+
+    public addResult(r: Result) {
+        this._results.push(r);
+    }
+
+    /**
+     * Insert result r at index i
+     * @param r Result to insert
+     * @param i Index position
+     */
+    public insertResult(r: Result, i: number) {
+        this._results.splice(i, 0, r);
+    }
+
+    /**
+     * @param name nom du résultat complémentaire
+     * @returns le nombre la taille d'un résultat complémentaire
+     */
+    public extraResultLength(name: string): number {
+        const r = this.getExtraResult(name);
+        if (r === undefined) {
+            return 0;
+        }
+        return Object.keys(r).length;
+    }
+
+    public getExtraResult(name: string): any {
+        const res = [];
+        for (const r of this._results) {
+            const er = r.getExtraResult(name);
+            if (er !== undefined) {
+                res.push(er);
+            }
+        }
+
+        switch (res.length) {
+            case 0:
+                return undefined;
+
+            case 1:
+                return res[0];
+
+            default:
+                throw new Error(
+                    "CalcResult.getExtraResult() : il existe plusieurs 'Result' avec le nom '" + name + "'",
+                );
+        }
+    }
+
+    public get log() {
+        return this._log;
+    }
+
+    protected get messageCount(): number {
+        return this._log.messages.length;
+    }
+
+    /**
+     * ajoute un message au journal
+     */
+    public addMessage(m: Message) {
+        this._log.add(m);
+    }
+
+    /**
+     * ajoute tous les messages d'un journal au journal
+     */
+    public addLog(l: cLog) {
+        this._log.addLog(l);
+    }
+
+    /**
+     * insert un message en début de liste
+     */
+    public insertMessage(m: Message) {
+        this._log.insert(m);
+    }
+
+    /**
+     * Teste si tous les résultats + complémentaires sont valides et journal sans erreur
+     * @returns true si le test est valide
+     */
+    public get ok(): boolean {
+        return this.resultsOk && !this.hasErrorMessages;
+    }
+
+    /**
+     * Teste si tous les résultats + complémentaires sont valides
+     * @returns true si le test est valide
+     */
+    public get resultsOk(): boolean {
+        if (this._results.length === 0 && this.log.messages.length === 0) {
+            return false;
+        }
+        for (const r of this._results) {
+            if (!r.resultsOk) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @returns true si au moins un message de log comporte un code d'erreur
+     */
+    public get hasErrorMessages(): boolean {
+        for (const m of this.log.messages) {
+            if (m.getSeverity() === MessageSeverity.ERROR) {
+                return true;
+            }
+        }
+
+        for (const r of this._results) {
+            if (r.hasErrorMessages) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/util/result.ts

 import { cLog } from "./log";
 import { Message, MessageCode, MessageSeverity } from "./message";
-
-export abstract class BaseResult {
-    /**
-     * Messages (erreurs, infos, ...)
-     */
-    private _log: cLog;
-
-    constructor() {
-        this._log = new cLog();
-    }
-
-    public get log() {
-        return this._log;
-    }
-
-    /**
-     * ajoute un message au journal
-     */
-    public addMessage(m: Message) {
-        this._log.add(m);
-    }
-
-    /**
-     * ajoute tous les messages d'un journal au journal
-     */
-    public addLog(l: cLog) {
-        this._log.addLog(l);
-    }
-
-    /**
-     * insert un message en début de liste
-     */
-    public insertMessage(m: Message) {
-        this._log.insert(m);
-    }
-
-    /**
-     * @returns true si 
-     */
-    public get ok(): boolean {
-        return this.resultsOk && !this.hasErrorMessages;
-    }
-
-    /**
-     * @returns true si tous les résultats (y compris les) sont
-     */
-    public abstract get resultsOk(): boolean;
-
-    /**
-     * @returns true si au moins un message de log comporte un code d'erreur
-     */
-    public abstract get hasErrorMessages(): boolean;
-
-    /**
-     * @param name nom du résultat complémentaire à retourner
-     * @returns un résultat complémentaire par son nom
-     */
-    public abstract getExtraResult(name: string): any;
-}
+import { CalcResult } from "./calcresult";
 
 /**
  * Résultat de calcul comprenant la valeur du résultat et des calculs annexes (flag, calculs intermédiaires...)
  * Représente une valeur unique
  */
-export class Result extends BaseResult {
+// tslint:disable-next-line:max-classes-per-file
+export class Result extends CalcResult {
     /**
      * Valeur calculée
      */
@@ -75,52 +18,52 @@ export class Result extends BaseResult {
      */
     private _extraResults: { [key: string]: any };
 
-    constructor(v: number | Message, d: {} = undefined) {
+    constructor(v: number | Message, d?: {}) {
         super();
-        if (typeof v == "number") {
+        if (typeof v === "number") {
             this._vCalc = v;
             const m = new Message(MessageCode.ERROR_OK);
             m.extraVar = d;
             this.addMessage(m);
-        }
-        else if (v instanceof Message) {
-            if (d != undefined)
+        } else if (v instanceof Message) {
+            if (d !== undefined) {
                 throw new Error("appel à Result.constructor() invalide");
+            }
             this.addMessage(v);
         }
         this._extraResults = {};
-    };
+    }
 
     get vCalc() { return this._vCalc; }
 
     get code(): MessageCode {
-        if (this.messageCount != 1)
+        if (this.messageCount !== 1) {
             throw new Error("appel à Result.code invalide, il n'y pas exactement un message de log");
+        }
         return this.log.messages[0].code;
     }
 
     get extraVar() {
-        if (this.messageCount != 1)
+        if (this.messageCount !== 1) {
             throw new Error("appel à Result.extraVar invalide, il n'y pas exactement un message de log");
+        }
         return this.log.messages[0].extraVar;
     }
 
-    private get messageCount(): number {
-        return this.log.messages.length;
-    }
-
     private get hasExtraResults(): boolean {
         return Object.keys(this._extraResults).length > 0;
     }
 
     public get resultsOk(): boolean {
-        return this._vCalc != undefined || this.hasExtraResults;
+        return this._vCalc !== undefined || this.hasExtraResults;
     }
 
     public get hasErrorMessages(): boolean {
-        for (let m of this.log.messages)
-            if (m.code != MessageCode.ERROR_OK && m.getSeverity() == MessageSeverity.ERROR)
+        for (const m of this.log.messages) {
+            if (m.code !== MessageCode.ERROR_OK && m.getSeverity() === MessageSeverity.ERROR) {
                 return true;
+            }
+        }
         return false;
     }
 
@@ -136,92 +79,23 @@ export class Result extends BaseResult {
         this._extraResults[name] = value;
     }
 
+    /**
+     * @param name nom du résultat complémentaire à retourner
+     * @returns un résultat complémentaire par son nom
+     */
     public getExtraResult(name: string): any {
-        for (let n in this._extraResults)
-            if (n == name)
+        for (const n in this._extraResults) {
+            if (n === name) {
                 return this._extraResults[n];
+            }
+        }
         return undefined;
     }
 
     public toString(): string {
-        if (this._vCalc != undefined)
+        if (this._vCalc !== undefined) {
             return String(this._vCalc);
-        return JSON.stringify(this);
-    }
-}
-
-/**
- * Résultat global d'un calcul
- * Peut comporter un ou plusieurs Result.
- */
-export class CalcResult extends BaseResult {
-    private _results: Result[];
-
-    constructor() {
-        super();
-        this._results = [];
-    }
-
-    private get result(): Result {
-        if (this._results.length != 1)
-            throw new Error("appel à une méthode de CalcResult invalide, il n'y a pas exactement un 'Result'");
-
-        return this._results[0];
-    }
-
-    public addResult(r: Result) {
-        this._results.push(r);
-    }
-
-    /**
-     * @param name nom du résultat complémentaire
-     * @returns le nombre la taille d'un résultat complémentaire
-     */
-    public extraResultLength(name: string): number {
-        const r = this.getExtraResult(name);
-        if (r == undefined)
-            return 0;
-        return Object.keys(r).length;
-    }
-
-    public getExtraResult(name: string): any {
-        let res = [];
-        for (let r of this._results) {
-            let er = r.getExtraResult(name);
-            if (er != undefined)
-                res.push(er);
-        }
-
-        switch (res.length) {
-            case 0:
-                return undefined;
-
-            case 1:
-                return res[0];
-
-            default:
-                throw new Error("CalcResult.getExtraResult() : il existe plusieurs 'Result' avec le nom '" + name + "'");
         }
-    }
-
-    public get resultsOk(): boolean {
-        if (this._results.length == 0 && this.log.messages.length == 0)
-            return false;
-        for (let r of this._results)
-            if (!r.resultsOk)
-                return false;
-        return true;
-    }
-
-    public get hasErrorMessages(): boolean {
-        for (let m of this.log.messages)
-            if (m.getSeverity() == MessageSeverity.ERROR)
-                return true;
-
-        for (let r of this._results)
-            if (r.hasErrorMessages)
-                return true;
-
-        return false;
+        return JSON.stringify(this);
     }
 }