implab/implabjs-core Commit - r25:35af87458b03

spelling fixes

andrei -

r25:35af87458b03 propose observables

parent child

Context file:

r25:35af87458b03

Collapse all files

docs/en/cancellations.md ~~docs/cancellations.ru.md~~ renamed 0 0

NO CONTENT: file renamed from docs/cancellations.ru.md to docs/en/cancellations.md

docs/en/observable.md ~~docs/observable.ru.md~~ renamed +1 -1

             # Observable
             Универсальный способ организации потока сообщений. Данный механизм может
             использоваться для оповещения об изменениях состояний объектов или для доставки
             самостоятельных событий, например, связанных с действиями пользователя.
             Является реализацией классического шаблона наблюдателя с возможность сообщить
             о коце потока событий. Данная реализация не содержит никаких дополнительных
             функций, таких как фильтрация, канал с состоянием, преобразования сообщений и
             т.п. Это сделано специально, чтобы реализация оставалась максимально простой.
             Пример того, как можно создать последовательность из 10 событий:
             ```ts
             var events = new Observable(async (notify, error, complete) => {
                 // цикл в котором возникает событие
                 for(let i = 0; i < 10; i++) {
                     await delay(1000);
                     // в качестве данных передается номер события
                     notify(i);
                 }
                 // по окончании последовательности информируем, что событий больше не будет
                 compelte();
             });
             // создаем окно с отображением хода событий
             var progress = showProgress({ min: 0, max: 9, current: 0});
             // подписываемся на события
             events.on(
                 // обработчик очередного события
                 msg => {
                     progress.setValue(msg);
-                }.
+                },
                 // обработчик ошибки
                 e => {
                     progress.showError(e);
                 },
                 // обработчик конца потока
                 () => {
                     progress.close();
                 }
             );
             ```
             Пример создания `Observable` из событий другого объекта, например, виджета:
             ```ts
             postCreate() {
                 // превращаем события виджета в Observable
                 this.mouseMove = new Observable((notify) => {
                     this.moveArea.on('mousemove',(x) => notify(x.) );
                 });
             }
             ```
             Пример инициализации `Observable` внутри класса и генерация событий:
             ```ts
             class PositionWidget extends Widget {
                 _nextPosition: (pos: Position) => void
                 _complete: () => void
                 readonly position: Observable<Position>;
                 constructor(...args[]) {
                     super(args);
                     this.position = new Observable<Position>((notify, error, complete) => {
                         this._nextPosition = notify;
                         this._complete = complete
                     });
                 }
                 destroy() {
                     this._complete();
                     super();
                 }
             }
             ```

docs/ru/cancellations.md docs/cancellations.ru.md copied 0 0

NO CONTENT: file copied from docs/cancellations.ru.md to docs/ru/cancellations.md

docs/ru/observable.md docs/observable.ru.md copied +1 -1

             # Observable
             Универсальный способ организации потока сообщений. Данный механизм может
             использоваться для оповещения об изменениях состояний объектов или для доставки
             самостоятельных событий, например, связанных с действиями пользователя.
             Является реализацией классического шаблона наблюдателя с возможность сообщить
             о коце потока событий. Данная реализация не содержит никаких дополнительных
             функций, таких как фильтрация, канал с состоянием, преобразования сообщений и
             т.п. Это сделано специально, чтобы реализация оставалась максимально простой.
             Пример того, как можно создать последовательность из 10 событий:
             ```ts
             var events = new Observable(async (notify, error, complete) => {
                 // цикл в котором возникает событие
                 for(let i = 0; i < 10; i++) {
                     await delay(1000);
                     // в качестве данных передается номер события
                     notify(i);
                 }
                 // по окончании последовательности информируем, что событий больше не будет
                 compelte();
             });
             // создаем окно с отображением хода событий
             var progress = showProgress({ min: 0, max: 9, current: 0});
             // подписываемся на события
             events.on(
                 // обработчик очередного события
                 msg => {
                     progress.setValue(msg);
-                }.
+                },
                 // обработчик ошибки
                 e => {
                     progress.showError(e);
                 },
                 // обработчик конца потока
                 () => {
                     progress.close();
                 }
             );
             ```
             Пример создания `Observable` из событий другого объекта, например, виджета:
             ```ts
             postCreate() {
                 // превращаем события виджета в Observable
                 this.mouseMove = new Observable((notify) => {
                     this.moveArea.on('mousemove',(x) => notify(x.) );
                 });
             }
             ```
             Пример инициализации `Observable` внутри класса и генерация событий:
             ```ts
             class PositionWidget extends Widget {
                 _nextPosition: (pos: Position) => void
                 _complete: () => void
                 readonly position: Observable<Position>;
                 constructor(...args[]) {
                     super(args);
                     this.position = new Observable<Position>((notify, error, complete) => {
                         this._nextPosition = notify;
                         this._complete = complete
                     });
                 }
                 destroy() {
                     this._complete();
                     super();
                 }
             }
             ```

src/ts/Observable.ts +1 -1

             import { IObservable, IDestroyable, ICancellation } from './interfaces';
             import { Cancellation } from './Cancellation'
             import { argumentNotNull } from './safe';
             interface Handler<T> {
                 (x: T): void
             }
             interface Initializer<T> {
                 (notify: Handler<T>, error?: (e: any) => void, complete?: () => void): void;
             }
             // TODO: think about to move this interfaces.ts and make it public
             interface IObserver<T> {
                 next(event: T): void
                 error(e: any): void
                 complete(): void
             }
             const noop = () => {};
             export class Observable<T> implements IObservable<T> {
                 private _once = new Array<IObserver<T>>();
                 private _observers = new Array<IObserver<T>>();
                 private _complete: boolean
                 private _error: any
                 constructor(func?: Initializer<T>) {
                     if (func)
                         func(
                             this._notifyNext.bind(this),
                             this._notifyError.bind(this),
                             this._notifyCompleted.bind(this)
                         );
                 }
                 /**
                  * Registers handlers for the current observable object.
                  *
                  * @param next the handler for events
                  * @param error the handler for a error
                  * @param complete the handler for a completion
                  * @returns {IDestroyable} the handler for the current subscription, this
                  *  handler can be used to unsubscribe from events.
                  *
                  */
                 on(next: Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
                     argumentNotNull(next, "next");
                     let me = this;
                     let observer: IObserver<T> & IDestroyable = {
                         next: next,
                         error: error ? error.bind(null) : noop,
                         complete: complete ? complete.bind(null) : noop,
                         destroy() {
                             me._removeObserver(this);
                         }
+                    };
                     this._addObserver(observer);
                     return observer;
                 }
                 private _addObserver(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     } else {
                         this._observers.push(observer);
                     }
                 }
                 /**
                  * Waits for the next event. This method can't be used to read messages
                  * as a sequence since it can skip some messages between calls.
                  *
                  * @param ct a cancellation token
                  */
                 next(ct: ICancellation = Cancellation.none): Promise<T> {
                     return new Promise<T>((resolve, reject) => {
                         let observer: IObserver<T> = {
                             next: resolve,
                             error: reject,
                             complete: () => reject("No more events are available")
                         };
                         if (this._addOnce(observer) && ct.isSupported()) {
                             ct.register((e) => {
                                 this._removeOnce(observer);
                                 reject(e);
                             });
                         }
                     });
                 }
                 private _addOnce(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                         return false;
                     }
                     this._once.push(observer);
                     return true;
                 }
                 protected onObserverException(e: any) {
                 }
                 private _removeOnce(d: IObserver<T>) {
                     let i = this._once.indexOf(d);
                     if (i >= 0)
                         this._once.splice(i, 1);
                 }
                 private _removeObserver(d: IObserver<T>) {
                     let i = this._observers.indexOf(d);
                     if (i >= 0)
                         this._observers.splice(i, 1);
                 }
                 private _notify(guard: (observer: IObserver<T>) => void) {
                     if (this._once.length) {
                         for (let i = 0; i < this._once.length; i++)
                             guard(this._once[i]);
                         this._once = [];
                     }
                     for (let i = 0; i < this._observers.length; i++)
                         guard(this._observers[i]);
                 }
                 protected _notifyNext(evt: T) {
                     let guard = (observer: IObserver<T>) => {
                         try {
                             observer.next(evt);
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     }
                     this._notify(guard);
                 }
                 protected _notifyError(e: any) {
                     let guard = (observer: IObserver<T>) => {
                         try {
                             observer.error(e);
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     }
                     this._notify(guard);
                     this._observers = [];
                 }
                 protected _notifyCompleted() {
                     let guard = (observer: IObserver<T>) => {
                         try {
                             observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     }
                     this._notify(guard);
                     this._observers = [];
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages