Returns the value in the given cell.
976482
@Override
    public Object getValueAt(int row, int column) {
        switch (column) {
        case 0:
            return expressions.get(row);
        case 1:
            return values.get(row);
        }
        return "";
    }
1066409
function (cell, counter) {
      var alphaNum = instance.utils.getCellAlphaNum(cell),
          alpha = alphaNum.alpha,
          col = instance.utils.toChar(parseInt(instance.utils.toNum(alpha) + counter, 10)),
          row = alphaNum.num;

      if (!col || col.length === 0) {
        col = 'A';
      }

      var fixedCol = alpha[0] === '$' || false,
          fixedRow = alpha[alpha.length - 1] === '$' || false;

      col = (fixedCol ? '$' : '') + col;
      row = (fixedRow ? '$' : '') + row;

      return col + '' + row;
    }
953905
function (id) {
      id = id.replace(/\$/g, '');
      return instance.helper.cellValue.call(this, id);
    }
1318429
function (cell) {
      var num = cell.match(/\d+$/),
          alpha = cell.replace(num, '');

      return {
        row: parseInt(num[0], 10) - 1,
        col: instance.utils.toNum(alpha)
      };
    }
603826
function(strId) {
        var idx = -1,
            li = strId.lastIndexOf("_cell");

        if (li > -1) {
            idx = parseInt(strId.substring(li + 5), 10);
        }

        return idx;
    }
578909
def getValue(self, row):
        ''
        if self._cachedValues is None:
            return self.calcValue(row)

        k = id(row)
        if k in self._cachedValues:
            return self._cachedValues[k]

        ret = self.calcValue(row)
        self._cachedValues[k] = ret

        cachesize = options.col_cache_size
        if cachesize > 0 and len(self._cachedValues) > cachesize:
            self._cachedValues.popitem(last=False)

        return ret
1065884
function (cell) {
      var num = cell.match(/\d+$/),
          alpha = cell.replace(num, '');

      return {
        alpha: alpha,
        num: parseInt(num[0], 10)
      }
    }
962211
function (cell) {
      var value,
          fnCellValue = instance.custom.cellValue,
          element = this,
          item = instance.matrix.getItem(cell);

      // check if custom cellValue fn exists
      if (instance.utils.isFunction(fnCellValue)) {

        var cellCoords = instance.utils.cellCoords(cell),
            cellId = instance.utils.translateCellCoords({row: element.row, col: element.col});

        // get value
        value = item ? item.value : fnCellValue(cellCoords.row, cellCoords.col);

        if (instance.utils.isNull(value)) {
          value = 0;
        }

        if (cellId) {
          //update dependencies
          instance.matrix.updateItem(cellId, {deps: [cell]});
        }

      } else {

        // get value
        value = item ? item.value : document.getElementById(cell).value;

        //update dependencies
        instance.matrix.updateElementItem(element, {deps: [cell]});
      }

      // check references error
      if (item && item.deps) {
        if (item.deps.indexOf(cellId) !== -1) {
          throw Error('REF');
        }
      }

      // check if any error occurs
      if (item && item.error) {
        throw Error(item.error);
      }

      // return value if is set
      if (instance.utils.isSet(value)) {
        var result = instance.helper.number(value);

        return !isNaN(result) ? result : value;
      }

      // cell is not available
      throw Error('NOT_AVAILABLE');
    }
605919
public static ICellValue from(Object o) {
        if (o == null) { return BLANK; }
        else if (o instanceof String) { return new CellValue(o, String.class); }
        else if (o instanceof Double) { return new CellValue(o, Double.class); }
        else if (o instanceof Integer) { return new CellValue(new Double((Integer) o)); }
        else if (o instanceof Boolean) { return new CellValue(o, Boolean.class); }

        throw new CalculationEngineException(String.format("The object %s of class %s is not supported as type for CellValue", o, o.getClass().getSimpleName()));
    }
1251392
private Object getCellValue(Cell cell) {
    Object value;

    // Empty cells are null, instead of BLANK
    if (cell == null) {
      return null;
    }

    switch (cell.getCellTypeEnum()) {
      case STRING:
        value = cell.getStringCellValue();
        break;
      case NUMERIC:
        if (isCellDateFormatted(cell)) {
          try {
            // Excel dates are LocalDateTime, stored without timezone.
            // Interpret them as UTC to prevent ambiguous DST overlaps which happen in other
            // timezones.
            setUserTimeZone(LocaleUtil.TIMEZONE_UTC);
            Date dateCellValue = cell.getDateCellValue();
            value = formatUTCDateAsLocalDateTime(dateCellValue);
          } finally {
            resetUserTimeZone();
          }
        } else {
          value = cell.getNumericCellValue();
        }
        break;
      case BOOLEAN:
        value = cell.getBooleanCellValue();
        break;
      case FORMULA:
        value = getTypedFormulaValue(cell);
        break;
      default:
        value = null;
        break;
    }
    return value;
  }
449322
function (cell) {
            try {
                var start = domUtils.getXY(cell).x + cell.offsetWidth,
                    rows = this.table.rows, cells , returns = [];
                for (var i = 0; i < this.rowsNum; i++) {
                    cells = rows[i].cells;
                    for (var j = 0, tmpCell; tmpCell = cells[j++];) {
                        var tmpStart = domUtils.getXY(tmpCell).x;
                        if (tmpStart > start) break;
                        if (tmpStart == start && tmpCell.colSpan == 1) {
                            returns.push(tmpCell);
                            break;
                        }
                    }
                }
                return returns;
            } catch (e) {
                showError(e);
            }
        }
409365
public C getCell(T item) {
        C cell = pool.poll();
        if(cell != null) {
            cell.updateItem(item);
        } else {
            cell = cellFactory.apply(item);
        }
        return cell;
    }
318846
public int getValue(int c, int column) {
        if (isCompacted || c < 0 || c > MAX_CP || column < 0
                || column >= (columns - 2)) {
            return 0;
        }
        int index = findRow(c);
        return v[index + 2 + column];
    }
972302
def GetColumnNumber (self, columnName):
                """"""
                for row in range(1, self.maxRow + 1):
                        for column in range(1, self.maxColumn + 1):
                                if self.GetCellValue(column, row, "") == columnName:
                                        return column
                return 0
811686
public static Object getDataValue(CellDataType cellDataType, String value, SharedStringsTable sharedStringsTable, String numFmtString) {
		if (null == value) {
			return null;
		}

		Object result;
		switch (cellDataType) {
		case BOOL:
			result = (value.charAt(0) != '0');
			break;
		case ERROR:
			result = StrUtil.format("\\\"ERROR: {} ", value);
			break;
		case FORMULA:
			result = StrUtil.format("\"{}\"", value);
			break;
		case INLINESTR:
			result = new XSSFRichTextString(value).toString();
			break;
		case SSTINDEX:
			try {
				final int index = Integer.parseInt(value);
				result = new XSSFRichTextString(sharedStringsTable.getEntryAt(index)).getString();
			} catch (NumberFormatException e) {
				result = value;
			}
			break;
		case NUMBER:
			result = getNumberValue(value, numFmtString);
			break;
		case DATE:
			try {
				result = getDateValue(value);
			} catch (Exception e) {
				result = value;
			}
			break;
		default:
			result = value;
			break;
		}
		return result;
	}
1223427
function (cell, counter) {
      var alphaNum = instance.utils.getCellAlphaNum(cell),
          alpha = alphaNum.alpha,
          col = alpha,
          row = parseInt(alphaNum.num + counter, 10);

      if (row < 1) {
        row = 1;
      }

      return col + '' + row;
    }
126922
public static Cell findCell(Sheet sheet, String cellRefValue) {
        val cellRef = new CellReference(cellRefValue);
        val row = sheet.getRow(cellRef.getRow());
        if (row == null) {
            log.warn("unable to find row for " + cellRefValue);
            return null;
        }

        val cell = row.getCell(cellRef.getCol());
        if (cell == null) {
            log.warn("unable to find cell for " + cellRefValue);
        }

        return cell;
    }