Class Indicator<Events>

*Example of an options definition with the most common attributes:

this.prototype.options = {
   'chartType': {
       type: 'number',
       [name: 'Name'],
       [_set: function],
       [value: 'line'],                    // options without value get forwarded to the _get callback
       [_get: function],                   // either _get or value must be specified
       [flags: BG.charts.Object.EOptionFlags.EXPOSED]   // various flags; e.g. exposed => hint for ui; this option can be shown
   },
};

Type Parameters

  • Events extends Record<string, (...args: any) => void> = Record<string, (...args: any) => void>

Hierarchy (View Summary)

Constructors

constructor

Properties

optionGroups options

Methods

addListener attr calculateDisplacementIndices deserialize didUpdateOptions emit flat get getGroups getInputs getLayers getRange getScale getState listeners on once onDestroy onIndicatorCalculate onIndicatorData onIndicatorInit onIndicatorRestart onIndicatorStart onIndicatorStop onRecover onStart onStop recover removeAllListeners removeListener set setMaxListeners setNumberOfInputs setParameters setTypeAndName toString validate willUpdateOptions getAlternatives guard listenerCount setDefaultMaxListeners

Constructors

constructor

  • new Indicator<
        Events extends
            Record<string, (...args: any) => void> = Record<
            string,
            (...args: any) => void,
        >,
    >(
        config: BG.charts.Indicator.TConfig,
    ): BG.charts.Indicator<Events>

  • The base class for the calculation of technical indicators. Indicators are managed by and added to an instance of BG.charts.Data

    To display the values calculated by an indicator, the generated buffers have to be referenced by an instance of BG.charts.Layer that is added to a BG.charts.Chart.

    Indicators have to provide information about their values, and the preferred type of layer via the BG.charts.Indicator:getLayers method.

    Type Parameters

    • Events extends Record<string, (...args: any) => void> = Record<string, (...args: any) => void>

    Parameters

    Returns BG.charts.Indicator<Events>

Properties

optionGroups

optionGroups: OptionGroup[]

options

options: { [key: string]: any }

Methods

addListener

  • addListener<
        Type extends string
        | number
        | symbol,
        Callback extends (...args: any) => void,
    >(
        type: Type,
        listener: Callback,
    ): this

  • Type Parameters

    • Type extends string | number | symbol
    • Callback extends (...args: any) => void

    Parameters

    Returns this

    Description

    adds a listener to the end of the listeners array for the specified event.

attr

  • attr(
        this: BG.charts.Object<Record<string, (...args: any) => void>>,
        s: string,
        a: string,
        v?: any,
    ): any

  • returns or sets the attribute of an option this function should be used with care - modifications of internal properties might break stuff!

    Parameters

    • this: BG.charts.Object<Record<string, (...args: any) => void>>
    • s: string
    • a: string
    • Optionalv: any

    Returns any

calculateDisplacementIndices

  • calculateDisplacementIndices(displacement: string | number): number

  • helper method to convert string displacements into numbers

    Parameters

    • displacement: string | number

    Returns number

deserialize

  • deserialize(options: { [key: string]: any }): void

  • called after each deserialization default implementation of this method applies all options via set

    Parameters

    • options: { [key: string]: any }

    Returns void

    Overridable

didUpdateOptions

  • didUpdateOptions(
        this: BG.charts.Object<Record<string, (...args: any) => void>>,
    ): void

  • must be called after willUpdateOptions once all actions that might potentially changed values of any options are done

    IMPORTANT: methods must be called in balance; e.g. for each call to willUpdateOptions, you must call didUpdateOptions exactly once.

    Parameters

    Returns void

emit

  • emit<
        Type extends string
        | number
        | symbol,
        Callback extends (...args: any) => void,
    >(
        type: Type,
        ...params: Parameters<Callback>,
    ): boolean

  • Type Parameters

    • Type extends string | number | symbol
    • Callback extends (...args: any) => void

    Parameters

    Returns boolean

    Description

    execute each of the listeners in order with the supplied parameters.

flat

  • flat(
        readWriteOnly?: boolean,
        modifiedOnly?: boolean,
        nonEphemeralOnly?: boolean,
    ): { [key: string]: any }

  • returns a flat representation of all available config options in the form of a key-value-object optionally only values that are not read-only can be returned

    IMPORTANT: this method will always convert I18NStrings to strings, so for displaying strings in a UI use individual calls to BG.charts.Object:get instead

    Parameters

    • OptionalreadWriteOnly: boolean

      default: true

    • OptionalmodifiedOnly: boolean

      default: true

    • OptionalnonEphemeralOnly: boolean

      default: true

    Returns { [key: string]: any }

get

  • get(s?: string, flags?: number): any

  • returns the value of the requested option, or a list of all available config options if no parameter is specified.

    Parameters

    • Optionals: string
    • Optionalflags: number

    Returns any

getGroups

  • getGroups(): OptionGroup[]

  • returns the categorization of the objects options can be used for displaying a more structured user interface

    Returns OptionGroup[]

getInputs

  • getInputs(): string[]

  • returns the used inputs

    Returns string[]

getLayers

  • getLayers(): {
        bufferHandles: number[];
        id: string;
        legend?: boolean;
        options?: { [key: string]: any };
        type: string;
    }[]

  • returns the suggested layers used to visualize the indicator

    Returns {
        bufferHandles: number[];
        id: string;
        legend?: boolean;
        options?: { [key: string]: any };
        type: string;
    }[]

    Overridable

getRange

  • getRange(): null | number[]

  • returns the requested range

    Returns null | number[]

    Overridable

getScale

getState

listeners

  • listeners<
        Type extends string
        | number
        | symbol,
        Callback extends (...args: any) => void,
    >(
        type: Type,
    ): Callback[]

  • Type Parameters

    • Type extends string | number | symbol
    • Callback extends (...args: any) => void

    Parameters

    Returns Callback[]

    Description

    returns an array of listeners for the specified event.

on

  • on<
        Type extends string
        | number
        | symbol,
        Callback extends (...args: any) => void,
    >(
        type: Type,
        listener: Callback,
    ): this

  • Type Parameters

    • Type extends string | number | symbol
    • Callback extends (...args: any) => void

    Parameters

    Returns this

    Description

    alias for addListener

once

  • once<
        Type extends string
        | number
        | symbol,
        Callback extends (...args: any) => void,
    >(
        type: Type,
        listener: Callback,
    ): this

  • Type Parameters

    • Type extends string | number | symbol
    • Callback extends (...args: any) => void

    Parameters

    Returns this

    Description

    adds a one time listener for the event. This listener is invoked only the next time the event is fired, after which it is removed.

onDestroy

  • onDestroy(): void

  • called when an object will be permanently discarded no other methods will be called on it ever again after this point

    IMPORTANT: this method should ONLY be called directly on the Controller all other objects will be destroyed automatically by the implementation

    Returns void

    Overridable

onIndicatorCalculate

  • onIndicatorCalculate(
        api: IndicatorAPI,
        startIndex: number,
        endIndex: number,
    ): void

  • called to calculate all values from startIndex to endIndex

    Parameters

    • api: IndicatorAPI

      pointer to an api object

    • startIndex: number

      index of the first value to calculate

    • endIndex: number

      index of the last value to calculate

    Returns void

    Overridable

onIndicatorData

  • onIndicatorData(api: IndicatorAPI): void

  • called when underlying data changes

    Parameters

    Returns void

    Overridable

onIndicatorInit

  • onIndicatorInit(): void

  • called to initialize the indicator

    this is only called once, immediately after the constructor it is required because in contrast to the constructor events emitted from this method can be handled E.g. if the indicator needs to asynchronously load data it can trigger the loading event from here

    Returns void

    Overridable

onIndicatorRestart

  • onIndicatorRestart(api: IndicatorAPI): void

  • called to restart the indicator by default this automatically calls onEnd onStart onData indicators can however implement their own logic, e.g. to reuse buffers

    Parameters

    Returns void

    Overridable

onIndicatorStart

  • onIndicatorStart(api: IndicatorAPI): void

  • called to register and initialize the indicator

    Parameters

    Returns void

    Overridable

onIndicatorStop

  • onIndicatorStop(api: IndicatorAPI): void

  • called to shutdown and deinitialize the indicator

    Parameters

    Returns void

    Overridable

onRecover

  • onRecover(): void

  • life cycle method; called when the object should recover from an error and resume normal operation

    this will only be called if the object encountered a RecoverableError, and is always triggered by a manual user interaction

    always called between start and stop

    Returns void

    Overridable

onStart

  • onStart(context: BG.charts.TContext): void

  • life cycle method; called when the object should start normal operation at this point is is already completely initialized

    Parameters

    Returns void

    Overridable

onStop

  • onStop(): void

  • life cycle method; called when the object should stop normal operation if objects have any pending subscriptions/requests, they should all be stopped here

    the object is also responsible for clearing the loading flag from it's state if it is currently active failing to do so will trigger a fatal error

    object might be started again afterwards (start) or destroyed (destroy) this is not known yet at this point

    called after start or restart

    Returns void

    Overridable

recover

  • recover(): boolean

  • can be called to tell the object that it should recover from an error and resume will have no effect if no retryable error is currently associated with the object

    Returns boolean

removeAllListeners

  • removeAllListeners<Type extends string | number | symbol>(type?: Type): this

  • Type Parameters

    • Type extends string | number | symbol

    Parameters

    Returns this

    Description

    removes all listeners, or those of the specified event.

removeListener

  • removeListener<
        Type extends string
        | number
        | symbol,
        Callback extends (...args: any) => void,
    >(
        type: Type,
        listener: Callback,
    ): this

  • Type Parameters

    • Type extends string | number | symbol
    • Callback extends (...args: any) => void

    Parameters

    Returns this

    Description

    remove a listener from the listener array for the specified event.

set

  • set(
        s: null | string | { [key: string]: any },
        v?: any,
        flags?: BG.charts.Object.EFlags,
    ): boolean

  • will set validate and then set the specified option(s) to the provided value(s) after validation

    NOTE: if multiple options are used, will return false if at least one value is not valid values are applied individually however, so one option might be set even if the value for another is invalid

    Parameters

    Returns boolean

setMaxListeners

  • setMaxListeners(maxListeners: number): this

  • Parameters

    • maxListeners: number

    Returns this

    Description

    by default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default which helps finding memory leaks. Obviously not all Emitters should be limited to 10. This function allows that limit to be increased. Set to zero for unlimited.

setNumberOfInputs

  • setNumberOfInputs(
        this: BG.charts.Indicator<Record<string, (...args: any) => void>>,
        numInputs: number,
        names?: string | string[],
    ): boolean

  • set number of usable inputs; must be at least 1 calling this method resets previously required buffers

    the optional second parameter can be used to provide name(s) for the input option(s) Note: number of provided names needs to be identical to requested number of inputs

    Parameters

    • this: BG.charts.Indicator<Record<string, (...args: any) => void>>
    • numInputs: number
    • Optionalnames: string | string[]

    Returns boolean

setParameters

  • setParameters(
        params: (string | { [key: string]: string | number })[],
        name?: string,
    ): void

  • set options to be considered "parameters"

    parameters show up in the name of the indicator, e.g. in the legend entry or a UI e.g. as follows: type(parameter1, parameter2)

    the optional second parameter can be used to specify a custom name to be used instead of the type

    Parameters

    • params: (string | { [key: string]: string | number })[]

      ordered list of parameters to be shown in the name

    • Optionalname: string

      option name to be used instead of type

    Returns void

setTypeAndName

  • setTypeAndName(objType?: string, objName?: string): void

  • Sets the objName and objType of the Object reverts to the default ones if no arguments are given

    Parameters

    • OptionalobjType: string
    • OptionalobjName: string

    Returns void

toString

  • toString(): string

  • Returns a string representation of an object.

    Returns string

validate

  • validate(
        s: string | { [key: string]: any },
        v?: any,
        flags?: BG.charts.Object.EFlags,
    ): boolean

  • will set validate value(s) for the specified option(s)

    NOTE: if multiple options are used, will return false if at least one value is not valid

    Parameters

    Returns boolean

willUpdateOptions

  • willUpdateOptions(options?: string | string[]): void

  • when using custom getters/setters (via _get/_set) in options, the values of options can change without .set being called - or there might not even be a setter for readonly options; for example, if the getter simply returns the value of a member variable this variable could be modified directly. In this case, events such as optionChanged would not be fired, and listeners would not be informed about the change.

    To account for such cases, the methods willUpdateOptions and didUpdateOptions should be called directly BEFORE and AFTER actions that might potentially change values of options. the correct events will then automatically be triggered when calling didUpdateOptions.

    if the options that could change are known, they can be supplied via the optional parameter. This provides a small performance gain in most situations.

    IMPORTANT: methods must be called in balance; e.g. for each call to willUpdateOptions, you must call didUpdateOptions exactly once.

    Parameters

    • Optionaloptions: string | string[]

    Returns void

StaticgetAlternatives

  • getAlternatives(): {
        identifier: string;
        replace: (
            object: Record<string, any>,
        ) => {
            identifier: string;
            input?: string;
            objType: string;
            state: Record<string, any>;
        };
    }[]

  • Method for plugins to describe which other plugins they want to replace

    Returns {
        identifier: string;
        replace: (
            object: Record<string, any>,
        ) => {
            identifier: string;
            input?: string;
            objType: string;
            state: Record<string, any>;
        };
    }[]

    Overridable

Staticguard

  • guard(cb: Function): void

  • Parameters

    • cb: Function

    Returns void

    Description

    set custom error handler for event listeners

StaticlistenerCount

StaticsetDefaultMaxListeners

  • setDefaultMaxListeners(maxListeners: number): void

  • Parameters

    • maxListeners: number

    Returns void

    Description

    set default amount for limit warning

Settings

Member Visibility

On This Page

Constructors
Properties
Methods