class_FrameworkDirectoryPointer.php

Go to the documentation of this file.

<?php
class FrameworkDirectoryPointer extends BaseFrameworkSystem {
        private $pathName = "";

        private $dirPointer = null;

        protected function __construct () {
                // Call parent constructor
                parent::__construct(__CLASS__);

                // Clean-up a little
                $this->removeNumberFormaters();
                $this->removeSystemArray();
        }

        public function __destruct() {
                // Is there a resource pointer? Then we have to close the directory here!
                if (is_resource($this->getPointer())) {
                        // Try to close a directory
                        $this->closeDirectory();
                }

                // Call the parent destructor
                parent::__destruct();
        }

        public final static function createFrameworkDirectoryPointer ($pathName, $inConstructor = false) {
                // Some pre-sanity checks...
                if (is_null($pathName)) {
                        // No pathname given
                        if ($inConstructor) {
                                return null;
                        } else {
                                throw new PathIsEmptyException(null, self::EXCEPTION_UNEXPECTED_EMPTY_STRING);
                        }
                } elseif (!is_string($pathName)) {
                        // Is not a string
                        if ($inConstructor) {
                                return null;
                        } else {
                                throw new InvalidPathStringException(null, self::EXCEPTION_INVALID_STRING);
                        }
                } elseif (!is_dir($pathName)) {
                        // Not a directory
                        if ($inConstructor) {
                                return null;
                        } else {
                                throw new PathIsNoDirectoryException($pathName, self::EXCEPTION_INVALID_PATH_NAME);
                        }
                } elseif (!is_readable($pathName)) {
                        // Not readable
                        if ($inConstructor) {
                                return null;
                        } else {
                                throw new PathReadProtectedException($pathName, self::EXCEPTION_READ_PROTECED_PATH);
                        }
                }

                // Try to open a handler
                $dirPointer = @opendir($pathName);
                if (!is_resource($dirPointer)) {
                        // Something bad happend
                        if ($inConstructor) {
                                return null;
                        } else {
                                throw new DirPointerNotOpenedException($pathName, self::EXCEPTION_DIR_POINTER_INVALID);
                        }
                }

                // Create new instance
                $pointerInstance = new FrameworkDirectoryPointer();

                // Set directory pointer and path name
                $pointerInstance->setPointer($dirPointer);
                $pointerInstance->setPathName($pathName);

                // Return the instance
                return $pointerInstance;
        }

        public function readRawDirectory () {
                // Read data from the directory pointer and return it
                return readdir($this->getPointer());
        }

        public function readDirectoryExcept ($except = "") {
                if ((empty($except)) || (!is_array($except)) || (count($except) == 0)) {
                        // No exception given, so read all data
                        return $this->readRawDirectory();
                }

                // Read a raw line...
                $rawLine = $this->readRawDirectory();

                // Shall we exclude directories?
                if ((!is_null($rawLine)) && ($rawLine !== false) && (in_array($rawLine, $except))) {
                        // Exclude this part
                        return $this->readDirectoryExcept($except);
                } elseif ((!is_null($rawLine)) && ($rawLine !== false)) {
                        // Return read data
                        return $rawLine;
                }

                // End pointer reached
                return null;
        }

        public function closeDirectory () {
                // Close the directory pointer and reset the instance variable
                @closedir($this->getPointer());
                $this->setPointer(null);
                $this->setPathName("");
        }

        public final function setPointer ($dirPointer) {
                // Sanity-check if pointer is a valid directory resource
                if (is_resource($dirPointer) || is_null($dirPointer)) {
                        // Is a valid resource
                        $this->dirPointer = $dirPointer;
                } else {
                        // Throw exception
                        throw new InvalidDirectoryResourceException($this, self::EXCEPTION_INVALID_DIRECTORY_POINTER);
                }
        }

        public final function getPointer () {
                return $this->dirPointer;
        }

        public final function setPathName ($pathName) {
                $pathName = (string) $pathName;
                $this->pathName = $pathName;
        }

        public final function getPathName () {
                return $this->pathName;
        }
}

// [EOF]
?>