Returns the content of the file

@throws \axy\htpasswd\errors\InvalidFileFormat
326915
public function getContent()
    {
        $this->load();
        $content = [];
        foreach ($this->users as $user) {
            $content[] = $user->getFileLine().PHP_EOL;
        }
        return implode('', $content);
    }
773538
public function getFileContents()
        {
            if ($this->fileContentsCache === null && $filePath = $this->getFile()) {

                // Return null if the file doesn't actually exist - this may
                // happen in cases where the filename is provided as, for
                // example, 'Unknown'
                if (!File::exists($filePath)) {
                    return null;
                }

                $this->fileContentsCache = File::read($filePath);
            }

            return $this->fileContentsCache;
        }
109372
protected function read()
    {
        $filename = $this->filename;
        if (!$this->isFileWritable() && file_exists($this->getCacheFilename())) {
            $filename = $this->getCacheFilename();
        }

        if (!file_exists($filename)) {
            return array();
        }

        $ret = Yaml::parse(file_get_contents($filename));
        if (false === $ret || array() === $ret) {
            throw new \InvalidArgumentException(sprintf('The %s file is not valid.', $filename));
        }

        if (isset($ret['parameters']) && is_array($ret['parameters'])) {
            return $ret['parameters'];
        } else {
            return array();
        }
    }
937808
private function content()
    {
        $handle = fopen($this->_config, 'r');
        $content = @json_decode(stream_get_contents($handle));

        return $content;
    }
658470
public function getContents()
    {
        $content = '';
        while(!$this->streamable->isEOF()) {
            $r = $this->streamable->read(1024);
            if ($r == null)
                break;

            $content .= $r;
        }
        
        return $content;
    }
299559
public function getContents()
    {
        if (self::SCHEME_RESOURCE === $this->getScheme()) {
            $contents = '';
            while ($data = fread($this->stream, 2048)) {
                $contents .= $data;
            }
        } else {
            $contents = file_get_contents($this->uri);
        }
        return $contents;
    }
325234
public function getContent()
    {
        if ($this->content === null) {
            if (is_array($this->variables)) {
                extract($this->variables);
            } else {
                if ($this->variables !== null) {
                    throw new \InvalidArgumentException('$variables argument should be null or an array');
                }
            }

            ob_start();
            include($this->path);
            $this->content = ob_get_clean();
        }

        return $this->content;
    }
582306
public function getContent()
    {
        if (is_null($this->content)) {
            $this->content = $this->input;
        }
        return $this->content;
    }
678942
protected function getFileContent($path)
    {
        if (false === file_exists($path)) {
            throw new \InvalidArgumentException(sprintf('File "%s" does not exist.', $path));
        }
        
        return file_get_contents($path);
    }
640163
public function getContents()
    {
        $contents = file_get_contents($this->getPath());

        foreach ($this->getReplaces() as $search => $replace) {
            $contents = str_replace('$'.strtoupper($search).'$', $replace, $contents);
        }

        return $contents;
    }
1105536
public function getContent() {
        static $content  = '';
        static $isRead = false;

        if (!$isRead) {
            if ($this->getContentType() == 'multipart/form-data') {
                // file upload
                if ($_POST) {                                                           // php://input is not available with
                    $content = '$_POST => '.print_r($_POST, true).NL;                   // enctype="multipart/form-data"
                    // TODO: we should limit excessive variable values to 1KB
                }
                $content .= '$_FILES => '.print_r($this->getFiles(), true);
            }
            else {
                // regular request body
                $content = file_get_contents('php://input');
            }
            $isRead = true;
        }
        return $content;
    }
1347405
public function read()
    {
        $contents = false;

        if ($this->isFile() && $this->isReadable()) {
            $contents = file_get_contents($this->realPath);
        }

        return $contents;
    }
1300327
public function getData()
    {
        if ($this->tempFileName == '') {
            return $this->outputMemory(true);
        } else {
            $this->flush();
            return file_get_contents($this->tempFileName);
        }
    }
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;
	}
920128
public function getContent() {
        $content = file_get_contents($this->fileSource);
        foreach ($this->rules as $rule)
            $content = $rule->apply($content);
        return new TextFileContent($content);
    }
256714
public function load()
    {
        $this->raw = $this->exists() ? (string) file_get_contents($this->filename) : '';
        $this->content = null;

        return $this->raw;
    }
152847
public function read() {
		if (!$this->exists()) {
			throw new FileException(sprintf('File does not exist: %s', $this->getFilename()));
		}

		if (!$this->isReadable()) {
			throw new FileException(sprintf('You don\'t have permissions to access %s file', $this->getFilename()));
		}

		return file_get_contents($this->pathname);
	}