Add the response to the deque.
186184
def send_response_message(self, request_id, meta, body):
        
        self.response_messages.append((request_id, meta, body))
939456
def process_response(self, response):
        """"""
        self.response_headers = [(k, v) for k, v in sorted(response.headers.items())]
772995
def send_response(self, transaction):
        
        if transaction.cacheHit is False:
            """
            handling response based on the code
            """
            logger.debug("handling response")
            self._handle_response(transaction)
        return transaction
727737
def start_response_callback(start_response, transaction_id):
        """"""
        def callback(status, headers, exc_info=None):
            """Add our headers to response using a closure."""
            headers.append(('X-Transaction-Id', transaction_id))
            # Call upstream start_response
            start_response(status, headers, exc_info)
        return callback
1304572
public void addResponse(RecordResponse response) {
        if (records == null) {
            records = new RecordResponse[1];
        }
        else {
            RecordResponse old[] = records;
            records = new RecordResponse[old.length + 1];

            System.arraycopy(old, 0, records, 0, old.length);
        }
        records[records.length - 1] = response;
    }
1371573
public static void pushContext() {
        RpcInternalContext context = LOCAL.get();
        if (context != null) {
            Deque<RpcInternalContext> deque = DEQUE_LOCAL.get();
            if (deque == null) {
                deque = new ArrayDeque<RpcInternalContext>();
                DEQUE_LOCAL.set(deque);
            }
            deque.push(context);
            LOCAL.set(null);
        }
    }
1165386
public void addResponse(CheckRequest req, CheckResponse resp) {
    if (cache == null) {
      return;
    }
    String signature = sign(req).toString();
    long now = ticker.read();
    int quotaScale = 0; // WIP
    synchronized (cache) {
      CachedItem item = cache.getIfPresent(signature);
      if (item == null) {
        cache.put(signature, new CachedItem(resp, req, kinds, now, quotaScale));
      } else {
        item.lastCheckTimestamp = now;
        item.response = resp;
        item.quotaScale = quotaScale;
        item.isFlushing = false;
        cache.put(signature, item);
      }
    }
  }
318839
def process_response(self, request, response):
        """"""

        # For debug only.
        if not settings.DEBUG:
            return response

        # Check for responses where the data can't be inserted.
        content_encoding = response.get('Content-Encoding', '')
        content_type = response.get('Content-Type', '').split(';')[0]
        if any((getattr(response, 'streaming', False),
                'gzip' in content_encoding,
                content_type not in _HTML_TYPES)):
            return response

        content = force_text(response.content, encoding=settings.DEFAULT_CHARSET)

        pattern = re.escape('</body>')
        bits = re.split(pattern, content, flags=re.IGNORECASE)

        if len(bits) > 1:
            bits[-2] += debug_payload(request, response, self.view_data)
            response.content = "</body>".join(bits)
            if response.get('Content-Length', None):
                response['Content-Length'] = len(response.content)

        return response
1150408
def add(self, req: Request):
        
        key = req.key
        if key not in self:
            self[key] = ReqState(req)
        return self[key]
943035
def add_answer_at_time(self, record, now):
        """"""
        if record is not None:
            if now == 0 or not record.is_expired(now):
                self.answers.append((record, now))
                if record.rrsig is not None:
                    self.answers.append((record.rrsig, now))
123349
def process_response(self, request, response):
        
        if hasattr(threadlocal, 'auditlog'):
            pre_save.disconnect(sender=LogEntry, dispatch_uid=threadlocal.auditlog['signal_duid'])

        return response
1372161
def make_response(event):
    """"""
    code, message = event.status
    response = jsonify(**event.response)
    response.headers['X-Hub-Event'] = event.receiver_id
    response.headers['X-Hub-Delivery'] = event.id
    if message:
        response.headers['X-Hub-Info'] = message
    add_link_header(response, {'self': url_for(
        '.event_item', receiver_id=event.receiver_id, event_id=event.id,
        _external=True
    )})
    return response, code
1135478
def _add_response(self, response, weight=1):
        
        # If no response with this priority level has been defined yet, create a new list
        if response.priority not in self._responses:
            self._responses[response.priority] = [(response, weight)]
            return

        # Otherwise, add this trigger to an existing priority list
        self._responses[response.priority].append((response, weight))
905352
def add_question(self, qname, rdtype, rdclass=dns.rdataclass.IN):
        

        self._set_section(QUESTION)
        before = self.output.tell()
        qname.to_wire(self.output, self.compress, self.origin)
        self.output.write(struct.pack("!HH", rdtype, rdclass))
        after = self.output.tell()
        if after >= self.max_size:
            self._rollback(before)
            raise dns.exception.TooBig
        self.counts[QUESTION] += 1
847404
protected static function _addChainedResponse($response)
    {
        $firstChainedMethodName = key($response);

        if (isset(self::$returnValues[$firstChainedMethodName])) {
            self::$returnValues[$firstChainedMethodName] = array_replace_recursive(
                self::$returnValues[$firstChainedMethodName],
                $response[$firstChainedMethodName]
            );
        } else {
            self::$returnValues[$firstChainedMethodName] = $response[$firstChainedMethodName];
        }
    }
696435
def update_response_object(self, service_id, version_number, name_key, **kwargs):
		""""""
		body = self._formdata(kwargs, FastlyResponseObject.FIELDS)
		content = self._fetch("/service/%s/version/%d/response_object/%s" % (service_id, version_number, name_key), method="PUT", body=body)
		return FastlyResponseObject(self, content)
518835
def update_from_response(self, response):
        
        if 'Table' in response:
            self._dict.update(response['Table'])
        elif 'TableDescription' in response:
            self._dict.update(response['TableDescription'])
        if 'KeySchema' in self._dict:
            self._schema = Schema(self._dict['KeySchema'])