Returns a sublist of the cells that belong to the specified family.

@see RowCell#compareByNative() For details about the ordering.
557263
public List<RowCell> getCells(@Nonnull String family) {
    Preconditions.checkNotNull(family, "family");

    int start = getFirst(family, null);
    if (start < 0) {
      return ImmutableList.of();
    }

    int end = getLast(family, null, start);

    return getCells().subList(start, end + 1);
  }
784085
def siblings(self):
        """"""
        return list(filter(lambda x: id(x) != id(self), self.parent.childs))
1196405
@Override
    public boolean relative(int rows) throws SQLException {
        checkClosed();

        if (rowCount == 0) {
            return false;
        }
        if (cursorPosition == Position.afterLast && rows > 0) {
            return false;
        }
        if (cursorPosition == Position.beforeFirst && rows <= 0) {
            return false;
        }
        if (table.getActiveRowIndex() + rows >= rowCount) {
            cursorPosition = Position.afterLast;
            if (table.getActiveRowIndex() + rows == rowCount) {
                return true;
            }
            return false;
        }
        try {
            // for negative row numbers, resetRowPosition method is called
            // and the cursor advances to the desired row from top of the table
            int rowsToMove = table.getActiveRowIndex() + rows;
            if (cursorPosition == Position.beforeFirst || rows < 0) {
                if(cursorPosition == Position.afterLast) {
                    rowsToMove = rowCount + rows;
                }
                else if(cursorPosition == Position.beforeFirst) {
                    rowsToMove = rows - 1;
                }
                else {
                    rowsToMove = table.getActiveRowIndex() + rows;
                }
                if(rowsToMove < 0){
                    beforeFirst();
                    return false;
                }
                table.resetRowPosition();
                table.advanceToRow(0);
            }
            cursorPosition = Position.middle;
            return table.advanceToRow(rowsToMove);
        } catch (Exception x) {
            throw SQLError.get(x);
        }
    }
9716
public List<Cell> getCellsCopy()
    {
        final ArrayList<Cell> cells = new ArrayList<>(this.getCellsCount());

        for (Cell c: this)
        {
            cells.add(c);
        }
        return cells;
    }
546622
public static <T extends Comparable<? super T>> ArrayList<T> sortThis(ArrayList<T> list)
    {
        return ArrayListIterate.sortThis(list, Comparators.naturalOrder());
    }
1045681
public static Row getRowFromCells(Cells cells) {
        Object[] values = cells.getCellValues().toArray();
        return RowFactory.create(values);
    }
298590
public Set<String> getRequiredColumnFamilies() {
    Set<String> set = new HashSet<String>();
    for (FieldMapping mapping : fieldMappings) {
      if (FieldMapping.MappingType.KEY != mapping.getMappingType())
      set.add(mapping.getFamilyAsString());
    }
    return set;
  }
198510
function($Cell, oCell) {
			var bGroup = TableUtils.Grouping.isInGroupingRow($Cell);
			var bSum = TableUtils.Grouping.isInSumRow($Cell);
			var bSupportStyleClass = !!oCell && !!oCell.hasStyleClass;

			var bIsRowHidden = $Cell.parent().hasClass("sapUiTableRowHidden");
			var bIsCellHidden = $Cell.hasClass("sapUiTableCellHidden");
			var bNoMeasureInFirstCellInGroup = bGroup && $Cell.hasClass("sapUiTableCellFirst") && !$Cell.hasClass("sapUiTableMeasureCell");
			var bGroupCellHiddenByApp = bGroup && bSupportStyleClass && oCell.hasStyleClass("sapUiAnalyticalTableGroupCellHidden");
			var bSumCellHiddenByApp = bSum && bSupportStyleClass && oCell.hasStyleClass("sapUiAnalyticalTableSumCellHidden");

			return bIsRowHidden || bIsCellHidden || bNoMeasureInFirstCellInGroup || bGroupCellHiddenByApp || bSumCellHiddenByApp;
		}
953390
public void containsCell(Cell<?, ?, ?> cell) {
    checkNotNull(cell);
    checkNoNeedToDisplayBothValues("cellSet()").that(actual().cellSet()).contains(cell);
  }
658546
public static <T, L extends List<T>> L sortThis(L list, Comparator<? super T> comparator)
    {
        if (list instanceof MutableList)
        {
            ((MutableList<T>) list).sortThis(comparator);
        }
        else if (list instanceof ArrayList)
        {
            ArrayListIterate.sortThis((ArrayList<T>) list, comparator);
        }
        else
        {
            if (list.size() > 1)
            {
                Collections.sort(list, comparator);
            }
        }
        return list;
    }
517681
private List<HBaseCell> getRelationCell(EntityMetadata m, Object rowId, List<RelationHolder> relations)
            throws IOException
    {
        List<HBaseCell> relationCells = new ArrayList<HBaseCell>();
        for (RelationHolder relation : relations)
        {
            HBaseCell hBaseCell = new HBaseCell(m.getTableName(), relation.getRelationName(),
                    relation.getRelationValue());
            relationCells.add(hBaseCell);
        }
        return relationCells;
    }
726511
@SuppressWarnings("rawtypes")
    protected ColumnFamily getColumnFamilyViaColumnName(String columnFamilyName, Object rowKey) {
        return getColumnFamilyViaColumnName(columnFamilyName, rowKey.getClass());
    }
2240
private static List<Column> getAncestorColumns(Resource currentResource, Resource rootResource) {
    List<Column> columns = new ArrayList<>();
    List<Resource> ancestors = getAncestors(currentResource, rootResource);
    for (int i = 0; i < ancestors.size(); i++) {
      Resource r = ancestors.get(i);

      String activeId;
      if (i < ancestors.size() - 1) {
        activeId = ancestors.get(i + 1).getPath();
      }
      else {
        activeId = currentResource.getPath();
      }

      Column column = new Column()
          .columnId(r.getPath())
          .lazy(true)
          .activeId(activeId);
      columns.add(column);
    }
    return columns;
  }
433913
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>, T3 extends Comparable<T3>> int compare(T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3) {
        int res = 0;

        if ((res = N.compare(a1, b1)) != 0) {
            return res;
        } else if ((res = N.compare(a2, b2)) != 0) {
            return res;
        }

        return N.compare(a3, b3);
    }
552078
protected List<Object> getRowCells(int row) {
		List<Object> cells = new ArrayList<>();
		for (int col = 0; col < getTable().getColumnCount(); col++) {
			Object value = getTable().getValueAt(row, col);
			cells.add(value == null ? "" : value.toString());
		}
		return cells;
	}
964776
def getcellslice(self, rownr, blc, trc, inc=[]):
        """"""
        return self._table.getcellslice(self._column, rownr, blc, trc, inc)
650235
def get_families(self):
        
        if self.retrieved:
            raise errors.IllegalState('List has already been retrieved.')
        self.retrieved = True
        return objects.FamilyList(self._results, runtime=self._runtime)