Process the event

@param evt
the jawr watch event
495403
public void process(JawrWatchEvent evt) {

		Path resolvedPath = evt.getResolvedPath();
		List<PathMapping> mappings = watcher.getPathToResourceBundle().get(evt.getDirPath());
		if (mappings != null) {

			boolean isDir = Files.isDirectory(resolvedPath, NOFOLLOW_LINKS);
			List<JoinableResourceBundle> bundles = new ArrayList<>();
			List<PathMapping> recursivePathMappings = new ArrayList<>();
			for (PathMapping mapping : mappings) {

				String filePath = resolvedPath.toFile().getAbsolutePath();
				if (mapping.isAsset()) {
					String fileName = FileNameUtils.getName(filePath);
					if (fileName.equals(FileNameUtils.getName(mapping.getPath()))) {
						bundles.add(mapping.getBundle());
					}
				} else {
					if (isDir) {
						if (mapping.isRecursive() && (!mapping.hasFileFilter() || mapping.accept(filePath))) {
							bundles.add(mapping.getBundle());
						}
					} else if (!mapping.hasFileFilter() || mapping.accept(filePath)) {
						bundles.add(mapping.getBundle());
					}
					if (mapping.isRecursive()) {
						recursivePathMappings.add(mapping);
					}
				}
			}

			if (!bundles.isEmpty()) {
				bundlesHandler.notifyModification(bundles);
			}

			if (!recursivePathMappings.isEmpty()) {

				// if directory is created, and watching
				// recursively,
				// then
				// register it and its sub-directories
				if (evt.getKind() == ENTRY_CREATE && isDir) {
					try {
						watcher.registerAll(resolvedPath, recursivePathMappings);
					} catch (IOException e) {
						if (LOGGER.isWarnEnabled()) {
							LOGGER.warn(e.getMessage());
						}
					}
				}
			}
		}

		lastProcessTime.set(Calendar.getInstance().getTimeInMillis());
	}
942682
private void process(Path dir, Path file, WatchEvent.Kind<?> evtType) throws TTException, IOException,
        InterruptedException {
        // LOGGER.info("Processing " + file.getFileName() + " with event "
        // + evtType);
        IFilelistenerWriteTrx trx = null;
        String rootPath = getListenerRootPath(dir);

        String relativePath = file.toFile().getAbsolutePath();
        relativePath = relativePath.substring(getListenerRootPath(dir).length(), relativePath.length());

        for (Entry<String, String> e : mFilelistenerToPaths.entrySet()) {
            if (e.getValue().equals(getListenerRootPath(dir))) {
                trx = mTrx.get(e.getKey());
            }
        }

        if (file.toFile().isDirectory()) {
            if (evtType == ENTRY_CREATE) {
                addSubDirectory(dir, file);
                return;
            } else if (evtType == ENTRY_DELETE) {
                for (String s : trx.getFilePaths()) {
                    if (s.contains(relativePath)) {
                        trx.removeFile(s);
                    }
                }
            }
        } else {
            // if (mLockedFiles.get(rootPath + File.separator
            // + file.toFile().getName()) != null) {
            // if (mLockedFiles.get(
            // rootPath + File.separator + file.toFile().getName())
            // .isFinished()) {
            // ExecutorService s = mExecutorMap
            // .get(getListenerRootPath(dir));
            // if (s != null && !s.isShutdown()) {
            //
            // FilesystemNotification n = new FilesystemNotification(
            // file.toFile(), relativePath, rootPath, evtType,
            // trx);
            // if (mObserver != null) {
            // n.addObserver(mObserver);
            // }
            // mFsnOnHold.remove(rootPath + File.separator
            // + file.toFile().getName());
            // mLockedFiles.put(rootPath + File.separator
            // + file.toFile().getName(), n);
            // s.submit(n);
            // }
            // } else {
            // FilesystemNotification n = new FilesystemNotification(
            // file.toFile(), relativePath, rootPath, evtType, trx);
            // if (mObserver != null) {
            // n.addObserver(mObserver);
            // }
            // mFsnOnHold.put(rootPath + File.separator
            // + file.toFile().getName(), n);
            // }
            // } else {
            ExecutorService s = mExecutorMap.get(getListenerRootPath(dir));
            if (s != null && !s.isShutdown()) {
                FilesystemNotification n =
                    new FilesystemNotification(file.toFile(), relativePath, rootPath, evtType, trx);
                if (mObserver != null) {
                    n.addObserver(mObserver);
                }
                // mLockedFiles.put(rootPath + File.separator
                // + file.toFile().getName(), n);

                s.submit(n);
                // }
            }
        }

    }
932591
def on_event(self, evt, is_final):
        
        response = self.response
        for msg in XmlHelper.message_iter(evt):
            bars = msg.GetElement('barData').GetElement('barTickData')
            for i in range(bars.NumValues):
                bar = bars.GetValue(i)
                ts = bar.GetElement(0).Value
                response['time'].append(datetime(ts.year, ts.month, ts.day, ts.hour, ts.minute))
                response['open'].append(bar.GetElement(1).Value)
                response['high'].append(bar.GetElement(2).Value)
                response['low'].append(bar.GetElement(3).Value)
                response['close'].append(bar.GetElement(4).Value)
                response['volume'].append(bar.GetElement(5).Value)
                response['events'].append(bar.GetElement(6).Value)

        if is_final:
            idx = response.pop('time')
            self.response = DataFrame(response, columns=['open', 'high', 'low', 'close', 'volume', 'events'], index=idx)
968551
function (evt) {
            this._move(evt.src);
            this._initialDrag = null;
            this._initialSavedX = null;
            if (this._oldValue[0] !== this.value[0] || this._oldValue[1] !== this.value[1]) {
                if (this._cfg.onchange) {
                    this._context.evalCallback(this._cfg.onchange);
                }
            }
        }
416189
def on_event(self, evt, is_final):
        
        for msg in XmlHelper.message_iter(evt):
            # Single security element in historical request
            node = msg.GetElement('securityData')
            if node.HasElement('securityError'):
                secid = XmlHelper.get_child_value(node, 'security')
                self.security_errors.append(XmlHelper.as_security_error(node.GetElement('securityError'), secid))
            else:
                self.on_security_data_node(node)
415188
protected void handleHoverEvent(Event evt) {
    if(evt.getTarget() instanceof Element) {
      Element e = (Element) evt.getTarget();
      Node next = e.getNextSibling();
      if(next instanceof Element) {
        toggleTooltip((Element) next, evt.getType());
      }
      else {
        LoggingUtil.warning("Tooltip sibling not found.");
      }
    }
    else {
      LoggingUtil.warning("Got event for non-Element?!?");
    }
  }
400166
def process_events(self):
        
        while self._eventq:
            raw_event = self._eventq.popleft()  # pop next event
            if self._watch_manager.ignore_events:
                log.debug("Event ignored: %s" % repr(raw_event))
                continue
            watch_ = self._watch_manager.get_watch(raw_event.wd)
            if (watch_ is None) and not (raw_event.mask & IN_Q_OVERFLOW):
                if not (raw_event.mask & IN_IGNORED):
                    # Not really sure how we ended up here, nor how we should
                    # handle these types of events and if it is appropriate to
                    # completly skip them (like we are doing here).
                    log.warning("Unable to retrieve Watch object associated to %s",
                                repr(raw_event))
                continue
            revent = self._sys_proc_fun(raw_event)  # system processings
            if watch_ and watch_.proc_fun:
                watch_.proc_fun(revent)  # user processings
            else:
                self._default_proc_fun(revent)
        self._sys_proc_fun.cleanup()  # remove olds MOVED_* events records
        if self._coalesce:
            self._eventset.clear()
889099
function (evt) {
                this._dragStartPosition = null;
                disconnectMouseEvents(this);

                var element = this._activeDrag;
                if (element) {
                    element.end();
                }

                this._candidateForDrag = null;
                this._activeDrag = null;
            }
782832
private void trackingStopMenuItemActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_trackingStopMenuItemActionPerformed
        if (trackingWorker != null) {
            trackingWorker.cancel();
        } else {
            assert(false);
        }
    }
89359
public void propertyChange(PropertyChangeEvent evt) {
        // monitor "beanContext" property
        if ("beanContext".equals(evt.getPropertyName()) && contains(evt.getSource())) {
            BeanContext bc = (BeanContext) getPeer();
            if (bc.equals(evt.getOldValue()) && !bc.equals(evt.getNewValue())) {
                internalRemove(evt.getSource(), false);
            }
        }
    }
708352
@Override
    public void process(Object event) throws Exception {
        int secOffset = TimeUtils.secOffset();
        if (secOffset < UPLOAD_TIME_OFFSET_SEC) {
            JStormUtils.sleepMs((UPLOAD_TIME_OFFSET_SEC - secOffset) * 1000);
        } else if (secOffset == UPLOAD_TIME_OFFSET_SEC) {
            // do nothing
        } else {
            JStormUtils.sleepMs((60 - secOffset + UPLOAD_TIME_OFFSET_SEC) * 1000);
        }
        if (topologyMetricContext.getUploadedWorkerNum() > 0) {
            metricLogger.info("force upload metrics.");
            mergeAndUploadMetrics();
        }
    }
617656
function WEvent(evt) {
  if (evt) {
    this.originalEvent = evt;
    this.type = evt.type;
    this.which = evt.which || evt.charCode || evt.keyCode;
    if (!this.which && evt.button !== undefined) {
      this.which = ( evt.button & 1 ? 1 : ( evt.button & 2 ? 3 : ( evt.button & 4 ? 2 : 0 ) ) );
    }
    this.button = evt.button;
    this.currentTarget = evt.currentTarget;
    this.delegateTarget = null;
    this.target = evt.target || evt.srcElement;
    this.shiftKey = evt.shiftKey;
    this.altKey = evt.altKey;
    this.ctrlKey = evt.ctrlKey;
    this.metaKey = evt.metaKey;
  }
  this.current = undefined;
  this.previous = undefined;
  this.eventId = _.uniqueId('e');
  this.propagationStopped = false;
  this.immediatePropagationStopped = false;
}
690889
@Override
	public void processEvent(ComponentSystemEvent event) throws AbortProcessingException {
		if (event instanceof PostAddToViewEvent) {
			if ("non-sticky".equals(getFixed()) || ("bottom".equals(getPosition()) && (!isSticky()))) {
				AddResourcesListener.addExtCSSResource("sticky-footer-navbar.css");
				/*UIOutput resource = new UIOutput();
				resource.getAttributes().put("name", "css/sticky-footer-navbar.css");
				resource.getAttributes().put("library", C.BSF_LIBRARY);
				resource.getAttributes().put("target", "head");
				resource.setRendererType("javax.faces.resource.Stylesheet");
				FacesContext.getCurrentInstance().getViewRoot().addComponentResource(FacesContext.getCurrentInstance(),
						resource);*/
			}
		}
		super.processEvent(event);
	}
172548
protected void processStart(Endpoint endpoint, EventTypeEnum eventType) {
        if (!sendLifecycleEvent) {
            return;
        }

        Event event = createEvent(endpoint, eventType);
        queue.add(event);
    }
909686
function(evt) {
        delete this.startEvt;
        var features = this.getFeatures(evt);
        var over = {}, newly = [], feature;
        for (var i=0, len=features.length; i<len; ++i) {
            feature = features[i];
            over[feature.id] = feature;
            if (!this.cache[feature.id]) {
                newly.push(feature);
            }
        }
        // check if already over features
        var out = [];
        for (var id in this.cache) {
            feature = this.cache[id];
            if (feature.layer && feature.layer.map) {
                if (!over[feature.id]) {
                    out.push(feature);
                }
            } else {
                // removed
                delete this.cache[id];
            }
        }
        // fire featureover events
        var more;
        for (i=0, len=newly.length; i<len; ++i) {
            feature = newly[i];
            this.cache[feature.id] = feature;
            more = this.triggerEvent("featureover", {feature: feature});
            if (more === false) {
                break;
            }
        }
        // fire featureout events
        for (i=0, len=out.length; i<len; ++i) {
            feature = out[i];
            delete this.cache[feature.id];
            more = this.triggerEvent("featureout", {feature: feature});
            if (more === false) {
                break;
            }
        }
    }
664050
private void processEvent(NFAState nfaState, IN event, long timestamp) throws Exception {
		try (SharedBufferAccessor<IN> sharedBufferAccessor = partialMatches.getAccessor()) {
			Collection<Map<String, List<IN>>> patterns =
				nfa.process(sharedBufferAccessor, nfaState, event, timestamp, afterMatchSkipStrategy, cepTimerService);
			processMatchedSequences(patterns, timestamp);
		}
	}
452427
function on(evt, handler) {
            var _this = this;

            var thisArg = arguments[2] === undefined ? null : arguments[2];

            // if multiple events are passed, call our utility method `eachEvt` to deal with this.
            // if it returns `true`, we should exit, because we're actually being called recursively.
            // If it returns `false`, we're not being called with multiple parameters (this time, anyway),
            // and so can continue processing.
            if (eachEvt(evt, handler, thisArg, function () {
                for (var _len2 = arguments.length, _ = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                    _[_key2] = arguments[_key2];
                }

                return _this.on.apply(_this, _);
            })) {
                return this;
            } // simplify typing; eH = eventHandlers
            var eH = this[_eventHandlers];

            if (!eH.has(evt)) {
                // if we don't have an event category already in the map, create it as a new map
                // this map will be of the form bindingObject:methods.
                eH.set(evt, new core.Map());
            }

            // simplify typing; objMap == objectMap (bindingObject:methods)
            var objMap = eH.get(evt);

            if (!objMap.has(thisArg)) {
                // if we don't have `thisArg` in the map, make a set for it. The set is the set of functions
                // and we use a set so as to prevent duplicates automatically.
                objMap.set(thisArg, new core.Set());
            }
            var handlerSet = objMap.get(thisArg);

            if (typeof handler === "function") {
                // add the handler
                handlerSet.add(handler);
            } else {
                // a little error checking!
                throw new TypeError("Event handler must be a function.");
            }

            return this;
        }