KnitFlow/assets/core_tgx/util_class/OnFuncCenter.ts

type ListenerFunc = (...args: any) => void
class EventData {
    public listener!: ListenerFunc;
    public object: any;
}

/**委托事件，适用于不是频繁订阅删除*/
export class OnFuncCenter {
    public static Creat():OnFuncCenter{return new OnFuncCenter()};
    private _events: Array<EventData>;
    constructor() {
        this._events = [];
    }
    clean():void{
        this._events=[];
    }
    /**
     * 注册事件
     * @param listener   处理事件的侦听器函数
     * @param object     侦听函数绑定的作用域对象
     */
    on(listener: ListenerFunc, object: object) {
        let list: Array<EventData> = this._events;
        let length = list.length;
        for (let i = 0; i < length; i++) {
            let bin = list[i];
            if (bin.listener == listener && bin.object==object) {
                console.warn(listener,"same!");
                return;
            }
        }
        let data: EventData = new EventData();
        data.listener = listener;
        data.object = object;
        list.push(data);
    }
    /**
     * 监听一次事件，事件响应后，该监听自动移除
     * @param listener  事件触发回调方法
     * @param object    侦听函数绑定的作用域对象
     */
    once(listener: ListenerFunc, object: object) {
        let _listener: any = (...$args: any) => {
            this.off(_listener,object);
            _listener = null;
            listener.call(object,...$args);
        }
        this.on(_listener, object);
    }
    /**
     * 移除事件
     * @param listener  处理事件的侦听器函数
     * @param object    侦听函数绑定的作用域对象
     */
    off(listener: ListenerFunc,object:object) {
        let list: Array<EventData> = this._events;
        let length = list.length;
        for (let i = 0; i < length; i++) {
            let bin: EventData = list[i];
            if (bin.listener == listener && bin.object == object) {
                list.splice(i, 1);
                break;
            }
        }
    }
    /** 
     * 触发事件
     * @param args(any) 事件参数
     */
    call(...args: any) {
        let list: Array<EventData> = this._events;
        let temp: Array<EventData> = list.concat();
        let length = temp.length;
        for (let i = 0; i < length; i++) {
           let eventBin = temp[i];
           eventBin.listener.call(eventBin.object,...args);
       }
    }
}







class Event<T> {
    public listener!: (data:T) => void;
    public object: any;
}
/**委托事件，泛型约束参数，适用于不是频繁订阅删除*/
export class OnFuncT<T> {
    private _events: Array<Event<T>>;
    constructor() {
        this._events = [];
    }
    clean():void{
        this._events=[];
    }
    /**
     * 注册事件
     * @param listener   处理事件的侦听器函数
     * @param object     侦听函数绑定的作用域对象
     */
    on(listener: (data:T) => void, object: object) {
        let list: Array<Event<T>> = this._events;
        let length = list.length;
        for (let i = 0; i < length; i++) {
            let bin = list[i];
            if (bin.listener == listener && bin.object==object) {
                console.warn(listener,"same!");
                return;
            }
        }
        let data:Event<T> = new Event<T>;
        data.listener = listener;
        data.object = object;
        list.push(data);
    }
    /**
     * 监听一次事件，事件响应后，该监听自动移除
     * @param listener  事件触发回调方法
     * @param object    侦听函数绑定的作用域对象
     */
    once(listener: (data:T) => void, object: object) {
        let _listener: any = (data:T) => {
            this.off(_listener,object);
            _listener = null;
            listener.call(object,data);
        }
        this.on(_listener, object);
    }
    /**
     * 移除事件
     * @param listener  处理事件的侦听器函数
     * @param object    侦听函数绑定的作用域对象
     */
    off(listener:(data:T) => void ,object:object) {
        let list: Array<Event<T>> = this._events;
        let length = list.length;
        for (let i = 0; i < length; i++) {
            let bin:Event<T> = list[i];
            if (bin.listener == listener && bin.object == object) {
                list.splice(i, 1);
                break;
            }
        }
    }
    /** 
     * 触发事件
     * @param args(any) 事件参数
     */
    call(data:T) {
        let list: Array<Event<T>> = this._events;
        let temp: Array<Event<T>> = list.concat();
        let length = temp.length;
        for (let i = 0; i < length; i++) {
           let eventBin = temp[i];
           eventBin.listener.call(eventBin.object,data);
       }
    }




}