1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 

<?php
/**
 * This file contains file utilities.
 */
namespace IU\PHPCap;

/**
 * File utility class for dealing with files.
 */
class FileUtil
{
    
    protected static $errorHandler = null;
    
    /**
     * Reads the contents of the specified file and returns it as a string.
     *
     * @param string $filename the name of the file that is to be read.
     *
     * @throws PhpCapException if an error occurs while trying to read the file.
     *
     * @return string the contents of the specified file.
     */
    public static function fileToString($filename)
    {
        $errorHandler = static::getErrorHandler();
        
        if (!file_exists($filename)) {
            $errorHandler->throwException(
                'The input file "'.$filename.'" could not be found.',
                ErrorHandlerInterface::INPUT_FILE_NOT_FOUND
            );
        } elseif (!is_readable($filename)) {
            $errorHandler->throwException(
                'The input file "'.$filename.'" was unreadable.',
                ErrorHandlerInterface::INPUT_FILE_UNREADABLE
            );
        } // @codeCoverageIgnore
        
        $contents = file_get_contents($filename);

        if ($contents === false) {
            $error = error_get_last();
            $errorMessage = null;
            if ($error != null && array_key_exists('message', $error)) {
                $errorMessage = $error['message'];
            }
            
            if (isset($errorMessage)) {
                $errorHandler->throwException(
                    'An error occurred in input file "'.$filename.'": '.$errorMessage,
                    ErrorHandlerInterface::INPUT_FILE_ERROR
                );
            } else { // @codeCoverageIgnore
                $errorHandler->throwException(
                    'An error occurred in input file "'.$filename.'"',
                    ErrorHandlerInterface::INPUT_FILE_ERROR
                );
            } // @codeCoverageIgnore
        } // @codeCoverageIgnore
        
        return $contents;
    }
 
    /**
     * Writes the specified string to the specified file.
     *
     * @param string $string the string to write to the file.
     * @param string $filename the name of the file to write the string.
     * @param boolean $append if true, the file is appended if it already exists. If false,
     *        the file is created if it doesn't exist, and overwritten if it does.
     *
     * @throws PhpCapException if an error occurs.
     *
     * @return mixed false on failure, and the number of bytes written on success.
     */
    public static function writeStringToFile($string, $filename, $append = false)
    {
        $errorHandler = static::getErrorHandler();
        
        $result = false;
        if ($append === true) {
            $result = file_put_contents($filename, $string, FILE_APPEND);
        } else {
            $result = file_put_contents($filename, $string);
        }
        
        if ($result === false) {
            $error = error_get_last();
            $errorMessage = null;
            if ($error != null && array_key_exists('message', $error)) {
                $errorMessage = $error['message'];
            }
            
            if (isset($errorMessage)) {
                $errorHandler->throwException(
                    'An error occurred in output file "'.$filename.'": '.$errorMessage,
                    ErrorHandlerInterface::OUTPUT_FILE_ERROR
                );
            } else { // @codeCoverageIgnore
                $errorHandler->throwException(
                    'An error occurred in output file "'.$filename.'"',
                    ErrorHandlerInterface::OUTPUT_FILE_ERROR
                );
            } // @codeCoverageIgnore
        } // @codeCoverageIgnore
            
        return $result;
    }
    
    /**
     * Appends the specified string to the specified file.
     *
     * @param string $string the string to append.
     * @param string $filename the name of the file that is appended.
     *
     * @throws PhpCapException if an error occurs.
     *
     * @return mixed false on failure, and the number of bytes appended on success.
     */
    public static function appendStringToFile($string, $filename)
    {
        $result = static::writeStringToFile($string, $filename, true);
        return $result;
    }
    
    /**
     * Gets the error handler for the class.
     *
     * @return ErrorHandlerInterface the error handler for the class.
     */
    public static function getErrorHandler()
    {
        if (!isset(self::$errorHandler)) {
            self::$errorHandler = new ErrorHandler();
        }
        return self::$errorHandler;
    }
    
    /**
     * Sets the error handler used for methods in this class.
     *
     * @param ErrorHandlerInterface $errorHandler
     */
    public static function setErrorHandler($errorHandler)
    {
        # Get the current error handler to make sure it's set,
        # since it will need to be used if the passed error
        # handler is invalid
        $currentErrorHandler = static::getErrorHandler();
        
        if (!($errorHandler instanceof ErrorHandlerInterface)) {
            $message = 'The error handler argument is not valid, because it doesn\'t implement '
                .ErrorHandlerInterface::class.'.';
                $code = ErrorHandlerInterface::INVALID_ARGUMENT;
            $currentErrorHandler->throwException($message, $code);
        } // @codeCoverageIgnore
        self::$errorHandler = $errorHandler;
    }
}