PHP Q_Response::isBuffered方法代码示例

//.........这里部分代码省略.........
                 if (!in_array($method, $methods)) {
                     throw new Q_Exception_MethodNotSupported(compact('method'));
                 }
                 $method_event = 'Q/' . strtolower($method);
                 if (!isset(self::$skip['Q/method']) and !isset(self::$skip[$method_event])) {
                     if (!Q::canHandle($method_event)) {
                         throw new Q_Exception_MethodNotSupported(compact('method'));
                     }
                     Q::event($method_event);
                 }
             }
             // You can calculate some analytics here, and store them somewhere
             if (!isset(self::$skip['Q/analytics'])) {
                 /**
                  * @event Q/analytics
                  * @param {array} $routed_uri_array
                  */
                 Q::event('Q/analytics', $routed_uri_array, true);
             }
             if (!isset(self::$skip['Q/errors'])) {
                 // Check if any errors accumulated
                 if (Q_Response::getErrors()) {
                     // There were processing errors -- render a response
                     self::result('Processing errors');
                     self::errors(null, $module, null);
                     return false;
                 }
             }
             // When handling all further events, you should probably
             // refrain from changing server state, and only do reading.
             // That is because GET in HTTP is not supposed to have side effects
             // for which the client is responsible.
             // Start buffering the response, unless otherwise requested
             $handler = Q_Response::isBuffered();
             if ($handler !== false) {
                 $ob = new Q_OutputBuffer($handler);
             }
             // Generate and render a response
             /**
              * @event Q/response
              * @param {array} $routed_uri_array
              */
             self::$response_started = true;
             Q::event("Q/response", $routed_uri_array);
             if (!empty($ob)) {
                 $ob->endFlush();
             }
             self::result("Served response");
             return true;
         } catch (Q_Exception_DispatcherForward $e) {
             if (!empty($ob)) {
                 $ob->getClean();
             }
             self::handleForwardException($e);
         } catch (Q_Exception_DispatcherErrors $e) {
             if (!empty($ob)) {
                 $partial_response = $ob->getClean();
             } else {
                 $partial_response = null;
             }
             self::errors(null, $module, $partial_response);
             self::result("Rendered errors");
             return true;
         } catch (Exception $exception) {
             if (!empty($ob)) {
                 $partial_response = $ob->getClean();

 /**
  * Gets or sets whether the response is buffered.
  * @method isBuffered
  * @static
  * @param {boolean} [$new_value=null] If not present, just returns the current value of this setting.
  *  If true or false, sets the setting to this value, and returns the setting's old value.
  * @return {boolean}
  */
 static function isBuffered($new_value = null)
 {
     $old_value = self::$isBuffered;
     if (isset($new_value)) {
         self::$isBuffered = $new_value;
     }
     return $old_value;
 }

 /**
  * Sets whether the response is buffered from the config, if any
  * @method setResponseBuffered
  * @static
  */
 static function setResponseBuffered()
 {
     $handler = Q_Config::get('Q', 'response', 'isBuffered', null);
     if (isset($handler)) {
         Q_Response::isBuffered($handler);
     }
 }

 /**
  * Returns a response to the client.
  * @param {boolean} [$closeConnection=false] Whether to send headers to close the connection
  * @method response
  * @static
  */
 static function response($closeConnection = false)
 {
     if (self::$servedResponse) {
         return;
         // response was served, and no new dispatch started
     }
     // Start buffering the response, unless otherwise requested
     $handler = Q_Response::isBuffered();
     if ($handler !== false) {
         $ob = new Q_OutputBuffer($handler);
     }
     if (!empty($_GET['Q_ct'])) {
         Q_Response::setCookie('Q_ct', $_GET['Q_ct']);
     }
     if (!empty($_GET['Q_cordova'])) {
         Q_Response::setCookie('Q_cordova', $_GET['Q_cordova']);
     }
     Q_Response::sendCookieHeaders();
     // Generate and render a response
     /**
      * Gives the app a chance to generate a response.
      * You should not change the server state when handling this event.
      * @event Q/response
      * @param {array} $routed
      */
     self::$startedResponse = true;
     Q::event("Q/response", self::$routed);
     if ($closeConnection) {
         header("Connection: close");
         header("Content-Length: " . $ob->getLength());
     }
     if (!empty($ob)) {
         $ob->endFlush();
     }
     if ($closeConnection) {
         ob_end_flush();
         flush();
     }
     self::$servedResponse = true;
     self::result("Served response");
     return true;
 }