The handling method.
323590
@Override
    public <E> DynamicType.Builder<E> processMethod(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation)
    {
        String methodName = method.getName();
        if (ReflectionUtility.isGetMethod(method))
            return createInterceptor(builder, method);
        else if (ReflectionUtility.isSetMethod(method))
            return createInterceptor(builder, method);
        else if (methodName.startsWith("addAll"))
            return createInterceptor(builder, method);
        else if (methodName.startsWith("add"))
            return createInterceptor(builder, method);
        else
            throw new WindupException("Only get*, set*, add*, and addAll* method names are supported for @"
                        + SetInProperties.class.getSimpleName() + ", found at: " + method.getName());
    }
1353311
protected void handleResponse(Object control) {
        this.sorted = (Boolean) invokeMethod("isSorted", responseControlClass, control);
        this.resultCode = (Integer) invokeMethod("getResultCode", responseControlClass, control);
	}
192331
def handle(self):
        """"""
        body = None
        req = self.request
        res = self.response
        rou = self.router
        con = None
        start = time.time()

        try:
            con = self.create_controller()
            con.call = self
            self.controller = con
            if not self.quiet:
                con.log_start(start)

            # the controller handle method will manipulate self.response, it first
            # tries to find a handle_HTTP_METHOD method, if it can't find that it
            # will default to the handle method (which is implemented on Controller).
            # method arguments are passed in so child classes can add decorators
            # just like the HTTP_METHOD that will actually handle the request
            controller_args, controller_kwargs = con.find_method_params()
            controller_method = getattr(con, "handle_{}".format(req.method), None)
            if not controller_method:
                controller_method = getattr(con, "handle")

            if not self.quiet:
                logger.debug("Using handle method: {}.{}".format(
                    con.__class__.__name__,
                    controller_method.__name__
                ))
            controller_method(*controller_args, **controller_kwargs)

        except Exception as e:
            self.handle_error(e) # this will manipulate self.response

        finally:
            if res.code == 204:
                res.headers.pop('Content-Type', None)
                res.body = None # just to be sure since body could've been ""

            if con:
                if not self.quiet:
                    con.log_stop(start)

        return res
137457
private void handleRelease() {
        float speed = Math.max(dragHelper.getDragSpeed(), animationSpeed);

        if (getTopMargin() > initialMargin ||
                (dragHelper.getDragSpeed() > animationSpeed && dragHelper.getDragDistance() > 0) ||
                (getDeviceType(getContext()) == DeviceType.TABLET && isMaximized() &&
                        getTopMargin() > minMargin)) {
            animateHideView(parentHeight - getTopMargin(), speed, new DecelerateInterpolator(),
                    true);
        } else {
            animateShowView(-(getTopMargin() - minMargin), speed, new DecelerateInterpolator());
        }
    }
1123132
public function handle()
    {
        parent::handle();

        $controllerGenerator = new APIControllerGenerator($this->commandData);
        $controllerGenerator->generate();

        $this->performPostActions();
    }
710169
public function handle()
    {
        if (parent::handle() === false && ! $this->option('force')) {
            return;
        }

        if ($this->option('migration')) {
            $this->createMigration();
        }
    }
708785
protected function handleOutdent()
    {

        $this->level--;

        $this->currentParent = $this->currentParent->parent;

        if ($this->inMixin && $this->level <= $this->mixinLevel) {

            $this->inMixin = false;
            $this->mixinLevel = null;
        }
    }
218210
def handle(self):
        ''''''
        try:
            yield self
        except:
            # Requeue the message and raise the original exception
            typ, value, trace = sys.exc_info()
            if not self.processed:
                try:
                    self.req(self.delay())
                except socket.error:
                    self.connection.close()
            raise typ, value, trace
        else:
            if not self.processed:
                try:
                    self.fin()
                except socket.error:
                    self.connection.close()
722719
function handler() {
        try {
          if (this.readyState === this.DONE) {

            var response = _buildResponse(this, options.fullResponse);

            // Resolve or reject promise given the response status.
            // HTTP status of 2xx is considered a success.
            if (this.status >= 200 && this.status < 300) {

              if (successCallback) {
                Logger.warnCallbackDeprecation();
                successCallback(response);
              }
              resolve(response);

            } else {
              errorHandler(response);
            }
          }
        } catch (exception) {
          // Do nothing, will be handled by ontimeout.
        }
      }
448035
def handle(self):
        
        while True:
            # TODO: Queue.get() (and anything using thread.allocate_lock
            #       ignores signals :(  so timeout periodically to allow delivery
            try:
                callable = None # ensure no lingering references to past work while blocking
                callable = self._Q.get(True, 1.0)
            except Empty:
                continue  # retry on timeout
            try:
                if callable is self._stopit:
                    break
                callable()
            except:
                _log.exception("Error from WorkQueue")
            finally:
                self._Q.task_done()
782160
private void handleThrows() {
    Scope curScope = scope;
    while (curScope != null) {
      if (curScope.kind == Scope.Kind.TRY) {
        scope.mergeInto(curScope.next);
      }
      curScope = curScope.next;
    }
  }
476826
public function handle() {
        $actions = func_get_args();

        if ($actions === array('*') || empty($actions)) {
            $this->_handled = array('*');
        } else {
            $this->_handled = array_unique(array_intersect($actions, get_class_methods($this->controller)));
        }
    }
1329618
public function handle()
    {
        $arguments    = func_get_args();
        $handleMethod = array_shift($arguments);

        return call_user_func_array([$this->handler->initialize($this), $handleMethod], $arguments);
    }
287537
public Callable<?> handle(Object instance, Method origin, Object[] arguments) throws Throwable {
        try {
            return (Callable<?>) mAdvice.getClass().getMethod("handle", Object.class, Method.class,
                    Object[].class).invoke(mAdvice, instance, origin, arguments);
        } catch (InvocationTargetException e) {
            throw e.getCause();
        }
    }
402411
public function handle()
    {
        if (!$this->passesAuthorization()) {
            return;
        }
        $uri        = uri();
        $handler    = $this->createMenu();
        $handler->uri($uri);
        $components = app('ui-components')->findAllByResource($uri);



        foreach ($components as $component) {
            if (array_get($component, 'data.dispatchable') === false) {
                continue;
            }
            if (!$component['name']) {
                continue;
            }
            $this->createItem($component);
        }
    }
1092726
def handle(self):
        
        # Unpack the data from the request
        data, socket = self.request
        
        try:
            # Parse it as JSON
            message_attrs = json.loads(data.decode('utf-8'))
            # Fluff it up into a proper logging record
            record = logging.makeLogRecord(message_attrs)
        except:
            # Complain someone is sending us bad logging data
            logging.error("Malformed log message from {}".format(self.client_address[0]))
        else:
            # Log level filtering should have been done on the remote end. The handle() method
            # skips it on this end.
            log.handle(record)
1327550
function handler() {
		// Get the current orientation.
		var orientation = get_orientation();

		if ( orientation !== last_orientation ) {
			// The orientation has changed, so trigger the orientationchange event.
			last_orientation = orientation;
			win.trigger( event_name );
		}
	}