Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?

@param	string		$pCoord		Coordinate address of the cell to check
@return	boolean
173926
public function isDataSet($pCoord) {
		if ($pCoord === $this->_currentObjectID) {
			return true;
		}
		//	Check if the requested entry exists in the cache
		return isset($this->_cellCache[$pCoord]);
	}
174655
public function setOrderPCode($orderPCode)
    {
        if (!is_array($orderPCode)) {
            $this->orderPCode = null;

            return false;
        }
        $isValid = true;
        $index = 0;
        while ($isValid && $index < count($orderPCode)) {
            if (strlen($orderPCode[$index]) > 20) {
                $isValid = false;
            } else {
                $isValid = true;
            }
            $index++;
        }
        if (!$isValid) {
            $this->orderPCode = null;

            return false;
        }
        $this->orderPCode = $orderPCode;

        return true;
    }
80434
public function getCacheData($pCoord) {
		if ($pCoord === $this->_currentObjectID) {
			return $this->_currentObject;
		}
		$this->_storeData();

		//	Check if the entry that has been requested actually exists
		$obj = null;
		if (parent::isDataSet($pCoord)) {
			$success = false;
			$obj = wincache_ucache_get($this->_cachePrefix.$pCoord.'.cache', $success);
			if ($success === false) {
				//	Entry no longer exists in WinCache, so clear it from the cache array
				parent::deleteCacheData($pCoord);
				throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in WinCache');
			}
		} else {
			//	Return null if requested entry doesn't exist in cache
			return null;
		}

		//	Set current entry to the requested entry
		$this->_currentObjectID = $pCoord;
		$this->_currentObject = unserialize($obj);
        //    Re-attach this as the cell's parent
        $this->_currentObject->attach($this);

		//	Return requested entry
		return $this->_currentObject;
	}
143266
public function isListedInCache($lookup_hash)
  {
    // by default no match in cache
    $matched_listnames=null;
    
    $hex_lookup_hash=bin2hex($lookup_hash);
    
    foreach($this->getLists() as $listname => $liststate){
      $listdir=$this->getListStorageDir($listname);
      if(!is_dir($listdir)){
        $this->debugLog('isListedInCache() no list directory found for list '.$listname);
        continue;
      }
      if(!is_file($listdir.$this->fullhash_cache_filename)){
        //$this->debugLog('isListedInCache() no fullcache file found for list '.$listname);
        // no cache file, nothing to look up
        continue;
      }
      $cached_hashes=explode("\n",file_get_contents($listdir.$this->fullhash_cache_filename));
      foreach($cached_hashes as $cache_entry){
        $cache_parts=explode(';',$cache_entry);
        // 0:prefix;1:fullhash;2:expire_timestamp
        if($cache_parts[0]===substr($hex_lookup_hash,0,strlen($cache_parts[0]))){
          // ok prefix hash match 
          if(is_null($matched_listnames)){
            $matched_listnames=array();
          }
          // test against full hash
          if($cache_parts[1]===$hex_lookup_hash){
            // full hash match
            if($cache_parts[2]<time()){
              // expired full match must result in cache-miss so it gets re-fetched
              return null;
            }
            $matched_listnames[]=$listname;
            // we can skip to the next list
            continue(2);
          }
        }
      }
    }
    
    if(is_null($matched_listnames)){
      // we still have a complete cache miss, as a last resort
      // check if the prefix is in the negative cache file
      if(is_file($this->storage_dir.$this->fullhash_cache_filename)){
        // negative cache file
        $negative_prefixes=explode("\n",file_get_contents($this->storage_dir.$this->fullhash_cache_filename));
        foreach($negative_prefixes as $cache_entry){
          $cache_parts=explode(';',$cache_entry);
          // 0:prefix;1:expire_timestamp
          if($cache_parts[0]===substr($hex_lookup_hash,0,strlen($cache_parts[0]))){
            // ok prefix hash match 
            if(is_null($matched_listnames)){
              $matched_listnames=array();
            }
            if($cache_parts[1]<time()){
              // expired prefix match must result in cache-miss so it gets re-fetched
              return null;
            }
          }
        }
      }
      
    }
    
    return $matched_listnames;
  }
614805
public static function coordinateFromString($pCoordinateString = 'A1')
	{
		if (preg_match("/^([$]?[A-Z]{1,3})([$]?\d{1,7})$/", $pCoordinateString, $matches)) {
			return array($matches[1],$matches[2]);
		} elseif ((strpos($pCoordinateString,':') !== FALSE) || (strpos($pCoordinateString,',') !== FALSE)) {
			throw new PHPExcel_Exception('Cell coordinate string can not be a range of cells');
		} elseif ($pCoordinateString == '') {
			throw new PHPExcel_Exception('Cell coordinate can not be zero-length string');
		}

		throw new PHPExcel_Exception('Invalid cell coordinate '.$pCoordinateString);
	}
1350249
public function checkIfpageShouldBeIndexed($uid, $language_uid)
    {
        $index = true;

        if ($this->cachedPageRecords[$language_uid][$uid]['hidden']) {
            $index = false;
        }

        if ($this->cachedPageRecords[$language_uid][$uid]['no_search']) {
            $index = false;
        }

        if (!in_array($this->cachedPageRecords[$language_uid][$uid]['doktype'], $this->indexDokTypes)) {
            $index = false;
        }

        return $index;
    }
723179
public function storeDeliveryThemeIdToCache($deliveryId, $themeId)
    {
        try {
            return $this->getCache()->put($themeId, $this->getCacheKey($deliveryId), 60);
        }
        catch (\common_exception_NotImplemented $e) {
            return false;
        }
    }
169534
public function getCellByColumnAndRow($pColumn = 0, $pRow = 1)
    {
        $columnLetter = PHPExcel_Cell::stringFromColumnIndex($pColumn);
        $coordinate = $columnLetter . $pRow;

        if ($this->_cellCollection->isDataSet($coordinate)) {
            return $this->_cellCollection->getCacheData($coordinate);
        }

		return $this->_createNewCell($coordinate);
    }
1299611
public function setSelectedCells($pCoordinate = 'A1')
    {
        // Uppercase coordinate
        $pCoordinate = strtoupper($pCoordinate);

        // Convert 'A' to 'A:A'
        $pCoordinate = preg_replace('/^([A-Z]+)$/', '${1}:${1}', $pCoordinate);

        // Convert '1' to '1:1'
        $pCoordinate = preg_replace('/^([0-9]+)$/', '${1}:${1}', $pCoordinate);

        // Convert 'A:C' to 'A1:C1048576'
        $pCoordinate = preg_replace('/^([A-Z]+):([A-Z]+)$/', '${1}1:${2}1048576', $pCoordinate);

        // Convert '1:3' to 'A1:XFD3'
        $pCoordinate = preg_replace('/^([0-9]+):([0-9]+)$/', 'A${1}:XFD${2}', $pCoordinate);

        if (strpos($pCoordinate, ':') !== false || strpos($pCoordinate, ',') !== false) {
            list($first, ) = PHPExcel_Cell::splitRange($pCoordinate);
            $this->activeCell = $first[0];
        } else {
            $this->activeCell = $pCoordinate;
        }
        $this->selectedCells = $pCoordinate;
        return $this;
    }
927580
public static function isDateTime(PHPExcel_Cell $pCell)
    {
        return self::isDateTimeFormat(
            $pCell->getWorksheet()->getStyle(
                $pCell->getCoordinate()
            )->getNumberFormat()
        );
    }
852992
public static function stringFromColumnIndex($pColumnIndex = 0)
	{
		//	Using a lookup cache adds a slight memory overhead, but boosts speed
		//	caching using a static within the method is faster than a class static,
		//		though it's additional memory overhead
		static $_indexCache = array();

		if (!isset($_indexCache[$pColumnIndex])) {
			// Determine column string
			if ($pColumnIndex < 26) {
				$_indexCache[$pColumnIndex] = chr(65 + $pColumnIndex);
			} elseif ($pColumnIndex < 702) {
				$_indexCache[$pColumnIndex] = chr(64 + ($pColumnIndex / 26)) .
											  chr(65 + $pColumnIndex % 26);
			} else {
				$_indexCache[$pColumnIndex] = chr(64 + (($pColumnIndex - 26) / 676)) .
											  chr(65 + ((($pColumnIndex - 26) % 676) / 26)) .
											  chr(65 + $pColumnIndex % 26);
			}
		}
		return $_indexCache[$pColumnIndex];
	}
105445
public function cellSpan($position = null)
    {
        $row = $this->rowData($position);
        $cellIndex = $this->cellRowIndex($position);

        // Cellspan (defaults to 1)
        return isset($row['columns'][$cellIndex]) ? (int)$row['columns'][$cellIndex] : null;
    }
305866
public function addCacheData($pCoord, PHPExcel_Cell $cell) {
		$this->_cellCache[$pCoord] = $cell;

		//	Set current entry to the new/updated entry
		$this->_currentObjectID = $pCoord;

		return $cell;
	}
1088969
protected function _storeData() {
		if ($this->_currentCellIsDirty) {
			$this->_currentObject->detach();

			$obj = serialize($this->_currentObject);
			if (!$this->_memcache->replace($this->_cachePrefix.$this->_currentObjectID.'.cache',$obj,NULL,$this->_cacheTime)) {
				if (!$this->_memcache->add($this->_cachePrefix.$this->_currentObjectID.'.cache',$obj,NULL,$this->_cacheTime)) {
					$this->__destruct();
					throw new PHPExcel_Exception('Failed to store cell '.$this->_currentObjectID.' in MemCache');
				}
			}
			$this->_currentCellIsDirty = false;
		}
		$this->_currentObjectID = $this->_currentObject = null;
	}
1306789
public function isDataSet($pCoord)
    {
        if ($pCoord === $this->currentObjectID) {
            return true;
        }

        //    Check if the requested entry exists in the cache
        $query = "SELECT id FROM kvp_".$this->TableName." WHERE id='".$pCoord."'";
        $cellResultSet = $this->DBHandle->query($query, SQLITE_ASSOC);
        if ($cellResultSet === false) {
            throw new PHPExcel_Exception(sqlite_error_string($this->DBHandle->lastError()));
        } elseif ($cellResultSet->numRows() == 0) {
            //    Return null if requested entry doesn't exist in cache
            return false;
        }
        return true;
    }
948486
public function getCacheData($pCoord) {
		if ($pCoord === $this->_currentObjectID) {
			return $this->_currentObject;
		}
		$this->_storeData();

		//	Check if the entry that has been requested actually exists
		if (!isset($this->_cellCache[$pCoord])) {
			//	Return null if requested entry doesn't exist in cache
			return null;
		}

		//	Set current entry to the requested entry
		$this->_currentObjectID = $pCoord;
		$this->_currentObject = igbinary_unserialize($this->_cellCache[$pCoord]);
        //    Re-attach this as the cell's parent
        $this->_currentObject->attach($this);

		//	Return requested entry
		return $this->_currentObject;
	}
1052825
public function isDataSet($pCoord) {
		if ($pCoord === $this->_currentObjectID) {
			return true;
		}

		//	Check if the requested entry exists in the cache
		$query = "SELECT id FROM kvp_".$this->_TableName." WHERE id='".$pCoord."'";
		$cellResultSet = $this->_DBHandle->query($query,SQLITE_ASSOC);
		if ($cellResultSet === false) {
			throw new PHPExcel_Exception(sqlite_error_string($this->_DBHandle->lastError()));
		} elseif ($cellResultSet->numRows() == 0) {
			//	Return null if requested entry doesn't exist in cache
			return false;
		}
		return true;
	}