_id
stringlengths 2
7
| title
stringlengths 3
151
| partition
stringclasses 3
values | text
stringlengths 83
13k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q251100 | OLERead.getStream | validation | public function getStream($stream)
{
if ($stream === null) {
return null;
}
$streamData = '';
if ($this->props[$stream]['size'] < self::SMALL_BLOCK_THRESHOLD) {
$rootdata = $this->_readData($this->props[$this->rootentry]['startBlock']);
$block = $this->props[$stream]['startBlock'];
while ($block != -2) {
$pos = $block * self::SMALL_BLOCK_SIZE;
$streamData .= substr($rootdata, $pos, self::SMALL_BLOCK_SIZE);
$block = self::getInt4d($this->smallBlockChain, $block * 4);
}
return $streamData;
}
$numBlocks = $this->props[$stream]['size'] / self::BIG_BLOCK_SIZE;
if ($this->props[$stream]['size'] % self::BIG_BLOCK_SIZE != 0) {
++$numBlocks;
}
if ($numBlocks == 0) {
return '';
}
$block = $this->props[$stream]['startBlock'];
while ($block != -2) {
$pos = ($block + 1) * self::BIG_BLOCK_SIZE;
$streamData .= substr($this->data, $pos, self::BIG_BLOCK_SIZE);
$block = self::getInt4d($this->bigBlockChain, $block * 4);
}
return $streamData;
} | php | {
"resource": ""
} |
q251101 | OLERead.getInt4d | validation | private static function getInt4d($data, $pos)
{
if (trim($data) == '') {
// No data provided
throw new ReaderException('Parameter data is empty.');
} elseif ($pos < 0) {
// Invalid position
throw new ReaderException('Parameter pos=' . $pos . ' is invalid.');
}
$len = strlen($data);
if ($len < $pos + 4) {
$data .= str_repeat("\0", $pos + 4 - $len);
}
// FIX: represent numbers correctly on 64-bit system
// http://sourceforge.net/tracker/index.php?func=detail&aid=1487372&group_id=99160&atid=623334
// Changed by Andreas Rehm 2006 to ensure correct result of the <<24 block on 32 and 64bit systems
$_or_24 = ord($data[$pos + 3]);
if ($_or_24 >= 128) {
// negative number
$_ord_24 = -abs((256 - $_or_24) << 24);
} else {
$_ord_24 = ($_or_24 & 127) << 24;
}
return ord($data[$pos]) | (ord($data[$pos + 1]) << 8) | (ord($data[$pos + 2]) << 16) | $_ord_24;
} | php | {
"resource": ""
} |
q251102 | Worksheet.writeDimension | validation | private function writeDimension(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// dimension
$objWriter->startElement('dimension');
$objWriter->writeAttribute('ref', $pSheet->calculateWorksheetDimension());
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251103 | Worksheet.writeSheetFormatPr | validation | private function writeSheetFormatPr(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// sheetFormatPr
$objWriter->startElement('sheetFormatPr');
// Default row height
if ($pSheet->getDefaultRowDimension()->getRowHeight() >= 0) {
$objWriter->writeAttribute('customHeight', 'true');
$objWriter->writeAttribute('defaultRowHeight', StringHelper::formatNumber($pSheet->getDefaultRowDimension()->getRowHeight()));
} else {
$objWriter->writeAttribute('defaultRowHeight', '14.4');
}
// Set Zero Height row
if ((string) $pSheet->getDefaultRowDimension()->getZeroHeight() == '1' ||
strtolower((string) $pSheet->getDefaultRowDimension()->getZeroHeight()) == 'true') {
$objWriter->writeAttribute('zeroHeight', '1');
}
// Default column width
if ($pSheet->getDefaultColumnDimension()->getWidth() >= 0) {
$objWriter->writeAttribute('defaultColWidth', StringHelper::formatNumber($pSheet->getDefaultColumnDimension()->getWidth()));
}
// Outline level - row
$outlineLevelRow = 0;
foreach ($pSheet->getRowDimensions() as $dimension) {
if ($dimension->getOutlineLevel() > $outlineLevelRow) {
$outlineLevelRow = $dimension->getOutlineLevel();
}
}
$objWriter->writeAttribute('outlineLevelRow', (int) $outlineLevelRow);
// Outline level - column
$outlineLevelCol = 0;
foreach ($pSheet->getColumnDimensions() as $dimension) {
if ($dimension->getOutlineLevel() > $outlineLevelCol) {
$outlineLevelCol = $dimension->getOutlineLevel();
}
}
$objWriter->writeAttribute('outlineLevelCol', (int) $outlineLevelCol);
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251104 | Worksheet.writeCols | validation | private function writeCols(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// cols
if (count($pSheet->getColumnDimensions()) > 0) {
$objWriter->startElement('cols');
$pSheet->calculateColumnWidths();
// Loop through column dimensions
foreach ($pSheet->getColumnDimensions() as $colDimension) {
// col
$objWriter->startElement('col');
$objWriter->writeAttribute('min', Coordinate::columnIndexFromString($colDimension->getColumnIndex()));
$objWriter->writeAttribute('max', Coordinate::columnIndexFromString($colDimension->getColumnIndex()));
if ($colDimension->getWidth() < 0) {
// No width set, apply default of 10
$objWriter->writeAttribute('width', '9.10');
} else {
// Width set
$objWriter->writeAttribute('width', StringHelper::formatNumber($colDimension->getWidth()));
}
// Column visibility
if ($colDimension->getVisible() == false) {
$objWriter->writeAttribute('hidden', 'true');
}
// Auto size?
if ($colDimension->getAutoSize()) {
$objWriter->writeAttribute('bestFit', 'true');
}
// Custom width?
if ($colDimension->getWidth() != $pSheet->getDefaultColumnDimension()->getWidth()) {
$objWriter->writeAttribute('customWidth', 'true');
}
// Collapsed
if ($colDimension->getCollapsed() == true) {
$objWriter->writeAttribute('collapsed', 'true');
}
// Outline level
if ($colDimension->getOutlineLevel() > 0) {
$objWriter->writeAttribute('outlineLevel', $colDimension->getOutlineLevel());
}
// Style
$objWriter->writeAttribute('style', $colDimension->getXfIndex());
$objWriter->endElement();
}
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251105 | Worksheet.writeDataValidations | validation | private function writeDataValidations(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// Datavalidation collection
$dataValidationCollection = $pSheet->getDataValidationCollection();
// Write data validations?
if (!empty($dataValidationCollection)) {
$dataValidationCollection = Coordinate::mergeRangesInCollection($dataValidationCollection);
$objWriter->startElement('dataValidations');
$objWriter->writeAttribute('count', count($dataValidationCollection));
foreach ($dataValidationCollection as $coordinate => $dv) {
$objWriter->startElement('dataValidation');
if ($dv->getType() != '') {
$objWriter->writeAttribute('type', $dv->getType());
}
if ($dv->getErrorStyle() != '') {
$objWriter->writeAttribute('errorStyle', $dv->getErrorStyle());
}
if ($dv->getOperator() != '') {
$objWriter->writeAttribute('operator', $dv->getOperator());
}
$objWriter->writeAttribute('allowBlank', ($dv->getAllowBlank() ? '1' : '0'));
$objWriter->writeAttribute('showDropDown', (!$dv->getShowDropDown() ? '1' : '0'));
$objWriter->writeAttribute('showInputMessage', ($dv->getShowInputMessage() ? '1' : '0'));
$objWriter->writeAttribute('showErrorMessage', ($dv->getShowErrorMessage() ? '1' : '0'));
if ($dv->getErrorTitle() !== '') {
$objWriter->writeAttribute('errorTitle', $dv->getErrorTitle());
}
if ($dv->getError() !== '') {
$objWriter->writeAttribute('error', $dv->getError());
}
if ($dv->getPromptTitle() !== '') {
$objWriter->writeAttribute('promptTitle', $dv->getPromptTitle());
}
if ($dv->getPrompt() !== '') {
$objWriter->writeAttribute('prompt', $dv->getPrompt());
}
$objWriter->writeAttribute('sqref', $coordinate);
if ($dv->getFormula1() !== '') {
$objWriter->writeElement('formula1', $dv->getFormula1());
}
if ($dv->getFormula2() !== '') {
$objWriter->writeElement('formula2', $dv->getFormula2());
}
$objWriter->endElement();
}
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251106 | Worksheet.writeHyperlinks | validation | private function writeHyperlinks(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// Hyperlink collection
$hyperlinkCollection = $pSheet->getHyperlinkCollection();
// Relation ID
$relationId = 1;
// Write hyperlinks?
if (!empty($hyperlinkCollection)) {
$objWriter->startElement('hyperlinks');
foreach ($hyperlinkCollection as $coordinate => $hyperlink) {
$objWriter->startElement('hyperlink');
$objWriter->writeAttribute('ref', $coordinate);
if (!$hyperlink->isInternal()) {
$objWriter->writeAttribute('r:id', 'rId_hyperlink_' . $relationId);
++$relationId;
} else {
$objWriter->writeAttribute('location', str_replace('sheet://', '', $hyperlink->getUrl()));
}
if ($hyperlink->getTooltip() != '') {
$objWriter->writeAttribute('tooltip', $hyperlink->getTooltip());
}
$objWriter->endElement();
}
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251107 | Worksheet.writeProtectedRanges | validation | private function writeProtectedRanges(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
if (count($pSheet->getProtectedCells()) > 0) {
// protectedRanges
$objWriter->startElement('protectedRanges');
// Loop protectedRanges
foreach ($pSheet->getProtectedCells() as $protectedCell => $passwordHash) {
// protectedRange
$objWriter->startElement('protectedRange');
$objWriter->writeAttribute('name', 'p' . md5($protectedCell));
$objWriter->writeAttribute('sqref', $protectedCell);
if (!empty($passwordHash)) {
$objWriter->writeAttribute('password', $passwordHash);
}
$objWriter->endElement();
}
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251108 | Worksheet.writeMergeCells | validation | private function writeMergeCells(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
if (count($pSheet->getMergeCells()) > 0) {
// mergeCells
$objWriter->startElement('mergeCells');
// Loop mergeCells
foreach ($pSheet->getMergeCells() as $mergeCell) {
// mergeCell
$objWriter->startElement('mergeCell');
$objWriter->writeAttribute('ref', $mergeCell);
$objWriter->endElement();
}
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251109 | Worksheet.writePrintOptions | validation | private function writePrintOptions(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// printOptions
$objWriter->startElement('printOptions');
$objWriter->writeAttribute('gridLines', ($pSheet->getPrintGridlines() ? 'true' : 'false'));
$objWriter->writeAttribute('gridLinesSet', 'true');
if ($pSheet->getPageSetup()->getHorizontalCentered()) {
$objWriter->writeAttribute('horizontalCentered', 'true');
}
if ($pSheet->getPageSetup()->getVerticalCentered()) {
$objWriter->writeAttribute('verticalCentered', 'true');
}
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251110 | Worksheet.writePageMargins | validation | private function writePageMargins(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// pageMargins
$objWriter->startElement('pageMargins');
$objWriter->writeAttribute('left', StringHelper::formatNumber($pSheet->getPageMargins()->getLeft()));
$objWriter->writeAttribute('right', StringHelper::formatNumber($pSheet->getPageMargins()->getRight()));
$objWriter->writeAttribute('top', StringHelper::formatNumber($pSheet->getPageMargins()->getTop()));
$objWriter->writeAttribute('bottom', StringHelper::formatNumber($pSheet->getPageMargins()->getBottom()));
$objWriter->writeAttribute('header', StringHelper::formatNumber($pSheet->getPageMargins()->getHeader()));
$objWriter->writeAttribute('footer', StringHelper::formatNumber($pSheet->getPageMargins()->getFooter()));
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251111 | Worksheet.writePageSetup | validation | private function writePageSetup(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// pageSetup
$objWriter->startElement('pageSetup');
$objWriter->writeAttribute('paperSize', $pSheet->getPageSetup()->getPaperSize());
$objWriter->writeAttribute('orientation', $pSheet->getPageSetup()->getOrientation());
if ($pSheet->getPageSetup()->getScale() !== null) {
$objWriter->writeAttribute('scale', $pSheet->getPageSetup()->getScale());
}
if ($pSheet->getPageSetup()->getFitToHeight() !== null) {
$objWriter->writeAttribute('fitToHeight', $pSheet->getPageSetup()->getFitToHeight());
} else {
$objWriter->writeAttribute('fitToHeight', '0');
}
if ($pSheet->getPageSetup()->getFitToWidth() !== null) {
$objWriter->writeAttribute('fitToWidth', $pSheet->getPageSetup()->getFitToWidth());
} else {
$objWriter->writeAttribute('fitToWidth', '0');
}
if ($pSheet->getPageSetup()->getFirstPageNumber() !== null) {
$objWriter->writeAttribute('firstPageNumber', $pSheet->getPageSetup()->getFirstPageNumber());
$objWriter->writeAttribute('useFirstPageNumber', '1');
}
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251112 | Worksheet.writeBreaks | validation | private function writeBreaks(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// Get row and column breaks
$aRowBreaks = [];
$aColumnBreaks = [];
foreach ($pSheet->getBreaks() as $cell => $breakType) {
if ($breakType == PhpspreadsheetWorksheet::BREAK_ROW) {
$aRowBreaks[] = $cell;
} elseif ($breakType == PhpspreadsheetWorksheet::BREAK_COLUMN) {
$aColumnBreaks[] = $cell;
}
}
// rowBreaks
if (!empty($aRowBreaks)) {
$objWriter->startElement('rowBreaks');
$objWriter->writeAttribute('count', count($aRowBreaks));
$objWriter->writeAttribute('manualBreakCount', count($aRowBreaks));
foreach ($aRowBreaks as $cell) {
$coords = Coordinate::coordinateFromString($cell);
$objWriter->startElement('brk');
$objWriter->writeAttribute('id', $coords[1]);
$objWriter->writeAttribute('man', '1');
$objWriter->endElement();
}
$objWriter->endElement();
}
// Second, write column breaks
if (!empty($aColumnBreaks)) {
$objWriter->startElement('colBreaks');
$objWriter->writeAttribute('count', count($aColumnBreaks));
$objWriter->writeAttribute('manualBreakCount', count($aColumnBreaks));
foreach ($aColumnBreaks as $cell) {
$coords = Coordinate::coordinateFromString($cell);
$objWriter->startElement('brk');
$objWriter->writeAttribute('id', Coordinate::columnIndexFromString($coords[0]) - 1);
$objWriter->writeAttribute('man', '1');
$objWriter->endElement();
}
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251113 | Worksheet.writeSheetData | validation | private function writeSheetData(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet, array $pStringTable)
{
// Flipped stringtable, for faster index searching
$aFlippedStringTable = $this->getParentWriter()->getWriterPart('stringtable')->flipStringTable($pStringTable);
// sheetData
$objWriter->startElement('sheetData');
// Get column count
$colCount = Coordinate::columnIndexFromString($pSheet->getHighestColumn());
// Highest row number
$highestRow = $pSheet->getHighestRow();
// Loop through cells
$cellsByRow = [];
foreach ($pSheet->getCoordinates() as $coordinate) {
$cellAddress = Coordinate::coordinateFromString($coordinate);
$cellsByRow[$cellAddress[1]][] = $coordinate;
}
$currentRow = 0;
while ($currentRow++ < $highestRow) {
// Get row dimension
$rowDimension = $pSheet->getRowDimension($currentRow);
// Write current row?
$writeCurrentRow = isset($cellsByRow[$currentRow]) || $rowDimension->getRowHeight() >= 0 || $rowDimension->getVisible() == false || $rowDimension->getCollapsed() == true || $rowDimension->getOutlineLevel() > 0 || $rowDimension->getXfIndex() !== null;
if ($writeCurrentRow) {
// Start a new row
$objWriter->startElement('row');
$objWriter->writeAttribute('r', $currentRow);
$objWriter->writeAttribute('spans', '1:' . $colCount);
// Row dimensions
if ($rowDimension->getRowHeight() >= 0) {
$objWriter->writeAttribute('customHeight', '1');
$objWriter->writeAttribute('ht', StringHelper::formatNumber($rowDimension->getRowHeight()));
}
// Row visibility
if ($rowDimension->getVisible() == false) {
$objWriter->writeAttribute('hidden', 'true');
}
// Collapsed
if ($rowDimension->getCollapsed() == true) {
$objWriter->writeAttribute('collapsed', 'true');
}
// Outline level
if ($rowDimension->getOutlineLevel() > 0) {
$objWriter->writeAttribute('outlineLevel', $rowDimension->getOutlineLevel());
}
// Style
if ($rowDimension->getXfIndex() !== null) {
$objWriter->writeAttribute('s', $rowDimension->getXfIndex());
$objWriter->writeAttribute('customFormat', '1');
}
// Write cells
if (isset($cellsByRow[$currentRow])) {
foreach ($cellsByRow[$currentRow] as $cellAddress) {
// Write cell
$this->writeCell($objWriter, $pSheet, $cellAddress, $aFlippedStringTable);
}
}
// End row
$objWriter->endElement();
}
}
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251114 | Worksheet.writeDrawings | validation | private function writeDrawings(XMLWriter $objWriter = null, PhpspreadsheetWorksheet $pSheet = null, $includeCharts = false)
{
$chartCount = ($includeCharts) ? $pSheet->getChartCollection()->count() : 0;
// If sheet contains drawings, add the relationships
if (($pSheet->getDrawingCollection()->count() > 0) ||
($chartCount > 0)) {
$objWriter->startElement('drawing');
$objWriter->writeAttribute('r:id', 'rId1');
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251115 | Worksheet.writeLegacyDrawing | validation | private function writeLegacyDrawing(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// If sheet contains comments, add the relationships
if (count($pSheet->getComments()) > 0) {
$objWriter->startElement('legacyDrawing');
$objWriter->writeAttribute('r:id', 'rId_comments_vml1');
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251116 | Worksheet.writeLegacyDrawingHF | validation | private function writeLegacyDrawingHF(XMLWriter $objWriter, PhpspreadsheetWorksheet $pSheet)
{
// If sheet contains images, add the relationships
if (count($pSheet->getHeaderFooter()->getImages()) > 0) {
$objWriter->startElement('legacyDrawingHF');
$objWriter->writeAttribute('r:id', 'rId_headerfooter_vml1');
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251117 | Workbook.writeWorkbook | validation | public function writeWorkbook(Spreadsheet $spreadsheet, $recalcRequired = false)
{
// Create XML writer
if ($this->getParentWriter()->getUseDiskCaching()) {
$objWriter = new XMLWriter(XMLWriter::STORAGE_DISK, $this->getParentWriter()->getDiskCachingDirectory());
} else {
$objWriter = new XMLWriter(XMLWriter::STORAGE_MEMORY);
}
// XML header
$objWriter->startDocument('1.0', 'UTF-8', 'yes');
// workbook
$objWriter->startElement('workbook');
$objWriter->writeAttribute('xml:space', 'preserve');
$objWriter->writeAttribute('xmlns', 'http://schemas.openxmlformats.org/spreadsheetml/2006/main');
$objWriter->writeAttribute('xmlns:r', 'http://schemas.openxmlformats.org/officeDocument/2006/relationships');
// fileVersion
$this->writeFileVersion($objWriter);
// workbookPr
$this->writeWorkbookPr($objWriter);
// workbookProtection
$this->writeWorkbookProtection($objWriter, $spreadsheet);
// bookViews
if ($this->getParentWriter()->getOffice2003Compatibility() === false) {
$this->writeBookViews($objWriter, $spreadsheet);
}
// sheets
$this->writeSheets($objWriter, $spreadsheet);
// definedNames
$this->writeDefinedNames($objWriter, $spreadsheet);
// calcPr
$this->writeCalcPr($objWriter, $recalcRequired);
$objWriter->endElement();
// Return
return $objWriter->getData();
} | php | {
"resource": ""
} |
q251118 | Workbook.writeFileVersion | validation | private function writeFileVersion(XMLWriter $objWriter)
{
$objWriter->startElement('fileVersion');
$objWriter->writeAttribute('appName', 'xl');
$objWriter->writeAttribute('lastEdited', '4');
$objWriter->writeAttribute('lowestEdited', '4');
$objWriter->writeAttribute('rupBuild', '4505');
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251119 | Workbook.writeWorkbookPr | validation | private function writeWorkbookPr(XMLWriter $objWriter)
{
$objWriter->startElement('workbookPr');
if (Date::getExcelCalendar() == Date::CALENDAR_MAC_1904) {
$objWriter->writeAttribute('date1904', '1');
}
$objWriter->writeAttribute('codeName', 'ThisWorkbook');
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251120 | Workbook.writeBookViews | validation | private function writeBookViews(XMLWriter $objWriter, Spreadsheet $spreadsheet)
{
// bookViews
$objWriter->startElement('bookViews');
// workbookView
$objWriter->startElement('workbookView');
$objWriter->writeAttribute('activeTab', $spreadsheet->getActiveSheetIndex());
$objWriter->writeAttribute('autoFilterDateGrouping', '1');
$objWriter->writeAttribute('firstSheet', '0');
$objWriter->writeAttribute('minimized', '0');
$objWriter->writeAttribute('showHorizontalScroll', '1');
$objWriter->writeAttribute('showSheetTabs', '1');
$objWriter->writeAttribute('showVerticalScroll', '1');
$objWriter->writeAttribute('tabRatio', '600');
$objWriter->writeAttribute('visibility', 'visible');
$objWriter->endElement();
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251121 | Workbook.writeWorkbookProtection | validation | private function writeWorkbookProtection(XMLWriter $objWriter, Spreadsheet $spreadsheet)
{
if ($spreadsheet->getSecurity()->isSecurityEnabled()) {
$objWriter->startElement('workbookProtection');
$objWriter->writeAttribute('lockRevision', ($spreadsheet->getSecurity()->getLockRevision() ? 'true' : 'false'));
$objWriter->writeAttribute('lockStructure', ($spreadsheet->getSecurity()->getLockStructure() ? 'true' : 'false'));
$objWriter->writeAttribute('lockWindows', ($spreadsheet->getSecurity()->getLockWindows() ? 'true' : 'false'));
if ($spreadsheet->getSecurity()->getRevisionsPassword() != '') {
$objWriter->writeAttribute('revisionsPassword', $spreadsheet->getSecurity()->getRevisionsPassword());
}
if ($spreadsheet->getSecurity()->getWorkbookPassword() != '') {
$objWriter->writeAttribute('workbookPassword', $spreadsheet->getSecurity()->getWorkbookPassword());
}
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251122 | Workbook.writeCalcPr | validation | private function writeCalcPr(XMLWriter $objWriter, $recalcRequired = true)
{
$objWriter->startElement('calcPr');
// Set the calcid to a higher value than Excel itself will use, otherwise Excel will always recalc
// If MS Excel does do a recalc, then users opening a file in MS Excel will be prompted to save on exit
// because the file has changed
$objWriter->writeAttribute('calcId', '999999');
$objWriter->writeAttribute('calcMode', 'auto');
// fullCalcOnLoad isn't needed if we've recalculating for the save
$objWriter->writeAttribute('calcCompleted', ($recalcRequired) ? 1 : 0);
$objWriter->writeAttribute('fullCalcOnLoad', ($recalcRequired) ? 0 : 1);
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251123 | Workbook.writeSheet | validation | private function writeSheet(XMLWriter $objWriter, $pSheetname, $pSheetId = 1, $pRelId = 1, $sheetState = 'visible')
{
if ($pSheetname != '') {
// Write sheet
$objWriter->startElement('sheet');
$objWriter->writeAttribute('name', $pSheetname);
$objWriter->writeAttribute('sheetId', $pSheetId);
if ($sheetState != 'visible' && $sheetState != '') {
$objWriter->writeAttribute('state', $sheetState);
}
$objWriter->writeAttribute('r:id', 'rId' . $pRelId);
$objWriter->endElement();
} else {
throw new WriterException('Invalid parameters passed.');
}
} | php | {
"resource": ""
} |
q251124 | Workbook.writeDefinedNames | validation | private function writeDefinedNames(XMLWriter $objWriter, Spreadsheet $spreadsheet)
{
// Write defined names
$objWriter->startElement('definedNames');
// Named ranges
if (count($spreadsheet->getNamedRanges()) > 0) {
// Named ranges
$this->writeNamedRanges($objWriter, $spreadsheet);
}
// Other defined names
$sheetCount = $spreadsheet->getSheetCount();
for ($i = 0; $i < $sheetCount; ++$i) {
// definedName for autoFilter
$this->writeDefinedNameForAutofilter($objWriter, $spreadsheet->getSheet($i), $i);
// definedName for Print_Titles
$this->writeDefinedNameForPrintTitles($objWriter, $spreadsheet->getSheet($i), $i);
// definedName for Print_Area
$this->writeDefinedNameForPrintArea($objWriter, $spreadsheet->getSheet($i), $i);
}
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251125 | Workbook.writeNamedRanges | validation | private function writeNamedRanges(XMLWriter $objWriter, Spreadsheet $spreadsheet)
{
// Loop named ranges
$namedRanges = $spreadsheet->getNamedRanges();
foreach ($namedRanges as $namedRange) {
$this->writeDefinedNameForNamedRange($objWriter, $namedRange);
}
} | php | {
"resource": ""
} |
q251126 | Workbook.writeDefinedNameForNamedRange | validation | private function writeDefinedNameForNamedRange(XMLWriter $objWriter, NamedRange $pNamedRange)
{
// definedName for named range
$objWriter->startElement('definedName');
$objWriter->writeAttribute('name', $pNamedRange->getName());
if ($pNamedRange->getLocalOnly()) {
$objWriter->writeAttribute('localSheetId', $pNamedRange->getScope()->getParent()->getIndex($pNamedRange->getScope()));
}
// Create absolute coordinate and write as raw text
$range = Coordinate::splitRange($pNamedRange->getRange());
$iMax = count($range);
for ($i = 0; $i < $iMax; ++$i) {
$range[$i][0] = '\'' . str_replace("'", "''", $pNamedRange->getWorksheet()->getTitle()) . '\'!' . Coordinate::absoluteReference($range[$i][0]);
if (isset($range[$i][1])) {
$range[$i][1] = Coordinate::absoluteReference($range[$i][1]);
}
}
$range = Coordinate::buildRange($range);
$objWriter->writeRawData($range);
$objWriter->endElement();
} | php | {
"resource": ""
} |
q251127 | Workbook.writeDefinedNameForAutofilter | validation | private function writeDefinedNameForAutofilter(XMLWriter $objWriter, Worksheet $pSheet, $pSheetId = 0)
{
// definedName for autoFilter
$autoFilterRange = $pSheet->getAutoFilter()->getRange();
if (!empty($autoFilterRange)) {
$objWriter->startElement('definedName');
$objWriter->writeAttribute('name', '_xlnm._FilterDatabase');
$objWriter->writeAttribute('localSheetId', $pSheetId);
$objWriter->writeAttribute('hidden', '1');
// Create absolute coordinate and write as raw text
$range = Coordinate::splitRange($autoFilterRange);
$range = $range[0];
// Strip any worksheet ref so we can make the cell ref absolute
if (strpos($range[0], '!') !== false) {
list($ws, $range[0]) = explode('!', $range[0]);
}
$range[0] = Coordinate::absoluteCoordinate($range[0]);
$range[1] = Coordinate::absoluteCoordinate($range[1]);
$range = implode(':', $range);
$objWriter->writeRawData('\'' . str_replace("'", "''", $pSheet->getTitle()) . '\'!' . $range);
$objWriter->endElement();
}
} | php | {
"resource": ""
} |
q251128 | Permission.init | validation | static function init()
{
if (self::$initialized == false) {
self::$NONE = new Permission(1, "none");
self::$SOI = new Permission(2, "soi");
self::$COI = new Permission(3, "coi");
self::$DOI = new Permission(4, "doi");
self::$DOI_PLUS = new Permission(5, "doi+");
self::$OTHER = new Permission(6, "other");
self::$initialized = true;
}
} | php | {
"resource": ""
} |
q251129 | Permission.getPermission | validation | static function getPermission($code)
{
switch ($code) {
case 1:
return self::$NONE;
case "none":
return self::$NONE;
case 2:
return self::$SOI;
case "soi":
return self::$SOI;
case 3:
return self::$COI;
case "coi":
return self::$COI;
case 4:
return self::$DOI;
case "doi":
return self::$DOI;
case 5:
return self::$DOI_PLUS;
case "doi+":
return self::$DOI_PLUS;
case 6:
return self::$OTHER;
case "other":
return self::$OTHER;
default:
return self::$OTHER;
}
} | php | {
"resource": ""
} |
q251130 | ResponseParser.json | validation | public static function json($response)
{
$body = self::toString($response);
$data = json_decode($body, true);
if (JSON_ERROR_NONE !== json_last_error()) {
throw new RuntimeException('Unable to parse response body into JSON: ' . json_last_error());
}
return $data === null ? [] : $data;
} | php | {
"resource": ""
} |
q251131 | ResponseParser.xml | validation | public static function xml($response)
{
$body = self::toString($response);
$errorMessage = null;
$internalErrors = libxml_use_internal_errors(true);
$disableEntities = libxml_disable_entity_loader(true);
libxml_clear_errors();
$xml = null;
try {
$xml = new \SimpleXMLElement((string) $body ?: /** @lang text */
'<root />', LIBXML_NONET);
} catch (\Exception $e) {
$errorMessage = $e->getMessage();
}
libxml_clear_errors();
libxml_use_internal_errors($internalErrors);
libxml_disable_entity_loader($disableEntities);
if ($errorMessage !== null) {
throw new RuntimeException('Unable to parse response body into XML: ' . $errorMessage);
}
return $xml;
} | php | {
"resource": ""
} |
q251132 | AbstractWidget.createHint | validation | protected function createHint()
{
if ($this->getElement()->getHint()) {
$this->hint = $this->builder->make('hint', $this->getElement()->getHintAttributes(), $this->getElement()->getHint());
}
} | php | {
"resource": ""
} |
q251133 | AbstractWidget.createError | validation | protected function createError()
{
$error = $this->getForm()->getValidator()->getMessages($this->getElement()->getName());
if ($error) {
$this->error = $this->builder->make('error', [], $error);
}
} | php | {
"resource": ""
} |
q251134 | AbstractWidget.getInputProps | validation | protected function getInputProps()
{
$props = (array)$this->getElement()->getAttributes();
$props['name'] = $this->get('_element')->get('name');
$props['_form'] = $this->getForm();
$props['_element'] = $this->getElement();
return $props;
} | php | {
"resource": ""
} |
q251135 | ShippingMethodBag.add | validation | public function add($item)
{
if ($item instanceof ShippingMethodInterface) {
$this->items[] = $item;
} else {
$this->items[] = new Item($item);
}
} | php | {
"resource": ""
} |
q251136 | Parser.convert | validation | private function convert($token)
{
if (preg_match('/"([^"]|""){0,255}"/', $token)) {
return $this->convertString($token);
} elseif (is_numeric($token)) {
return $this->convertNumber($token);
// match references like A1 or $A$1
} elseif (preg_match('/^\$?([A-Ia-i]?[A-Za-z])\$?(\d+)$/', $token)) {
return $this->convertRef2d($token);
// match external references like Sheet1!A1 or Sheet1:Sheet2!A1 or Sheet1!$A$1 or Sheet1:Sheet2!$A$1
} elseif (preg_match('/^' . self::REGEX_SHEET_TITLE_UNQUOTED . '(\\:' . self::REGEX_SHEET_TITLE_UNQUOTED . ')?\\!\$?[A-Ia-i]?[A-Za-z]\$?(\\d+)$/u', $token)) {
return $this->convertRef3d($token);
// match external references like 'Sheet1'!A1 or 'Sheet1:Sheet2'!A1 or 'Sheet1'!$A$1 or 'Sheet1:Sheet2'!$A$1
} elseif (preg_match("/^'" . self::REGEX_SHEET_TITLE_QUOTED . '(\\:' . self::REGEX_SHEET_TITLE_QUOTED . ")?'\\!\\$?[A-Ia-i]?[A-Za-z]\\$?(\\d+)$/u", $token)) {
return $this->convertRef3d($token);
// match ranges like A1:B2 or $A$1:$B$2
} elseif (preg_match('/^(\$)?[A-Ia-i]?[A-Za-z](\$)?(\d+)\:(\$)?[A-Ia-i]?[A-Za-z](\$)?(\d+)$/', $token)) {
return $this->convertRange2d($token);
// match external ranges like Sheet1!A1:B2 or Sheet1:Sheet2!A1:B2 or Sheet1!$A$1:$B$2 or Sheet1:Sheet2!$A$1:$B$2
} elseif (preg_match('/^' . self::REGEX_SHEET_TITLE_UNQUOTED . '(\\:' . self::REGEX_SHEET_TITLE_UNQUOTED . ')?\\!\$?([A-Ia-i]?[A-Za-z])?\$?(\\d+)\\:\$?([A-Ia-i]?[A-Za-z])?\$?(\\d+)$/u', $token)) {
return $this->convertRange3d($token);
// match external ranges like 'Sheet1'!A1:B2 or 'Sheet1:Sheet2'!A1:B2 or 'Sheet1'!$A$1:$B$2 or 'Sheet1:Sheet2'!$A$1:$B$2
} elseif (preg_match("/^'" . self::REGEX_SHEET_TITLE_QUOTED . '(\\:' . self::REGEX_SHEET_TITLE_QUOTED . ")?'\\!\\$?([A-Ia-i]?[A-Za-z])?\\$?(\\d+)\\:\\$?([A-Ia-i]?[A-Za-z])?\\$?(\\d+)$/u", $token)) {
return $this->convertRange3d($token);
// operators (including parentheses)
} elseif (isset($this->ptg[$token])) {
return pack('C', $this->ptg[$token]);
// match error codes
} elseif (preg_match('/^#[A-Z0\\/]{3,5}[!?]{1}$/', $token) or $token == '#N/A') {
return $this->convertError($token);
// commented so argument number can be processed correctly. See toReversePolish().
/*elseif (preg_match("/[A-Z0-9\xc0-\xdc\.]+/", $token))
{
return($this->convertFunction($token, $this->_func_args));
}*/
// if it's an argument, ignore the token (the argument remains)
} elseif ($token == 'arg') {
return '';
}
// TODO: use real error codes
throw new WriterException("Unknown token $token");
} | php | {
"resource": ""
} |
q251137 | Parser.convertNumber | validation | private function convertNumber($num)
{
// Integer in the range 0..2**16-1
if ((preg_match('/^\\d+$/', $num)) and ($num <= 65535)) {
return pack('Cv', $this->ptg['ptgInt'], $num);
}
// A float
if (BIFFwriter::getByteOrder()) { // if it's Big Endian
$num = strrev($num);
}
return pack('Cd', $this->ptg['ptgNum'], $num);
} | php | {
"resource": ""
} |
q251138 | Parser.convertString | validation | private function convertString($string)
{
// chop away beggining and ending quotes
$string = substr($string, 1, -1);
if (strlen($string) > 255) {
throw new WriterException('String is too long');
}
return pack('C', $this->ptg['ptgStr']) . StringHelper::UTF8toBIFF8UnicodeShort($string);
} | php | {
"resource": ""
} |
q251139 | Parser.convertFunction | validation | private function convertFunction($token, $num_args)
{
$args = $this->functions[$token][1];
// Fixed number of args eg. TIME($i, $j, $k).
if ($args >= 0) {
return pack('Cv', $this->ptg['ptgFuncV'], $this->functions[$token][0]);
}
// Variable number of args eg. SUM($i, $j, $k, ..).
if ($args == -1) {
return pack('CCv', $this->ptg['ptgFuncVarV'], $num_args, $this->functions[$token][0]);
}
} | php | {
"resource": ""
} |
q251140 | Parser.convertError | validation | private function convertError($errorCode)
{
switch ($errorCode) {
case '#NULL!':
return pack('C', 0x00);
case '#DIV/0!':
return pack('C', 0x07);
case '#VALUE!':
return pack('C', 0x0F);
case '#REF!':
return pack('C', 0x17);
case '#NAME?':
return pack('C', 0x1D);
case '#NUM!':
return pack('C', 0x24);
case '#N/A':
return pack('C', 0x2A);
}
return pack('C', 0xFF);
} | php | {
"resource": ""
} |
q251141 | Parser.advance | validation | private function advance()
{
$i = $this->currentCharacter;
$formula_length = strlen($this->formula);
// eat up white spaces
if ($i < $formula_length) {
while ($this->formula[$i] == ' ') {
++$i;
}
if ($i < ($formula_length - 1)) {
$this->lookAhead = $this->formula[$i + 1];
}
$token = '';
}
while ($i < $formula_length) {
$token .= $this->formula[$i];
if ($i < ($formula_length - 1)) {
$this->lookAhead = $this->formula[$i + 1];
} else {
$this->lookAhead = '';
}
if ($this->match($token) != '') {
$this->currentCharacter = $i + 1;
$this->currentToken = $token;
return 1;
}
if ($i < ($formula_length - 2)) {
$this->lookAhead = $this->formula[$i + 2];
} else { // if we run out of characters lookAhead becomes empty
$this->lookAhead = '';
}
++$i;
}
//die("Lexical error ".$this->currentCharacter);
} | php | {
"resource": ""
} |
q251142 | Parser.parse | validation | public function parse($formula)
{
$this->currentCharacter = 0;
$this->formula = $formula;
$this->lookAhead = isset($formula[1]) ? $formula[1]
: '';
$this->advance();
$this->parseTree = $this->condition();
return true;
} | php | {
"resource": ""
} |
q251143 | ReferenceHelper.cellAddressInDeleteRange | validation | private static function cellAddressInDeleteRange($cellAddress, $beforeRow, $pNumRows, $beforeColumnIndex, $pNumCols)
{
list($cellColumn, $cellRow) = Coordinate::coordinateFromString($cellAddress);
$cellColumnIndex = Coordinate::columnIndexFromString($cellColumn);
// Is cell within the range of rows/columns if we're deleting
if ($pNumRows < 0 &&
($cellRow >= ($beforeRow + $pNumRows)) &&
($cellRow < $beforeRow)) {
return true;
} elseif ($pNumCols < 0 &&
($cellColumnIndex >= ($beforeColumnIndex + $pNumCols)) &&
($cellColumnIndex < $beforeColumnIndex)) {
return true;
}
return false;
} | php | {
"resource": ""
} |
q251144 | ReferenceHelper.updateCellReference | validation | public function updateCellReference($pCellRange = 'A1', $pBefore = 'A1', $pNumCols = 0, $pNumRows = 0)
{
// Is it in another worksheet? Will not have to update anything.
if (strpos($pCellRange, '!') !== false) {
return $pCellRange;
// Is it a range or a single cell?
} elseif (!Coordinate::coordinateIsRange($pCellRange)) {
// Single cell
return $this->updateSingleCellReference($pCellRange, $pBefore, $pNumCols, $pNumRows);
} elseif (Coordinate::coordinateIsRange($pCellRange)) {
// Range
return $this->updateCellRange($pCellRange, $pBefore, $pNumCols, $pNumRows);
}
// Return original
return $pCellRange;
} | php | {
"resource": ""
} |
q251145 | ReferenceHelper.updateCellRange | validation | private function updateCellRange($pCellRange = 'A1:A1', $pBefore = 'A1', $pNumCols = 0, $pNumRows = 0)
{
if (!Coordinate::coordinateIsRange($pCellRange)) {
throw new Exception('Only cell ranges may be passed to this method.');
}
// Update range
$range = Coordinate::splitRange($pCellRange);
$ic = count($range);
for ($i = 0; $i < $ic; ++$i) {
$jc = count($range[$i]);
for ($j = 0; $j < $jc; ++$j) {
if (ctype_alpha($range[$i][$j])) {
$r = Coordinate::coordinateFromString($this->updateSingleCellReference($range[$i][$j] . '1', $pBefore, $pNumCols, $pNumRows));
$range[$i][$j] = $r[0];
} elseif (ctype_digit($range[$i][$j])) {
$r = Coordinate::coordinateFromString($this->updateSingleCellReference('A' . $range[$i][$j], $pBefore, $pNumCols, $pNumRows));
$range[$i][$j] = $r[1];
} else {
$range[$i][$j] = $this->updateSingleCellReference($range[$i][$j], $pBefore, $pNumCols, $pNumRows);
}
}
}
// Recreate range string
return Coordinate::buildRange($range);
} | php | {
"resource": ""
} |
q251146 | ReferenceHelper.updateSingleCellReference | validation | private function updateSingleCellReference($pCellReference = 'A1', $pBefore = 'A1', $pNumCols = 0, $pNumRows = 0)
{
if (Coordinate::coordinateIsRange($pCellReference)) {
throw new Exception('Only single cell references may be passed to this method.');
}
// Get coordinate of $pBefore
list($beforeColumn, $beforeRow) = Coordinate::coordinateFromString($pBefore);
// Get coordinate of $pCellReference
list($newColumn, $newRow) = Coordinate::coordinateFromString($pCellReference);
// Verify which parts should be updated
$updateColumn = (($newColumn[0] != '$') && ($beforeColumn[0] != '$') && (Coordinate::columnIndexFromString($newColumn) >= Coordinate::columnIndexFromString($beforeColumn)));
$updateRow = (($newRow[0] != '$') && ($beforeRow[0] != '$') && $newRow >= $beforeRow);
// Create new column reference
if ($updateColumn) {
$newColumn = Coordinate::stringFromColumnIndex(Coordinate::columnIndexFromString($newColumn) + $pNumCols);
}
// Create new row reference
if ($updateRow) {
$newRow = $newRow + $pNumRows;
}
// Return new reference
return $newColumn . $newRow;
} | php | {
"resource": ""
} |
q251147 | Color.map | validation | public static function map($color, $palette, $version)
{
if ($color <= 0x07 || $color >= 0x40) {
// special built-in color
return Color\BuiltIn::lookup($color);
} elseif (isset($palette, $palette[$color - 8])) {
// palette color, color index 0x08 maps to pallete index 0
return $palette[$color - 8];
}
// default color table
if ($version == Xls::XLS_BIFF8) {
return Color\BIFF8::lookup($color);
}
// BIFF5
return Color\BIFF5::lookup($color);
} | php | {
"resource": ""
} |
q251148 | Segment.setBlocSize | validation | public function setBlocSize($size) {
if (null !== $this->memory) {
throw new Exception\RuntimeException(
'You can not change the segment size because memory is already allocated.'
. ' Use realloc() function to create new memory segment.'
);
}
$this->blocSize = (integer) $size;
return $this;
} | php | {
"resource": ""
} |
q251149 | Legend.setPosition | validation | public function setPosition($position)
{
if (!in_array($position, self::$positionXLref)) {
return false;
}
$this->position = $position;
return true;
} | php | {
"resource": ""
} |
q251150 | Legend.setPositionXL | validation | public function setPositionXL($positionXL)
{
if (!isset(self::$positionXLref[$positionXL])) {
return false;
}
$this->position = self::$positionXLref[$positionXL];
return true;
} | php | {
"resource": ""
} |
q251151 | AbstractJSONWrapper.toArray | validation | function toArray() {
$result = array();
$object_vars = get_object_vars($this);
// copy each of this objects properties to an associative array
// indexed by the property names
foreach($object_vars as $key => $value) {
if($value == null) { continue; }
// if $value is an object, we can call toArray on it, and it
// should be serialized (isEmpty returns true) than we call
// toArray and insert the result in our array;
// otherwise we insert the value as-is
if(gettype($value) == "object" &&
is_subclass_of($value, 'AbstractJSONWrapper')) {
if(!$value->isEmpty()) {
$result[$key] = $value->toArray();
}
} else {
// TODO: maybe deal with com_maileon_api_json_AbstractJSONWrapper
// derived classes that have 'non-serializable' properties
$result[$key] = $value;
}
}
// return the resulting array
return $result;
} | php | {
"resource": ""
} |
q251152 | AbstractJSONWrapper.fromArray | validation | function fromArray($object_vars) {
// copy each key to the property named the same way; if the property
// is a serializable Maileon class, call fromArray on it
foreach($object_vars as $key => $value) {
if(class_exists('AbstractJSONWrapper') && is_subclass_of( $this->{$key},'AbstractJSONWrapper' )) {
$this->{$key}->fromArray($value);
} else {
$this->{$key} = $value;
}
}
} | php | {
"resource": ""
} |
q251153 | Mailing.fromXML | validation | function fromXML($xmlElement)
{
if (isset($xmlElement->id)) $this->id = $xmlElement->id;
if (isset($xmlElement->fields)) {
$this->fields = array();
foreach ($xmlElement->fields->children() as $field) {
$this->fields[trim($field->name)] = (string)$field->value; // The trim is required to make a safer string from the object
}
}
} | php | {
"resource": ""
} |
q251154 | Mailing.getFieldValue | validation | function getFieldValue($fieldName)
{
$name = trim($fieldName);
if (isset($this->fields)) {
return ($this->fields[$name]);
}
return;
} | php | {
"resource": ""
} |
q251155 | NoAssociationsIndexMenuFactory.create | validation | public function create($modelName, ModelConfig $config = null) {
$menu = new Menu();
$addMenuItem = new LinkMenuItem();
$addMenuItem->setText(Lang::trans('Add'));
$addMenuItem->setIcon(Icons::ion_plus);
$addMenuItem->setTarget(URL::route($this->aujaRouter->getCreateName($modelName)));
$menu->addMenuItem($addMenuItem);
$spacerMenuItem = new SpacerMenuItem();
$spacerMenuItem->setText(Lang::trans($modelName));
$menu->addMenuItem($spacerMenuItem);
$resourceMenuItem = new ResourceMenuItem();
$resourceMenuItem->setTarget(URL::route($this->aujaRouter->getIndexName($modelName)));
$model = $this->aujaConfigurator->getModel($modelName);
if($this->aujaConfigurator->isSearchable($model, $config)){
$target = urldecode(URL::route($this->aujaRouter->getIndexName($modelName), ['q' => '%s'])); /* urldecode because the '%' gets escaped. */
$property = new Searchable($target);
$resourceMenuItem->addProperty($property);
}
$menu->addMenuItem($resourceMenuItem);
return $menu;
} | php | {
"resource": ""
} |
q251156 | SpreadsheetView.render | validation | public function render($action = null, $layout = null) {
$this->viewPath .= DS . 'Spreadsheet';
$content = parent::render($action, false);
if ($this->response->type() == 'text/html') {
return $content;
}
ob_start();
$writer = IOFactory::createWriter($this->Spreadsheet, CAKE_SPREADSHEET_PHPSPREADSHEET_WRITER);
$writer->setPreCalculateFormulas(false);
$writer->save('php://output');
$content = ob_get_clean();
$this->Blocks->set('content', $content);
$fileName = $this->getFileName();
$fileName .= '.' . CAKE_SPREADSHEET_FILE_EXTENSION;
$this->response->download($fileName);
return $this->Blocks->get('content');
} | php | {
"resource": ""
} |
q251157 | AujaConfigurator.configure | validation | public function configure(array $modelConfigurations) {
if (empty($modelConfigurations)) {
throw new \LogicException('Supply at least one model or model configuration!');
}
/* First define the models and their columns. */
foreach ($modelConfigurations as $className) {
$modelClass = $className;
if (is_subclass_of($className, 'Illuminate\Database\Eloquent\Model')) {
$config = new ModelConfig();
$config->setModelClass($modelClass);
}
else if (is_subclass_of($className, 'Label305\AujaLaravel\Config\ModelConfig')) {
$config = new $className();
$modelClass = $config->getModelClass();
}
else {
throw new \InvalidArgumentException(
"Model configuration should be class name string of either a ModelConfig or Eloquent subclass."
);
}
$model = new Model($modelClass);
$this->models[$modelClass] = $model;
$this->relations[$modelClass] = [];
$configResolver = new ConfigResolver($config, $model);
$this->configs[$modelClass] = $configResolver->resolve();
$this->findColumns($this->models[$modelClass]);
$this->configs[$modelClass] = $configResolver->resolve(); // TODO: Find a workaround for doing this twice.
}
/* Find relations */
$this->findRelations(array_values($this->models));
} | php | {
"resource": ""
} |
q251158 | AujaConfigurator.getRelationsForModel | validation | public function getRelationsForModel(Model $model) {
if (empty($this->models)) {
throw new \LogicException('AujaConfigurator not configured yet! Call configure first.');
}
return !is_null($model) && isset($this->relations[$model->getName()]) ? $this->relations[$model->getName()] : [];
} | php | {
"resource": ""
} |
q251159 | AujaConfigurator.getTableName | validation | public function getTableName(Model $model, ModelConfig $config = null) {
if (empty($this->models)) {
throw new \LogicException('AujaConfigurator not configured yet! Call configure first.');
}
if (!isset($this->configs[$model->getName()])) {
throw new \LogicException(sprintf('AujaConfigurator not configured for model %s', $model->getName()));
}
$result = null;
if ($config != null && $config->getTableName() != null) {
$result = $config->getTableName();
} else {
$modelConfig = $this->configs[$model->getName()];
$result = $modelConfig->getTableName();
}
return $result;
} | php | {
"resource": ""
} |
q251160 | AujaConfigurator.findColumns | validation | private function findColumns(Model $model) {
//$this->app['log']->debug('Finding columns for model ' . $model->getName());
$tableName = $this->getTableName($model);
if (!$this->databaseRepository->hasTable($tableName)) {
throw new \InvalidArgumentException(sprintf('Table %s for %s does not exist!', $tableName, $model->getName()));
}
$columns = $this->databaseRepository->getColumnListing($tableName);
foreach ($columns as $columnName) {
//$this->app['log']->debug(sprintf('Adding column %s to %s', $columnName, $model->getName()));
$columnType = $this->databaseRepository->getColumnType($tableName, $columnName);
$model->addColumn(new Column($columnName, $columnType));
}
} | php | {
"resource": ""
} |
q251161 | AujaConfigurator.findSimpleRelations | validation | private function findSimpleRelations(Model $model) {
//$this->app['log']->debug(sprintf('Finding relations for %s', $model->getName()));
foreach ($model->getColumns() as $column) {
if (ends_with($column->getName(), self::ID_SUFFIX)) {
$this->defineRelation($model, $column->getName());
}
}
} | php | {
"resource": ""
} |
q251162 | AujaConfigurator.findManyToManyRelations | validation | private function findManyToManyRelations(array $models) {
//$this->app['log']->debug('Finding many to many relations');
for ($i = 0; $i < sizeof($models); $i++) {
for ($j = $i + 1; $j < sizeof($models); $j++) {
$model1 = $models[$i];
$model2 = $models[$j];
/* We assume names of pivot tables are alphabetically ordered */
if (strcasecmp($model1->getName(), $model2->getName()) < 0) {
$tableName = strtolower($model1->getName()) . '_' . strtolower($model2->getName());
} else {
$tableName = strtolower($model2->getName()) . '_' . strtolower($model1->getName());
}
if ($this->databaseRepository->hasTable($tableName)) {
$this->defineManyToManyRelation($model1, $model2);
}
}
}
} | php | {
"resource": ""
} |
q251163 | AujaConfigurator.defineManyToManyRelation | validation | private function defineManyToManyRelation(Model $model1, Model $model2) {
//$this->app['log']->info(sprintf('%s has and belongs to many %s', $model1->getName(), str_plural($model2->getName())));
$this->relations[$model1->getName()][] = new Relation($model1, $model2, Relation::HAS_AND_BELONGS_TO);
$this->relations[$model2->getName()][] = new Relation($model2, $model1, Relation::HAS_AND_BELONGS_TO);
} | php | {
"resource": ""
} |
q251164 | Parameters.requireParam | validation | public function requireParam($key)
{
$param = $this->fetch($key, function ($key) {
throw new ParameterMissingException("Missing param '$key'");
});
if ($this->valueIsEmpty($param)) {
throw new ParameterMissingException("Missing param '$key'");
}
return $param;
} | php | {
"resource": ""
} |
q251165 | Parameters.filter | validation | public function filter(Parameters $params, array $permitted = array())
{
$this->cleanUnwanted($params, $permitted);
$this->handleArrays($params, $permitted);
$this->handleCollections($params, $permitted);
} | php | {
"resource": ""
} |
q251166 | Parameters.handleCollections | validation | private function handleCollections(Parameters $params, array $permitted = array())
{
// if is empty, any value is allowed
if (empty($permitted)) {
return;
}
$keys = $params->keys();
$intKeys = $keys->select(function ($value) {
return is_int($value);
});
if ($keys->count() === $intKeys->count()) {
foreach ($keys as $key) {
$value = $params[$key];
if ($value instanceof Parameters) {
$this->filter($value, $permitted);
}
}
}
} | php | {
"resource": ""
} |
q251167 | Parameters.handleArrays | validation | private function handleArrays(Parameters $params, array $permitted = array())
{
foreach ($permitted as $key => $allowed) {
if (is_array($allowed) && $params->hasKey($key)) {
$value = $params[$key];
if ($value instanceof Parameters) {
$this->filter($value, $allowed);
} else {
$this->handleUnpermittedParam($key, $params);
}
}
}
} | php | {
"resource": ""
} |
q251168 | Parameters.cleanUnwanted | validation | private function cleanUnwanted(Parameters $params, $permitted)
{
foreach ($params->toArray() as $key => $value) {
if (is_array($value) && !is_int($key)) {
if (!array_key_exists($key, $permitted)) {
$this->handleUnpermittedParam($key, $params);
}
} elseif (!is_int($key) && !in_array($key, $permitted) && !array_key_exists($key, $permitted)) {
$this->handleUnpermittedParam($key, $params);
}
}
} | php | {
"resource": ""
} |
q251169 | Parameters.valueIsEmpty | validation | protected function valueIsEmpty($value)
{
return (
is_object($value) &&
$value instanceof Parameters &&
$value->isEmpty()
) || (is_array($value) && !count($value));
} | php | {
"resource": ""
} |
q251170 | Parameters.handleUnpermittedParam | validation | protected function handleUnpermittedParam($key, $params)
{
if ($this->getThrowExceptions()) {
$message = "Parameter '$key' is not allowed";
throw new UnpermittedParameterException($message);
}
$params->delete($key);
} | php | {
"resource": ""
} |
q251171 | Column.setFilterType | validation | public function setFilterType($pFilterType)
{
if (!in_array($pFilterType, self::$filterTypes)) {
throw new PhpSpreadsheetException('Invalid filter type for column AutoFilter.');
}
$this->filterType = $pFilterType;
return $this;
} | php | {
"resource": ""
} |
q251172 | Column.getRule | validation | public function getRule($pIndex)
{
if (!isset($this->ruleset[$pIndex])) {
$this->ruleset[$pIndex] = new Column\Rule($this);
}
return $this->ruleset[$pIndex];
} | php | {
"resource": ""
} |
q251173 | Column.addRule | validation | public function addRule(Column\Rule $pRule)
{
$pRule->setParent($this);
$this->ruleset[] = $pRule;
return $this;
} | php | {
"resource": ""
} |
q251174 | Rule.setRuleType | validation | public function setRuleType($pRuleType)
{
if (!in_array($pRuleType, self::$ruleTypes)) {
throw new PhpSpreadsheetException('Invalid rule type for column AutoFilter Rule.');
}
$this->ruleType = $pRuleType;
return $this;
} | php | {
"resource": ""
} |
q251175 | Rule.setValue | validation | public function setValue($pValue)
{
if (is_array($pValue)) {
$grouping = -1;
foreach ($pValue as $key => $value) {
// Validate array entries
if (!in_array($key, self::$dateTimeGroups)) {
// Remove any invalid entries from the value array
unset($pValue[$key]);
} else {
// Work out what the dateTime grouping will be
$grouping = max($grouping, array_search($key, self::$dateTimeGroups));
}
}
if (count($pValue) == 0) {
throw new PhpSpreadsheetException('Invalid rule value for column AutoFilter Rule.');
}
// Set the dateTime grouping that we've anticipated
$this->setGrouping(self::$dateTimeGroups[$grouping]);
}
$this->value = $pValue;
return $this;
} | php | {
"resource": ""
} |
q251176 | Rule.setOperator | validation | public function setOperator($pOperator)
{
if (empty($pOperator)) {
$pOperator = self::AUTOFILTER_COLUMN_RULE_EQUAL;
}
if ((!in_array($pOperator, self::$operators)) &&
(!in_array($pOperator, self::$topTenValue))) {
throw new PhpSpreadsheetException('Invalid operator for column AutoFilter Rule.');
}
$this->operator = $pOperator;
return $this;
} | php | {
"resource": ""
} |
q251177 | Rule.setGrouping | validation | public function setGrouping($pGrouping)
{
if (($pGrouping !== null) &&
(!in_array($pGrouping, self::$dateTimeGroups)) &&
(!in_array($pGrouping, self::$dynamicTypes)) &&
(!in_array($pGrouping, self::$topTenType))) {
throw new PhpSpreadsheetException('Invalid rule type for column AutoFilter Rule.');
}
$this->grouping = $pGrouping;
return $this;
} | php | {
"resource": ""
} |
q251178 | Worksheet.checkSheetCodeName | validation | private static function checkSheetCodeName($pValue)
{
$CharCount = Shared\StringHelper::countCharacters($pValue);
if ($CharCount == 0) {
throw new Exception('Sheet code name cannot be empty.');
}
// Some of the printable ASCII characters are invalid: * : / \ ? [ ] and first and last characters cannot be a "'"
if ((str_replace(self::$invalidCharacters, '', $pValue) !== $pValue) ||
(Shared\StringHelper::substring($pValue, -1, 1) == '\'') ||
(Shared\StringHelper::substring($pValue, 0, 1) == '\'')) {
throw new Exception('Invalid character found in sheet code name');
}
// Maximum 31 characters allowed for sheet title
if ($CharCount > 31) {
throw new Exception('Maximum 31 characters allowed in sheet code name.');
}
return $pValue;
} | php | {
"resource": ""
} |
q251179 | Worksheet.checkSheetTitle | validation | private static function checkSheetTitle($pValue)
{
// Some of the printable ASCII characters are invalid: * : / \ ? [ ]
if (str_replace(self::$invalidCharacters, '', $pValue) !== $pValue) {
throw new Exception('Invalid character found in sheet title');
}
// Maximum 31 characters allowed for sheet title
if (Shared\StringHelper::countCharacters($pValue) > 31) {
throw new Exception('Maximum 31 characters allowed in sheet title.');
}
return $pValue;
} | php | {
"resource": ""
} |
q251180 | Worksheet.addChart | validation | public function addChart(Chart $pChart, $iChartIndex = null)
{
$pChart->setWorksheet($this);
if ($iChartIndex === null) {
$this->chartCollection[] = $pChart;
} else {
// Insert the chart at the requested index
array_splice($this->chartCollection, $iChartIndex, 0, [$pChart]);
}
return $pChart;
} | php | {
"resource": ""
} |
q251181 | Worksheet.calculateColumnWidths | validation | public function calculateColumnWidths()
{
// initialize $autoSizes array
$autoSizes = [];
foreach ($this->getColumnDimensions() as $colDimension) {
if ($colDimension->getAutoSize()) {
$autoSizes[$colDimension->getColumnIndex()] = -1;
}
}
// There is only something to do if there are some auto-size columns
if (!empty($autoSizes)) {
// build list of cells references that participate in a merge
$isMergeCell = [];
foreach ($this->getMergeCells() as $cells) {
foreach (Coordinate::extractAllCellReferencesInRange($cells) as $cellReference) {
$isMergeCell[$cellReference] = true;
}
}
// loop through all cells in the worksheet
foreach ($this->getCoordinates(false) as $coordinate) {
$cell = $this->getCell($coordinate, false);
if ($cell !== null && isset($autoSizes[$this->cellCollection->getCurrentColumn()])) {
//Determine if cell is in merge range
$isMerged = isset($isMergeCell[$this->cellCollection->getCurrentCoordinate()]);
//By default merged cells should be ignored
$isMergedButProceed = false;
//The only exception is if it's a merge range value cell of a 'vertical' randge (1 column wide)
if ($isMerged && $cell->isMergeRangeValueCell()) {
$range = $cell->getMergeRange();
$rangeBoundaries = Coordinate::rangeDimension($range);
if ($rangeBoundaries[0] == 1) {
$isMergedButProceed = true;
}
}
// Determine width if cell does not participate in a merge or does and is a value cell of 1-column wide range
if (!$isMerged || $isMergedButProceed) {
// Calculated value
// To formatted string
$cellValue = NumberFormat::toFormattedString(
$cell->getCalculatedValue(),
$this->getParent()->getCellXfByIndex($cell->getXfIndex())->getNumberFormat()->getFormatCode()
);
$autoSizes[$this->cellCollection->getCurrentColumn()] = max(
(float) $autoSizes[$this->cellCollection->getCurrentColumn()],
(float) Shared\Font::calculateColumnWidth(
$this->getParent()->getCellXfByIndex($cell->getXfIndex())->getFont(),
$cellValue,
$this->getParent()->getCellXfByIndex($cell->getXfIndex())->getAlignment()->getTextRotation(),
$this->getParent()->getDefaultStyle()->getFont()
)
);
}
}
}
// adjust column widths
foreach ($autoSizes as $columnIndex => $width) {
if ($width == -1) {
$width = $this->getDefaultColumnDimension()->getWidth();
}
$this->getColumnDimension($columnIndex)->setWidth($width);
}
}
return $this;
} | php | {
"resource": ""
} |
q251182 | Worksheet.setTitle | validation | public function setTitle($pValue, $updateFormulaCellReferences = true, $validate = true)
{
// Is this a 'rename' or not?
if ($this->getTitle() == $pValue) {
return $this;
}
// Old title
$oldTitle = $this->getTitle();
if ($validate) {
// Syntax check
self::checkSheetTitle($pValue);
if ($this->parent) {
// Is there already such sheet name?
if ($this->parent->sheetNameExists($pValue)) {
// Use name, but append with lowest possible integer
if (Shared\StringHelper::countCharacters($pValue) > 29) {
$pValue = Shared\StringHelper::substring($pValue, 0, 29);
}
$i = 1;
while ($this->parent->sheetNameExists($pValue . ' ' . $i)) {
++$i;
if ($i == 10) {
if (Shared\StringHelper::countCharacters($pValue) > 28) {
$pValue = Shared\StringHelper::substring($pValue, 0, 28);
}
} elseif ($i == 100) {
if (Shared\StringHelper::countCharacters($pValue) > 27) {
$pValue = Shared\StringHelper::substring($pValue, 0, 27);
}
}
}
$pValue .= " $i";
}
}
}
// Set title
$this->title = $pValue;
$this->dirty = true;
if ($this->parent && $this->parent->getCalculationEngine()) {
// New title
$newTitle = $this->getTitle();
$this->parent->getCalculationEngine()
->renameCalculationCacheForWorksheet($oldTitle, $newTitle);
if ($updateFormulaCellReferences) {
ReferenceHelper::getInstance()->updateNamedFormulas($this->parent, $oldTitle, $newTitle);
}
}
return $this;
} | php | {
"resource": ""
} |
q251183 | Worksheet.setProtection | validation | public function setProtection(Protection $pValue)
{
$this->protection = $pValue;
$this->dirty = true;
return $this;
} | php | {
"resource": ""
} |
q251184 | Worksheet.setCellValueExplicit | validation | public function setCellValueExplicit($pCoordinate, $pValue, $pDataType)
{
// Set value
$this->getCell($pCoordinate)->setValueExplicit($pValue, $pDataType);
return $this;
} | php | {
"resource": ""
} |
q251185 | Worksheet.getCellByColumnAndRow | validation | public function getCellByColumnAndRow($columnIndex, $row, $createIfNotExists = true)
{
$columnLetter = Coordinate::stringFromColumnIndex($columnIndex);
$coordinate = $columnLetter . $row;
if ($this->cellCollection->has($coordinate)) {
return $this->cellCollection->get($coordinate);
}
// Create new cell object, if required
return $createIfNotExists ? $this->createNewCell($coordinate) : null;
} | php | {
"resource": ""
} |
q251186 | Worksheet.createNewCell | validation | private function createNewCell($pCoordinate)
{
$cell = new Cell(null, DataType::TYPE_NULL, $this);
$this->cellCollection->add($pCoordinate, $cell);
$this->cellCollectionIsSorted = false;
// Coordinates
$aCoordinates = Coordinate::coordinateFromString($pCoordinate);
if (Coordinate::columnIndexFromString($this->cachedHighestColumn) < Coordinate::columnIndexFromString($aCoordinates[0])) {
$this->cachedHighestColumn = $aCoordinates[0];
}
$this->cachedHighestRow = max($this->cachedHighestRow, $aCoordinates[1]);
// Cell needs appropriate xfIndex from dimensions records
// but don't create dimension records if they don't already exist
$rowDimension = $this->getRowDimension($aCoordinates[1], false);
$columnDimension = $this->getColumnDimension($aCoordinates[0], false);
if ($rowDimension !== null && $rowDimension->getXfIndex() > 0) {
// then there is a row dimension with explicit style, assign it to the cell
$cell->setXfIndex($rowDimension->getXfIndex());
} elseif ($columnDimension !== null && $columnDimension->getXfIndex() > 0) {
// then there is a column dimension, assign it to the cell
$cell->setXfIndex($columnDimension->getXfIndex());
}
return $cell;
} | php | {
"resource": ""
} |
q251187 | Worksheet.cellExists | validation | public function cellExists($pCoordinate)
{
// Worksheet reference?
if (strpos($pCoordinate, '!') !== false) {
$worksheetReference = self::extractSheetTitle($pCoordinate, true);
return $this->parent->getSheetByName($worksheetReference[0])->cellExists(strtoupper($worksheetReference[1]));
}
// Named range?
if ((!preg_match('/^' . Calculation::CALCULATION_REGEXP_CELLREF . '$/i', $pCoordinate, $matches)) &&
(preg_match('/^' . Calculation::CALCULATION_REGEXP_NAMEDRANGE . '$/i', $pCoordinate, $matches))) {
$namedRange = NamedRange::resolveRange($pCoordinate, $this);
if ($namedRange !== null) {
$pCoordinate = $namedRange->getRange();
if ($this->getHashCode() != $namedRange->getWorksheet()->getHashCode()) {
if (!$namedRange->getLocalOnly()) {
return $namedRange->getWorksheet()->cellExists($pCoordinate);
}
throw new Exception('Named range ' . $namedRange->getName() . ' is not accessible from within sheet ' . $this->getTitle());
}
} else {
return false;
}
}
// Uppercase coordinate
$pCoordinate = strtoupper($pCoordinate);
if (Coordinate::coordinateIsRange($pCoordinate)) {
throw new Exception('Cell coordinate can not be a range of cells.');
} elseif (strpos($pCoordinate, '$') !== false) {
throw new Exception('Cell coordinate must not be absolute.');
}
// Cell exists?
return $this->cellCollection->has($pCoordinate);
} | php | {
"resource": ""
} |
q251188 | Worksheet.getRowDimension | validation | public function getRowDimension($pRow, $create = true)
{
// Found
$found = null;
// Get row dimension
if (!isset($this->rowDimensions[$pRow])) {
if (!$create) {
return null;
}
$this->rowDimensions[$pRow] = new RowDimension($pRow);
$this->cachedHighestRow = max($this->cachedHighestRow, $pRow);
}
return $this->rowDimensions[$pRow];
} | php | {
"resource": ""
} |
q251189 | Worksheet.getColumnDimension | validation | public function getColumnDimension($pColumn, $create = true)
{
// Uppercase coordinate
$pColumn = strtoupper($pColumn);
// Fetch dimensions
if (!isset($this->columnDimensions[$pColumn])) {
if (!$create) {
return null;
}
$this->columnDimensions[$pColumn] = new ColumnDimension($pColumn);
if (Coordinate::columnIndexFromString($this->cachedHighestColumn) < Coordinate::columnIndexFromString($pColumn)) {
$this->cachedHighestColumn = $pColumn;
}
}
return $this->columnDimensions[$pColumn];
} | php | {
"resource": ""
} |
q251190 | Worksheet.getStyleByColumnAndRow | validation | public function getStyleByColumnAndRow($columnIndex1, $row1, $columnIndex2 = null, $row2 = null)
{
if ($columnIndex2 !== null && $row2 !== null) {
$cellRange = Coordinate::stringFromColumnIndex($columnIndex1) . $row1 . ':' . Coordinate::stringFromColumnIndex($columnIndex2) . $row2;
return $this->getStyle($cellRange);
}
return $this->getStyle(Coordinate::stringFromColumnIndex($columnIndex1) . $row1);
} | php | {
"resource": ""
} |
q251191 | Worksheet.duplicateStyle | validation | public function duplicateStyle(Style $pCellStyle, $pRange)
{
// Add the style to the workbook if necessary
$workbook = $this->parent;
if ($existingStyle = $this->parent->getCellXfByHashCode($pCellStyle->getHashCode())) {
// there is already such cell Xf in our collection
$xfIndex = $existingStyle->getIndex();
} else {
// we don't have such a cell Xf, need to add
$workbook->addCellXf($pCellStyle);
$xfIndex = $pCellStyle->getIndex();
}
// Calculate range outer borders
list($rangeStart, $rangeEnd) = Coordinate::rangeBoundaries($pRange . ':' . $pRange);
// Make sure we can loop upwards on rows and columns
if ($rangeStart[0] > $rangeEnd[0] && $rangeStart[1] > $rangeEnd[1]) {
$tmp = $rangeStart;
$rangeStart = $rangeEnd;
$rangeEnd = $tmp;
}
// Loop through cells and apply styles
for ($col = $rangeStart[0]; $col <= $rangeEnd[0]; ++$col) {
for ($row = $rangeStart[1]; $row <= $rangeEnd[1]; ++$row) {
$this->getCell(Coordinate::stringFromColumnIndex($col) . $row)->setXfIndex($xfIndex);
}
}
return $this;
} | php | {
"resource": ""
} |
q251192 | Worksheet.duplicateConditionalStyle | validation | public function duplicateConditionalStyle(array $pCellStyle, $pRange = '')
{
foreach ($pCellStyle as $cellStyle) {
if (!($cellStyle instanceof Conditional)) {
throw new Exception('Style is not a conditional style');
}
}
// Calculate range outer borders
list($rangeStart, $rangeEnd) = Coordinate::rangeBoundaries($pRange . ':' . $pRange);
// Make sure we can loop upwards on rows and columns
if ($rangeStart[0] > $rangeEnd[0] && $rangeStart[1] > $rangeEnd[1]) {
$tmp = $rangeStart;
$rangeStart = $rangeEnd;
$rangeEnd = $tmp;
}
// Loop through cells and apply styles
for ($col = $rangeStart[0]; $col <= $rangeEnd[0]; ++$col) {
for ($row = $rangeStart[1]; $row <= $rangeEnd[1]; ++$row) {
$this->setConditionalStyles(Coordinate::stringFromColumnIndex($col) . $row, $pCellStyle);
}
}
return $this;
} | php | {
"resource": ""
} |
q251193 | Worksheet.setBreak | validation | public function setBreak($pCoordinate, $pBreak)
{
// Uppercase coordinate
$pCoordinate = strtoupper($pCoordinate);
if ($pCoordinate != '') {
if ($pBreak == self::BREAK_NONE) {
if (isset($this->breaks[$pCoordinate])) {
unset($this->breaks[$pCoordinate]);
}
} else {
$this->breaks[$pCoordinate] = $pBreak;
}
} else {
throw new Exception('No cell coordinate specified.');
}
return $this;
} | php | {
"resource": ""
} |
q251194 | Worksheet.mergeCells | validation | public function mergeCells($pRange)
{
// Uppercase coordinate
$pRange = strtoupper($pRange);
if (strpos($pRange, ':') !== false) {
$this->mergeCells[$pRange] = $pRange;
// make sure cells are created
// get the cells in the range
$aReferences = Coordinate::extractAllCellReferencesInRange($pRange);
// create upper left cell if it does not already exist
$upperLeft = $aReferences[0];
if (!$this->cellExists($upperLeft)) {
$this->getCell($upperLeft)->setValueExplicit(null, DataType::TYPE_NULL);
}
// Blank out the rest of the cells in the range (if they exist)
$count = count($aReferences);
for ($i = 1; $i < $count; ++$i) {
if ($this->cellExists($aReferences[$i])) {
$this->getCell($aReferences[$i])->setValueExplicit(null, DataType::TYPE_NULL);
}
}
} else {
throw new Exception('Merge must be set on a range of cells.');
}
return $this;
} | php | {
"resource": ""
} |
q251195 | Worksheet.mergeCellsByColumnAndRow | validation | public function mergeCellsByColumnAndRow($columnIndex1, $row1, $columnIndex2, $row2)
{
$cellRange = Coordinate::stringFromColumnIndex($columnIndex1) . $row1 . ':' . Coordinate::stringFromColumnIndex($columnIndex2) . $row2;
return $this->mergeCells($cellRange);
} | php | {
"resource": ""
} |
q251196 | Worksheet.unmergeCellsByColumnAndRow | validation | public function unmergeCellsByColumnAndRow($columnIndex1, $row1, $columnIndex2, $row2)
{
$cellRange = Coordinate::stringFromColumnIndex($columnIndex1) . $row1 . ':' . Coordinate::stringFromColumnIndex($columnIndex2) . $row2;
return $this->unmergeCells($cellRange);
} | php | {
"resource": ""
} |
q251197 | Worksheet.protectCells | validation | public function protectCells($pRange, $pPassword, $pAlreadyHashed = false)
{
// Uppercase coordinate
$pRange = strtoupper($pRange);
if (!$pAlreadyHashed) {
$pPassword = Shared\PasswordHasher::hashPassword($pPassword);
}
$this->protectedCells[$pRange] = $pPassword;
return $this;
} | php | {
"resource": ""
} |
q251198 | Worksheet.protectCellsByColumnAndRow | validation | public function protectCellsByColumnAndRow($columnIndex1, $row1, $columnIndex2, $row2, $password, $alreadyHashed = false)
{
$cellRange = Coordinate::stringFromColumnIndex($columnIndex1) . $row1 . ':' . Coordinate::stringFromColumnIndex($columnIndex2) . $row2;
return $this->protectCells($cellRange, $password, $alreadyHashed);
} | php | {
"resource": ""
} |
q251199 | Worksheet.unprotectCells | validation | public function unprotectCells($pRange)
{
// Uppercase coordinate
$pRange = strtoupper($pRange);
if (isset($this->protectedCells[$pRange])) {
unset($this->protectedCells[$pRange]);
} else {
throw new Exception('Cell range ' . $pRange . ' not known as protected.');
}
return $this;
} | php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.