Gets the favorite entry for a given row.

@param row the widget used to display the favorite
@return the favorite entry for the widget
357517
private CmsFavoriteEntry getEntry(Component row) {

        if (row instanceof CmsFavInfo) {

            return ((CmsFavInfo)row).getEntry();

        }
        return null;

    }
1260327
public function getCurrentOption(Row $row)
	{
		foreach ($this->getOptions() as $option) {
			if ($option->getValue() == $row->getValue($this->getColumn())) {
				return $option;
			}
		}

		return null;
	}
190230
private function getRow($row)
    {
        $content = $this->getContent();

        if (! $content->has($row)) {
            throw new InvalidShoppingCartRowException();
        }

        return $content->get($row);
    }
72202
@Override
    public List<V> row(int row) {
        Preconditions.checkElementIndex(row, rowCount(), "Row index");
        int base = row * rowCount;
        return new Inner<V>(this, base, columnCount, 1);
    }
1183306
public FavoriteResources favoriteResources() {
        if (favorites.get() == null) {
            favorites.compareAndSet(null, new FavoriteResourcesImpl(this));
        }
        return favorites.get();
    }
1342559
public InternalRow getRow(int rowId) {
    assert(rowId >= 0 && rowId < numRows);
    row.rowId = rowId;
    return row;
  }
603038
private String getRow(String rowKey) {
        try {
            return cache.get(rowKey);
        } catch (Exception e) {
            if (e.getCause() instanceof RowNotFoundException) {
                return null;
            }
            throw new RuntimeException(e);
        }
    }
674906
public List<String> getRowContents(Row row, int size) {
        logger.entering(new Object[] { row, size });
        List<String> rowData = new ArrayList<String>();
        if (row != null) {
            for (int i = 1; i <= size; i++) {
                String data = null;
                if (row.getCell(i) != null) {
                    data = row.getCell(i).toString();
                }
                rowData.add(data);
            }
        }
        logger.exiting(rowData);
        return rowData;
    }
900847
public ENTITY mapFromRow(Row row) {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(format("Map row %s back to entity of type %s", row, entityClass.getCanonicalName()));
        }

        validateNotNull(row, "Row object should not be null");
        final String tableName = row.getColumnDefinitions().asList().get(0).getTable();
        final String entityTableName = meta_internal.getTableOrViewName();
        validateTableTrue(entityTableName.equals(tableName),
                "CQL row is from table '%s', it cannot be mapped to entity '%s' associated to table '%s'",
                tableName, entityClass.getCanonicalName(), entityTableName);
        return meta_internal.createEntityFrom(row);
    }
623820
public ConsumeRowResult consumeRow(final InputRow row) {
        final FilterOutcomes outcomes = new FilterOutcomesImpl(_alwaysSatisfiedOutcomes);
        final ConsumeRowHandlerDelegate delegate = new ConsumeRowHandlerDelegate(_consumers, row, 0, outcomes);
        return delegate.consume();
    }
36298
@Override
    public Map<String, Object> apply(final Map<String, Object> row) {
        Map<String, Object> cleanRow, filteredRow;

        // Make sure the row isn't null.
        if (row == null) {
            cleanRow = new LinkedHashMap<>();
        } else {
            cleanRow = new LinkedHashMap<>(row);
        }

        // Copy the row so we avoid concurrent modifications.
        filteredRow = new LinkedHashMap<>();

        // Iterate through the requested columns and add/override the ones
        // the user wants to see.
        for (String column : columns) {
            if (cleanRow.containsKey(column)) {
                filteredRow.put(column, cleanRow.get(column));
            } else {
                filteredRow.put(column, null);
            }
        }

        return filteredRow;
    }
1043428
@Override
  public Bytes get(Bytes row, Column col) {
    Bytes val = txb.get(row, col);
    if (val != null) {
      txLog.filteredAdd(LogEntry.newGet(row, col, val), filter);
    }
    return val;
  }
873855
public Object[] getRow(int row) {
    Object[] ret = new Object[columns.size()];
    for(int c = 0; c < columns.size(); c++) {
      ret[c] = data(row, c);
    }
    return ret;
  }
79034
public static Row copy(Row row) {
		final Row newRow = new Row(row.fields.length);
		System.arraycopy(row.fields, 0, newRow.fields, 0, row.fields.length);
		return newRow;
	}
1333047
public Vector4f getRow(int row, Vector4f dest) throws IndexOutOfBoundsException {
        switch (row) {
        case 0:
            dest.x = m00;
            dest.y = m10;
            dest.z = m20;
            dest.w = m30;
            break;
        case 1:
            dest.x = m01;
            dest.y = m11;
            dest.z = m21;
            dest.w = m31;
            break;
        case 2:
            dest.x = m02;
            dest.y = m12;
            dest.z = m22;
            dest.w = m32;
            break;
        case 3:
            dest.x = m03;
            dest.y = m13;
            dest.z = m23;
            dest.w = m33;
            break;
        default:
            throw new IndexOutOfBoundsException();
        }
        return dest;
    }
970831
@NonNull
    Collection<TObj> getRowItems(int row) {
        Collection<TObj> result = new LinkedList<>();
        SparseArrayCompat<TObj> array = mData.get(row);
        for (int count = array.size(), i = 0; i < count; i++) {
            int key = array.keyAt(i);
            TObj columnObj = array.get(key);
            if (columnObj != null) {
                result.add(columnObj);
            }

        }
        return result;
    }
319247
protected Object getTopRowBean(final List<Integer> row) {
		// Get root level
		List<?> lvl = getBeanList();
		if (lvl == null || lvl.isEmpty()) {
			return null;
		}

		// Get root row bean (ie top level)
		int rowIdx = row.get(0);
		Object rowData = lvl.get(rowIdx);
		return rowData;
	}