class_DatabaseResult.php

Go to the documentation of this file.

<?php
class DatabaseResult extends BaseFrameworkSystem implements SearchableResult, UpdateableResult, SeekableIterator {
        // Exception constants
        const EXCEPTION_INVALID_DATABASE_RESULT = 0x1c0;
        const EXCEPTION_RESULT_UPDATE_FAILED    = 0x1c1;

        private $currentPos = -1;

        private $currentRow = null;

        private $resultArray = array();

        private $outDated = array();

        private $affectedRows = 0;

        private $foundValue = "";

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

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

        public final static function createDatabaseResult (array $resultArray) {
                // Get a new instance
                $resultInstance = new DatabaseResult();

                // Set the result array
                $resultInstance->setResultArray($resultArray);

                // Return the instance
                return $resultInstance;
        }

        protected final function setResultArray (array $resultArray) {
                $this->resultArray = $resultArray;
        }

        private function updateCurrentEntryByCriteria (LocalUpdateCriteria $updateInstance) {
                // Get the current entry key
                $entryKey = $this->key();

                // Now get the update criteria array and update all entries
                foreach ($updateInstance->getUpdateCriteria() as $criteriaKey => $criteriaValue) {
                        // Update data
                        $this->resultArray['rows'][$entryKey][$criteriaKey] = $criteriaValue;

                        // Mark it as out-dated
                        $this->outDated[$criteriaKey] = 1;
                } // END - foreach
        }

        public function next () {
                // Default is not valid
                $nextValid = false;

                // Is the result valid?
                if ($this->valid()) {
                        // Next entry found, so count one up and cache it
                        $this->currentPos++;
                        $this->currentRow = $this->resultArray['rows'][$this->currentPos];
                        $nextValid = true;
                } // END - if

                // Return the result
                return $nextValid;
        }

        public function seek ($index) {
                // Rewind to beginning
                $this->rewind();

                // Search for the entry
                while ($this->currentPos < $index && ($this->valid())) {
                        // Continue on
                        $this->next();
                } // END - while
        }

        public function current () {
                // Default is not found
                $current = null;

                // Does the current enty exist?
                if (isset($this->resultArray['rows'][$this->currentPos])) {
                        // Then get it
                        $current = $this->resultArray['rows'][$this->currentPos];
                } // END - if

                // Return the result
                return $current;
        }

        public function valid () {
                // By default nothing is valid
                $isValid = false;

                // Check if 
                if (($this->ifStatusIsOkay()) && (isset($this->resultArray['rows'][($this->currentPos + 1)])) && (isset($this->resultArray['rows'][0]))) {
                        // All fine!
                        $isValid = true;
                } // END - if

                // Return the result
                return $isValid;
        }

        public function ifStatusIsOkay () {
                return ((isset($this->resultArray['status'])) && ($this->resultArray['status'] === "ok"));
        }

        public function key () {
                return $this->currentPos;
        }

        public function rewind () {
                $this->currentPos = -1;
                $this->currentRow = array();
        }

        public function searchEntry (LocalSearchCriteria $criteriaInstance) {
                die(__METHOD__.": Unfinished!");
        }

        public function add2UpdateQueue (LocalUpdateCriteria $criteriaInstance) {
                // Rewind the pointer
                $this->rewind();

                // Get search criteria
                $searchInstance = $criteriaInstance->getSearchInstance();

                // And start looking for the result
                $foundEntries = 0;
                while (($this->valid()) && ($foundEntries < $searchInstance->getLimit())) {
                        // Get next entry
                        $this->next();
                        $currentEntry = $this->current();

                        // Is this entry found?
                        if ($searchInstance->ifEntryMatches($currentEntry)) {
                                // Update this entry
                                $this->updateCurrentEntryByCriteria($criteriaInstance);

                                // Count one up
                                $foundEntries++;
                        } // END - if
                } // END - while

                // Set affected rows
                $this->setAffectedRows($foundEntries);

                // If no entry is found/updated throw an exception
                if ($foundEntries == 0) {
                        // Throw an exception here
                        throw new ResultUpdateException($this, self::EXCEPTION_RESULT_UPDATE_FAILED);
                } // END - if

                // Set search instance
                $this->setSearchInstance($searchInstance);
        }

        public final function setAffectedRows ($rows) {
                $this->affectedRows = $rows;
        }

        public final function getAffectedRows () {
                return $this->affectedRows;
        }

        public final function getFoundValue () {
                return $this->foundValue;
        }

        public function ifDataNeedsFlush () {
                $needsUpdate = (count($this->outDated) > 0);
                return $needsUpdate;
        }

        public function addElementsToDataSet (StoreableCriteria $criteriaInstance) {
                // Walk only through out-dated columns
                foreach ($this->outDated as $key => $dummy) {
                        // Does this key exist?
                        //* DEBUG: */ echo "outDated: {$key}<br />\n";
                        if ($this->find($key)) {
                                // Then update it
                                $criteriaInstance->addCriteria($key, $this->getFoundValue());
                        } // END - if
                } // END - foreach
        }

        public function find ($key) {
                // By default nothing is found
                $found = false;

                // Rewind the pointer
                $this->rewind();

                // Walk through all entries
                while ($this->valid()) {
                        // Advance to next entry
                        $this->next();

                        // Get the whole array
                        $currentEntry = $this->current();

                        // Is the element there?
                        if (isset($currentEntry[$key])) {
                                // Okay, found!
                                $found = true;

                                // So "cache" it
                                $this->foundValue = $currentEntry[$key];

                                // And stop searching
                                break;
                        } // END - if
                } // END - while

                // Return the result
                return $found;
        }

        public function solveResultIndex ($databaseColumn, BaseDatabaseWrapper $wrapperInstance, array $callBack) {
                // By default nothing is found
                $indexValue = 0;

                // Is the element in result itself found?
                if ($this->find($databaseColumn)) {
                        // Use this value
                        $indexValue = $this->getFoundValue();
                } elseif ($this->find($wrapperInstance->getIndexKey())) {
                        // Use this value
                        $indexValue = $this->getFoundValue();
                }

                // Set the index
                call_user_func_array($callBack, array($indexValue));
        }
}

// [EOF]
?>