*/
private $header = array();
+ /**
+ * Seek positions for gaps ("fragmentation")
+ */
+ private $gaps = array();
+
+ /**
+ * Seek positions for damaged entries (e.g. mismatching hash sum, ...)
+ */
+ private $damagedEntries = array();
+
/**
* Protected constructor
*
self::LENGTH_POSITION +
strlen(self::SEPARATOR_HEADER_ENTRIES)
);
+
+ // Init counters and gaps array
+ $this->initCountersGapsArray();
+ }
+
+ /**
+ * 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
+ * analyzeStackFile() instead of this method.
+ *
+ * @return void
+ */
+ private function initCountersGapsArray () {
+ // Init counter and seek position
+ $this->setCounter(0);
+ $this->setSeekPosition(0);
+
+ // Init arrays
+ $this->gaps = array();
+ $this->damagedEntries = array();
}
/**
*
* @return $totalEntries Total entries in this stack
*/
- private function getCounter () {
+ private final function getCounter () {
// Get it
return $this->totalEntries;
}
*
* @return void
*/
- private function incrementCounter () {
+ private final function incrementCounter () {
// Get it
$this->totalEntries++;
}
*
* @return $seekPosition Current seek position (stored here in object)
*/
- private function getSeekPosition () {
+ private final function getSeekPosition () {
// Get it
return $this->seekPosition;
}
* @param $seekPosition Current seek position (stored here in object)
* @return void
*/
- private function setSeekPosition ($seekPosition) {
+ private final function setSeekPosition ($seekPosition) {
// And set it
$this->seekPosition = $seekPosition;
}
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput(sprintf('[%s:%d:] EXIT!', __METHOD__, __LINE__));
}
+ /**
+ * Analyzes entries in stack 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 analyzeStackFile () {
+ //* 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->initCountersGapsArray();
+
+ // 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 file-based stack.
*
* @param $fileName File name of this stack
+ * @param $type Type of this stack (e.g. url_source for URL sources)
* @return void
*/
- protected function initFileStack ($fileName) {
- // Get a file i/o pointer instance
+ protected function initFileStack ($fileName, $type) {
+ // Get a file i/o pointer instance for stack file
$pointerInstance = ObjectFactory::createObjectByConfiguredName('file_raw_input_output_class', array($fileName));
// Get iterator instance
// Load the file header
$this->readFileHeader();
+
+ // Count all entries in file
+ $this->analyzeStackFile();
+
+ /*
+ * Get stack index instance. This can be used for faster
+ * "defragmentation" and startup.
+ */
+ $indexInstance = FileStackIndexFactory::createFileStackIndexInstance($fileName, $type);
+
+ // And set it here
+ $this->setIndexInstance($indexInstance);
}
/**
* @param $stackerName Name of the stack
* @param $value Value to add to this stacker
* @return void
+ * @throws FullStackerException If the stack is full
*/
protected function addValue ($stackerName, $value) {
- } elseif ($this->isStackFull($stackerName)) {
+ // Do some tests
+ if ($this->isStackFull($stackerName)) {
// Stacker is full
throw new FullStackerException(array($this, $stackerName, $value), self::EXCEPTION_STACKER_IS_FULL);
- }
+ } // END - if
// Now add the value to the stack
$this->partialStub('stackerName=' . $stackerName . ',value[]=' . gettype($value));
*
* @param $stackerName Name of the stack
* @return $value Value of last added value
+ * @throws EmptyStackerException If the stack is empty
*/
protected function getLastValue ($stackerName) {
// Is the stack not yet initialized or full?
- } elseif ($this->isStackEmpty($stackerName)) {
+ if ($this->isStackEmpty($stackerName)) {
// Throw an exception
throw new EmptyStackerException(array($this, $stackerName), self::EXCEPTION_STACKER_IS_EMPTY);
- }
+ } // END - if
// Now get the last value
$this->partialStub('stackerName=' . $stackerName);
*
* @param $stackerName Name of the stack
* @return $value Value of last added value
+ * @throws EmptyStackerException If the stack is empty
*/
protected function getFirstValue ($stackerName) {
// Is the stack not yet initialized or full?
- } elseif ($this->isStackEmpty($stackerName)) {
+ if ($this->isStackEmpty($stackerName)) {
// Throw an exception
throw new EmptyStackerException(array($this, $stackerName), self::EXCEPTION_STACKER_IS_EMPTY);
- }
+ } // END - if
// Now get the first value
$this->partialStub('stackerName=' . $stackerName);
*
* @param $stackerName Name of the stack
* @return $value Value "poped" from array
+ * @throws EmptyStackerException If the stack is empty
*/
protected function popLast ($stackerName) {
// Is the stack not yet initialized or full?
- } elseif ($this->isStackEmpty($stackerName)) {
+ if ($this->isStackEmpty($stackerName)) {
// Throw an exception
throw new EmptyStackerException(array($this, $stackerName), self::EXCEPTION_STACKER_IS_EMPTY);
- }
+ } // END - if
// Now, remove the last entry, we don't care about the return value here, see elseif() block above
$this->partialStub('stackerName=' . $stackerName);
*
* @param $stackerName Name of the stack
* @return $value Value "shifted" from array
- * @throws NoStackerException If the named stacker was not found
* @throws EmptyStackerException If the named stacker is empty
*/
protected function popFirst ($stackerName) {
// Is the stack not yet initialized or full?
- } elseif ($this->isStackEmpty($stackerName)) {
+ if ($this->isStackEmpty($stackerName)) {
// Throw an exception
throw new EmptyStackerException(array($this, $stackerName), self::EXCEPTION_STACKER_IS_EMPTY);
- }
+ } // END - if
// Now, remove the last entry, we don't care about the return value here, see elseif() block above
$this->partialStub('stackerName=' . $stackerName);
return NULL;
}
+ /**
+ * Checks whether the given stack is full
+ *
+ * @param $stackerName Name of the stack
+ * @return $isFull Whether the stack is full
+ */
+ protected function isStackFull ($stackerName) {
+ // File-based stacks will only run full if the disk space is low.
+ // @TODO Please implement this, returning FALSE
+ $isFull = FALSE;
+
+ // Return result
+ return $isFull;
+ }
+
+ /**
+ * Checks whether the given stack is empty
+ *
+ * @param $stackerName Name of the stack
+ * @return $isEmpty Whether the stack is empty
+ * @throws NoStackerException If given stack is missing
+ */
+ public function isStackEmpty ($stackerName) {
+ // So, is the stack empty?
+ $isEmpty = (($this->getStackCount($stackerName)) == 0);
+
+ // Return result
+ return $isEmpty;
+ }
+
/**
* Initializes given stacker
*
* @throws UnsupportedOperationException This method is not (and maybe never will be) supported
*/
public function initStack ($stackerName, $forceReInit = FALSE) {
- throw new UnsupportedOperationException(array($this, __FUNCTION__, $executorInstance), self::EXCEPTION_UNSPPORTED_OPERATION);
+ throw new UnsupportedOperationException(array($this, __FUNCTION__, $this->getIteratorInstance()->getPointerInstance()), self::EXCEPTION_UNSPPORTED_OPERATION);
}
/**
* @throws UnsupportedOperationException This method is not (and maybe never will be) supported
*/
public function initStacks (array $stacks, $forceReInit = FALSE) {
- throw new UnsupportedOperationException(array($this, __FUNCTION__, $executorInstance), self::EXCEPTION_UNSPPORTED_OPERATION);
+ throw new UnsupportedOperationException(array($this, __FUNCTION__, $this->getIteratorInstance()->getPointerInstance()), self::EXCEPTION_UNSPPORTED_OPERATION);
}
/**
* @throws UnsupportedOperationException This method is not (and maybe never will be) supported
*/
public function isStackInitialized ($stackerName) {
- throw new UnsupportedOperationException(array($this, __FUNCTION__, $executorInstance), self::EXCEPTION_UNSPPORTED_OPERATION);
+ throw new UnsupportedOperationException(array($this, __FUNCTION__, $this->getIteratorInstance()->getPointerInstance()), self::EXCEPTION_UNSPPORTED_OPERATION);
}
/**
* @return $count Size of stack (array count)
*/
public function getStackCount ($stackerName) {
- // Now, count the array of entries
- $this->partialStub('stackerName=' . $stackerName);
- $count = 0;
-
- // Return result
- return $count;
- }
-
- /**
- * Checks whether the given stack is empty
- *
- * @param $stackerName Name of the stack
- * @return $isEmpty Whether the stack is empty
- * @throws UnsupportedOperationException This method is not (and maybe never will be) supported
- */
- public final function isStackEmpty ($stackerName) {
- throw new UnsupportedOperationException(array($this, __FUNCTION__, $executorInstance), self::EXCEPTION_UNSPPORTED_OPERATION);
+ // Now, simply return the found count value, this must be up-to-date then!
+ return $this->getCounter();
}
}
projects / core.git / blobdiff