Get a shallow copy of the cells in this row.
@return a List&lt;Cell&gt; shallow copy of the cells in this row.
9716
public List<Cell> getCellsCopy()
    {
        final ArrayList<Cell> cells = new ArrayList<>(this.getCellsCount());

        for (Cell c: this)
        {
            cells.add(c);
        }
        return cells;
    }
1239197
public Cell<C, T> row() {
        if (cells.size() > 0)
            endRow();
        if (rowDefaults != null)
            toolkit.freeCell(rowDefaults);
        rowDefaults = toolkit.obtainCell(this);
        rowDefaults.clear();
        return rowDefaults;
    }
1009823
public Cells getValueCells(String table) {
        Cells res = new Cells(table);
        for (Cell cell : getCellsByTable(table)) {
            if (!cell.isKey()) {
                res.add(table, cell);
            }
        }

        return res;
    }
543491
public static List<List<DTCellValue52>> makeDataLists( Object[][] oldData ) {
        List<List<DTCellValue52>> newData = new ArrayList<List<DTCellValue52>>();
        for ( int iRow = 0; iRow < oldData.length; iRow++ ) {
            Object[] oldRow = oldData[ iRow ];
            List<DTCellValue52> newRow = makeDataRowList( oldRow );
            newData.add( newRow );
        }
        return newData;
    }
129093
public ArrayList<String> getRows() {
		ArrayList<String> rows = new ArrayList<String>();
		for (String row : rowLookup.keySet()) {
			HeaderInfo hi = rowLookup.get(row);
			if (!hi.isHide()) {
				rows.add(row);
			}
		}
		return rows;
	}
948077
public Table dropDuplicateRows() {

        Table sorted = this.sortOn(columnNames().toArray(new String[columns().size()]));
        Table temp = emptyCopy();

        for (int row = 0; row < rowCount(); row++) {
            if (temp.isEmpty() || !Rows.compareRows(row, sorted, temp)) {
                Rows.appendRowToTable(row, sorted, temp);
            }
        }
        return temp;
    }
677794
public CmsAliasTableRow copy() {

        CmsAliasTableRow result = new CmsAliasTableRow();
        result.setKey(m_key);
        result.setResourcePath(m_resourcePath);
        result.setStructureId(m_structureId);
        result.setChanged(m_isChanged);
        result.setMode(m_mode);
        result.setPathError(m_pathError);
        result.setAliasError(m_aliasError);
        result.setAliasPath(m_aliasPath);
        result.setEdited(m_isEdited);
        result.setOriginalStructureId(m_originalStructureId);

        return result;
    }
1301286
public List<T> getSelectedList() {
		final int[] selectedRows = getSelectedRows();
		int selectedRow;
		final int rowCount = getRowCount();
		final int length = selectedRows.length;
		final List<T> selectedList = new ArrayList<>(length);
		for (int i = 0; i < length; i++) {
			selectedRow = selectedRows[i];
			// getSelectedRows peut renvoyer des lignes qui ne sont plus
			// dans la table si ce sont les denières sélectionnées
			if (selectedRow >= 0 && selectedRow < rowCount) {
				selectedList.add(getObjectAt(selectedRow));
			}
		}

		return selectedList;
	}
215462
@Override
    public ImmutableSet<Cell<V>> cells() {
        return ImmutableSet.<Cell<V>>of(cell);
    }
792507
List<CmsAliasTableRow> copyData(List<CmsAliasTableRow> data) {

        List<CmsAliasTableRow> result = new ArrayList<CmsAliasTableRow>();
        for (CmsAliasTableRow row : data) {
            CmsAliasTableRow copiedRow = row.copy();
            result.add(copiedRow);
        }
        return result;
    }
503846
@Override
    public Iterator<Cell> iterator()
    {
        if (cells != null)
        {
            return cells.iterator();
        }
        else // if (pbRow != null)
        {
            assert pbRow != null;

            return ConvertibleIteratorUtils.iterateAsCell(pbRow.getCellsList().iterator(),
                    // if there is no ColumnDescription what else we could do with that?
                    pbColumnDescriptions == null ?  Collections.emptyIterator() : pbColumnDescriptions.iterator());
        }
    }
1190162
public java.util.List<com.google.bigtable.v2.ReadRowsResponse.CellChunk> getChunksList() {
    return chunks_;
  }
1197074
public Set<?> getSelectedRows() {
		Set<?> keys = getComponentModel().selectedRows;
		if (keys == null) {
			return Collections.emptySet();
		} else {
			return Collections.unmodifiableSet(keys);
		}
	}
1275145
function getCellsAtRow(
    opts: Options,
    // The table
    table: Block,
    rowIndex: number
): List<Block> {
    return table.nodes.get(rowIndex).nodes;
}
235500
public Iterable<String[]> toArrays() {
    checkState(!isClosed, WORKBOOK_CLOSED);
    Iterable<String[]> arraysIterable = Iterables.transform(sheet, item -> {
      List<String> list = rowToList(item);
      return list.toArray(new String[list.size()]);
    });
    return hasHeader ? Iterables.skip(arraysIterable, 1) : arraysIterable;
  }
52587
public static DBObject getDBObjectFromCell(Cells cells) {

        DBObject bson = new BasicDBObject();
        for (Cell cell : cells) {
            if (cell.getValue() != null) {
                if (Collection.class.isAssignableFrom(cell.getCellValue().getClass())) {
                    Collection c = (Collection) cell.getCellValue();
                    Iterator iterator = c.iterator();
                    List<Object> innerBsonList = new ArrayList<>();

                    while (iterator.hasNext()) {
                        Object currentO = iterator.next();
                        if(currentO instanceof Cells){
                            innerBsonList.add(getDBObjectFromCell((Cells) currentO));
                        }else{
                            innerBsonList.add(currentO);
                        }
                    }
                    bson.put(cell.getCellName(), innerBsonList);
                } else if (Cells.class.isAssignableFrom(cell.getCellValue().getClass())) {
                    bson.put(cell.getCellName(), getDBObjectFromCell((Cells) cell.getCellValue()));
                } else {
                    bson.put(cell.getCellName(), cell.getCellValue());
                }
            }
        }

        return bson;
    }
551564
public static Collection<Row> getRowsFromsCells(Collection<Cells> cellsCol) {
        Collection<Row> result = new ArrayList<>();
        for (Cells cells : cellsCol) {
            result.add(getRowFromCells(cells));
        }
        return result;
    }