jdk-sandbox: comparison jdk/src/share/classes/javax/swing/table/DefaultTableModel.java

equal deleted inserted replaced

-:3fb50df97199
+:4050cc242edf
 /**
 * The <code>Vector</code> of <code>Vectors</code> of
 * <code>Object</code> values.
 */
-protected Vector<Vector<Object>>    dataVector;
+@SuppressWarnings("rawtypes")
+protected Vector<Vector>    dataVector;
 /** The <code>Vector</code> of column identifiers. */
-protected Vector<Object>    columnIdentifiers;
+@SuppressWarnings("rawtypes")
+protected Vector    columnIdentifiers;
+// Unfortunately, for greater source compatibility the inner-most
+// Vector in the two fields above is being left raw. The Vector is
+// read as well as written so using Vector<?> is not suitable and
+// using Vector<Object> (without adding copying of input Vectors),
+// would disallow existing code that used, say, a Vector<String>
+// as an input parameter.
 //
 // Constructors
 //
 *                          <code>null</code> then the model has no columns
 * @param rowCount           the number of rows the table holds
 * @see #setDataVector
 * @see #setValueAt
 */
-public DefaultTableModel(Vector<Object> columnNames, int rowCount) {
+public DefaultTableModel(Vector<?> columnNames, int rowCount) {
 setDataVector(newVector(rowCount), columnNames);
 }
 /**
 *  Constructs a <code>DefaultTableModel</code> with as many
 * @param columnNames       <code>vector</code> containing the names
 *                          of the new columns
 * @see #getDataVector
 * @see #setDataVector
 */
-public DefaultTableModel(Vector<Vector<Object>> data, Vector<Object> columnNames) {
+@SuppressWarnings("rawtypes")
+public DefaultTableModel(Vector<? extends Vector> data, Vector<?> columnNames) {
 setDataVector(data, columnNames);
 }
 /**
 *  Constructs a <code>DefaultTableModel</code> and initializes the table
 *
 * @see #newDataAvailable
 * @see #newRowsAdded
 * @see #setDataVector
 */
-public Vector<Vector<Object>> getDataVector() {
+@SuppressWarnings("rawtypes")
+public Vector<Vector> getDataVector() {
 return dataVector;
 }
 private static <E> Vector<E> nonNullVector(Vector<E> v) {
 return (v != null) ? v : new Vector<>();
 *
 * @param   dataVector         the new data vector
 * @param   columnIdentifiers     the names of the columns
 * @see #getDataVector
 */
-public void setDataVector(Vector<Vector<Object>> dataVector,
+@SuppressWarnings({"rawtypes", "unchecked"})
-Vector<Object> columnIdentifiers) {
+public void setDataVector(Vector<? extends Vector> dataVector,
-this.dataVector = nonNullVector(dataVector);
+Vector<?> columnIdentifiers) {
+this.dataVector = nonNullVector((Vector<Vector>)dataVector);
 this.columnIdentifiers = nonNullVector(columnIdentifiers);
 justifyRows(0, getRowCount());
 fireTableStructureChanged();
 }
 for (int i = from; i < to; i++) {
 if (dataVector.elementAt(i) == null) {
 dataVector.setElementAt(new Vector<>(), i);
 }
-((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
+dataVector.elementAt(i).setSize(getColumnCount());
 }
 }
 /**
 *  Ensures that the new rows have the correct number of columns.
 *  <code>null</code> values unless <code>rowData</code> is specified.
 *  Notification of the row being added will be generated.
 *
 * @param   rowData          optional data of the row being added
 */
-public void addRow(Vector<Object> rowData) {
+public void addRow(Vector<?> rowData) {
 insertRow(getRowCount(), rowData);
 }
 /**
 *  Adds a row to the end of the model.  The new row will contain
 *
 * @param   row             the row index of the row to be inserted
 * @param   rowData         optional data of the row being added
 * @exception  ArrayIndexOutOfBoundsException  if the row was invalid
 */
-public void insertRow(int row, Vector<Object> rowData) {
+public void insertRow(int row, Vector<?> rowData) {
 dataVector.insertElementAt(rowData, row);
 justifyRows(row, row+1);
 fireTableRowsInserted(row, row);
 }
 * @param   columnIdentifiers  vector of column identifiers.  If
 *                          <code>null</code>, set the model
 *                          to zero columns
 * @see #setNumRows
 */
-public void setColumnIdentifiers(Vector<Object> columnIdentifiers) {
+public void setColumnIdentifiers(Vector<?> columnIdentifiers) {
 setDataVector(dataVector, columnIdentifiers);
 }
 /**
 * Replaces the column identifiers in the model.  If the number of
 *  <code>tableChanged</code> notification message to all the listeners.
 *
 * @param   columnName the identifier of the column being added
 * @param   columnData       optional data of the column being added
 */
-public void addColumn(Object columnName, Vector<Object> columnData) {
+@SuppressWarnings("unchecked") // Adding element to raw columnIdentifiers
+public void addColumn(Object columnName, Vector<?> columnData) {
 columnIdentifiers.addElement(columnName);
 if (columnData != null) {
 int columnSize = columnData.size();
 if (columnSize > getRowCount()) {
 dataVector.setSize(columnSize);
 * @return                  the value Object at the specified cell
 * @exception  ArrayIndexOutOfBoundsException  if an invalid row or
 *               column was given
 */
 public Object getValueAt(int row, int column) {
+@SuppressWarnings("unchecked")
 Vector<Object> rowVector = dataVector.elementAt(row);
 return rowVector.elementAt(column);
 }
 /**
 * @param   column          the column whose value is to be changed
 * @exception  ArrayIndexOutOfBoundsException  if an invalid row or
 *               column was given
 */
 public void setValueAt(Object aValue, int row, int column) {
+@SuppressWarnings("unchecked")
 Vector<Object> rowVector = dataVector.elementAt(row);
 rowVector.setElementAt(aValue, column);
 fireTableCellUpdated(row, column);
 }

changeset 26351	4050cc242edf
parent 25568	b906a74c6882