Check if the provided parameter is a valid Event Handler

@param {*} eventHandler Object to test
@return {Boolean} True if the parameter is valid eventHandler
960987
function _gpfEventsIsValidHandler (eventHandler) {
    var type = typeof eventHandler,
        validator = _gpfEventsHandlerValidators[type];
    if (validator === undefined) {
        return false;
    }
    return validator(eventHandler);
}
133845
function ()
		{
			if (_.isNull(_listeners))
				return false;

			var isArray = _.isArray(_listeners), listener, len, args=[], _arguments=arguments;			

			var eventObject = function ()
				{
					var args = _.toArray(_arguments);
					var evtObj = this;
					args.unshift(this);
					this.index=0;
					Object.defineProperty(this,'event',{value:self,enumerable:false,writable:false});
					Object.defineProperty(this,'owner',{value:self.getParent(),enumerable:false,writable:false});
					Object.defineProperty(this,'evetName',{value:self.getEventName(),enumerable:true,writable:false});
					Object.defineProperty(this,'stopPropagation',{value:false,enumerable:false});
					Object.defineProperty(this,'lastListeners',{value:(isArray ? _listeners.length : 1),enumerable:false});
					Object.defineProperty(this,'listeners',{value:_listeners,enumerable:false,writable:false});
					Object.defineProperty(this,'arguments',{value:args,enumerable:false,writable:false});
					if (_config.async)
						this.next = function () {
							if (_.isArray(this.listeners))
							{							
								if (this.listeners.length == this.lastListeners)
									this.index++;

								var listener = this.listeners[this.index];
								var evtObj = this;
								self.callListener(listener,evtObj);
							}
						};
				},
				ieo = arguments[0] != null && typeof arguments[0] == 'object'
									&& arguments[0].stopPropagation!=undefined ? true : false,
				evtObj = ieo ? arguments[0] : new eventObject;

			if (!isArray)
			{
				self.callListener(_listeners,evtObj);
			} else
			{
				if (_listeners.length==2)
				{

					self.callListener(_listeners[0],evtObj);

					if (evtObj.stopPropagation === true || _config.async === true)
						return false;
				
					listener = _listeners.length == 2 ? _listeners[1] : _listeners[0];
					self.callListener(listener,evtObj);

				} else {
					var listeners = _listeners.slice();

					if (_config.async === true)
						self.callListener(listeners[0],evtObj);
					else 
						for (var i = 0, l = listeners.length; i < l; i++)
						{

							if (evtObj.stopPropagation == true)
								return true;

							self.callListener(listeners[i],evtObj);
						}
				}
			}
			return true;
        }
172039
@Override
	public boolean acceptsEvent(String type, Object event, Function<String, String> resolver) {
		return false;
	}
704987
public boolean validateEventName(String eventName) {
        boolean isValid = false;
        if ((AuditConstants.validEventNamesList).contains(eventName))
            isValid = true;
        return isValid;
    }
929479
function warnEventListenMethod(eventBind, owner) {
    var valid = true;
    var method = owner;
    each(eventBind.expr.name.paths, function (path) {
        method = method[path.value];
        valid = !!method;
        return valid;
    });

    if (!valid) {
        var paths = [];
        each(eventBind.expr.name.paths, function (path) {
            paths.push(path.value);
        });

        warn(eventBind.name + ' listen fail,"' + paths.join('.') + '" not exist');
    }
}
92193
function eventListenerHub(emitter, eventName) {
  var self = object.create(eventListenerHub.prototype);

  self.emitter = emitter;
  self.eventName = eventName;
  self.handlers = [];
  self.defaultHandlerFn = null;

  return self;
}
1004901
function modelOrCollectionEventHandler(type, identifier, context, eventFormat, callback) {
        var keys = identifier;
        if (_.isString(keys)) {
            keys = ensureArray(context.props[keys]);
        }

        var isArray = _.isArray(keys);
        _.each(keys, function(value, key) {
            if (isArray) {
                key = value;
                value = undefined;
            }
            var eventName;
            if (_.isString(eventFormat)) {
                eventName = eventFormat.replace('{key}', key);
            } else {
                eventName = eventFormat(key);
            }
            context[type + CAP_ON](eventName, _.bind(callback, { key: key, value: value }), this);
        }, this);
        // we would have missed this with _.each
        if (!keys && _.isFunction(eventFormat)) {
            var eventName = eventFormat(undefined);
            if (eventName) {
                context[type + CAP_ON](eventName, _.bind(callback, {}), this);
            }
        }
        return keys;
    }
180841
function (eventType, event, target) {

                if (!(event instanceof EventDispatcher.Event)) {
                    event = new EventDispatcher.Event(event);
                }

                if (!event.target) {
                    event.target = target || this;
                }

                event.type = eventType;


                if (!(this._eventHandlers[eventType] || this._eventHandlers["*"])) {
                    return event;
                }

                var list,
                    result, i;

                if (this._eventHandlers[eventType]) {

                    list = this._eventHandlers[eventType].slice();
                    for (i = 0; i < list.length; i++) {
                        if (list[i]) {
                            result = list[i].trigger(event, event.target);
                            if (result !== undefinedValue) {

                                if (result === false) {
                                    event.preventDefault();
                                    event.stopPropagation();
                                }
                            }

                            if (event.isImmediatePropagationStopped) {
                                break;
                            }
                        }
                    }
                }

                if (this._eventHandlers["*"]) {

                    list = this._eventHandlers["*"].slice();
                    for (i = 0; i < list.length; i++) {
                        if (list[i]) {
                            result = list[i].trigger(event, target);
                            if (result !== undefinedValue) {

                                if (result === false) {
                                    event.preventDefault();
                                    event.stopPropagation();
                                }
                            }

                            if (event.isImmediatePropagationStopped) {
                                break;
                            }
                        }
                    }
                }

                return event;
            }
462977
function validate() {

    logger.logEnter('validate');

    for (var i = 0; i < buffer.length; i++) {

      var eventData = buffer[i],
        typeName = eventData[0],
        typeKeys = eventTypes[typeName];

      if (!typeKeys) {

        emitter.emit('error', typeName + ' is not a known event type.');

        // Remove these events.
        eventCount -= eventData.length - 1;
        buffer.splice(i, 1);
        i--;

      } else {

        for (var j = 1; j < eventData.length; j++) {

          if (!validEvent(Object.keys(eventData[j]), typeKeys, emitter, typeName)) {

            // Remove this event.
            eventCount--;
            if (eventData.length === 2) {
              buffer.splice(i, 1);
              i--;
              break;
            } else {
              eventData.splice(j, 1);
              j--;
            }
          }
        }
      }
    }

    logger.logExit('validate');
  }
836966
function _gpfEventsTriggerHandler (event, eventsHandler, resolvePromise) {
    var eventHandler = _getEventHandler(event, eventsHandler);
    eventHandler(event);
    if (undefined !== resolvePromise) {
        resolvePromise(event);
    }
}
1248115
function registerInteractionHandler(fnHandler) {
			var aSuppressHandler = [],
				oParentDOM = this.$parent.get(0),
				oBlockLayerDOM = this.$blockLayer.get(0);

			for (var i = 0; i < aPreventedEvents.length; i++) {
				// Add event listeners with "useCapture" settings to suppress events before dispatching/bubbling starts
				oParentDOM.addEventListener(aPreventedEvents[i], fnHandler, {
					capture: true,
					passive: false
				});
				aSuppressHandler.push(EventTriggerHook.suppress(aPreventedEvents[i], oParentDOM, oBlockLayerDOM));
			}
			//for jQuery triggered events we also need the keydown handler
			this.$blockLayer.bind('keydown', fnHandler);

			return aSuppressHandler;
		}
526535
function isEventValid (comp, type) {
  // if a component has aleary triggered 'appear' event, then
  // the 'appear' even† can't be triggered again utill the
  // 'disappear' event triggered.
  if (appearEvts.indexOf(type) <= -1) {
    return true
  }
  if (comp._appear === undefined && type === 'disappear') {
    return false
  }
  let res
  if (comp._appear === undefined && type === 'appear') {
    res = true
  }
  else {
    res = type !== comp._appear
  }
  res && (comp._appear = type)
  return res
}
237184
function validateEvent(event) {
	if (typeof event !== 'object' || !event) throw new TypeError('event must be an Object');
	if (typeof event.type !== 'string' || !event.type.length) throw new TypeError('event.type must be a non-empty String');
	if (!event.aggregateId && !event.sagaId) throw new TypeError('either event.aggregateId or event.sagaId is required');
	if (event.sagaId && typeof event.sagaVersion === 'undefined') throw new TypeError('event.sagaVersion is required, when event.sagaId is defined');
}
1260591
function changeHandler(eventOptions = {}) {
    const { key, silent } = eventOptions;
    const def = defs.get(this);

    if (key && key in def.keys && !silent) {
        triggerOne(this, 'set', eventOptions);
        triggerOne(this, 'modify', eventOptions);
    }
}
790850
function createBindingHandlers({
    fullEventName,
    domEventHandler,
    selector
}) {
    return {
        bindHandler(evt = {}) {
            const { node } = evt;
            if (node) {
                dom.$(node).on(fullEventName, selector, domEventHandler);
            }
        },
        unbindHandler(evt = {}) {
            const { node } = evt;
            if (node) {
                dom.$(node).off(fullEventName, selector, domEventHandler);
            }
        }
    };
}
591444
function (eventType, callback, scope) {
                if (!eventType) {
                    // remove all events
                    this._eventHandlers = {};
                } else if (!callback) {
                    // remove all callbacks for these event
                    this._eventHandlers[eventType] = [];
                } else if (this._eventHandlers[eventType]) {
                    var list = this._eventHandlers[eventType];
                    for (var i = list.length - 1; i >= 0; i--) {
                        if (list[i].$callback == callback && (!scope || scope === list[i].scope)) {
                            list.splice(i, 1);  // delete callback
                        }
                    }
                }
            }
1300285
protected boolean isValidEventNameForScope(String eventName, Element listenerElement) {
    if (eventName != null && eventName.trim().length() > 0) {
      if ("start".equals(eventName) || "end".equals(eventName)) {
        return true;
      } else {
        addError("Attribute 'event' must be one of {start|end}", listenerElement);
      }
    } else {
      addError("Attribute 'event' is mandatory on listener", listenerElement);
    }
    return false;
  }