class_FileIoStream.php

Go to the documentation of this file.

<?php
class FileIoStream extends BaseFrameworkSystem implements FileInputStreamer, FileOutputStreamer {
        protected function __construct () {
                // Call parent constructor
                parent::__construct(__CLASS__);

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

        public final static function createFileIoStream () {
                // Create new instance
                $ioInstance = new FileIoStream();

                // Return the instance
                return $ioInstance;
        }

        public final function saveFile ($fileName, $dataArray) {
                // Try it five times
                $dirName = ""; $fileInstance = null;
                for ($idx = 0; $idx < 5; $idx++) {
                        // Get a file output pointer
                        try {
                                $fileInstance = FrameworkFileOutputPointer::createFrameworkFileOutputPointer($fileName, 'w');
                        } catch (FilePointerNotOpenedException $e) {
                                // Create missing directory
                                $dirName = dirname($fileName);
                                for ($idx2 = 0; $idx2 < (2 - $idx); $idx2++) {
                                        $dirName = dirname($dirName);
                                }
                                // Try to create it
                                @mkdir($dirName);
                        }
                }

                // Write a header information for validation purposes
                $fileInstance->writeToFile(sprintf("@head^%s:%s:%s:%s\n",
                        $dataArray[0],
                        time(),
                        strlen($dataArray[1]),
                        md5($dataArray[1])
                ));

                // Encode the (maybe) binary stream with Base64
                $b64Stream = base64_encode($dataArray[1]);

                // write the data line by line
                $line = str_repeat(" ", 50); $idx = 0;
                while (strlen($line) == 50) {
                        // Get 50 chars or less
                        $line = substr($b64Stream, $idx, 50);

                        // Save it to the stream
                        $fileInstance->writeToFile(sprintf("@data^%s:%s\n",
                                $line,
                                md5($line)
                        ));

                        // Advance to the next 50-chars block
                        $idx += 50;
                }

                // Close the file
                $fileInstance->closeFile();
        }

        public final function loadFileContents ($fqfn) {
                // Initialize some variables and arrays
                $inputBuffer = "";
                $lastBuffer = "";
                $header = array();
                $data = array();
                $readData = ""; // This will contain our read data

                // Get a file input handler
                $fileInstance = FrameworkFileInputPointer::createFrameworkFileInputPointer($fqfn);

                // Read all it's contents (we very and transparently decompress it below)
                while ($readRawLine = $fileInstance->readFromFile()) {
                        // Add the read line to the buffer
                        $inputBuffer .= $readRawLine;

                        // Break infinite loop maybe caused by the input handler
                        if ($lastBuffer == $inputBuffer) break;

                        // Remember last read line for avoiding possible infinite loops
                        $lastBuffer = $inputBuffer;
                }

                // Close directory handle
                $fileInstance->closeFile();

                // Convert it into an array
                $inputBuffer = explode("\n", $inputBuffer);

                // Now process the read lines and verify it's content
                foreach ($inputBuffer as $rawLine) {
                        // Trim it a little but not the leading spaces/tab-stops
                        $rawLine = rtrim($rawLine);

                        // Analyze this line
                        if (substr($rawLine, 0, 5) == "@head") {
                                // Header found, so let's extract it
                                $header = explode("^", $rawLine);
                                $header = trim($header[1]);

                                // Now we must convert it again into an array
                                $header = explode(":", $header);

                                // Is the header (maybe) valid?
                                if (count($header) != 4) {
                                        // Throw an exception
                                        throw new InvalidArrayCountException(array($this, 'header', count($header), 4), self::EXCEPTION_ARRAY_HAS_INVALID_COUNT);
                                }
                        } elseif (substr($rawLine, 0, 5) == "@data") {
                                // Is a data line!
                                $data = explode("^", $rawLine);
                                $data = $data[1];

                                // First element is the data, second the MD5 checksum
                                $data = explode(":", $data);

                                // Validate the read line
                                if (count($data) == 2) {
                                        if (md5($data[0]) != $data[1]) {
                                                // MD5 hash did not match!
                                                throw new InvalidMD5ChecksumException(array($this, md5($data[0]), $data[1]), self::EXCEPTION_MD5_CHECKSUMS_MISMATCH);
                                        }
                                } else {
                                        // Invalid count!
                                        throw new InvalidArrayCountException(array($this, "data", count($data), 2), self::EXCEPTION_ARRAY_HAS_INVALID_COUNT);
                                }

                                // Add this to the readData string
                                $readData .= $data[0];
                        } else {
                                // Other raw lines than header/data tagged lines and re-add the new-line char
                                $readData .= $rawLine."\n";
                        }
                }

                // Was raw lines read and no header/data?
                if ((!empty($readData)) && (count($header) == 0) && (count($data) == 0)) {
                        // Return raw lines back
                        return $readData;
                }

                // Was a header found?
                if (count($header) != 4) {
                        // Throw an exception
                        throw new InvalidArrayCountException(array($this, 'header', count($header), 4), self::EXCEPTION_ARRAY_HAS_INVALID_COUNT);
                }

                // Decode all from Base64
                $readData = @base64_decode($readData);

                // Does the size match?
                if (strlen($readData) != $header[2]) {
                        // Size did not match
                        throw new InvalidDataLengthException(array($this, strlen($readData), $header[2]), self::EXCEPTION_UNEXPECTED_STRING_SIZE);
                }

                // Validate the decoded data with the final MD5 hash
                if (md5($readData) != $header[3]) {
                        // MD5 hash did not match!
                        throw new InvalidMD5ChecksumException(array($this, md5($readData), $header[3]), self::EXCEPTION_MD5_CHECKSUMS_MISMATCH);
                }

                // Return all in an array
                return array(
                        'header' => $header,
                        'data'   => $readData
                );
        }
}

// [EOF]
?>