If input matches registered type, update handlers.
@param {edb.Input} input
423256
function(input) {
		var best = edb.InputPlugin._bestmatch(input.type, this._watches, true);
		if (best) {
			this._updatematch(input, best);
			this.done = this._done();
			this._updatehandlers(input);
			return true;
		}
		return false;
	}
380320
def _enter_handler(self, event):
        """"""
        iid = self.current_iid
        if iid is None or iid == self.active:
            return
        self.update_state(iid, "hover")
466986
function addType(typeName, type) {
	if (types[typeName]) {
		throw new Error("Type already registered '" + typeName + "'");
	}
	types[typeName] = type;
}
347199
public void setInput(int inputNum, INDArray input) {
        if (inputs == null) {
            //May be null after clear()
            inputs = new INDArray[numInputArrays];
        }
        inputs[inputNum] = input;
    }
831033
function(element, type, handler) {
    var types = type.split(' ');
    Utils.each(types, function(type){
      element.addEventListener(type, handler, false);
    });
  }
672727
function(types, handler, required) {
		types.forEach(function(Type) {
			if (gui.Type.isDefined(Type)) {
				this._addchecks(Type.$classid, [handler]);
				this._watches.push(Type);
				if (required) {
					this._needing.push(Type);
				}
			} else {
				throw new TypeError("Could not register input for undefined Type");
			}
		}, this);
		types.forEach(function(Type) {
			gui.Class.descendantsAndSelf(Type, function(T) {
				if (T.out(this.context)) { // type has been output already?
					this._maybeinput(edb.Output.$get(T));
				}
			}, this);
		}, this);
	}
1043665
function(input, eventType) {
		// We'd like to prevent autocomplete on the input datalist field
		input.setAttribute('autocomplete', 'off');

		// WAI ARIA attributes
		input.setAttribute('role', 'textbox');
		input.setAttribute('aria-haspopup', 'true');
		input.setAttribute('aria-autocomplete', 'list');
		input.setAttribute('aria-owns', input.getAttribute('list'));

		// Bind the keyup event on the related datalists input
		if (eventType === 'focusin') {
			input.addEventListener('keyup', inputInputList);

			input.addEventListener('focusout', changesInputList, true);

			// As only EDGE doesn't trigger the input event after selecting an item via mouse, we need to differentiate here
			if (isGteIE10 || (isEDGE && input.type === 'text')) {
				input.addEventListener('input', inputInputListIE);
			}
		} else if (eventType === 'blur') {
			input.removeEventListener('keyup', inputInputList);

			input.removeEventListener('focusout', changesInputList, true);

			// As only EDGE doesn't trigger the input event after selecting an item via mouse, we need to differentiate here
			if (isGteIE10 || (isEDGE && input.type === 'text')) {
				input.removeEventListener('input', inputInputListIE);
			}
		}

		// Add class for identifying that this input is even already being polyfilled
		input.className += ' ' + classNameInput;
	}
471442
function getTypesFromHandlers(handlers) {
  var types = keys(handlers);
  types = types.map(k => k.replace(/_.*/, ''));
  if (types.indexOf('end') !== -1) {
    types.push('add', 'update', 'delete');
  }
  return types;
}
183248
def _type_insert(self, handle, key, value):
    '''
    
    '''
    if value!=0:
      if isinstance(value,float):
        handle.incrbyfloat(key, value)
      else:
        handle.incr(key,value)
423312
function type(input) {

  //If the input value is null, undefined or NaN the toStringTypes object shouldn't be used
  if (input === null || input === undefined || (input !== input && String(input) === "NaN")) {
    return String(input);
  }

  // use the typeMap to detect the type and fallback to object if the type wasn't found
  return typeMap[Object.prototype.toString.call(input)] || "object";
}
1157611
function(_element,_type,_handler,_capture){
        var _result = {};
        // check element
        _element = _e._$get(_element);
        if (!_element){
            return null;
        }
        _e._$id(_element);
        _result.element = _element;
        // check event handler
        if (!_u._$isFunction(_handler)){
            return null;
        }
        _result.handler = _handler;
        // check type
        var _type = _getTypeList(_type);
        if (!_type){
            return null;
        }
        // save info
        _result.type = _type;
        _result.capture = !!_capture;
        return _result;
    }
171784
function is(type, input) {
  if (type === 'Object') return Object(input) === input;
  return toString.call(input) === '[object ' + type + ']';
}
713026
function(Type, type) {
		var classid = Type.$classid;
		this._map[classid] = type;
		return new edb.Input(Type, type);
	}
1302385
function( enabled ) {
		var handlers, type,
			method = enabled ? "enable" : "disable";

		this._enabled = enabled;
		for ( var i = 0; i < this.inputHandlers.length; i++ ) {
			handlers = this.inputHandlers[ i ];
			if ( handlers )  {
				for ( type in handlers ) {
					handlers[ type ][ method ]();
				}
			}
		}
	}
855269
function match(input) {
    let lowerInput = input.toLowerCase();
    let simpleMatch = _simpleMatch(lowerInput);
    let complexMatch = _complexMatch(lowerInput);
    let output = simpleMatch.concat(complexMatch);

    return output;
}
305356
function toObjectOrUndefined(input) {
    let object = input;
    if (typeof input === 'string') {
        try {
            object = JSON.parse(input);
        }
        catch (e) {}
    }
    if (typeof object === 'object') { return object; }
    return undefined;
}
1366571
function (type, handler) {

            // Validate arguments
            if (typeof type !== 'undefined' && typeof type !== 'string') {
                throw new Error('Type must be a string or undefined');
            }
            if (typeof handler !== 'undefined' && typeof handler !== 'function') {
                throw new Error('Handler must be a function or undefined');
            }

            // If no type is given, remove all handlers
            if (!type) {
                return delete this._events;
            }

            // Check for presence of event store
            if (!this._events || !this._events[type]) {
                return;
            }

            // If no handler is given, remove all handlers for this type
            if (!handler) {
                return delete this._events[type];
            }

            // Do we have a matching handler?
            var handlers = this._events[type];
            var i = arrayIndexOf(handlers, handler);
            if (i === -1) {
                return;
            }

            // Remove handler
            handlers.splice(i, 1);

        }