X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=inc%2Fclasses%2Fmain%2Fclass_BaseFrameworkSystem.php;h=8b6707dd2c7a282d62b8efa8b360fa5953811551;hb=2a73d3b2af7d916dfa771422ded7101912629e31;hp=0bd390928a913efcbcdedf2d8bd51c4e628172d9;hpb=e66d3ca35c4e5dd92c7f2e966d1386e970127114;p=core.git

diff --git a/inc/classes/main/class_BaseFrameworkSystem.php b/inc/classes/main/class_BaseFrameworkSystem.php
index 0bd39092..8b6707dd 100644
--- a/inc/classes/main/class_BaseFrameworkSystem.php
+++ b/inc/classes/main/class_BaseFrameworkSystem.php
@@ -23,6 +23,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
+	/**
+	 * Length of count
+	 */
+	const LENGTH_COUNT = 20;
+
+	/**
+	 * Length of position
+	 */
+	const LENGTH_POSITION = 20;
+
 	/**
 	 * The real class name
 	 */
@@ -178,6 +188,11 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
 	 */
 	private $pointerInstance = NULL;
 
+	/**
+	 * An instance of an index
+	 */
+	private $indexInstance = NULL;
+
 	/**
 	 * Thousands separator
 	 */
@@ -203,6 +218,41 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
 	 */
 	private $genericArray = array();
 
+	/**
+	 * Length of output from hash()
+	 */
+	private static $hashLength = NULL;
+
+	/**
+	 * Counter for total entries
+	 */
+	private $totalEntries = 0;
+
+	/**
+	 * Current seek position
+	 */
+	private $seekPosition = 0;
+
+	/**
+	 * Size of header
+	 */
+	private $headerSize = 0;
+
+	/**
+	 * File header
+	 */
+	private $header = array();
+
+	/**
+	 * Seek positions for gaps ("fragmentation")
+	 */
+	private $gaps = array();
+
+	/**
+	 * Seek positions for damaged entries (e.g. mismatching hash sum, ...)
+	 */
+	private $damagedEntries = array();
+
 	/***********************
 	 * Exception codes.... *
 	 ***********************/
@@ -462,7 +512,7 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
 		$this->debugBackTrace(sprintf('Tried to set a missing field. name=%s, value[%s]=%s',
 			$name,
 			gettype($value),
-			$value
+			print_r($value, TRUE)
 		));
 	}
 
@@ -1226,7 +1276,7 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
 	/**
 	 * Setter for InputOutputPointer instance
 	 *
-	 * @param	$pointerInstance	An instance of an InputOutputPointer
+	 * @param	$pointerInstance	An instance of an InputOutputPointer class
 	 * @return	void
 	 */
 	protected final function setPointerInstance (InputOutputPointer $pointerInstance) {
@@ -1236,12 +1286,31 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
 	/**
 	 * Getter for InputOutputPointer instance
 	 *
-	 * @return	$pointerInstance	An instance of an InputOutputPointer
+	 * @return	$pointerInstance	An instance of an InputOutputPointer class
 	 */
 	public final function getPointerInstance () {
 		return $this->pointerInstance;
 	}
 
+	/**
+	 * Setter for Indexable instance
+	 *
+	 * @param	$indexInstance	An instance of an Indexable class
+	 * @return	void
+	 */
+	protected final function setIndexInstance (Indexable $indexInstance) {
+		$this->indexInstance = $indexInstance;
+	}
+
+	/**
+	 * Getter for Indexable instance
+	 *
+	 * @return	$indexInstance	An instance of an Indexable class
+	 */
+	public final function getIndexInstance () {
+		return $this->indexInstance;
+	}
+
 	/**
 	 * Checks whether an object equals this object. You should overwrite this
 	 * method to implement own equality checks
@@ -2090,19 +2159,37 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
 	}
 
 	/**
-	 * Hashes a given string with a simple but stronger hash function (no salts)
+	 * Hashes a given string with a simple but stronger hash function (no salt)
+	 * and hex-encode it.
 	 *
 	 * @param	$str	The string to be hashed
 	 * @return	$hash	The hash from string $str
 	 */
-	public function hashString ($str) {
+	public static final function hash ($str) {
 		// Hash given string with (better secure) hasher
-		$hash = mhash(MHASH_SHA256, $str);
+		$hash = bin2hex(mhash(MHASH_SHA256, $str));
 
 		// Return it
 		return $hash;
 	}
 
+	/**
+	 * "Getter" for length of hash() output. This will be "cached" to speed up
+	 * things.
+	 *
+	 * @return	$length		Length of hash() output
+	 */
+	public static final function getHashLength () {
+		// Is it cashed?
+		if (is_null(self::$hashLength)) {
+			// No, then hash a string and save its length.
+			self::$hashLength = strlen(self::hash('abc123'));
+		} // END - if
+
+		// Return it
+		return self::$hashLength;
+	}
+
 	/**
 	 * Checks whether the given number is really a number (only chars 0-9).
 	 *
@@ -2755,6 +2842,328 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
 		// ... and return it
 		return $translated;
 	}
+
+	/**
+	 * Initializes counter for valid entries, arrays for damaged entries and
+	 * an array for gap seek positions. If you call this method on your own,
+	 * please re-analyze the file structure. So you are better to call
+	 * analyzeFile() instead of this method.
+	 *
+	 * @return	void
+	 */
+	protected function initCountersGapsArray () {
+		// Init counter and seek position
+		$this->setCounter(0);
+		$this->setSeekPosition(0);
+
+		// Init arrays
+		$this->gaps = array();
+		$this->damagedEntries = array();
+	}
+
+	/**
+	 * Getter for total entries
+	 *
+	 * @return	$totalEntries	Total entries in this file
+	 */
+	protected final function getCounter () {
+		// Get it
+		return $this->totalEntries;
+	}
+
+	/**
+	 * Setter for total entries
+	 *
+	 * @param	$totalEntries	Total entries in this file
+	 * @return	void
+	 */
+	protected final function setCounter ($counter) {
+		// Set it
+		$this->totalEntries = $counter;
+	}
+
+	/**
+	 * Increment counter
+	 *
+	 * @return	void
+	 */
+	protected final function incrementCounter () {
+		// Get it
+		$this->totalEntries++;
+	}
+
+	/**
+	 * Getter for header size
+	 *
+	 * @return	$totalEntries	Size of file header
+	 */
+	protected final function getHeaderSize () {
+		// Get it
+		return $this->headerSize;
+	}
+
+	/**
+	 * Setter for header size
+	 *
+	 * @param	$headerSize		Size of file header
+	 * @return	void
+	 */
+	protected final function setHeaderSize ($headerSize) {
+		// Set it
+		$this->headerSize = $headerSize;
+	}
+
+	/**
+	 * Getter for header array
+	 *
+	 * @return	$totalEntries	Size of file header
+	 */
+	protected final function getHeade () {
+		// Get it
+		return $this->header;
+	}
+
+	/**
+	 * Setter for header
+	 *
+	 * @param	$header		Array for a file header
+	 * @return	void
+	 */
+	protected final function setHeader (array $header) {
+		// Set it
+		$this->header = $header;
+	}
+
+	/**
+	 * Getter for seek position
+	 *
+	 * @return	$seekPosition	Current seek position (stored here in object)
+	 */
+	protected final function getSeekPosition () {
+		// Get it
+		return $this->seekPosition;
+	}
+
+	/**
+	 * Setter for seek position
+	 *
+	 * @param	$seekPosition	Current seek position (stored here in object)
+	 * @return	void
+	 */
+	protected final function setSeekPosition ($seekPosition) {
+		// And set it
+		$this->seekPosition = $seekPosition;
+	}
+
+	/**
+	 * Updates seekPosition attribute from file to avoid to much access on file.
+	 *
+	 * @return	void
+	 */
+	protected function updateSeekPosition () {
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+		// Get key (= seek position)
+		$seekPosition = $this->getIteratorInstance()->key();
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Setting seekPosition=%s', __METHOD__, __LINE__, $seekPosition));
+
+		// And set it here
+		$this->setSeekPosition($seekPosition);
+
+		//* 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
+	 */
+	protected function isFileHeaderInitialized () {
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+		// Is the method there?
+		assert(is_callable(array($this, 'readFileHeader')));
+
+		// 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;
+	}
+
+	/**
+	 * Checks whether the assigned file has been initialized
+	 *
+	 * @return	$isInitialized		Whether the file's size is zero
+	 */
+	protected function isFileInitialized () {
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+		// Get it from iterator which holds the pointer instance. If FALSE is returned
+		$fileSize = $this->getIteratorInstance()->size();
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] fileSize=%s', __METHOD__, __LINE__, $fileSize));
+
+		/*
+		 * The returned file size should not be FALSE or NULL as this means
+		 * that the pointer class does not work correctly.
+		 */
+		assert(is_int($fileSize));
+
+		// Is more than 0 returned?
+		$isInitialized = ($fileSize > 0);
+
+		// Return result
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] isInitialized=%d - EXIT!', __METHOD__, __LINE__, intval($isInitialized)));
+		return $isInitialized;
+	}
+
+	/**
+	 * Creates the assigned file
+	 *
+	 * @return	void
+	 */
+	protected function createFileHeader () {
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+		// The method flushFileHeader() must be callable
+		assert(is_callable(array($this, 'flushFileHeader')));
+
+		// The file's header should not be initialized here
+		assert(!$this->isFileHeaderInitialized());
+
+		// Simple flush file header which will create it.
+		$this->flushFileHeader();
+
+		// Rewind seek position (to beginning of file) and update/flush file header
+		$this->rewineUpdateSeekPosition();
+
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!!', __METHOD__, __LINE__));
+	}
+
+	/**
+	 * Seeks to beginning of file, updates seek position in this object and
+	 * flushes the header.
+	 *
+	 * @return	void
+	 */
+	protected function rewineUpdateSeekPosition () {
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+		// Seek to beginning of file
+		$this->getIteratorInstance()->rewind();
+
+		// And update seek position ...
+		$this->updateSeekPosition();
+
+		// ... to write it back into the file
+		$this->flushFileHeader();
+
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!!', __METHOD__, __LINE__));
+	}
+
+	/**
+	 * Seeks to old position
+	 *
+	 * @return	void
+	 */
+	protected function seekToOldPosition () {
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+		// Seek to currently ("old") saved position
+		$this->getIteratorInstance()->seek($this->getSeekPosition());
+
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!!', __METHOD__, __LINE__));
+	}
+
+	/**
+	 * Writes data at given position
+	 *
+	 * @param	$seekPosition	Seek position
+	 * @param	$data			Data to be written
+	 * @param	$flushHeader	Whether to flush the header (default: flush)
+	 * @return	void
+	 */
+	protected function writeData ($seekPosition, $data, $flushHeader = TRUE) {
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] seekPosition=%s,data()=%s - CALLED!', __METHOD__, __LINE__, $seekPosition, strlen($data)));
+
+		// Write data at given position
+		$this->getIteratorInstance()->writeAtPosition($seekPosition, $data);
+
+		// Update seek position
+		$this->updateSeekPosition();
+
+		// Flush the header?
+		if ($flushHeader === TRUE) {
+			// Flush header
+			$this->flushFileHeader();
+
+			// Seek to old position
+			$this->seekToOldPosition();
+		} // END - if
+
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!', __METHOD__, __LINE__));
+	}
+
+	/**
+	 * Pre-allocates file (if enabled) with some space for later faster write access.
+	 *
+	 * @param	$type	Type of the file
+	 * @return	void
+	 */
+	protected function preAllocateFile ($type) {
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] CALLED!', __METHOD__, __LINE__));
+
+		// caluclateMinimumFileEntryLength() must be callable
+		assert(is_callable(array($this, 'caluclateMinimumFileEntryLength')));
+
+		// Is it enabled?
+		if ($this->getConfigInstance()->getConfigEntry($type . '_pre_allocate_enabled') != 'Y') {
+			// Not enabled
+			self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Not pre-allocating file.', __METHOD__, __LINE__));
+
+			// Don't continue here.
+			return;
+		} // END - if
+
+		// Message to user
+		self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] Pre-allocating file ...', __METHOD__, __LINE__));
+
+		// Calculate minimum length for one entry
+		$minLengthEntry = $this->caluclateMinimumFileEntryLength();
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] minLengthEntry=%s', __METHOD__, __LINE__, $minLengthEntry));
+
+		// Calulcate seek position
+		$seekPosition = $minLengthEntry * $this->getConfigInstance()->getConfigEntry($type . '_pre_allocate_count');
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] seekPosition=%s', __METHOD__, __LINE__, $seekPosition));
+
+		// Now simply write a NUL there. This will pre-allocate the file.
+		$this->writeData($seekPosition, chr(0));
+
+		// Rewind seek position (to beginning of file) and update/flush file header
+		$this->rewineUpdateSeekPosition();
+
+		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!', __METHOD__, __LINE__));
+	}
 }
 
 // [EOF]