Process the input buffer.
515600
def process_frames(self):
        '''
        
        '''
        while len(self._frame_buffer):
            # It would make sense to call next_frame, but it's
            # technically faster to repeat the code here.
            frame = self._frame_buffer.popleft()

            if self._emergency_close_pending:
                # Implement stability rule from AMQP 0.9.1 section 1.5.2.5.
                # Method channel.close: "After sending this method, any
                # received methods except Close and Close-OK MUST be discarded."
                #
                # NOTE: presently, we limit our implementation of the rule to
                # the "emergency close" scenario to avoid potential adverse
                # side-effect during normal user-initiated close
                if (not isinstance(frame, MethodFrame) or
                      frame.class_id != self.channel.CLASS_ID or
                      frame.method_id not in (self.channel.CLOSE_METHOD_ID,
                                              self.channel.CLOSE_OK_METHOD_ID)):
                    self.logger.warn("Emergency channel close: dropping input "
                                     "frame %.255s", frame)
                    continue
            try:
                self.dispatch(frame)
            except ProtocolClass.FrameUnderflow:
                return
            except (ConnectionClosed, ChannelClosed):
                # Immediately raise if connection or channel is closed
                raise
            except Exception:
                self.logger.exception(
                    "Closing on failed dispatch of frame %.255s", frame)

                # Spec says that channel should be closed if there's a framing
                # error. Unsure if we can send close if the current exception
                # is transport level (e.g. gevent.GreenletExit)
                self._emergency_close_pending = True

                # Preserve the original exception and traceback during cleanup,
                # only allowing system-exiting exceptions (e.g., SystemExit,
                # KeyboardInterrupt) to override it
                try:
                    raise
                finally:
                    try:
                        self.close(500, "Failed to dispatch %s" % (str(frame)))
                    except Exception:
                        # Suppress secondary non-system-exiting exception in
                        # favor of the original exception
                        self.logger.exception("Channel close failed")
                        pass
942062
public function process()
    {
        parent::process();

        if (is_int($this->background)) {

            extract($this->getBackgroundCoordinates($this->getGravity()));
            imagefill($this->resource, $x1, $y1, $this->background);
            imagefill($this->resource, $x2, $y2, $this->background);

        }
    }
807849
def _set_input_buffer(self, text):
        """"""
        if self.current_prompt_pos is not None:
            self.replace_text(self.current_prompt_pos, 'eol', text)
        else:
            self.insert(text)
        self.set_cursor_position('eof')
1374179
public function process()
    {
        parent::process();

        if ($this->value === null) {
            return;
        }

        $float_value = $this->getNumericValue($this->value);

        if ($float_value === null) {
            $this->addMessage($this->getValidationMessage('float'));
        } else {
            $this->value = $float_value;
        }
    }
600934
@Handler
    public void onOutput(Output<ByteBuffer> event, Channel channel) {
        Writer writer = outputWriters.get(channel);
        if (writer != null) {
            writer.write(event.buffer());
        }
    }
970371
private void processInput(boolean endOfInput) throws IOException {
        // Prepare decoderIn for reading
        decoderIn.flip();
        CoderResult coderResult;
        while (true) {
            coderResult = decoder.decode(decoderIn, decoderOut, endOfInput);
            if (coderResult.isOverflow()) {
                flushOutput();
            } else if (coderResult.isUnderflow()) {
                break;
            } else {
                // The decoder is configured to replace malformed input and unmappable characters,
                // so we should not get here.
                throw new IOException("Unexpected coder result");
            }
        }
        // Discard the bytes that have been read
        decoderIn.compact();
    }
775517
def process(self, chars):
        

        while len(chars) > 0:
            self.consume(chars[0])
            chars = chars[1:]
665581
public function process()
    {
        parent::process();

        // process input cells
        foreach ($this->replicators as $replicator_id) {
            foreach ($this->input_cells as $cell) {
                $cell->process($replicator_id);
            }
        }
    }
1108184
def handle_input(self, event):
        """"""
        self.update_timeval()
        self.events = []
        code = self._get_event_key_code(event)

        if code in self.codes:
            new_code = self.codes[code]
        else:
            new_code = 0
        event_type = self._get_event_type(event)
        value = self._get_key_value(event, event_type)
        scan_event, key_event = self.emulate_press(
            new_code, code, value, self.timeval)

        self.events.append(scan_event)
        self.events.append(key_event)
        # End with a sync marker
        self.events.append(self.sync_marker(self.timeval))
        # We are done
        self.write_to_pipe(self.events)
520286
protected function processInputFiles()
    {
        $passwords = array();
        foreach ($this->_files as $handle => $file) {
            $this->addArg($handle.'=',$file['name']);
            if ($file['password']!==null) {
                $passwords[$handle] = $file['password'];
            }
        }
        if ($passwords!==array()) {
            $this->addArg('input_pw');
            foreach ($passwords as $handle => $password) {
                $this->addArg($handle.'=', $password);
            }
        }
    }
211148
def _process_incoming_data(self):
        
        while self._running.is_set():
            if self.poller.is_ready:
                self.data_in += self._receive()
                self.data_in = self._on_read_impl(self.data_in)
655961
protected void process(StringBuffer buf, Object p) {
		buf.append('<');
		buf.append(p);
		buf.append('>');
		buf.append(this.get(p));
		buf.append("</");
		buf.append(p);
		buf.append('>');
	}
129752
public function process() {
    foreach ($this->sheet->getRowIterator() as $row) {
      if ($row->getRowIndex() < $this->getOption('minRow')) {
        $this->log .= 'Skip.minRow: '.$row->getRowIndex()."\n";
        continue;
      }
      
      if ($row->getRowIndex() > $this->getOption('maxRow')) {
          $this->log .= 'Break.maxRow: '.$row->getRowIndex()."\n";
          break;
      }
      
      $this->log .= 'processRow('.$row->getRowIndex().")\n";
      $this->currentRow = $row;
      $this->processRow($row);
    }
  }
405212
def process(self, buff):
        '''
            
        '''
        
        # adding the current to the available
        self.memory = self.memory + buff 
        self._available = len(self.memory)
        idx = 0
        # prepare pointers and inputs
        # read first byte 
        
        handleheader = self.handle_read_header
        handlelength = self.handle_read_length
        handlevalue = self.handle_read_value
        handleegend = self.handle_segment_ended
        # process input while exists
        while self._available >= self._advance:
            # expected start of a new segment
            if self._scstate.value <= ScannerState.WAITING_FOR_HEADER.value:
                self._advance = 1
                handleheader(self.memory[idx])
            # the scanner expects to read one or multiple bytes that contain an 
            # integer contain the length of the value to be expected
            elif self._scstate is ScannerState.WAITING_FOR_LENGTH:
                self._advance = self._state[3]
                # breaking if not available
                if self._available < self._state[3]:
                    break
                handlelength(self.memory, idx, idx + self._advance)
                # if the scanner is expecting to parse one or multiple bytes as the value of the segment
            elif self._scstate is ScannerState.WAITING_FOR_VALUE:
                self._advance = self._state[3]
                if self._available < self._advance:
                    break
                handlevalue(self.memory, idx, idx + self._advance)
            # if the scanner is expecting to parse an extension
            elif self._scstate is ScannerState.WAITING_FOR_EXT_TYPE:
                self._advance = 1
                self.handle_read_ext_type(self.memory, idx)
            
            # if a data segment is ended
            if self._scstate is ScannerState.SEGMENT_ENDED:
                handleegend()
            # proceed with scanning
            
            self._available -= self._advance   
            idx = idx + self._advance
            self._advance = 1
        
        #  finished processing all since it needed extra info     
        self.memory = buffer(self.memory, idx, len(self.memory))
1120371
private void advanceBufferIfNecessary() {
    ReadableBuffer buffer = buffers.peek();
    if (buffer.readableBytes() == 0) {
      buffers.remove().close();
    }
  }
898472
private void process()
    {
        if (requestUri.length() > 1) {
            parts = new ArrayList<String>(10);
            for ( int i = 1; i < requestUri.length(); ) {
                int sIdx = i;
                int eIdx = requestUri.indexOf('/', sIdx + 1);
                
                //not matched or reach the end
                if ( eIdx == -1 ) {
                    parts.add(requestUri.substring(sIdx));
                    break;
                } 
                
                parts.add(requestUri.substring(sIdx, eIdx));
                i = eIdx + 1;
            }
            
            /*
             * check and add a empty method name
             * with request style like /tokenizer/
            */
            if ( requestUri.charAt(requestUri.length()-1) == '/' ) {
                parts.add("");
            }
            
            int length = parts.size();
            if ( length > 1 ) {
                IStringBuffer sb = new IStringBuffer();
                for ( int i = 0; i < length - 1; i++ ) {
                    int l = sb.length();
                    sb.append(parts.get(i));
                    
                    //make sure the first letter is uppercase
                    char chr = sb.charAt(l);
                    if ( chr >= 90 ) {
                        chr -= 32;
                        sb.set(l, chr);
                    }
                }
                
                controller = sb.toString();
            }
            
            method = parts.get(length-1);
        }
    }
496497
def process(data)
      @buffer << data

      lines = @buffer.split "\n"
      @buffer = @buffer.end_with?("\n") ? '' : lines.pop

      lines.each do |line|
        yield line.strip
      end
    end