Adds a column to the table

@param  mixed $content     The data of the column
@param  int   $columnIndex The column index to populate
@param  int   $rowIndex    The row index, if the row isn't starting from zero, specify it here.

@return static
16396
public function addColumn($content, $columnIndex = null, $rowIndex = null)
    {
        $rowIndex = $rowIndex === null
            ? $this->rowIndex
            : $rowIndex;
        if ($columnIndex === null) {
            $columnIndex = isset($this->rows[ $rowIndex ])
                ? count($this->rows[ $rowIndex ])
                : 0;
        }
        $this->rows[ $rowIndex ][ $columnIndex ] = $content;

        return $this;
    }
737678
public JTextField createFilterTextField(int columnIndex)
    {
        while (textFields.size() - 1 < columnIndex)
        {
            textFields.add(null);
        }
        JTextField textField = new JTextField();
        textFields.set(columnIndex, textField);
        
        Document document = textField.getDocument();
        document.addDocumentListener(new DocumentListener()
        {
            @Override
            public void removeUpdate(DocumentEvent e)
            {
                updateFilter();
            }
            
            @Override
            public void insertUpdate(DocumentEvent e)
            {
                updateFilter();
            }
            
            @Override
            public void changedUpdate(DocumentEvent e)
            {
                updateFilter();
            }
        });
        return textField;
    }
1352648
public Row addColumn(int index, String name, Object value) {
        Objects.requireNonNull(name, "Name of the column cannot be null");
        Objects.requireNonNull(value, "Value of " + name + " cannot be null");
        final Column column = new Column(index, name, value);
        return this.addColumn(column);
    }
231687
public void setupCellPositoin(final int rowIndex, final int columnIndex) {
        
        if(topLeftPoisitoin == null) {
            this.topLeftPoisitoin = new Point(columnIndex, rowIndex);
        }
        
        if(bottomRightPosition == null) {
            this.bottomRightPosition = new Point(columnIndex, rowIndex);
        }
        
        // 左上のセルの位置の設定
        if(topLeftPoisitoin.x > columnIndex) {
            this.topLeftPoisitoin.x = columnIndex;
        }
        
        if(topLeftPoisitoin.y > rowIndex) {
            this.topLeftPoisitoin.y = rowIndex;
        }
        
        // 右下のセルの位置の設定
        if(bottomRightPosition.x < columnIndex) {
            this.bottomRightPosition.x = columnIndex;
        }
        
        if(bottomRightPosition.y < rowIndex) {
            this.bottomRightPosition.y = rowIndex;
        }
    }
274476
public function addIndex(Index $index)
    {
        if ($this->hasIndex($index->getName())) {
            throw SchemaException::tableIndexAlreadyExists($this->getName(), $index->getName());
        }

        foreach ($index->getColumnNames() as $columnName) {
            if (!$this->hasColumn($columnName)) {
                throw SchemaException::tableColumnDoesNotExist($this->getName(), $columnName);
            }
        }

        foreach ($this->getIndexes() as $indexCandidate) {
            if ($indexCandidate->isBetterThan($index)) {
                return;
            }
        }

        foreach ($this->getIndexes() as $indexCandidate) {
            if ($index->isBetterThan($indexCandidate)) {
                $this->dropIndex($indexCandidate->getName());
            }
        }

        $this->indexes[$index->getName()] = $index;
    }
1332547
public function &Row($RowIndex) {
		$Result = &$this->Result();
      if(isset($Result[$RowIndex]))
			return $Result[$RowIndex];
      return $this->_EOF;
   }
713234
public function addRow($colsCount=NULL) {
		$rowCount=$this->rowCount() + 1;
		$this->setRowsCount($rowCount, $colsCount, true);
		return $this->content[$rowCount - 1];
	}
1133438
public function index(string $indexName): IndexColumnsDefiner
    {
        return new IndexColumnsDefiner(function (array $columnNames) use ($indexName) {
            $this->indexes[] = new Index($this->orm->getNamespace() . $indexName, false, $columnNames);
        });
    }
421508
public function setCellValue($columnId, $rowId, $content, $forceCreation = false)
    {
        $returnValue = (bool) false;

        
		//TODO: for creating row and column if not exists?
		if(isset($this->columns[$columnId])){
			if(isset($this->rows[$rowId])){
				$this->rows[$rowId][$columnId] = $content;
				$returnValue = true;
			}
		}
        

        return (bool) $returnValue;
    }
1287017
final public function addIndex(Index $index): Table
    {
        if ($this->hasIndex($index::getName())) {
            throw new InvalidArgumentException('Foreign key '.$index::getName().' already exists in the table '.$this::getName());
        }

        $this->indexes[$index::getName()] = $index;

        return $this;
    }
202079
public function thOpenEnd($colName, $content) {
    $this->tsection->thOpenEnd($this->rowName, $colName, $content);
  }
282321
public function setColumnWidth($columnIndex, $width)
    {
        $this->columnWidths[(int) $columnIndex] = (int) $width;

        return $this;
    }
1341963
public synchronized Future<?> addIndexedColumn(ColumnDefinition cdef)
    {
        if (indexesByColumn.containsKey(cdef.name.bytes))
            return null;

        assert cdef.getIndexType() != null;

        SecondaryIndex index;
        try
        {
            index = SecondaryIndex.createInstance(baseCfs, cdef);
        }
        catch (ConfigurationException e)
        {
            throw new RuntimeException(e);
        }

        // Keep a single instance of the index per-cf for row level indexes
        // since we want all columns to be under the index
        if (index instanceof PerRowSecondaryIndex)
        {
            SecondaryIndex currentIndex = rowLevelIndexMap.get(index.getClass());

            if (currentIndex == null)
            {
                rowLevelIndexMap.put(index.getClass(), index);
                index.init();
            }
            else
            {
                index = currentIndex;
                index.addColumnDef(cdef);
                logger.info("Creating new index : {}",cdef);
            }
        }
        else
        {
            // TODO: We sould do better than throw a RuntimeException
            if (cdef.getIndexType() == IndexType.CUSTOM && index instanceof AbstractSimplePerColumnSecondaryIndex)
                throw new RuntimeException("Cannot use a subclass of AbstractSimplePerColumnSecondaryIndex as a CUSTOM index, as they assume they are CFS backed");
            index.init();
        }

        // link in indexedColumns. this means that writes will add new data to
        // the index immediately,
        // so we don't have to lock everything while we do the build. it's up to
        // the operator to wait
        // until the index is actually built before using in queries.
        indexesByColumn.put(cdef.name.bytes, index);

        // Add to all indexes set:
        allIndexes.add(index);

        // if we're just linking in the index to indexedColumns on an
        // already-built index post-restart, we're done
        if (index.isIndexBuilt(cdef.name.bytes))
            return null;

        return index.buildIndexAsync();
    }
519699
function(index) {
    if(lang.isNumber(index)&& this._elColgroup) {
        var nextSibling = this._elColgroup.childNodes[index] || null;
        this._elColgroup.insertBefore(document.createElement("col"), nextSibling);
    }
}
1243457
public function addRow($data = null)
    {
        $this->rowIndex++;
        if (is_array($data)) {
            foreach ($data as $column => $content) {
                $this->rows[ $this->rowIndex ][ $column ] = $content;
            }
        }

        return $this;
    }
1162058
public function addIndex($indexName) {
    if (is_array($indexName)) {
      $this->indexes = $indexName;
    } else {
      $this->indexes[] = $indexName;
    }
    $this->indexes = array_unique($this->indexes);
  }
880198
public function getCellByIndex($columnIndex)
    {
        if (!isset($this->_cells[$columnIndex - 1])) {
            $this->_cells[$columnIndex - 1] = new PHPRtfLite_Table_Cell($this->_table, $this->_rowIndex, $columnIndex);
        }

        return $this->_cells[$columnIndex - 1];
    }