Returns the chunked file's content.
The content consists of the header, then every chunk and then the footer.
@return TextFileContent
349310
public function getContent() {
        return new TextFileContent(
            $this->content . ($this->footer === "" ? "" : $this->footer . $this->newline));
    }
202584
public String getContent() {

        if ((m_content.length() == 0) && (getFile() != null)) {
            m_content = new String(getFile().getContents());
        }
        return m_content;
    }
79495
public function getStubContent()
    {
        $content  = '';
        $filename = $this->getStub();
        if ($filename) {
            $content = file_get_contents($this->getPHPCI()->buildPath . DIRECTORY_SEPARATOR . $this->getStub());
        }
        return $content;
    }
526877
final public function getContent(): string
    {
        if (null === $this->content) {
            $this->content = $this->doGetContent($this->getContentPartNumber());
        }

        return $this->content;
    }
193895
public function getFileContents() : string
    {
        // No point in continuing if there is no file assigned to this frame.
        if (!$this->file || $this->file === 'Unknown') {
            return '';
        }

        // If the contents aren't cached yet, grab them into our rudimentary in-memory cache.
        // Note: This may cache a boolean false if the retrieval fails for whatever reason. We're gonna handle
        // that afterwards and return an empty string instead.
        if (!isset(static::$files[$this->file])) {
            static::$files[$this->file] = file_get_contents($this->file);
        }

        // Return the cached contents of the file or an empty string if no contents could be fetched.
        return static::$files[$this->file] ?: '';
    }
239336
public function getContents()
    {
        // If an offset is provided
        if ($this->offset !== -1) {
            // Seek to the offset
            $this->stream->seek($this->offset);
        }

        // If a max length is provided
        if ($this->maxLength !== -1) {
            // Read from the offset till the maxLength
            return $this->stream->read($this->maxLength);
        }

        return $this->stream->getContents();
    }
1026679
public function getFileContents()
    {
        $result = null;
        $fsl = $this->getFile()->getFileStorageLocationObject();
        if ($fsl !== null) {
            $app = Application::getFacadeApplication();
            $cf = $app->make('helper/concrete/file');
            try {
                $result = $fsl->getFileSystemObject()->read($cf->prefix($this->fvPrefix, $this->fvFilename));
                if ($result === false) {
                    $result = null;
                }
            } catch (FileNotFoundException $x) {
            }
        }

        return $result;
    }
582306
public function getContent()
    {
        if (is_null($this->content)) {
            $this->content = $this->input;
        }
        return $this->content;
    }
979227
public function getContents()
    {
        $sErrorLogPath = $this->getErrorLogPathWithName();

        $sLog = '';

        if ( is_file( $sErrorLogPath ) ) {
            $fErrorLog = fopen( $sErrorLogPath, "r" );

            while ( !feof( $fErrorLog ) ) {
                $sLog .= trim( fgets( $fErrorLog, 4096 ) ) . PHP_EOL;
            }

            fclose( $fErrorLog );
        }

        return $sLog;
    }
1060159
public function getContent() : ?string 
    {
        if ( ! $this->hasContent()) {
            $this->setContent($this->getDefaultContent());
        }
        return $this->content;
    }
1297385
public function getContent() {
        $content = "";
        $maxLen = 0;

        foreach ($this->logs as $log)
            if ($log[0]) {
                $name = $log[0]->getFeature()->getName();
                $maxLen = strlen($name) > $maxLen ? strlen($name) : $maxLen;
            }
        
        foreach ($this->logs as $log)
            $content .= sprintf("%-{$maxLen}s | $log[1]\n", $log[0] ? $log[0]->getFeature()->getName() : "");
        
        return new TextFileContent($content);
    }
640331
public function getContents()
	{
		$level = error_reporting(0);
		$content = file_get_contents($this->getPathname());
		error_reporting($level);

		if (false === $content)
		{
			$error = error_get_last();
			throw new RuntimeException($error['message']);
		}

		return $content;
	}
1007537
public function getAllContents()
    {
        $sLog    = '';
        $sFormat = "----------------------------------------------------------------------\n" .
                   "%s\n" .
                   "----------------------------------------------------------------------\n\n" .
                   "%s\n\n";

        $sLogDirectoryPath = $this->getErrorLogPath();
        $hDir              = @opendir( $sLogDirectoryPath );

        if ( !empty( $hDir ) ) {
            while ( false !== ( $sFileName = readdir( $hDir ) ) ) {
                $sLog .= $this->_getFormattedContents( $sLogDirectoryPath, $sFileName, $sFormat );
            }
        }

        return $sLog;
    }
237624
protected function getFileContent()
    {
        if (ends_with($this->file->getFilename(), '.blade.php')) {
            return $this->renderBlade();
        } elseif (ends_with($this->file->getFilename(), '.md')) {
            return $this->renderMarkdown();
        }

        return $this->file->getContents();
    }
234504
protected function fileContents() {
    // File contents are built up.
    $file_contents = array_merge(
      $this->file_header(),
      $this->code_header(),
      $this->code_body(),
      array(
        $this->code_footer(),
      )
    );

    return $file_contents;
  }
61023
public function getFileContent()
    {
        $file = $this->getAttribute('file');
        if (empty($file) && !$this->getIsNewRecord()) {
            $file = $this->refreshFile();
        }

        if (empty($file)) {
            return null;
        } elseif ($file instanceof Download) {
            $fileSize = $file->getSize();
            return empty($fileSize) ? null : $file->toString();
        } elseif ($file instanceof UploadedFile) {
            return file_get_contents($file->tempName);
        } elseif (is_string($file)) {
            if (file_exists($file)) {
                return file_get_contents($file);
            }
            throw new InvalidParamException("File '{$file}' does not exist.");
        }

        throw new InvalidParamException('Unsupported type of "file" attribute.');
    }
377920
public function getContent() {

            if($this->isSeekable())
                $this->rewind();

            if (!$this->isReadable() || ($contents = stream_get_contents($this->stream)) === false) {
                throw new \RuntimeException('Could not get contents of not readable stream');
            }

            return $contents;

        }