Handle the ActionPush action.
196501
def _handle_actionpush(self, length):
        """"""
        init_pos = self._src.tell()
        while self._src.tell() < init_pos + length:
            obj = _make_object("ActionPush")
            obj.Type = unpack_ui8(self._src)
            # name and how to read each type
            push_types = {
                0: ("String", self._get_struct_string),
                1: ("Float", lambda: unpack_float(self._src)),
                2: ("Null", lambda: None),
                4: ("RegisterNumber", lambda: unpack_ui8(self._src)),
                5: ("Boolean", lambda: unpack_ui8(self._src)),
                6: ("Double", lambda: unpack_double(self._src)),
                7: ("Integer", lambda: unpack_ui32(self._src)),
                8: ("Constant8", lambda: unpack_ui8(self._src)),
                9: ("Constant16", lambda: unpack_ui16(self._src)),
            }
            name, func = push_types[obj.Type]
            setattr(obj, name, func())
            yield obj
361730
def perform(action_name, container, **kwargs):
    
    cf = container_fabric()
    cf.call(action_name, container, **kwargs)
917153
def rpush(self, key, value, *values):
        
        return self.execute(b'RPUSH', key, value, *values)
582725
async def handle_action(self, action_type, payload, **kwds):
        
        # if there is a service attached to the action handler
        if hasattr(self, 'service'):
            # handle roll calls
            await roll_call_handler(self.service, action_type, payload, **kwds)
10587
def _post_action(self, action):
        """"""
        ret = super()._post_action(action)
        self._gripper_visualization()
        return ret
1355078
final void push(UniCompletion<?,?> c) {
        if (c != null) {
            while (result == null && !tryPushStack(c))
                lazySetNext(c, null); // clear on failure
        }
    }
1332170
def handle_update(self, action, params):
    """"""
    _LOGGER.debug('Keypad: "%s" %s Action: %s Params: %s"' % (
                  self._keypad.name, self, action, params))
    if action != Led._ACTION_LED_STATE:
      _LOGGER.debug("Unknown action %d for led %d in keypad %d" % (
          action, self.number, self.keypad.name))
      return False
    elif len(params) < 1:
      _LOGGER.debug("Unknown params %s (action %d on led %d in keypad %d)" % (
          params, action, self.number, self.keypad.name))
      return False
    self._state = bool(params[0])
    self._query_waiters.notify()
    self._dispatch_event(Led.Event.STATE_CHANGED, {'state': self._state})
    return True
649650
public function handle(JobPushed $event)
    {
        $this->jobs->pushed(
            $event->connectionName, $event->queue, $event->payload
        );
    }
255776
def process_action(ctx, param, value):
    """"""
    actions = current_app.extensions['invenio-access'].actions
    if value not in actions:
        raise click.BadParameter('Action "%s" is not registered.', value)
    return actions[value]
707377
@Override
    public boolean handleAction (final ActionEvent action)
    {
        final boolean[] handled = new boolean[1];

        // let our delegates have a crack at the action
        applyToDelegates(new DelegateOp(PlaceControllerDelegate.class) {
            @Override
            public void apply (PlaceControllerDelegate delegate) {
                // we take advantage of short-circuiting here
                handled[0] = handled[0] || delegate.handleAction(action);
            }
        });

        // if they didn't handle it, pass it off to the super class
        return handled[0] || super.handleAction(action);
    }
13900
def call_action(self, service_name, action_name, **kwargs):
        """"""
        action = self.services[service_name].actions[action_name]
        return action.execute(**kwargs)
1244092
public function handle(JobPushed $event)
    {
        $monitoring = $this->tags->monitored($event->payload->tags());

        if (! empty($monitoring)) {
            $this->tags->add($event->payload->id(), $monitoring);
        }
    }
352042
def handle_action
      timeline_item = find_timeline_item(self.glass_item_id)

      # TODO: Should we uniq these? When glass doesn't have connection, it will queue up
      # actions, so users might press the same one multiple times.
      user_actions.uniq.each do |user_action|
        type = user_action[:type] == "CUSTOM" ? user_action[:payload] : user_action[:type]
        json_to_return = self.reply_request_hash ? self.reply_request_hash : self.params
        timeline_item.send("handles_#{type.downcase}", json_to_return)
      end if user_actions
    end
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)));
        }
    }
26773
public void handleTouchEvent(MotionEvent ev){
        if(ev.getAction() == MotionEvent.ACTION_MOVE){
            // A finger is dragging about
            if(mTexHeight != 0 && mTexWidth != 0){
                mSummedTouchPosition[0] += (2 * (ev.getX() - mLastTouchPosition[0])) / mTexWidth;
                mSummedTouchPosition[1] += (2 * (ev.getY() - mLastTouchPosition[1])) / -mTexHeight;
                mLastTouchPosition[0] = ev.getX();
                mLastTouchPosition[1] = ev.getY();
            }
        }else if(ev.getAction() == MotionEvent.ACTION_DOWN){
            // The primary finger has landed
            mLastTouchPosition[0] = ev.getX();
            mLastTouchPosition[1] = ev.getY();
        }
    }
352693
def act(self, action):
    """"""
    if action and action.ListFields():  # Skip no-ops.
      return self.actions(sc_pb.RequestAction(actions=[action]))
1212245
private void doAction(List<ActionBlock> actions) throws ActionException {
        try {
            actions.get(nextStep).execute();
        } catch (ActionException e) {
            throw e;
        } catch (Exception e) {
            throw new ActionException("Exception raised by step: " + nextStep, e);
        }
    }