Get cell at a specific coordinate by using numeric cell coordinates

@param  string $pColumn Numeric column coordinate of the cell
@param string $pRow Numeric row coordinate of the cell
@return PHPExcel_Cell Cell that was found
438388
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);
    }
428909
public function merge($cell, $row, $numCell, $border=false){
        $style = array(
            'alignment' => array(
                'horizontal' => PHPExcel_Style_Alignment::HORIZONTAL_CENTER,)
        );
        $from = $this->getColumnName($cell) . $row;
        $to =  $this->getColumnName(($cell+$numCell - 1)) . $row;
        $this->engine->getActiveSheet()->mergeCells("$from:$to");
        $this->engine->getActiveSheet()->getStyle("$from:$to")
             ->applyFromArray($style);
        if($border){
            $this->engine->getActiveSheet()->getStyle("$from:$to")
                ->applyFromArray($this->style);
        }
        return $this;
    }
1148711
public function getDataValidation($pCellCoordinate = 'A1')
    {
        // return data validation if we already have one
        if (isset($this->_dataValidationCollection[$pCellCoordinate])) {
            return $this->_dataValidationCollection[$pCellCoordinate];
        }

        // else create data validation
        $this->_dataValidationCollection[$pCellCoordinate] = new PHPExcel_Cell_DataValidation();
        return $this->_dataValidationCollection[$pCellCoordinate];
    }
1214852
private static function getValidCellRange($startRow, $startColumn, $endRow, $endColumn)
    {
        if ($endRow === null) {
            $endRow = $startRow;
        }
        elseif ($startRow > $endRow) {
            $temp = $startRow;
            $startRow = $endRow;
            $endRow = $temp;
        }

        if ($endColumn === null) {
            $endColumn = $startColumn;
        }
        elseif ($startColumn > $endColumn) {
            $temp = $startColumn;
            $startColumn = $endColumn;
            $endColumn = $temp;
        }

        return array($startRow, $startColumn, $endRow, $endColumn);
    }
1205893
public function getCacheData($pCoord)
    {
        if ($pCoord === $this->currentObjectID) {
            return $this->currentObject;
        }
        $this->storeData();

        //    Check if the entry that has been requested actually exists
        if (parent::isDataSet($pCoord)) {
            $obj = apc_fetch($this->cachePrefix . $pCoord . '.cache');
            if ($obj === false) {
                //    Entry no longer exists in APC, so clear it from the cache array
                parent::deleteCacheData($pCoord);
                throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in APC cache');
            }
        } 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;
    }
1354411
public function getColumnDimension($pColumn = 'A', $create = true)
    {
        // Uppercase coordinate
        $pColumn = strtoupper($pColumn);

        // Fetch dimensions
        if (!isset($this->columnDimensions[$pColumn])) {
            if (!$create) {
                return null;
            }
            $this->columnDimensions[$pColumn] = new PHPExcel_Worksheet_ColumnDimension($pColumn);

            if (PHPExcel_Cell::columnIndexFromString($this->cachedHighestColumn) < PHPExcel_Cell::columnIndexFromString($pColumn)) {
                $this->cachedHighestColumn = $pColumn;
            }
        }
        return $this->columnDimensions[$pColumn];
    }
1226726
public function isDataSet($pCoord)
    {
        if ($pCoord === $this->currentObjectID) {
            return true;
        }

        //    Check if the requested entry exists in the cache
        $this->selectQuery->bindValue('id', $pCoord, SQLITE3_TEXT);
        $cellResult = $this->selectQuery->execute();
        if ($cellResult === false) {
            throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
        }
        $cellData = $cellResult->fetchArray(SQLITE3_ASSOC);

        return ($cellData === false) ? false : true;
    }
447229
public final Object getSimpleId(final Class<?> pFieldType,
    final IRecordSet<RS> pFrom, final String pColumnAlias) throws Exception {
    if (Integer.class == pFieldType) {
      return pFrom.getInteger(pColumnAlias);
    } else if (Long.class == pFieldType) {
      return pFrom.getLong(pColumnAlias);
    } else if (String.class == pFieldType) {
      return pFrom.getString(pColumnAlias);
    } else {
      String msg =
        "There is no rule to get column ID-able "
          + pColumnAlias + " of " + pFieldType;
      throw new ExceptionWithCode(ExceptionWithCode.NOT_YET_IMPLEMENTED,
        msg);
    }
  }
439935
public function calculateFormula($formula, $cellID=NULL, PHPExcel_Cell $pCell = NULL) {
		//	Initialise the logging settings
		$this->formulaError = null;
		$this->_debugLog->clearLog();
		$this->_cyclicReferenceStack->clear();

		//	Disable calculation cacheing because it only applies to cell calculations, not straight formulae
		//	But don't actually flush any cache
		$resetCache = $this->getCalculationCacheEnabled();
		$this->_calculationCacheEnabled = FALSE;
		//	Execute the calculation
		try {
			$result = self::_unwrapResult($this->_calculateFormulaValue($formula, $cellID, $pCell));
		} catch (PHPExcel_Exception $e) {
			throw new PHPExcel_Calculation_Exception($e->getMessage());
		}

		//	Reset calculation cacheing to its previous state
		$this->_calculationCacheEnabled = $resetCache;

		return $result;
	}
1124189
public function setBreak($pCell = 'A1', $pBreak = PHPExcel_Worksheet::BREAK_NONE)
    {
        // Uppercase coordinate
        $pCell = strtoupper($pCell);

        if ($pCell != '') {
        	if ($pBreak == PHPExcel_Worksheet::BREAK_NONE) {
        		if (isset($this->_breaks[$pCell])) {
	            	unset($this->_breaks[$pCell]);
        		}
        	} else {
	            $this->_breaks[$pCell] = $pBreak;
	        }
        } else {
            throw new PHPExcel_Exception('No cell coordinate specified.');
        }

        return $this;
    }
271482
function getColumn($c) {
		if (!isset($this->columns[$c])) {
			throw new \OutOfBoundsException("Unknown column $c");
		}
		return $this->columns[$c];
	}
548143
private function drawLine(int $lineNumber, array $rowContent, string $sepPrefix = 'sep_'): string
    {
        $line = '';
        foreach ($rowContent as $columnName => $cellContent) {
            $lineContent = '';

            // If the line contains some text...
            if (isset($cellContent[$lineNumber])) {
                // Use it
                $lineContent = $cellContent[$lineNumber];
            }

            $alignSpaces = 0;

            // Count characters and draw spaces if needed
            if (iconv_strlen($lineContent) < $this->columnsWidths[$columnName]) {
                $alignSpaces = $this->columnsWidths[$columnName] - iconv_strlen($lineContent);
            }

            // Draw the line
            $line
                // Vertical Separator
                .= $this->options[$sepPrefix . 'v']
                // + left padding
                . $this->drawSpaces($this->options['cells_padding'][3]);

            if (false === isset($this->options['columns'][$columnName]['align'])) {
                $this->options['columns'][$columnName]['align'] = $this->options['default_cell_align'];
            }

            switch ($this->options['columns'][$columnName]['align']) {
                case 'left':
                    $line .=
                        // + content
                        trim($lineContent)
                        // + right spaces
                        . $this->drawSpaces($alignSpaces);
                    break;

                case 'right':
                    $line .=
                        // + right spaces
                        $this->drawSpaces($alignSpaces)
                        // + content
                        . trim($lineContent);
                    break;
            }

            // + right padding
            $line .= $this->drawSpaces($this->options['cells_padding'][1]);
        }

        return $line . $this->options[$sepPrefix . 'v'] . PHP_EOL;
    }
1121940
def getcol(self, startrow=0, nrow=-1, rowincr=1):
        """"""
        return self._table.getcol(self._column, startrow, nrow, rowincr)
889671
public function removeColumn($pColumn = 'A', $pNumCols = 1) {
        if (!is_numeric($pColumn)) {
            $pColumn = PHPExcel_Cell::stringFromColumnIndex(PHPExcel_Cell::columnIndexFromString($pColumn) - 1 + $pNumCols);
            $objReferenceHelper = PHPExcel_ReferenceHelper::getInstance();
            $objReferenceHelper->insertNewBefore($pColumn . '1', -$pNumCols, 0, $this);
        } else {
            throw new PHPExcel_Exception("Column references should not be numeric.");
        }
        return $this;
    }
712256
public function getCellByColumnAndRow($pColumn = 0, $pRow = 1)
    {
        $columnLetter = PHPExcel_Cell::stringFromColumnIndex($pColumn);
        $coordinate = $columnLetter . $pRow;

        if (!$this->_cellCollection->isDataSet($coordinate)) {
            $cell = $this->_cellCollection->addCacheData($coordinate, new PHPExcel_Cell(NULL, PHPExcel_Cell_DataType::TYPE_NULL, $this));
            $this->_cellCollectionIsSorted = false;

            if (PHPExcel_Cell::columnIndexFromString($this->_cachedHighestColumn) < $pColumn)
                $this->_cachedHighestColumn = $columnLetter;

            $this->_cachedHighestRow = max($this->_cachedHighestRow,$pRow);

            return $cell;
        }

        return $this->_cellCollection->getCacheData($coordinate);
    }
1116183
public function getCacheData($pCoord)
    {
        if ($pCoord === $this->currentObjectID) {
            return $this->currentObject;
        }
        $this->storeData();

        $query = "SELECT value 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 null;
        }

        //    Set current entry to the requested entry
        $this->currentObjectID = $pCoord;

        $cellResult = $cellResultSet->fetchSingle();
        $this->currentObject = unserialize($cellResult);
        //    Re-attach this as the cell's parent
        $this->currentObject->attach($this);

        //    Return requested entry
        return $this->currentObject;
    }
943024
public function getRowDimension($pRow = 1)
    {
        // Found
        $found = null;

        // Get row dimension
        if (!isset($this->_rowDimensions[$pRow])) {
            $this->_rowDimensions[$pRow] = new PHPExcel_Worksheet_RowDimension($pRow);

            $this->_cachedHighestRow = max($this->_cachedHighestRow,$pRow);
        }
        return $this->_rowDimensions[$pRow];
    }