Access a row
 @overload row(row)
   Get a row
   @param row [String]
   @return [Hash]
 @overload row(row, val)
   Set a row
   @param row [String]
   @param val [Hash, Array]
   @return [Table]
425407
def row(row, val = nil)
      if val.nil?
        get_row(row)
      else
        set_row(row, val)
      end
    end
495880
private RowSet prepareFromRow(List<Object> rows, RowSet rowSet) throws Exception {
    for (Object row : rows) {
      rowSet.addRow((Object[]) row);
    }
    return rowSet;
  }
120636
def select_row(statement, build_arg = nil)
    rows = select(statement, build_arg)
    raise UnexpectedQueryResult, "selected #{rows.size} rows; expected 1" unless rows.size == 1
    rows[0]
  end
348427
def _SetRow(self, new_values, row=0):
        

        if not row:
            row = self._row_index

        if row > self.size:
            raise TableError("Entry %s beyond table size %s." % (row, self.size))

        self._table[row].values = new_values
1335038
public void set(final int row, final int col, final Object o) {
    if (o == null)
      cellValues[row][col] = new IcedWrapper(null);
    else if (o instanceof Double && Double.isNaN((double)o))
      cellValues[row][col] = new IcedWrapper(Double.NaN);
    else if (o instanceof int[])
      cellValues[row][col] = new IcedWrapper(Arrays.toString((int[])o));
    else if (o instanceof long[])
      cellValues[row][col] = new IcedWrapper(Arrays.toString((long[])o));
    else if (o instanceof float[])
      cellValues[row][col] = new IcedWrapper(Arrays.toString((float[])o));
    else if (o instanceof double[])
      cellValues[row][col] = new IcedWrapper(Arrays.toString((double[])o));
    else if (colTypes[col]=="string")
      cellValues[row][col] = new IcedWrapper(o.toString());
    else
      cellValues[row][col] = new IcedWrapper(o);
  }

  /**
   * Print table to String, using 2 spaces for padding between columns
   * @return String containing the ASCII version of the table
   */
  public String toString() {
    return toString(2, true);
  }
  /**
   * Print table to String, using user-given padding
   * @param pad number of spaces for padding between columns
   * @return String containing the ASCII version of the table
   */
  public String toString(final int pad) {
    return toString(pad, true);
  }

  private static int PRINTOUT_ROW_LIMIT = 20;
  private boolean skip(int row) {
    assert(PRINTOUT_ROW_LIMIT % 2 == 0);
    if (getRowDim() <= PRINTOUT_ROW_LIMIT) return false;
    if (row <= PRINTOUT_ROW_LIMIT/2) return false;
    if (row >= getRowDim()-PRINTOUT_ROW_LIMIT/2) return false;
    return true;
  }
  /**
   * Print table to String, using user-given padding
   * @param pad number of spaces for padding between columns
   * @param full whether to print the full table (otherwise top 5 and bottom 5 rows only)
   * @return String containing the ASCII version of the table
   */
  public String toString(final int pad, boolean full) {
    if (pad < 0)
      throw new IllegalArgumentException("pad must be a non-negative integer");

    final int rowDim = getRowDim();
    final int colDim = getColDim();

    final int actualRowDim = full ? rowDim : Math.min(PRINTOUT_ROW_LIMIT+1, rowDim);

    final String[][] cellStrings = new String[actualRowDim + 1][colDim + 1];
    for (String[] row: cellStrings)
      Arrays.fill(row, "");

    cellStrings[0][0] = colHeaderForRowHeaders != null ? colHeaderForRowHeaders : "";
    int row = 0;
    for (int r = 0; r < rowDim; ++r) {
      if (!full && skip(r)) continue;
      cellStrings[row+1][0] = rowHeaders[r];
      row++;
    }
    for (int c = 0; c < colDim; ++c)
      cellStrings[0][c+1] = colHeaders[c];

    for (int c = 0; c < colDim; ++c) {
      final String formatString = colFormats[c];
      row = 0;
      for (int r = 0; r < rowDim; ++r) {
        if (!full && skip(r)) continue;
        Object o = get(r,c);
        if ((o == null) || o instanceof Double && isEmpty((double)o)){
          cellStrings[row + 1][c + 1] = "";
          row++;
          continue;
        } else if (o instanceof Double && Double.isNaN((double)o)) {
          cellStrings[row + 1][c + 1] = "NaN";
          row++;
          continue;
        }
        try {
          if (o instanceof Double) cellStrings[row + 1][c + 1] = String.format(formatString, (Double) o);
          else if (o instanceof Float) cellStrings[row + 1][c + 1] = String.format(formatString, (Float) o);
          else if (o instanceof Integer) cellStrings[row + 1][c + 1] = String.format(formatString, (Integer) o);
          else if (o instanceof Long) cellStrings[row + 1][c + 1] = String.format(formatString, (Long) o);
          else if (o instanceof String) cellStrings[row + 1][c + 1] = (String)o;
          else cellStrings[row + 1][c + 1] = String.format(formatString, cellValues[r][c]);
        } catch(Throwable t) {
          cellStrings[row + 1][c + 1] = o.toString();
        }
        row++;
      }
    }

    final int[] colLen = new int[colDim + 1];
    for (int c = 0; c <= colDim; ++c) {
      for (int r = 0; r <= actualRowDim; ++r) {
        colLen[c] = Math.max(colLen[c], cellStrings[r][c].length());
      }
    }

    final StringBuilder sb = new StringBuilder();
    if (tableHeader.length() > 0) {
      sb.append(tableHeader);
    }
    if (tableDescription.length() > 0) {
      sb.append(" (").append(tableDescription).append(")");
    }
    sb.append(":\n");
    for (int r = 0; r <= actualRowDim; ++r) {
      int len = colLen[0];
      if (actualRowDim != rowDim && r - 1 == PRINTOUT_ROW_LIMIT/2) {
        assert(!full);
        sb.append("---");
      } else {
        if (len > 0)
          sb.append(String.format("%" + colLen[0] + "s", cellStrings[r][0]));
        for (int c = 1; c <= colDim; ++c) {
          len = colLen[c];
          if (len > 0)
            sb.append(String.format("%" + (len + pad) + "s", cellStrings[r][c].equals("null") ? "" : cellStrings[r][c]));
        }
      }
      sb.append("\n");
    }

   return sb.toString();
  }
1275145
function getCellsAtRow(
    opts: Options,
    // The table
    table: Block,
    rowIndex: number
): List<Block> {
    return table.nodes.get(rowIndex).nodes;
}
702284
public double[] getRow(int row) {
    double[] rowArray = new double[getColumnCount()];
    for (int i = 0; i < getColumnCount(); i++) {
      rowArray[i] = get(row, i);
    }
    return rowArray;
  }
1257932
def parse_row(self, row, row_index, cell_mode=CellMode.cooked):
    """"""
    return [self.parse_cell(cell, (col_index, row_index), cell_mode) \
            for col_index, cell in enumerate(row)]
861002
def select_values values
      return unless values
      values.each do |val|
        row = @list.index val
        add_row_selection_interval row, row unless row.nil?
      end
    end
614241
def get_cell(self, row, column):
        
        url = self.build_url(self._endpoints.get('get_cell').format(row=row, column=column))
        response = self.session.get(url)
        if not response:
            return None
        return self.range_constructor(parent=self, **{self._cloud_data_key: response.json()})
384499
def set_row(row, val)
      # Setter
      if !row.is_a?(String) || (!val.is_a?(Hash) && !val.is_a?(Array))
        raise ArgumentError, 'Illegal argument type'
      elsif val.is_a?(Array) && val.size != col_keys.size
        raise ArgumentError, 'Column size not match'
      end

      case val
      when Array
        if @row_keys[row]
          row = @row_keys[row]
          @content[row] = val
        else
          @row_keys[row] = @row_keys.size
          @content << val
        end
      when Hash
        unless @row_keys[row]
          @row_keys[row] = @row_keys.size
          @content << ([''] * @col_keys.size)
        end

        row = @row_keys[row]
        val.each do |k, v|
          col = @col_keys[k]
          @content[row][col] = v if col
        end
      end

      self
    end
111461
def dry_up row
      return row unless @previous_row
      row.clone.tap do |result|
        row.length.times do |i|
          if can_dry?(@headers[i]) && row[i] == @previous_row[i]
            result[i] = ''
          else
            break
          end
        end
      end
    end
1077405
public Object getValueAt(int row, int col) {

        if (row >= rows.size()) {
            return null;
        }

        Object[] colArray = (Object[]) rows.elementAt(row);

        if (col >= colArray.length) {
            return null;
        }

        return colArray[col];
    }
807355
def filter_rows
      return to_enum(:filter_rows) unless block_given?

      keep_rows = @index.map { |index| yield access_row(index) }

      where keep_rows
    end
396846
def _get_row(self, id):
        """"""
        return {name: d['func'](id) for (name, d) in self._columns.items()}
1006106
def NewRow(self, value=""):
        
        newrow = self.row_class()
        newrow.row = self.size + 1
        newrow.table = self
        headers = self._Header()
        for header in headers:
            newrow[header] = value
        return newrow
81478
def rows(self, table, cols):
        '''
        
        '''
        if self.orng_tables:
            data = []
            for ex in self.orng_tables[table]:
                data.append([ex[str(col)] for col in cols])
            return data
        else:
            return self.fetch(table, cols)