Element Strategy

This package helps to build strategies which your program should follow. It is not an finite state machine library.

Strategies are a part of machine state, and should be treated like step by step alghoritm.

For example if program faild due to exception it may change it's state to "failure" with specific strategy. It could've been some repair steps or cleanups before shutting down.

Generic Strategy

Main part of this package contain basic logic which is needed to manage strategy. Any implementation with unified API fits this construct. It may be Linear, Graph or any other Strategy.

It is highly recomended not to use generic constructs directly. You should always extends from it and make your own specific strategy.

Strategy Controller

Controller([ Element[] ]): controller

• @param {Element} Optional array of strategy elements
• @return {controller} new Controller object

Example:

/* create empty controller wihout any elements */
new Controller();

/*
 * create controller with two empty elements
 */
new Controller([new Element({}), new Element({})]);

Controller API

index: number

• @property
• @public

Points to current active element in strategy.

push(element: Element[]): number

• @method
• @public
• @param {Element} strategy Element
• @return {number} Index of new added element

Adds new Element at the end of strategy, and returns its index.

currentElement(): Element

• @method
• @public
• @return {Element} Current active element

move(step: number): boolean

• @method
• @public
• @return {bool} is move action successful

Move method contains logic which prevents to go out of range. Returns bool which indicates if strategy successfully move to next Element.

step param must be zero or positive and negative Integer.

Move calls hooks which may cause wanted side effects. These hooks are:

• onNext()
• onPrev()
• onAgain()
• onFinsih()

Hooks are part of Strategy Element API and it's required by implementing IElement Interface.

prev(): boolean

• @method
• @public
• @return {bool} is prev action successful

Move strategy by one step backward, and return true if ends with success.

next(): boolean

• @method
• @public
• @return {bool} is next action successful

Move strategy by one step forward, and return true if ends with success.

again(): boolean

• @method
• @public
• @return {bool} is next action successful

Repeats the same step, and return true if ends with success.

Strategy Element

Element(obj: Object): element

• @param {Object} Object which represents your strategy step
• @return {element} new Element object

Example:

/* create simple element which some method */
new Element({ init: function () {},
              run: function () {},
              report: function () {} });

Element API

Element implements IElement interface which define hooks unified API. Every hook takes one argument which is index of element.

It shouldn't return anything because all returned values will not be utilise. Purpose of these hooks is to create space for side effects like logging, event emmitting and so on.

onPush(index: number): void

• @method
• @public

onPush is invoke every time when new element is added to strategy and returns it's index.

onPrev(index: number): void

• @method
• @public

onPrev is invoke every time when strategy successfully goes backward.

onNext(index: number): void

• @method
• @public

onNext is invoke every time when strategy successfully goes forward.

onAgain(index: number): void

• @method
• @public

onAgain is invoke every time when strategy successfully repeat the step.

onFinish(index: number): void

• @method
• @public

onFinish is invoke every time when strategy passes last element.

Linear Strategy

Lienar strategy leverage Generic Strategy to make linear strategy, which should be processed one by one without jumping through all strategy Elements.

Linear strategy additionally implements rewind to first and fast forward to last element.

Controller API

first(): void

• @method
• @public

Rewind to first element in strategy.

last(): void

• @method
• @public

Fast forward to last element in strategy.