linked-value.ts

import { Nub } from "./nub";
import { ParamDefinition } from "./param/param-definition";
import { INamedIterableValues } from "./param/param-value-iterator";
import { ParamValueMode } from "./param/param-value-mode";
import { ParamValues } from "./param/param-values";

export class LinkedValue {
    /** linked value metadata (ex: calculator title for GUI) */
    public meta: any;

    /** target Nub */
    private _nub: Nub;

    /** target value : ParamDefinition (possibly in CALC mode) | undefined (ExtraResults) */
    private _element: INamedIterableValues;

    /** parameter / result symbol (ex: "Q") */
    private _symbol: string;

    /** magic param values: proxy to target when target is a not a result, handcrafted fake object otherwise */
    private _paramValues: ParamValues;

    constructor(nub: Nub, element: INamedIterableValues, symbol: string, meta: any = {}) {
        this._nub = nub;
        this._element = element;
        this._symbol = symbol;
        this.meta = meta;
    }

    public get nub() { return this._nub; }
    public get element() { return this._element; }
    public get symbol() { return this._symbol; }

    /**
     * Returns true if targetted value is a ParamDefinition (in CALC mode or not),
     * and not an extra result
     */
    public isParameter(): boolean {
        return (this.element instanceof ParamDefinition);
    }

    /**
     * Returns true if targetted value is a ParamDefinition in CALC mode
     * (might not have any value yet)
     */
    public isResult(): boolean {
        return (
            this.isParameter()
            && (this.element as ParamDefinition).valueMode === ParamValueMode.CALCUL
        );
    }

    /**
     * Returns true if targetted value is a ParamDefinition in CALC mode,
     * or in LINK mode targetting a result (might not have any value yet)
     */
    public isCalculated(): boolean {
        return (
            this.isResult()
            || this.isExtraResult()
            || (
                this.isParameter()
                && (this.element as ParamDefinition).valueMode === ParamValueMode.LINK
                && (this.element as ParamDefinition).referencedValue.isCalculated() // recursion
            )
        );
    }

    /**
     * Returns true if targetted value is an extra result