Generics\Streams\FileOutputStream

Complexity

Total Complexity

35

Size/Duplication

Total Lines	257
Duplicated Lines	5.45 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

79.27%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	open()	0	34	6
A	__destruct()	0	10	3
A	ready()	0	4	1
B	write()	0	23	6
A	close()	0	7	2
A	count()	0	8	2
A	__toString()	0	4	1
A	isWriteable()	0	4	1
A	flush()	0	8	2
A	lock()	7	7	3
A	unlock()	7	7	3
A	isLocked()	0	4	1
A	isOpen()	0	4	1
A	reset()	0	9	2

<?php

/**
 * This file is part of the PHP Generics package.
 *
 * @package Generics
 */
namespace Generics\Streams;

use Generics\FileExistsException;
use Generics\NoAccessException;
use Generics\LockException;
use Generics\Lockable;
use Generics\ResetException;
use Exception;

/**
 * This class provides a file output stream.
 *
 * @author Maik
 */
class FileOutputStream implements OutputStream, Lockable
{

    /**
     * The file handle
     *
     * @var resource
     */
    private $handle;

    /**
     * The absolute file path and name
     *
     * @var string
     */
    private $fileName;

    /**
     * Whether resource is locked
     *
     * @var bool
     */
    private $locked;

    /**
     * Whether to append
     *
     * @var bool
     */
    private $append;

    /**
     * Create a new FileOutputStream
     *
     * @param string $file
     *            The absolute (or relative) path to file to write into.
     * @param boolean $append
     *            Whether to append the data to an existing file.
     * @throws FileExistsException will be thrown in case of file exists and append is set to false.
     * @throws NoAccessException will be thrown in case of it is not possible to write to file.
     */
    public function __construct($file, $append = false)
    {
        $this->open($file, $append);
    }

    private function open($file, $append)
    {
        $this->locked = false;
        
        $mode = "wb";
        
        if (file_exists($file)) {
            if (! $append) {
                throw new FileExistsException("File $file already exists!");
            }
            
            if (! is_writable($file)) {
                throw new NoAccessException("Cannot write to file $file");
            }
            $mode = "ab";
        } else {
            if (! is_writable(dirname($file))) {
                throw new NoAccessException("Cannot write to file {file}", array(
                    'file' => $file
                ));
            }
        }
        
        $this->handle = fopen($file, $mode);
        
        if (! $this->ready()) {
            throw new StreamException("Could not open {file} for writing", array(
                'file' => $file
            ));
        }
        
        $this->fileName = $file;
        $this->append = $append;
    }

    /**
     * Cleanup (e.g.
     * release lock)
     */
    public function __destruct()
    {
        try {
            if ($this->locked) {
                $this->unlock();
            }
        } catch (\Generics\GenericsException $ex) {
            // Do nothing
        }
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Streams\Stream::ready()
     */
    public function ready(): bool
    {
        return is_resource($this->handle);
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Streams\OutputStream::write()
     */
    public function write($buffer)
    {
        if (! $this->ready()) {
            throw new StreamException("Stream is not open!");
        }
        
        if ($buffer instanceof InputStream) {
            $in = clone $buffer;
            assert($in instanceof InputStream);
            while ($in->ready()) {
                $buf = $in->read(1024);
                if (fwrite($this->handle, $buf) != strlen($buf)) {
                    throw new StreamException("Could not write memory stream into file");
                }
            }
        } else {
            $buffer = strval($buffer);
            if (fwrite($this->handle, $buffer) != strlen($buffer)) {
                throw new StreamException("Could not write buffer into file");
            }
            fflush($this->handle);
        }
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Streams\Stream::close()
     */
    public function close()
    {
        if (is_resource($this->handle)) {
            fclose($this->handle);
            $this->handle = null;
        }
    }

    /**
     *
     * {@inheritdoc}
     * @see \Countable::count()
     */
    public function count(): int
    {
        if (! $this->ready()) {
            throw new StreamException("Stream is not open!");
        }
        
        return ftell($this->handle);
    }

    /**
     * Retrieve the file path and name
     *
     * @return string
     */
    public function __toString(): string
    {
        return realpath($this->fileName);
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Streams\OutputStream::isWriteable()
     */
    public function isWriteable(): bool
    {
        return $this->ready();
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Streams\OutputStream::flush()
     */
    public function flush()
    {
        if (! $this->ready()) {
            throw new StreamException("Stream is not open!");
        }
        
        fflush($this->handle);
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Lockable::lock()
     */
    public function lock()
    {
        if ($this->locked || flock($this->handle, LOCK_EX) === false) {
            throw new LockException("Could not acquire lock");
        }
        $this->locked = true;
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Lockable::unlock()
     */
    public function unlock()
    {
        if (! $this->locked || flock($this->handle, LOCK_UN) === false) {
            throw new LockException("Could not release lock");
        }
        $this->locked = false;
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Lockable::isLocked()
     */
    public function isLocked(): bool
    {
        return $this->locked;
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Streams\Stream::isOpen()
     */
    public function isOpen(): bool
    {
        return is_resource($this->handle);
    }

    /**
     *
     * {@inheritdoc}
     * @see \Generics\Resettable::reset()
     */
    public function reset()
    {
        try {
            $this->close();
            $this->open($this->fileName, $this->append);
        } catch (Exception $ex) {
            throw new ResetException($ex->getMessage(), array(), $ex->getCode(), $ex);
        }
    }
}