Create recurisve dir.

@param mixed $value recursive status true|false.

@since 3.0.0

@return bool
428473
public function recursiveCreateDir($value = null)
    {
        return ($value === null) ? $this->recursiveDirectories : $this->recursiveDirectories = $value;
    }
1301055
public function createPlaceholder($value)
    {
        if (($key = array_search($value, $this->all()))) {
            $placeholder = $key;
        } else {
            $placeholder = $this->createUniquePlaceholder();
        }

        $value = $this->removeNestedPlaceholders($value);
        $this->items[$placeholder] = $value;

        return $placeholder;
    }
1327877
public static function mkdirs($dir, $mode = 0777, $recursive = true)
    {
        if (($dir === null) || $dir === '') {
            return false;
        }
        if (is_dir($dir) || $dir === '/') {
            return true;
        }
        if (self::mkdirs(dirname($dir), $mode, $recursive)) {
            return mkdir($dir, $mode);
        }
        return false;
    }
271815
public static function create($path, $mode = 0775, $recursive = true): bool
    {
        return (is_dir($path) || !(!@mkdir($path, $mode, $recursive) && !is_dir($path))) && is_writable($path);
    }
1109516
protected function makeCollection($value)
    {
        if ($value instanceof Collection) {
            return $value->getName();
        }
        if ($value instanceof Document) {
            return $value->getCollectionId();
        }

        return $value;
    }
504571
public function path($value = false, $overwrite = false)
    {
        if ($value === false) {
            return $this->path;
        }

        $oldPath = $this->path;

        if (!$overwrite && $this->adapter->fileExists($value)) {
            throw new FilesystemException("Cannot rename the file '{$this->path}' to '{$value}' because a file already exists");
        }

        (new static($value, $this->adapter))->remove();

        if (! $this->adapter->rename($this->path, $value)) {
            throw new FilesystemException("Cannot rename the file '{$this->path}' to '{$value}'");
        }

        $this->path = $value;
        $this->fs = null;
        $this->pathChanged($oldPath);

        return $this;
    }
590405
public static function create($value)
    {
        $class = static::class;
        if (!array_key_exists($class, self::$instances)) {
            self::$instances[$class] = [];
        }
        if (!array_key_exists($value, self::$instances[$class])) {
            self::$instances[$class][$value] = new static($value);
        }

        return self::$instances[$class][$value];
    }
191899
public function put($value)
    {

        if ($this->redis->lPush($this->channel, $value) !== false) {
            return true;
        }

        return false;
    }
373961
public function fs($value = null)
    {
        if (null === $value) {
            return $this->fs;
        }
        if (is_string($value))
            $value = new Filesystem($value);
        $this->fs = $value;
        foreach ($this->commands as $name => $command) {
            $command->fs = $value;
        }
        return $this;
    }
122986
protected function at($path, $value = false)
    {
        $path = $this->realpath($path);

        if (false === $value) {
            if (isset($this->files[$path]))
                return $this->files[$path];
            else
                return null;
        }

        if (null === $value) {
            unset($this->files[$path]);
            return $this;
        }

        $this->files[$path] = (object) $value;
        return $this;
    }
899333
public static function create($value)
    {
        if ($value instanceof \Exception) {
            return new Failure($value);
        }
        try {
            if ($value instanceof \Closure) {
                //test to ensure function doesn't throw exception or is an Exception
                $potentialException = $value();
                if ($potentialException instanceof \Exception) {
                    return new Failure($potentialException);
                }
            } elseif ($value instanceof Monadic) {
                return static::create($value->flatten());
            }

            return new Success($value);

        } catch (\Exception $e) {
            return new Failure($e);
        }
    }
565633
public function createReference($value)
    {
        $ref = $this->generateNextReference();
        $this->references[$ref] = $value;

        return $ref;
    }
804045
protected function deep_clone($value) {
        if (is_object($value)) {
            // Objects must be cloned to begin with.
            $value = clone $value;
        }
        if (is_array($value) || is_object($value)) {
            foreach ($value as $key => $subvalue) {
                $value[$key] = $this->deep_clone($subvalue);
            }
        }
        return $value;
    }
239413
public function createDirectory($directory, $chmod = null, $recurisve = true)
    {
        $chmod     = $chmod ?: $this->chmod;
        $directory = sprintf('%s/%s', $this->rootDir, trim($directory, '/'));

        if (!$this->fileSystem->exists($directory)) {
            try {
                $this->fileSystem->mkdir($directory);
            } catch (FsIOException $e) {
                throw new IOException($e->getMessage(), $e->getCode(), $e);
            }
        }

        return true;
    }
251236
public static function createDirectoryRecursively($dir)
    {
        if (DIRECTORY_SEPARATOR === "\\") {
            $dir = str_replace("/", "\\", $dir);
        }
        else if (DIRECTORY_SEPARATOR === "/") {
            $dir = str_replace("\\", "/", $dir);
        }

        $_config =& CKFinder_Connector_Core_Factory::getInstance("Core_Config");
        if ($perms = $_config->getChmodFolders()) {
            $oldUmask = umask(0);
            $bCreated = @mkdir($dir, $perms, true);
            umask($oldUmask);
        }
        else {
            $bCreated = @mkdir($dir, 0777, true);
        }

        return $bCreated;
    }
573205
public static function fromValue( $value )
	{
		$result = new ContextProvider();
		$result->m_iter = XPath2NodeIterator::Create( $value );
		return $result;
	}
668206
public function serialize($value)
    {
        $this->recursiveSetValues($value);
        $this->recursiveUnset($value, [Serializer::CLASS_IDENTIFIER_KEY]);
        $this->recursiveFlattenOneElementObjectsToScalarType($value);

        return $value;
    }