Convert a row of the table in a String,
where the every column is seperated with a delimiter.
@param pvRow Number of row.
@return The row as String.
487169
public String row2String(int pvRow) {
		StringBuffer sb = new StringBuffer();
		List<?> lvColumn = rows.get(pvRow);
		int lvSize = lvColumn.size();
		for (int i=0;i<lvSize; i++) {
			sb.append(lvColumn.get(i));
			if (i < (lvSize-1)) {
				sb.append(getDelimiter());
			}
		}
		return sb.toString();
	}
477748
public int getValueAtAsInteger(final int row, final int col) {
		final Object valueAt = getValueAt(row, col);
		int number = 0;
		if (valueAt != null && !valueAt.toString().equals("")) {
			number = Integer.parseInt(valueAt.toString().trim());
		}
		return number;

	}
610840
private String getRowFormat(List<Integer> widths) {
    StringBuilder rowFormat = new StringBuilder(spaces(this.indentation));
    for (int i=0; i< widths.size(); i++) {
      rowFormat.append("%");
      rowFormat.append(this.flags != null ? this.flags.get(i) : "");
      rowFormat.append(widths.get(i).toString());
      rowFormat.append("s");
      rowFormat.append(spaces(this.delimiterWidth));
    }
    rowFormat.append("\n");

    return rowFormat.toString();
  }
22463
def _row_to_str(self, row):
        # type: (List[str]) -> str
        
        _row_text = ''
        for col, width in self.col_widths.items():
            _row_text += self.COLUMN_SEP
            l_pad, r_pad = self._split_int(width - len(row[col]))
            _row_text += '{0}{1}{2}'.format(' ' * (l_pad + self.PADDING),
                                            row[col],
                                            ' ' * (r_pad + self.PADDING))

        _row_text += self.COLUMN_SEP + '\n'

        return _row_text
132286
function extractFromRow(row, context, asString)
{
  var map    = row._arrayProcessedColumns;
  var values = row.values;

  // get the value
  var columnIndex = this.getIndex();
  var ret = values[columnIndex];

  // if we want the value as a string, and the column is of type variant, and we
  // haven't already processed the value before, we don't need to process the
  // value, so only process if none of the aforementioned conditions are true
  if (!(asString && this.isVariant() && !map[columnIndex]))
  {
    // if the column value has not been processed yet, process it, put it back
    // in the values array, and remember that the value has been processed
    if (!map[columnIndex])
    {
      if (ret !== null)
      {
        ret = values[columnIndex] =
            context.convert(values[columnIndex], this, context);
      }
      map[columnIndex] = true;
    }

    // use the appropriate extraction function depending on whether
    // we want the value or a string representation of the value
    var extractFn = !asString ? context.toValue : context.toString;
    ret = extractFn(ret);
  }

  return ret;
}
649038
public double[] getRow(int row) {
        checkIndices(row, 0);
        AtomicVector rowEntry = getRow(row, -1, false);
        return (rowEntry == null)
            ? new double[cols.get()]
            : toArray(rowEntry, cols.get());
    }
703459
public String getRowsWithColumnsAndColumnsNamesAsString() {
		StringBuffer sb = new StringBuffer();
		String lvColumnNames = getColumnNames();
		if (lvColumnNames.trim().length() > 0) {
			sb.append(lvColumnNames);
			sb.append(CsvParser.CRLF);
		}
		sb.append(getRowsWithColumnsAsString());
		return sb.toString();
	}
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;
  }
1363509
public static String dumpCurrentRowToString(Cursor cursor) {
        StringBuilder sb = new StringBuilder();
        dumpCurrentRow(cursor, sb);
        return sb.toString();
    }
902451
private byte[] getNextRow(byte[] row, long writePointer, int count) {
    Bytes.putLong(row, queueRowPrefix.length, writePointer);
    Bytes.putInt(row, queueRowPrefix.length + Longs.BYTES, count + 1);
    return row;
  }
1116811
@Override public double[] getRow() {
    if (_fr.numRows() != 1)
      throw new IllegalArgumentException("Trying to get a single row from a multirow frame: " + _fr.numRows() + "!=1");

    double res[] = new double[_fr.numCols()];
    for (int i = 0; i < _fr.numCols(); ++i)
      res[i] = _fr.vec(i).at(0);
    return res;
  }
830505
function(gridRow){
		var rowId =  gridRow['$_#_@_id']
		var row = null
		var rowIndex = this.dataTable.getIndexByRowId(rowId)
		if(rowIndex > -1)
			row = this.dataTable.getRow(rowIndex);
		return row
	}
246913
public Vector3f getRow(int row, Vector3f dest) throws IndexOutOfBoundsException {
        switch (row) {
        case 0:
            dest.x = m00;
            dest.y = m10;
            dest.z = m20;
            break;
        case 1:
            dest.x = m01;
            dest.y = m11;
            dest.z = m21;
            break;
        case 2:
            dest.x = m02;
            dest.y = m12;
            dest.z = m22;
            break;
        default:
            throw new IndexOutOfBoundsException();
        }
        
        return dest;
    }
129554
def get_row_sep(self):
        """"""
        if self.eol_btn.isChecked():
            return u"\n"
        return to_text_string(self.line_edt_row.text())
1346317
public JSONStringer toJSONStringerV2(JSONStringer js) throws JSONException{
        // array of row data
            VoltTableRow row = cloneRow();
            row.resetRowPosition();
            js.array();
            while (row.advanceRow()) {
                js.object();
                for (int i = 0; i < getColumnCount(); i++) {

                    js.key(getColumnName(i));
                    row.putJSONRep(i, js);
                }
                js.endObject();
            }
            js.endArray();
        return js;
    }
745750
@Override
	protected String[] getRow(String[] resultRow) {
		return Arrays.copyOfRange(resultRow, 1, resultRow.length);
	}
324807
public String mkString(String rowsDelimiter, String columnsDelimiter) {
        return mkString(DEFAULT_FORMATTER, rowsDelimiter, columnsDelimiter);
    }