Returns the value at the specified position.

@param row
index of the row
@param col
index of the column

@return string representation of the specified field
1970
@Override
	public Object getValueAt(final int row, final int col)
	{

		switch (col) {
		case 0:
			return archives.get(row).getType();
		case 1:
			return archives.get(row).getStartPosition();
		case 2:
			return archives.get(row).getPath();
		}

		return "---";
	}
455975
public function getCellValue(int $col, int $row): string
    {
        if (!isset($this->structure[$row][$col])) {
            return '';
        }

        return $this->structure[$row][$col]['value'];
    }
238031
public double getColumnValueAsDouble(final int col) {
		final Object value = getColumnValue(col);
		if (value == null) {
			return 0;
		}
		return new Double(value.toString());
	}
646010
def get_value(self, spec, row):
        
        column = spec.get('column')
        default = spec.get('default')
        if column is None:
            if default is not None:
                return self.convert_type(default, spec)
            return
        value = row.get(column)
        if is_empty(value):
            if default is not None:
                return self.convert_type(default, spec)
            return None
        return self.convert_type(value, spec)
1302836
public Object column(int col) throws jsqlite.Exception {
	switch (column_type(col)) {
	case Constants.SQLITE_INTEGER:
	    return new Long(column_long(col));
	case Constants.SQLITE_FLOAT:
	    return new Double(column_double(col));
	case Constants.SQLITE_BLOB:
	    return column_bytes(col);
	case Constants.SQLITE3_TEXT:
	    return column_string(col);
	}
	return null;
    }
1041531
public Object get( int row, int col ) {
        return (dstore == null) ? null : dstore.get(row, col);
    }
1162665
public float getValueAtAsFloat(final int row, final int col) {
		final Object valueAt = getValueAt(row, col);
		float number = 0;
		if (valueAt != null && !valueAt.toString().equals("")) {
			number = Float.parseFloat(valueAt.toString().trim());
		}
		return number;
	}
470080
protected Object retriveValue(Class<?> type, RowData row, Column col) {
        if (StringUtils.isNotEmpty(col.getPattern())) {
            if (ClassUtils.isAssignable(type, Map.class)) {
                return row.getCellValuesAsMap(col.getPattern(), 1, col.getReplace());
            } else {
                return row.getCellValues(col.getPattern(), col.getReplace(),
                        col.isExcludeEmptyValue());
            }
        } else {
            if (ClassUtils.isAssignable(type, Integer.class)) {
                return row.getInt(col.getName(), col.getReplace());
            } else if (ClassUtils.isAssignable(type, Boolean.class)) {
                return row.getBoolean(col.getName(), col.getTrueStr(), col.getReplace());
            } else {
                return row.getCellValue(col.getName(), col.getReplace());
            }
        }
    }
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();
  }
107219
Index getIndexForColumn(int col) {

        int i = bestIndexForColumn[col];

        return i == -1 ? null
                       : this.indexList[i];
    }
28471
@Override
    public Object getValue(Query qr, int row) throws PageException {
	if (col == null) col = qr.getColumn(getColumn());
	return QueryUtil.getValue(col, row);
    }
638176
@Override
	public Object getValueAt(final int row, final int visibleColumnIndex) {
		final int actualIndex = this.visibilityManager.getActualIndexFromVisibleIndex(visibleColumnIndex);
		return getRecords().get(row).getColumnValue(actualIndex);
	}
968199
function get( $row, $col )
    {
        $pos = $row * $this->Cols + $col;
        $pos = base_convert( $pos, 10, 36 );
        return isset( $this->Matrix["*$pos"] ) ? $this->Matrix["*$pos"] : 0;
    }
575781
public <T> T get(int row, int col, DataType dataType)
	{
		List<String> rowList = row(row);
		
		if(rowList == null || rowList.isEmpty() || col >= rowList.size())
			return nullFor(dataType);
		
	
		String cell = rowList.get(col);
		
		
		
		T results = toType(cell,dataType);
		return results;
	}
413602
public function getValue($row, $col)
    {
        $returnValue = null;
        $data = $this->getData();
        if (isset($data[$row][$col])) {
            $returnValue = $data[$row][$col];
        } else if (isset($data[$row]) && is_string($col)) {
            // try to access by col name.
            $mapping = $this->getColumnMapping();
            for ($i = 0; $i < count($mapping); $i++) {

                if ($mapping[$i] == $col && isset($data[$row][$col])) {
                    // Column with name $col extists.
                    $returnValue = $data[$row][$col];
                }
            }
        } else {
            throw new InvalidArgumentException("No value at ${row},${col}.");
        }
        return $returnValue;
    }
696305
def get_position(self, row, col):
        """"""
        result = col
        self.log.debug('%s %s', row, col)
        lines = self.editor.getlines()[:row - 1]
        result += sum([len(l) + 1 for l in lines])
        self.log.debug(result)
        return result
861441
@Override
	public Object getValueAt(int row, int col) {
		// Get the href and the required field
		HistoryReference href = hrefList.get(row);
		try {
			switch (this.columns[col]) {
			case HREF_ID:		return href.getHistoryId();
			case TYPE_FLAG:		return this.getHrefTypeIcon(href);
			case METHOD:		return href.getMethod();
			case URL:			return href.getURI().toString();
			case CODE:			return href.getStatusCode();
			case REASON:		return href.getReason();
			case RTT:			return href.getRtt();
			case SIZE:			return href.getResponseBodyLength();
			case SESSION_ID:	return href.getSessionId();
			case ALERT_FLAG:	return this.getHrefAlertIcon(href);
			case TAGS:			return listToCsv(href.getTags());
			default:			return null;
			}
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
			return null;
		}
	}