Filters the Response.
963040
public function onKernelResponse(FilterResponseEvent $event)
    {
        if (!$event->isMasterRequest()) {
            return;
        }

        $response = $event->getResponse();

        if ($response instanceof StreamedResponse) {
            $response->send();
        }
    }
1010214
def ingress_filter(self, response):
        
        data = self.data_getter(response)
        if isinstance(data, dict):
            data = m_data.DictResponse(data)
        elif isinstance(data, list):
            data = m_data.ListResponse(data)
        else:
            return data
        data.meta = self.meta_getter(response)
        return data
594529
public function onKernelResponse(FilterResponseEvent $event)
    {
        $event->getResponse()->headers->set(self::HEADER_NAME, $this->requestId->get());
    }
27414
public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        InstanceInfo myInfo = ApplicationInfoManager.getInstance().getInfo();
        InstanceStatus status = myInfo.getStatus();
        if (status != InstanceStatus.UP && response instanceof HttpServletResponse) {
            HttpServletResponse httpRespone = (HttpServletResponse) response;
            httpRespone.sendError(SC_TEMPORARY_REDIRECT,
                    "Current node is currently not ready to serve requests -- current status: "
                            + status + " - try another DS node: ");
        }
        chain.doFilter(request, response);
    }
1208384
def filter(cls, **items):
        '''
        
        '''
        client = cls._new_api_client(subpath='/search')
        items_dict = dict((k, v) for k, v in list(items.items()))
        json_data = json.dumps(items_dict, sort_keys=True, indent=4)
        return client.make_request(cls, 'post', post_data=json_data)
1107248
public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		HttpServletRequest httpServletRequest = WebFilter.request.get();
		
		try {
			WebFilter.request.set((HttpServletRequest) request);
			chain.doFilter(request, response);
		} finally {
			WebFilter.request.set(httpServletRequest);
		}
	}
741200
public function onKernelResponse(FilterResponseEvent $e)
    {

        if (!$this->enabled) return;

        $response = $e->getResponse();

        //if supression is active, always return 200 no matter what
        $config = $e->getRequest()->attributes->get('_ac_web_service');

        if (!$config['negotiated']) {
            $config = $this->negotiateResponseFormat($e->getRequest(), $config);
        }

        if ($config['suppress_response_codes']) {
            $response = $response->setStatusCode(200);
        }

        //if JSONP, wrap use _callback param
        if ($config['is_jsonp']) {
            $response->headers->set('Content-Type', $this->formatHeaders['jsonp']);
            $response->setContent(sprintf("%s(%s);", $config['jsonp_callback'], $response->getContent()));
        }

        $e->getDispatcher()->dispatch(self::API_RESPONSE, $e);
    }
299413
function (isResponse, request, cb) {
                if (!this._filters) {
                    this.$callback(cb);
                    return;
                }
                var args = {
                    isResponse : isResponse,
                    request : request,
                    cb : cb,
                    filters : this._filters,
                    nbFilters : this._filters.length
                    // store the number of filters so that we do not call filters which were added after the call
                    // to _callFilters
                };
                if (this._filtersToBeLoaded > 0
                        && (request.sender == null || request.sender.classpath != "aria.core.FileLoader")) {
                    this._loadMissingFilters({
                        fn : this._continueCallingFilters,
                        args : args,
                        scope : this
                    });
                } else {
                    this._continueCallingFilters(null, args);
                }
            }
87059
def filter(self, value=None, model=None, context=None):
        
        if value is None:
            return value
        for filter_obj in self.filters:
            value = filter_obj.filter(
                value=value,
                model=model,
                context=context if self.use_context else None
            )
        return value
516582
function(isGlobal, server, err, msg, session, resp, opts, cb) {
  if(isGlobal) {
    cb(err, resp, opts);
    // after filter should not interfere response
    afterFilter(isGlobal, server, err, msg, session, resp, opts, cb);
  } else {
    afterFilter(isGlobal, server, err, msg, session, resp, opts, cb);
  }
}
747233
def handle_response(self, msgtype, msgid, response):
        """"""
        self._proxy.response(msgid, response)
1219282
def _filter(self, objects, **kwargs):
        """"""
        for obj in objects:
            if self.filter(obj, **kwargs) is False:
                return False

        return True
147088
public function filterResponse(SimplifiedResponse $response)
    {
        foreach ($this->filters as $filter) {
            $filter->filterResponse($response);
        }

        return $response;
    }
1231137
@Override
	public void filter(final ClientRequestContext requestContext, final ClientResponseContext responseContext) {
		final List<String> serializedHeaders = responseContext.getHeaders().get(TraceeConstants.TPIC_HEADER);
		if (serializedHeaders != null && backend.getConfiguration().shouldProcessContext(IncomingResponse)) {
			final Map<String, String> parsed = transportSerialization.parse(serializedHeaders);
			backend.putAll(backend.getConfiguration().filterDeniedParams(parsed, IncomingResponse));
		}
	}
1224467
public function onKernelResponse(FilterResponseEvent $event)
    {
        $response = $event->getResponse();
        $request  = $event->getRequest();
        if (!$event->isMasterRequest())
        {
            return;
        }
        if ($request->isXmlHttpRequest())
        {
            return;
        }
        $this->_injectDatatableScript($response, $request);
    }
1265406
public static function filterResponse(string $response) : string
    {
        $response = str_replace('{', '[', $response);
        $response = str_replace('}', ']', $response);
        $response = str_replace('":', '"=>', $response);
        return $response;
    }
893051
def filtered_response response
      raise Skydrive::Error.new({"code" => "no_response_received", "message" => "Request didn't make through or response not received"}) unless response
      if response.success?
        filtered_response = response.parsed_response
        if response.response.code =~ /(201|200)/
          raise Skydrive::Error.new(filtered_response["error"]) if filtered_response["error"]
          if filtered_response["data"]
            return Skydrive::Collection.new(self, filtered_response["data"])            
          elsif filtered_response["id"] && (filtered_response["id"].match /^comment\..+/)
            return Skydrive::Comment.new(self, filtered_response)
          elsif filtered_response["id"] && (filtered_response["id"].match /^file\..+/)
            return Skydrive::File.new(self, filtered_response)
          elsif filtered_response["type"]
            return "Skydrive::#{filtered_response["type"].capitalize}".constantize.new(self, filtered_response)
          else
            return filtered_response
          end
        else
          return true
        end
      else
        raise Skydrive::Error.new("code" => "http_error_#{response.response.code}", "message" => response.response.message)
      end
    end