Could generalize ("generic") more code which avoid some duplicate fields and methods...
[core.git] / inc / classes / main / index / class_BaseIndex.php
index 9d01952..046ec73 100644 (file)
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 class BaseIndex extends BaseFrameworkSystem {
+       /**
+        * Magic for this index
+        */
+       const INDEX_MAGIC = 'INDEXv0.1';
+
+       /**
+        * Separator for header data
+        */
+       const SEPARATOR_HEADER_DATA = 0x01;
+
+       /**
+        * Separator header->entries
+        */
+       const SEPARATOR_HEADER_ENTRIES = 0x02;
+
        /**
         * Protected constructor
         *
@@ -31,16 +46,185 @@ class BaseIndex extends BaseFrameworkSystem {
        protected function __construct ($className) {
                // Call parent constructor
                parent::__construct($className);
+
+               // Calculate header size
+               $this->setHeaderSize(
+                       strlen(self::INDEX_MAGIC) +
+                       strlen(self::SEPARATOR_HEADER_DATA) +
+                       self::LENGTH_COUNT +
+                       strlen(self::SEPARATOR_HEADER_ENTRIES)
+               );
        }
 
        /**
-        * Initializes this file based index
+        * Reads the file header
         *
-        * @param       $fileName       Name of the file to create an index for
+        * @return      void
+        */
+       private function readFileHeader () {
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+               // First rewind to beginning as the header sits at the beginning ...
+               $this->getIteratorInstance()->rewind();
+
+               // Then read it (see constructor for calculation)
+               $data = $this->getIteratorInstance()->read($this->headerSize);
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Read %d bytes (%d wanted).', __METHOD__, __LINE__, strlen($data), $this->headerSize));
+
+               // Have all requested bytes been read?
+               assert(strlen($data) == $this->headerSize);
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Passed assert().', __METHOD__, __LINE__));
+
+               // Last character must be the separator
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] data(-1)=%s', __METHOD__, __LINE__, dechex(ord(substr($data, -1, 1)))));
+               assert(substr($data, -1, 1) == chr(self::SEPARATOR_HEADER_ENTRIES));
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Passed assert().', __METHOD__, __LINE__));
+
+               // Okay, then remove it
+               $data = substr($data, 0, -1);
+
+               // And update seek position
+               $this->updateSeekPosition();
+
+               /*
+                * Now split it:
+                *
+                * 0 => magic
+                * 1 => total entries
+                */
+               $this->header = explode(chr(self::SEPARATOR_HEADER_DATA), $data);
+
+               // Check if the array has only 3 elements
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] header(%d)=%s', __METHOD__, __LINE__, count($this->header), print_r($this->header, TRUE)));
+               assert(count($this->header) == 2);
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Passed assert().', __METHOD__, __LINE__));
+
+               // Check magic
+               assert($this->header[0] == self::INDEX_MAGIC);
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Passed assert().', __METHOD__, __LINE__));
+
+               // Check length of count
+               assert(strlen($this->header[1]) == self::LENGTH_COUNT);
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Passed assert().', __METHOD__, __LINE__));
+
+               // Decode count
+               $this->header[1] = hex2bin($this->header[1]);
+
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!', __METHOD__, __LINE__));
+       }
+
+       /**
+        * Checks whether the file header is initialized
+        *
+        * @return      $isInitialized  Whether the file header is initialized
+        */
+       private function isFileHeaderInitialized () {
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+               // Default is not initialized
+               $isInitialized = FALSE;
+
+               // Is the file initialized?
+               if ($this->isFileInitialized()) {
+                       // Some bytes has been written, so rewind to start of it.
+                       $rewindStatus = $this->getIteratorInstance()->rewind();
+                       //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] rewindStatus=%s', __METHOD__, __LINE__, $rewindStatus));
+
+                       // Is the rewind() call successfull?
+                       if ($rewindStatus != 1) {
+                               // Something bad happened
+                               self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Could not rewind().', __METHOD__, __LINE__));
+                       } // END - if
+
+                       // Read file header
+                       $this->readFileHeader();
+
+                       // The above method does already check the header
+                       $isInitialized = TRUE;
+               } // END - if
+
+               // Return result
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] isInitialized=%d - EXIT!', __METHOD__, __LINE__, intval($isInitialized)));
+               return $isInitialized;
+       }
+
+       /**
+        * Flushes the file header
+        *
+        * @return      void
+        */
+       private function flushFileHeader () {
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+               // Put all informations together
+               $header = sprintf('%s%s',
+                       // Magic
+                       self::INDEX_MAGIC,
+
+                       // Separator position<->entries
+                       chr(self::SEPARATOR_HEADER_ENTRIES)
+               );
+
+               // Write it to disk (header is always at seek position 0)
+               $this->writeData(0, $header);
+
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!', __METHOD__, __LINE__));
+       }
+
+       /**
+        * Analyzes entries in index file. This will count all found (and valid)
+        * entries, mark invalid as damaged and count gaps ("fragmentation"). If
+        * only gaps are found, the file is considered as "virgin" (no entries).
+        *
+        * @return      void
+        */
+       private function analyzeFile () {
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+               // Make sure the file is initialized
+               assert($this->isFileInitialized());
+
+               // Init counters and gaps array
+               $this->initGapsArray();
+
+               // Output message (as this may take some time)
+               self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Analyzing file structure ... (this may take some time)', __METHOD__, __LINE__));
+
+               //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!', __METHOD__, __LINE__));
+       }
+
+       /**
+        * Initializes this index
+        *
+        * @param       $fileName       File name of this index
         * @return      void
         */
        protected function initIndex ($fileName) {
-               // @TODO
+               // Get a file i/o pointer instance for index file
+               $pointerInstance = ObjectFactory::createObjectByConfiguredName('file_raw_input_output_class', array($fileName));
+
+               // Get iterator instance
+               $iteratorInstance = ObjectFactory::createObjectByConfiguredName('file_io_iterator_class', array($pointerInstance));
+
+               // Is the instance implementing the right interface?
+               assert($iteratorInstance instanceof SeekableWritableFileIterator);
+
+               // Set iterator here
+               $this->setIteratorInstance($iteratorInstance);
+
+               // Is the file's header initialized?
+               if (!$this->isFileHeaderInitialized()) {
+                       // No, then create it (which may pre-allocate the index)
+                       $this->createFileHeader();
+
+                       // And pre-allocate a bit
+                       $this->preAllocateFile('index');
+               } // END - if
+
+               // Load the file header
+               $this->readFileHeader();
+
+               // Count all entries in file
+               $this->analyzeFile();
        }
 }