<?php

use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Filesystem\Exception\IOException;

class CCL
{
    /**
     * @return Symfony\Component\Filesystem\Filesystem
     */
    public static function _sym()
    {
        static $singleton = NULL;
        $singleton = $singleton ?: new Symfony\Component\Filesystem\Filesystem();
        return $singleton;
    }

    /**
     * @return CCL\Functions
     */
    public static function _ccl()
    {
        static $singleton = NULL;
        $singleton = $singleton ?: new CCL\Functions();
        return $singleton;
    }

    /**
     * Copies a file.
     *
     * If the target file is older than the origin file, it's always overwritten.
     * If the target file is newer, it is overwritten only when the
     * $overwriteNewerFiles option is set to true.
     *
     * @throws FileNotFoundException When originFile doesn't exist
     * @throws IOException           When copy fails
     *
     * @return void
     */
    public static function copy($originFile, $targetFile, bool $overwriteNewerFiles = TRUE)
    {
        return self::_sym()->copy($originFile, $targetFile, $overwriteNewerFiles);
    }

    /**
     * Creates a directory recursively.
     *
     * @throws IOException On any directory creation failure
     *
     * @return void
     */
    public static function mkdir($dirs, $mode = 511)
    {
        return self::_sym()->mkdir($dirs, $mode);
    }

    /**
     * Checks the existence of files or directories.
     */
    public static function exists($files)
    {
        self::_sym()->exists($files);
    }

    /**
     * Sets access and modification time of file.
     *
     * @param int|null $time  The touch time as a Unix timestamp, if not supplied the current system time is used
     * @param int|null $atime The access time as a Unix timestamp, if not supplied the current system time is used
     *
     * @throws IOException When touch fails
     *
     * @return void
     */
    public static function touch($files, $time = NULL, $atime = NULL)
    {
        return self::_sym()->touch($files, $time, $atime);
    }

    /**
     * Removes files or directories.
     *
     * @throws IOException When removal fails
     *
     * @return void
     */
    public static function remove($files)
    {
        return self::_sym()->remove($files);
    }

    /**
     * Change mode for an array of files or directories.
     *
     * @param int  $mode      The new mode (octal)
     * @param int  $umask     The mode mask (octal)
     * @param bool $recursive Whether change the mod recursively or not
     *
     * @throws IOException When the change fails
     *
     * @return void
     */
    public static function chmod($files, $mode, $umask = 0, $recursive = FALSE)
    {
        return self::_sym()->chmod($files, $mode, $umask, $recursive);
    }

    /**
     * Change the owner of an array of files or directories.
     *
     * @param string|int $user      A user name or number
     * @param bool       $recursive Whether change the owner recursively or not
     *
     * @throws IOException When the change fails
     *
     * @return void
     */
    public static function chown($files, $user, $recursive = FALSE)
    {
        return self::_sym()->chown($files, $user, $recursive);
    }

    /**
     * Change the group of an array of files or directories.
     *
     * @param string|int $group     A group name or number
     * @param bool       $recursive Whether change the group recursively or not
     *
     * @throws IOException When the change fails
     *
     * @return void
     */
    public static function chgrp($files, $group, $recursive = FALSE)
    {
        return self::_sym()->chgrp($files, $group, $recursive);
    }

    /**
     * Renames a file or a directory.
     *
     * @throws IOException When target file or directory already exists
     * @throws IOException When origin cannot be renamed
     *
     * @return void
     */
    public static function rename($origin, $target, $overwrite = FALSE)
    {
        return self::_sym()->rename($origin, $target, $overwrite);
    }

    /**
     * Creates a symbolic link or copy a directory.
     *
     * @throws IOException When symlink fails
     *
     * @return void
     */
    public static function symlink($originDir, $targetDir, $copyOnWindows = FALSE)
    {
        return self::_sym()->symlink($originDir, $targetDir, $copyOnWindows);
    }

    /**
     * Creates a hard link, or several hard links to a file.
     *
     * @param string|string[] $targetFiles The target file(s)
     *
     * @throws FileNotFoundException When original file is missing or not a file
     * @throws IOException           When link fails, including if link already exists
     *
     * @return void
     */
    public static function hardlink($originFile, $targetFiles)
    {
        return self::_sym()->hardlink($originFile, $targetFiles);
    }

    /**
     * Resolves links in paths.
     *
     * With $canonicalize = false (default)
     *      - if $path does not exist or is not a link, returns null
     *      - if $path is a link, returns the next direct target of the link without considering the existence of the target
     *
     * With $canonicalize = true
     *      - if $path does not exist, returns null
     *      - if $path exists, returns its absolute fully resolved final version
     */
    public static function readlink($path, $canonicalize = FALSE)
    {
        self::_sym()->readlink($path, $canonicalize);
    }

    /**
     * Given an existing path, convert it to a path relative to a given starting path.
     */
    public static function makePathRelative($endPath, $startPath)
    {
        self::_sym()->makePathRelative($endPath, $startPath);
    }

    /**
     * Mirrors a directory to another.
     *
     * Copies files and directories from the origin directory into the target directory. By default:
     *
     *  - existing files in the target directory will be overwritten, except if they are newer (see the `override` option)
     *  - files in the target directory that do not exist in the source directory will not be deleted (see the `delete` option)
     *
     * @param \Traversable|null $iterator Iterator that filters which files and directories to copy, if null a recursive iterator is created
     * @param array             $options  An array of boolean options
     *                                    Valid options are:
     *                                    - $options['override'] If true, target files newer than origin files are overwritten (see copy(), defaults to false)
     *                                    - $options['copy_on_windows'] Whether to copy files instead of links on Windows (see symlink(), defaults to false)
     *                                    - $options['delete'] Whether to delete files that are not in the source directory (defaults to false)
     *
     * @throws IOException When file type is unknown
     *
     * @return void
     */
    public static function mirror($originDir, $targetDir, $iterator = NULL, $options = [])
    {
        return self::_sym()->mirror($originDir, $targetDir, $iterator, $options);
    }

    /**
     * Returns whether the file path is an absolute path.
     */
    public static function isAbsolutePath($file)
    {
        self::_sym()->isAbsolutePath($file);
    }

    /**
     * Creates a temporary file with support for custom stream wrappers.
     *
     * @param string $prefix The prefix of the generated temporary filename
     *                       Note: Windows uses only the first three characters of prefix
     * @param string $suffix The suffix of the generated temporary filename
     *
     * @return string The new temporary filename (with path), or throw an exception on failure
     */
    public static function tempnam($dir, $prefix, $suffix = '')
    {
        return self::_sym()->tempnam($dir, $prefix, $suffix);
    }

    /**
     * Atomically dumps content into a file.
     *
     * @param string|resource $content The data to write into the file
     *
     * @throws IOException if the file cannot be written to
     *
     * @return void
     */
    public static function dumpFile($filename, $content)
    {
        return self::_sym()->dumpFile($filename, $content);
    }

    /**
     * Appends content to an existing file.
     *
     * @param string|resource $content The content to append
     * @param bool            $lock    Whether the file should be locked when writing to it
     *
     * @throws IOException If the file is not writable
     *
     * @return void
     */
    public static function appendToFile($filename, $content)
    {
        return self::_sym()->appendToFile($filename, $content);
    }

    /**
     * Assert that we are properly executing within the context of a compilation task.
     *
     * If this script tries to run in any other context, then you will get some
     * kind of error (e.g. class not found or RuntimeException).
     */
    public static function assertTask()
    {
        self::_ccl()->assertTask();
    }

    /**
     * Array-map function. Similar to array_map(), but tuned to key-value pairs.
     *
     * Example:
     *   $data = [100 => 'apple', 200 => 'banana'];
     *   $opposite = mapkv($data, function($k, $v){ return [-1 * $k => strtoupper($v)]; });
     *
     * This would return [-100 => 'APPLE', -200 => 'BANANA']
     *
     * By convention, mapping functions should return an 1-row array "[newKey => newValue]".
     *
     * Some unconventional forms are also defined:
     *  - Return empty array ==> Skip/omit the row
     *  - Return multiple items ==> Add all items to the result
     *  - Return an unkeyed (numeric) array ==> Discard original keys. Items are appended numerically (`$arr[] = $value`).
     *
     * @param array $array
     *   Values to iterate over
     * @param callable $func
     *   Callback function.
     *   function(scalar $key, mixed $value): array
     * @return array
     *   The filtered array.
     */
    public static function mapkv($array, $func)
    {
        return self::_ccl()->mapkv($array, $func);
    }

    /**
     * Map file-names.
     *
     * @param string $matchPat
     *   Ex: 'src/*.json'
     * @param string $outPat
     *   Ex: 'dest/#1.json'
     * @param bool $flip
     *   The orientation of the result map.
     *   If false, returned as "original => filtered".
     *   If true, returned as "filtered => original".
     * @return array
     *   List of files and the corresponding names.
     */
    public static function globMap($matchPat, $outPat, $flip = FALSE)
    {
        return self::_ccl()->globMap($matchPat, $outPat, $flip);
    }

    public static function chdir($directory)
    {
        self::_ccl()->chdir($directory);
    }

    /**
     * @param string|string[] $pats
     *   List of glob patterns.
     * @param null|int $flags
     * @return array
     *   List of matching files.
     */
    public static function glob($pats, $flags = NULL)
    {
        return self::_ccl()->glob($pats, $flags);
    }

    /**
     * Read a set of files and concatenate the results
     *
     * @param string|string[] $srcs
     *   Files to read. These may be globs.
     * @param string $newLine
     *   Whether to ensure that joined files have a newline separator.
     *   Ex: 'raw' (as-is), 'auto' (add if missing)
     * @return string
     *   The result of joining the files.
     */
    public static function cat($srcs, $newLine = 'auto')
    {
        return self::_ccl()->cat($srcs, $newLine);
    }
}
__halt_compiler();----SIGNATURE:----RHydH7VgvIoVsDA84YB5BqQ/rgLceqlFxBo6hZHk9mZZJRGWmlAS/dahohlOkU5KGGytAwEcadSF9a5cQ8Drypuj9VB0/MIGYQdJUTAjXgsnMjdI6O1ET4HRcjbhoAvPOT6Bgm2vHvKtReax1SSfrnzNJrYM3YiyUvF4or9c4+IBWGcZsD/DOJooqPYQ6m10TNoNnsV233z/4cNkQfA7bW1SLJxxmUDLCtISsQ/eZ1a2nXuQskoOhmTiJ6gOuA3q5KruU8bB3r8p5dK6AmSPG0h58/8G5j/5w8E18NfFRRMuHrIp2bBpQ2pS4+N8Kl8tRRxdl7J3uhm6sEasogNSpPEVX6NeVh/AowNwQzSk0w0zF36yMO8OXgbj29rmR2bDiUdTFs1zFHwcbpO4wLERKBIBP0xJVfgowqAXGwx8oqPiBxxkKNVs6zeo3AYmDr2ukeE5HhEBao7LTiBKPifC77qSYbdxav/iRNZd07Rv+wz4A+rLzr46kQNNOq/+A2nzUeJ3ob12exNdaiYFuA/YlyGvnCgAp4oQ/egX6fgVP/0iuoD6mYvMPtj064gFdaWbBWzbmwQe90RGsHJkAbEEryxJge6N+d/MHeoJvN0cpqsE9q/ua6BHbI8VBUPItir6v05g3S0hMOUANi2AU/ABSagZ57P41iXjbJHrIX5Aqc4=----ATTACHMENT:----NTA0MDg3NjcyMjY0NzcxMyA1MTk2MjMwNjkyMDg0NDUzIDg2MzcyMDgxMDcwOTExMDE=