Get the table cells size

@return int
161858
public function getTableCellSize()
    {
        if ($this->column_size===0 && $this->line_size===0 && $this->cell_size===0) {
            $this->_parseTableSizes();
        }
        return $this->cell_size;
    }
1186210
public function getSize() : int
    {
        $files = $this->getFiles();
        $size = 0;
        foreach($files as $file) {
            $size += $file->getSize();
        }
        return $size;
    }
1243574
public function render()
    {
        $this->calculateColumnWidth();
        $output = $this->isShowBorder
            ? $this->renderBorder()
            : '';
        foreach ($this->rows as $rowIndex => $row) {
            foreach ($row as $cellIndex => $cell) {
                $output .= $this->renderCell($cellIndex, $row);
            }
            $output .= "\n";
            if ($rowIndex === self::HEADER_INDEX) {
                $output .= $this->renderBorder();
            }
        }
        $output .= $this->isShowBorder
            ? $this->renderBorder()
            : '';

        return $output;
    }
93638
public int getRowWidth() {

        int overallWidth = 0;
        for (int i = 0; i < data.length; i++) {
            overallWidth += getTable().getColumnWidth(i);
        }
        return overallWidth;
    }
408604
public function size()
    {
        eZDebugSetting::writeDebug( 'kernel-clustering', "dfs::size()" );
        return isset( $this->metaData['size'] ) ? (int)$this->metaData['size'] : null;
    }
1097664
public static function getWidth()
    {
        $width = getenv('COLUMNS');
        if ($width !== false) {
            return (int) trim($width);
        }

        static::updateDimensions();

        return static::$width;
    }
766231
function columnNum(){
        var count;
        var $headerColumns = $header.find(opts.headerCellSelector);
        if(existingColGroup){
          count = $tableColGroup.find('col').length;
        } else {
          count = 0;
          $headerColumns.each(function () {
            count += parseInt(($(this).attr('colspan') || 1), 10);
          });
        }
        if(count !== lastColumnCount){
          lastColumnCount = count;
          var cells = [], cols = [], psuedo = [], content;
          for(var x = 0; x < count; x++){
            content = $headerColumns.eq(x).text();
            cells.push('<th class="floatThead-col" aria-label="'+content+'"/>');
            cols.push('<col/>');
            psuedo.push(
              $('<fthtd>').css({
                'display': 'table-cell',
                'height': 0,
                'width': 'auto'
              })
            );
          }

          cols = cols.join('');
          cells = cells.join('');

          if(createElements){
            $fthRow.empty();
            $fthRow.append(psuedo);
            $fthCells = $fthRow.find('fthtd');
          }

          $sizerRow.html(cells);
          $sizerCells = $sizerRow.find("th");
          if(!existingColGroup){
            $tableColGroup.html(cols);
          }
          $tableCells = $tableColGroup.find('col');
          $floatColGroup.html(cols);
          $headerCells = $floatColGroup.find("col");

        }
        return count;
      }
371919
protected function getModelPageSize()
    {
        $pageSize = $this->getModelInformation()->list->page_size;

        if (is_array($pageSize)) {
            return (int) head($pageSize);
        }

        return (int) $pageSize;
    }
895991
function getMinWidthByTableCells( cells ) {

        var minWidth = Number.MAX_VALUE;

        for( var i = 0, curCell; curCell = cells[ i ] ; i++ ) {

            minWidth = Math.min( minWidth, curCell.width || getTableCellWidth( curCell ) );

        }

        return minWidth;

    }
462743
public function getSize()
    {
        $size = $this->image->getSize();

        return $this->arr([
                              'width'  => $size->getWidth(),
                              'height' => $size->getHeight()
                          ]
        );
    }
61278
public function size()
    {
        $size = 0;
        if ( ! is_null($this->data_)) {
            $l = strlen($this->data_);
            $size += 1 + Protobuf::size_varint($l) + $l;
        }
        if ( ! is_null($this->uncompressSize_)) {
            $size += 1 + Protobuf::size_varint($this->uncompressSize_);
        }

        return $size;
    }
106144
public int getNumberOfColumns() {
        List<WebElement> cells;
        String xPath = getXPathBase() + "tr";

        List<WebElement> elements = HtmlElementUtils.locateElements(xPath);

        if (elements.size() > 0 && getDataStartIndex() - 1 < elements.size()) {
            cells = elements.get(getDataStartIndex() - 1).findElements(By.xpath("td"));
            return cells.size();
        }

        return 0;
    }
1110125
public function getCellSize()
    {

        if (is_null($this->cellsizeCache)) {
            $dataType = $this->getDataType();

            if ($dataType->isInFile()) {
                throw new ErrorException("Size-getter for data-cells stored in file is not implemented yet!");
            }

            if (!is_null($this->length)) {
                $this->cellsizeCache = $this->getLength()+$this->getSecondLength();

            } else {
                $length = $dataType->getByteLength();
    
                $this->cellsizeCache = (int)$length;
            }
        }

        return $this->cellsizeCache;
    }
1173878
public function getRowAndColumnCount()
    {
        $rows = $columns = 0;
        $trs = $this->getElementsByTagName('tr');
        foreach ($trs as $tr) {
            /** @var \DOMElement $tr */
            $rowspan = $tr->getAttribute('rowspan');
            $rows += ($rowspan || 1);

            // Now look for column-related info
            $columnsInThisRow = 0;
            $cells = $tr->getElementsByTagName('td');
            foreach ($cells as $cell) {
                /** @var \DOMElement $cell */
                $colspan = $cell->getAttribute('colspan');
                $columnsInThisRow += ($colspan || 1);
            }
            $columns = max($columns, $columnsInThisRow);
        }

        return ['rows' => $rows, 'columns' => $columns];
    }
812920
public function getTableColumnsOnly()
	{
		$data = $this->attributes;
		$tableColumns = $this->getStructure()->getTableColumns($this->table);
		if (!empty($tableColumns))
		{
			$data = array_intersect_key($data, $tableColumns);
		}
		return $data;
	}
1340589
public int size() {

        int acc = 0;

        for (Map.Entry<String, List<Cell>> entry : cells.entrySet()) {
            acc += entry.getValue().size();
        }

        return acc;
    }
438876
public function getWidth()
    {
        if ($this->_width) {
            return $this->_width;
        }
        return $this->_table->getColumn($this->_columnIndex)->getWidth();
    }