Find the default cell style for a column

@param columnIndex the column index
@return the style, null if none
768591
public TableCellStyle findDefaultCellStyle(final int columnIndex) {
        TableCellStyle s = this.columnStyles.get(columnIndex).getDefaultCellStyle();
        if (s == null) s = TableCellStyle.DEFAULT_CELL_STYLE;
        return s;
    }
242609
public function getColumnDefaultSort($columnKey)
	{
		if (isset($this->default_sort[$columnKey])) {
			return $this->default_sort[$columnKey];
		}

		return NULL;
	}
1311419
public CellStyle getOrCreateCellStyle(int x, int y) {
		final Cell cell = getOrCreateCell(x, y);
		CellStyle cellStyle = cell.getCellStyle();
		if (null == cellStyle) {
			cellStyle = this.workbook.createCellStyle();
			cell.setCellStyle(cellStyle);
		}
		return cellStyle;
	}
1180602
protected T getRowObject(int rowIndex) {
		int pageIndex = rowIndex - dataOffset;
		if (pageIndex >= 0 && pageIndex < data.size()) {
			return data.get(pageIndex);
		}
		return null;
	}
372030
public function getColumnStylesForColumn($columnIndex)
    {
        if (!$this->hasColumnStylesForColumn($columnIndex)) {
            return false;
        }

        $columnStyles = $this->getColumnStyles();

        return $columnStyles[$columnIndex] ?? false;
    }
107219
Index getIndexForColumn(int col) {

        int i = bestIndexForColumn[col];

        return i == -1 ? null
                       : this.indexList[i];
    }
959198
C getSizedCell(int itemIndex) {
        C cell = cellManager.getCell(itemIndex);
        double breadth = sizeTracker.breadthFor(itemIndex);
        double length = sizeTracker.lengthFor(itemIndex);
        orientation.resize(cell, breadth, length);
        return cell;
    }
1029738
public StyleRow getStyle(GeometryType geometryType) {

		StyleRow styleRow = null;

		if (geometryType != null && !styles.isEmpty()) {
			List<GeometryType> geometryTypes = GeometryUtils
					.parentHierarchy(geometryType);
			geometryTypes.add(0, geometryType);
			for (GeometryType type : geometryTypes) {
				styleRow = styles.get(type);
				if (styleRow != null) {
					break;
				}
			}
		}

		if (styleRow == null) {
			styleRow = defaultStyle;
		}

		if (styleRow == null && geometryType == null && styles.size() == 1) {
			styleRow = styles.values().iterator().next();
		}

		return styleRow;
	}
1143446
public int columnIndex(final int _tableIndex, final String _columnName)
    {
        final Optional<Column> colOpt = getColumns().stream()
                        .filter(column -> column.tableIndex == _tableIndex && column.columnName.equals(_columnName))
                        .findFirst();
        final int ret;
        if (colOpt.isPresent()) {
            ret = getColumns().indexOf(colOpt.get());
        } else {
            columns.add(new Column(tablePrefix, _tableIndex, _columnName));
            ret = getColumnIdx();
        }
        return ret;
    }
1064432
StageStyle getDefaultStyle() {
        final String style = annotation.stageStyle();
        return StageStyle.valueOf(style.toUpperCase());
    }
817351
public Optional<ColumnMapping> getColumnMapping(final int columnNumber) {
        return columns.stream()
                .filter(c -> c.getNumber() == columnNumber)
                .findFirst();
    }
940615
function findColMergedLastIndex(tableData, rowIndex, colIndex) {
  const cellData = tableData[rowIndex][colIndex];
  let foundColIndex = colIndex;

  if (cellData.colspan > 1) {
    foundColIndex += cellData.colspan - 1;
  }

  return foundColIndex;
}
781846
public static String getColumnDefaultValue (Connection conn, String table, String column)
        throws SQLException
    {
        ResultSet rs = getColumnMetaData(conn, table, column);
        try {
            return rs.getString("COLUMN_DEF");
        } finally {
            rs.close();
        }
    }
712349
public final String getColumnName(int index) {
    if (index < 0 || index >= columns.size()) {
      throw new InvalidOperationException("Invalid column index: " + index);
    }
    return columns.get(index);
  }
835653
@Nonnull
    public final Style getDefaultStyle(@Nonnull final String geometryType) {
        String normalizedGeomName = GEOMETRY_NAME_ALIASES.get(geometryType.toLowerCase());
        if (normalizedGeomName == null) {
            normalizedGeomName = geometryType.toLowerCase();
        }
        Style style = this.defaultStyle.get(normalizedGeomName.toLowerCase());
        if (style == null) {
            style = this.namedStyles.get(normalizedGeomName.toLowerCase());
        }

        if (style == null) {
            StyleBuilder builder = new StyleBuilder();
            final Symbolizer symbolizer;
            if (isPointType(normalizedGeomName)) {
                symbolizer = builder.createPointSymbolizer();
            } else if (isLineType(normalizedGeomName)) {
                symbolizer = builder.createLineSymbolizer(Color.black, 2);
            } else if (isPolygonType(normalizedGeomName)) {
                symbolizer = builder.createPolygonSymbolizer(Color.lightGray, Color.black, 2);
            } else if (normalizedGeomName.equalsIgnoreCase(Constants.Style.Raster.NAME)) {
                symbolizer = builder.createRasterSymbolizer();
            } else if (normalizedGeomName.startsWith(Constants.Style.OverviewMap.NAME)) {
                symbolizer = createMapOverviewStyle(normalizedGeomName, builder);
            } else {
                final Style geomStyle = this.defaultStyle.get(Geometry.class.getSimpleName().toLowerCase());
                if (geomStyle != null) {
                    return geomStyle;
                } else {
                    symbolizer = builder.createPointSymbolizer();
                }
            }
            style = builder.createStyle(symbolizer);
        }
        return style;
    }
1035966
public String getString(int columnIndex) {
		if (columnIndex < 0 || columnIndex >= data.length) {
			throw new IllegalArgumentException("Invalid index field: (" + columnIndex+"). Valid range is 0 to " + (data.length - 1));			
		}
		Object fieldValue = data[columnIndex];
		if (fieldValue == null) {
			return null;
		}
		if (fieldValue instanceof String) {
			return (String) fieldValue;
		}
		return fieldValue.toString();
	}
583058
void setDefaultExpression(int columnIndex, Expression def) {

        ColumnSchema column = getColumn(columnIndex);

        column.setDefaultExpression(def);
        setColumnTypeVars(columnIndex);
    }