Dump the content from the last response.

@return void
10682
public function dump()
    {
        $content = $this->response->getContent();

        $json = json_decode($content);

        if (json_last_error() === JSON_ERROR_NONE) {
            $content = $json;
        }

        dd($content);
    }
773277
public function flush()
    {
        if (!count($this->updated)) {
            // Not updated words
            return;
        }

        foreach ($this->updated as $lang => $true) {
            // Grouping all words by language
            $words = array();

            foreach ($this->words as $word => $wordLanguages) {
                if (in_array($lang, $wordLanguages)) {
                    $words[] = $word;
                }
            }

            $file = $this->dictionaryDir . '/' . $lang . '.php';
            file_put_contents($file, '<?php return ' . var_export($words, 1) . ';');
        }
    }
1335664
protected function _serialize()
    {
        $this->_renderRow($this->viewVars['_header']);
        $this->_renderContent();
        $this->_renderRow($this->viewVars['_footer']);
        $content = $this->_renderRow(false);
        $this->_resetStaticVariables = true;
        $this->_renderRow();

        return $content;
    }
1017632
function end()
    {
        $data = ob_get_contents();
        ob_end_clean();
        $this->save($data, $this->_id, $this->_group);
        echo($data);
    }
1021396
public function dump() : Generator
    {
        $nodes = [];

        $stack = [$this->root];

        while ($stack) {
            $current = array_pop($stack);

            if ($current instanceof BinaryNode) {
                foreach ($current->children() as $child) {
                    $stack[] = $child;
                }
            }

            yield $current;
        }
    }
1339436
public function executeAndReturnContent()
  {
    ob_start();
    Output::$controller = WebApp::$page->controller;
    include $this->file;
    $content = ob_get_contents();
    ob_clean();

    return $content;
  }
988801
public static function dump()
    {
        $modules = array();
        static::select('name', 'type', 'updated_at')->get()->each(function($module) use (&$modules) {
            if (!isset($modules[ $module->type ])) {
                $modules[ $module->type ] = array();
            }
            $modules[ $module->type ][ $module->name ] = $module->updated_at->timestamp;
        });
        return $modules;
    }
154520
public function output()
    {
        foreach ($this->headers as $name => $value) {
            header($name.': '.$value, true, $this->responseCode());
        }
        echo $this->body;
    }
577681
public static function dump() {
         global $DEBUG_STRING;
         $retval = '';
         $sess = (strlen(session_id()) > 0 );
         if ( $sess ) {
             // echo("<br/>=== DUMP ====<br/>".$_SESSION['__zzz_debug']."<br/>\n");flush();
             if (strlen($_SESSION['__zzz_debug']) > 0) {
                 $retval = $_SESSION['__zzz_debug'];
                 unset($_SESSION['__zzz_debug']);
             }
         }
         if ( strlen($retval) > 0 && strlen($DEBUG_STRING) > 0) {
             $retval .= "\n";
         }
         if (strlen($DEBUG_STRING) > 0) {
             $retval .= $DEBUG_STRING;
             $DEBUG_STRING = '';
         }
         return $retval;
     }
1072587
public function dump()
    {
        if ( $this->printVersion() )
        {
            return 0;
        }

        if ( !$this->parseConnectionInformation() )
        {
            return 1;
        }

        $db = new phpillowCustomConnection(
            $this->connectionInfo['host'],
            $this->connectionInfo['port'],
            $this->connectionInfo['user'],
            $this->connectionInfo['pass']
        );

        $writer = new phpillowToolMultipartWriter( $this->stdout );

        // Fetch and dump documents in chunks of 1000 documents, since the
        // memory consumption might be too high otherwise
        // @TODO: Make chunk-size configurable.
        $offset = null;
        $limit  = 1000;
        do {
            $docs = $db->get( $this->connectionInfo['path'] . '/_all_docs?limit=' . $limit .
                ( $offset !== null ? '&startkey="' . $offset . '"' : '' )
            );

            foreach ( $docs->rows as $nr => $doc )
            {
                if ( ( $nr === 0 ) &&
                     ( $offset !== null ) )
                {
                    // The document which equals the startkey and already has
                    // been dumped.
                    continue;
                }

                $offset = $doc['id'];

                $this->out( "Dumping document " . $doc['id'] . "\n" );
                $doc = $db->get( $this->connectionInfo['path'] . '/' . urlencode( $doc['id'] ) );

                // Skip deleted documents
                // @TODO: Make this configurable
                if ( isset( $doc->deleted ) &&
                     ( $doc->deleted === true ) )
                {
                    continue;
                }

                // Fetch attachments explicitly. Including the attachments in
                // the doc sometimes causes errors on CouchDB 0.10
                $doc = $doc->getFullDocument();
                if ( isset( $doc['_attachments'] ) )
                {
                    foreach ( $doc['_attachments'] as $name => $attachment )
                    {
                        $data = $db->get( $this->connectionInfo['path'] . '/' . urlencode( $doc['_id'] ) . '/' . $name, null, true );
                        $doc['_attachments'][$name]['data'] = $data->data;
                    }
                }

                $writer->writeDocument( $doc );
            }
        } while ( count( $docs->rows ) > 1 );

        unset( $writer );
        return 0;
    }
1094161
protected function dump() {
    $str = '';
    foreach (array_values($this->loadedObjects) as $curObject) {
      $str .= $curObject->dump();
    }
    return $str;
  }
1243886
protected function output()
    {
        if ($this->canSendHeaders() || $this->send_headers == false) {
            if ($this->send_headers) {
                // only send the content-type headers if no headers have been output
                // this will ease debugging on misconfigured servers where warnings
                // may have been output which break the image and prevent easily viewing
                // source to see the error.
                header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
                header("Last-Modified: " . gmdate("D, d M Y H:i:s") . "GMT");
                header("Cache-Control: no-store, no-cache, must-revalidate");
                header("Cache-Control: post-check=0, pre-check=0", false);
                header("Pragma: no-cache");
            }

            switch ($this->image_type) {
                case self::SI_IMAGE_JPEG:
                    if ($this->send_headers) header("Content-Type: image/jpeg");
                    imagejpeg($this->im, null, 90);
                    break;
                case self::SI_IMAGE_GIF:
                    if ($this->send_headers) header("Content-Type: image/gif");
                    imagegif($this->im);
                    break;
                default:
                    if ($this->send_headers) header("Content-Type: image/png");
                    imagepng($this->im);
                    break;
            }
        } else {
            echo '<hr /><strong>'
                .'Failed to generate captcha image, content has already been '
                .'output.<br />This is most likely due to misconfiguration or '
                .'a PHP error was sent to the browser.</strong>';
        }

        imagedestroy($this->im);
        restore_error_handler();

        if (!$this->no_exit) exit;
    }
152731
public function clear() {
        $this->header = array();
        $this->cookies = array();
        $this->files = array();
        $this->statusCode = null;
        $this->statusDescription = null;
        $this->output = '';

        if (ob_get_length() > 0) { 
            ob_clean(); 
        }
    }
544873
public function dump()
    {
        if ($this->hasChildren()) {
            $dump = [];
            foreach ($this->children as $child) {
                $dump[$child->getName()] = $child->dump();
            }
        } elseif (count($this->getValues()) === 1 && (!$this->hasTemplate() || !$this->getTemplate()->multiple_values)) {
            $dump = $this->values[0];
        } else {
            $dump = $this->values;
        }
        return $dump;
    }
1256504
function dump(){
		asort( $this->names, SORT_STRING );
		$t = max( 2, strlen( (string) $this->i ) );
		foreach( $this->names as $i => $n ){
			$i = str_pad( $i, $t, ' ', STR_PAD_LEFT );
			echo "$i => $n \n";
		}
	}
439988
public function finalize()
    {
        // Output our chunks.
        // Every output is split into 4 chunk strings (header, messages,
        // data, footer).
        foreach ($this->chunkStrings as $chunkString) {
            // Save everything to the file after we are done.
            $this->pool->chunks->saveDechunkedToFile($chunkString);
        }
    }
572158
private function dumpStructure() {
    dump("Requesters:");
    dump($this->requesters);

    dump("Request roots:");
    dump($this->requestRoots);

    dump("Request paths:");
    dump($this->requestPaths);

    dump("Local names:");
    dump($this->localNames);

    if (isset($this->tree)) {
      dump("Containment tree:");
      dump($this->tree);
    }
  }