| /* | |
| * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| package javax.swing.table; | |
| import java.io.Serializable; | |
| import java.util.Vector; | |
| import java.util.Enumeration; | |
| import javax.swing.event.TableModelEvent; | |
| /** | |
| * This is an implementation of <code>TableModel</code> that | |
| * uses a <code>Vector</code> of <code>Vectors</code> to store the | |
| * cell value objects. | |
| * <p> | |
| * <strong>Warning:</strong> <code>DefaultTableModel</code> returns a | |
| * column class of <code>Object</code>. When | |
| * <code>DefaultTableModel</code> is used with a | |
| * <code>TableRowSorter</code> this will result in extensive use of | |
| * <code>toString</code>, which for non-<code>String</code> data types | |
| * is expensive. If you use <code>DefaultTableModel</code> with a | |
| * <code>TableRowSorter</code> you are strongly encouraged to override | |
| * <code>getColumnClass</code> to return the appropriate type. | |
| * <p> | |
| * <strong>Warning:</strong> | |
| * Serialized objects of this class will not be compatible with | |
| * future Swing releases. The current serialization support is | |
| * appropriate for short term storage or RMI between applications running | |
| * the same version of Swing. As of 1.4, support for long term storage | |
| * of all JavaBeans | |
| * has been added to the <code>java.beans</code> package. | |
| * Please see {@link java.beans.XMLEncoder}. | |
| * | |
| * @author Philip Milne | |
| * | |
| * @see TableModel | |
| * @see #getDataVector | |
| */ | |
| @SuppressWarnings("serial") // Same-version serialization only | |
| public class DefaultTableModel extends AbstractTableModel implements Serializable { | |
| // | |
| // Instance Variables | |
| // | |
| /** | |
| * The <code>Vector</code> of <code>Vectors</code> of | |
| * <code>Object</code> values. | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| protected Vector<Vector> dataVector; | |
| /** The <code>Vector</code> of column identifiers. */ | |
| @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 | |
| // | |
| /** | |
| * Constructs a default <code>DefaultTableModel</code> | |
| * which is a table of zero columns and zero rows. | |
| */ | |
| public DefaultTableModel() { | |
| this(0, 0); | |
| } | |
| private static <E> Vector<E> newVector(int size) { | |
| Vector<E> v = new Vector<>(size); | |
| v.setSize(size); | |
| return v; | |
| } | |
| /** | |
| * Constructs a <code>DefaultTableModel</code> with | |
| * <code>rowCount</code> and <code>columnCount</code> of | |
| * <code>null</code> object values. | |
| * | |
| * @param rowCount the number of rows the table holds | |
| * @param columnCount the number of columns the table holds | |
| * | |
| * @see #setValueAt | |
| */ | |
| public DefaultTableModel(int rowCount, int columnCount) { | |
| this(newVector(columnCount), rowCount); | |
| } | |
| /** | |
| * Constructs a <code>DefaultTableModel</code> with as many columns | |
| * as there are elements in <code>columnNames</code> | |
| * and <code>rowCount</code> of <code>null</code> | |
| * object values. Each column's name will be taken from | |
| * the <code>columnNames</code> vector. | |
| * | |
| * @param columnNames <code>vector</code> containing the names | |
| * of the new columns; if this is | |
| * <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<?> columnNames, int rowCount) { | |
| setDataVector(newVector(rowCount), columnNames); | |
| } | |
| /** | |
| * Constructs a <code>DefaultTableModel</code> with as many | |
| * columns as there are elements in <code>columnNames</code> | |
| * and <code>rowCount</code> of <code>null</code> | |
| * object values. Each column's name will be taken from | |
| * the <code>columnNames</code> array. | |
| * | |
| * @param columnNames <code>array</code> containing the names | |
| * of the new columns; if this is | |
| * <code>null</code> then the model has no columns | |
| * @param rowCount the number of rows the table holds | |
| * @see #setDataVector | |
| * @see #setValueAt | |
| */ | |
| public DefaultTableModel(Object[] columnNames, int rowCount) { | |
| this(convertToVector(columnNames), rowCount); | |
| } | |
| /** | |
| * Constructs a <code>DefaultTableModel</code> and initializes the table | |
| * by passing <code>data</code> and <code>columnNames</code> | |
| * to the <code>setDataVector</code> method. | |
| * | |
| * @param data the data of the table, a <code>Vector</code> | |
| * of <code>Vector</code>s of <code>Object</code> | |
| * values | |
| * @param columnNames <code>vector</code> containing the names | |
| * of the new columns | |
| * @see #getDataVector | |
| * @see #setDataVector | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| public DefaultTableModel(Vector<? extends Vector> data, Vector<?> columnNames) { | |
| setDataVector(data, columnNames); | |
| } | |
| /** | |
| * Constructs a <code>DefaultTableModel</code> and initializes the table | |
| * by passing <code>data</code> and <code>columnNames</code> | |
| * to the <code>setDataVector</code> | |
| * method. The first index in the <code>Object[][]</code> array is | |
| * the row index and the second is the column index. | |
| * | |
| * @param data the data of the table | |
| * @param columnNames the names of the columns | |
| * @see #getDataVector | |
| * @see #setDataVector | |
| */ | |
| public DefaultTableModel(Object[][] data, Object[] columnNames) { | |
| setDataVector(data, columnNames); | |
| } | |
| /** | |
| * Returns the <code>Vector</code> of <code>Vectors</code> | |
| * that contains the table's | |
| * data values. The vectors contained in the outer vector are | |
| * each a single row of values. In other words, to get to the cell | |
| * at row 1, column 5: <p> | |
| * | |
| * <code>((Vector)getDataVector().elementAt(1)).elementAt(5);</code> | |
| * | |
| * @return the vector of vectors containing the tables data values | |
| * | |
| * @see #newDataAvailable | |
| * @see #newRowsAdded | |
| * @see #setDataVector | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| public Vector<Vector> getDataVector() { | |
| return dataVector; | |
| } | |
| private static <E> Vector<E> nonNullVector(Vector<E> v) { | |
| return (v != null) ? v : new Vector<>(); | |
| } | |
| /** | |
| * Replaces the current <code>dataVector</code> instance variable | |
| * with the new <code>Vector</code> of rows, <code>dataVector</code>. | |
| * Each row is represented in <code>dataVector</code> as a | |
| * <code>Vector</code> of <code>Object</code> values. | |
| * <code>columnIdentifiers</code> are the names of the new | |
| * columns. The first name in <code>columnIdentifiers</code> is | |
| * mapped to column 0 in <code>dataVector</code>. Each row in | |
| * <code>dataVector</code> is adjusted to match the number of | |
| * columns in <code>columnIdentifiers</code> | |
| * either by truncating the <code>Vector</code> if it is too long, | |
| * or adding <code>null</code> values if it is too short. | |
| * <p>Note that passing in a <code>null</code> value for | |
| * <code>dataVector</code> results in unspecified behavior, | |
| * an possibly an exception. | |
| * | |
| * @param dataVector the new data vector | |
| * @param columnIdentifiers the names of the columns | |
| * @see #getDataVector | |
| */ | |
| @SuppressWarnings({"rawtypes", "unchecked"}) | |
| public void setDataVector(Vector<? extends Vector> dataVector, | |
| Vector<?> columnIdentifiers) { | |
| this.dataVector = nonNullVector((Vector<Vector>)dataVector); | |
| this.columnIdentifiers = nonNullVector(columnIdentifiers); | |
| justifyRows(0, getRowCount()); | |
| fireTableStructureChanged(); | |
| } | |
| /** | |
| * Replaces the value in the <code>dataVector</code> instance | |
| * variable with the values in the array <code>dataVector</code>. | |
| * The first index in the <code>Object[][]</code> | |
| * array is the row index and the second is the column index. | |
| * <code>columnIdentifiers</code> are the names of the new columns. | |
| * | |
| * @param dataVector the new data vector | |
| * @param columnIdentifiers the names of the columns | |
| * @see #setDataVector(Vector, Vector) | |
| */ | |
| public void setDataVector(Object[][] dataVector, Object[] columnIdentifiers) { | |
| setDataVector(convertToVector(dataVector), convertToVector(columnIdentifiers)); | |
| } | |
| /** | |
| * Equivalent to <code>fireTableChanged</code>. | |
| * | |
| * @param event the change event | |
| * | |
| */ | |
| public void newDataAvailable(TableModelEvent event) { | |
| fireTableChanged(event); | |
| } | |
| // | |
| // Manipulating rows | |
| // | |
| private void justifyRows(int from, int to) { | |
| // Sometimes the DefaultTableModel is subclassed | |
| // instead of the AbstractTableModel by mistake. | |
| // Set the number of rows for the case when getRowCount | |
| // is overridden. | |
| dataVector.setSize(getRowCount()); | |
| for (int i = from; i < to; i++) { | |
| if (dataVector.elementAt(i) == null) { | |
| dataVector.setElementAt(new Vector<>(), i); | |
| } | |
| dataVector.elementAt(i).setSize(getColumnCount()); | |
| } | |
| } | |
| /** | |
| * Ensures that the new rows have the correct number of columns. | |
| * This is accomplished by using the <code>setSize</code> method in | |
| * <code>Vector</code> which truncates vectors | |
| * which are too long, and appends <code>null</code>s if they | |
| * are too short. | |
| * This method also sends out a <code>tableChanged</code> | |
| * notification message to all the listeners. | |
| * | |
| * @param e this <code>TableModelEvent</code> describes | |
| * where the rows were added. | |
| * If <code>null</code> it assumes | |
| * all the rows were newly added | |
| * @see #getDataVector | |
| */ | |
| public void newRowsAdded(TableModelEvent e) { | |
| justifyRows(e.getFirstRow(), e.getLastRow() + 1); | |
| fireTableChanged(e); | |
| } | |
| /** | |
| * Equivalent to <code>fireTableChanged</code>. | |
| * | |
| * @param event the change event | |
| * | |
| */ | |
| public void rowsRemoved(TableModelEvent event) { | |
| fireTableChanged(event); | |
| } | |
| /** | |
| * Obsolete as of Java 2 platform v1.3. Please use <code>setRowCount</code> instead. | |
| * @param rowCount the new number of rows | |
| */ | |
| public void setNumRows(int rowCount) { | |
| int old = getRowCount(); | |
| if (old == rowCount) { | |
| return; | |
| } | |
| dataVector.setSize(rowCount); | |
| if (rowCount <= old) { | |
| fireTableRowsDeleted(rowCount, old-1); | |
| } | |
| else { | |
| justifyRows(old, rowCount); | |
| fireTableRowsInserted(old, rowCount-1); | |
| } | |
| } | |
| /** | |
| * Sets the number of rows in the model. If the new size is greater | |
| * than the current size, new rows are added to the end of the model | |
| * If the new size is less than the current size, all | |
| * rows at index <code>rowCount</code> and greater are discarded. | |
| * | |
| * @see #setColumnCount | |
| * @since 1.3 | |
| * | |
| * @param rowCount number of rows in the model | |
| */ | |
| public void setRowCount(int rowCount) { | |
| setNumRows(rowCount); | |
| } | |
| /** | |
| * Adds a row to the end of the model. The new row will contain | |
| * <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<?> rowData) { | |
| insertRow(getRowCount(), rowData); | |
| } | |
| /** | |
| * Adds a row to the end of the model. The new row will contain | |
| * <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(Object[] rowData) { | |
| addRow(convertToVector(rowData)); | |
| } | |
| /** | |
| * Inserts a row at <code>row</code> in the model. The new row | |
| * will contain <code>null</code> values unless <code>rowData</code> | |
| * is specified. Notification of the row being added will be generated. | |
| * | |
| * @param row the row index of the row to be inserted | |
| * @param rowData optional data of the row being added | |
| * @throws ArrayIndexOutOfBoundsException if the row was invalid | |
| */ | |
| public void insertRow(int row, Vector<?> rowData) { | |
| dataVector.insertElementAt(rowData, row); | |
| justifyRows(row, row+1); | |
| fireTableRowsInserted(row, row); | |
| } | |
| /** | |
| * Inserts a row at <code>row</code> in the model. The new row | |
| * will contain <code>null</code> values unless <code>rowData</code> | |
| * is specified. Notification of the row being added will be generated. | |
| * | |
| * @param row the row index of the row to be inserted | |
| * @param rowData optional data of the row being added | |
| * @throws ArrayIndexOutOfBoundsException if the row was invalid | |
| */ | |
| public void insertRow(int row, Object[] rowData) { | |
| insertRow(row, convertToVector(rowData)); | |
| } | |
| private static int gcd(int i, int j) { | |
| return (j == 0) ? i : gcd(j, i%j); | |
| } | |
| private static <E> void rotate(Vector<E> v, int a, int b, int shift) { | |
| int size = b - a; | |
| int r = size - shift; | |
| int g = gcd(size, r); | |
| for(int i = 0; i < g; i++) { | |
| int to = i; | |
| E tmp = v.elementAt(a + to); | |
| for(int from = (to + r) % size; from != i; from = (to + r) % size) { | |
| v.setElementAt(v.elementAt(a + from), a + to); | |
| to = from; | |
| } | |
| v.setElementAt(tmp, a + to); | |
| } | |
| } | |
| /** | |
| * Moves one or more rows from the inclusive range <code>start</code> to | |
| * <code>end</code> to the <code>to</code> position in the model. | |
| * After the move, the row that was at index <code>start</code> | |
| * will be at index <code>to</code>. | |
| * This method will send a <code>tableChanged</code> notification | |
| message to all the listeners. | |
| * | |
| * <pre> | |
| * Examples of moves: | |
| * | |
| * 1. moveRow(1,3,5); | |
| * a|B|C|D|e|f|g|h|i|j|k - before | |
| * a|e|f|g|h|B|C|D|i|j|k - after | |
| * | |
| * 2. moveRow(6,7,1); | |
| * a|b|c|d|e|f|G|H|i|j|k - before | |
| * a|G|H|b|c|d|e|f|i|j|k - after | |
| * </pre> | |
| * | |
| * @param start the starting row index to be moved | |
| * @param end the ending row index to be moved | |
| * @param to the destination of the rows to be moved | |
| * @throws ArrayIndexOutOfBoundsException if any of the elements | |
| * would be moved out of the table's range | |
| * | |
| */ | |
| public void moveRow(int start, int end, int to) { | |
| int shift = to - start; | |
| int first, last; | |
| if (shift < 0) { | |
| first = to; | |
| last = end; | |
| } | |
| else { | |
| first = start; | |
| last = to + end - start; | |
| } | |
| rotate(dataVector, first, last + 1, shift); | |
| fireTableRowsUpdated(first, last); | |
| } | |
| /** | |
| * Removes the row at <code>row</code> from the model. Notification | |
| * of the row being removed will be sent to all the listeners. | |
| * | |
| * @param row the row index of the row to be removed | |
| * @throws ArrayIndexOutOfBoundsException if the row was invalid | |
| */ | |
| public void removeRow(int row) { | |
| dataVector.removeElementAt(row); | |
| fireTableRowsDeleted(row, row); | |
| } | |
| // | |
| // Manipulating columns | |
| // | |
| /** | |
| * Replaces the column identifiers in the model. If the number of | |
| * <code>newIdentifier</code>s is greater than the current number | |
| * of columns, new columns are added to the end of each row in the model. | |
| * If the number of <code>newIdentifier</code>s is less than the current | |
| * number of columns, all the extra columns at the end of a row are | |
| * discarded. | |
| * | |
| * @param columnIdentifiers vector of column identifiers. If | |
| * <code>null</code>, set the model | |
| * to zero columns | |
| * @see #setNumRows | |
| */ | |
| public void setColumnIdentifiers(Vector<?> columnIdentifiers) { | |
| setDataVector(dataVector, columnIdentifiers); | |
| } | |
| /** | |
| * Replaces the column identifiers in the model. If the number of | |
| * <code>newIdentifier</code>s is greater than the current number | |
| * of columns, new columns are added to the end of each row in the model. | |
| * If the number of <code>newIdentifier</code>s is less than the current | |
| * number of columns, all the extra columns at the end of a row are | |
| * discarded. | |
| * | |
| * @param newIdentifiers array of column identifiers. | |
| * If <code>null</code>, set | |
| * the model to zero columns | |
| * @see #setNumRows | |
| */ | |
| public void setColumnIdentifiers(Object[] newIdentifiers) { | |
| setColumnIdentifiers(convertToVector(newIdentifiers)); | |
| } | |
| /** | |
| * Sets the number of columns in the model. If the new size is greater | |
| * than the current size, new columns are added to the end of the model | |
| * with <code>null</code> cell values. | |
| * If the new size is less than the current size, all columns at index | |
| * <code>columnCount</code> and greater are discarded. | |
| * | |
| * @param columnCount the new number of columns in the model | |
| * | |
| * @see #setRowCount | |
| * @since 1.3 | |
| */ | |
| public void setColumnCount(int columnCount) { | |
| columnIdentifiers.setSize(columnCount); | |
| justifyRows(0, getRowCount()); | |
| fireTableStructureChanged(); | |
| } | |
| /** | |
| * Adds a column to the model. The new column will have the | |
| * identifier <code>columnName</code>, which may be null. This method | |
| * will send a | |
| * <code>tableChanged</code> notification message to all the listeners. | |
| * This method is a cover for <code>addColumn(Object, Vector)</code> which | |
| * uses <code>null</code> as the data vector. | |
| * | |
| * @param columnName the identifier of the column being added | |
| */ | |
| public void addColumn(Object columnName) { | |
| addColumn(columnName, (Vector<Object>)null); | |
| } | |
| /** | |
| * Adds a column to the model. The new column will have the | |
| * identifier <code>columnName</code>, which may be null. | |
| * <code>columnData</code> is the | |
| * optional vector of data for the column. If it is <code>null</code> | |
| * the column is filled with <code>null</code> values. Otherwise, | |
| * the new data will be added to model starting with the first | |
| * element going to row 0, etc. This method will send a | |
| * <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 | |
| */ | |
| @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); | |
| } | |
| justifyRows(0, getRowCount()); | |
| int newColumn = getColumnCount() - 1; | |
| for(int i = 0; i < columnSize; i++) { | |
| Vector<Object> row = dataVector.elementAt(i); | |
| row.setElementAt(columnData.elementAt(i), newColumn); | |
| } | |
| } | |
| else { | |
| justifyRows(0, getRowCount()); | |
| } | |
| fireTableStructureChanged(); | |
| } | |
| /** | |
| * Adds a column to the model. The new column will have the | |
| * identifier <code>columnName</code>. <code>columnData</code> is the | |
| * optional array of data for the column. If it is <code>null</code> | |
| * the column is filled with <code>null</code> values. Otherwise, | |
| * the new data will be added to model starting with the first | |
| * element going to row 0, etc. This method will send a | |
| * <code>tableChanged</code> notification message to all the listeners. | |
| * | |
| * @param columnName identifier of the newly created column | |
| * @param columnData new data to be added to the column | |
| * | |
| * @see #addColumn(Object, Vector) | |
| */ | |
| public void addColumn(Object columnName, Object[] columnData) { | |
| addColumn(columnName, convertToVector(columnData)); | |
| } | |
| // | |
| // Implementing the TableModel interface | |
| // | |
| /** | |
| * Returns the number of rows in this data table. | |
| * @return the number of rows in the model | |
| */ | |
| public int getRowCount() { | |
| return dataVector.size(); | |
| } | |
| /** | |
| * Returns the number of columns in this data table. | |
| * @return the number of columns in the model | |
| */ | |
| public int getColumnCount() { | |
| return columnIdentifiers.size(); | |
| } | |
| /** | |
| * Returns the column name. | |
| * | |
| * @return a name for this column using the string value of the | |
| * appropriate member in <code>columnIdentifiers</code>. | |
| * If <code>columnIdentifiers</code> does not have an entry | |
| * for this index, returns the default | |
| * name provided by the superclass. | |
| */ | |
| public String getColumnName(int column) { | |
| Object id = null; | |
| // This test is to cover the case when | |
| // getColumnCount has been subclassed by mistake ... | |
| if (column < columnIdentifiers.size() && (column >= 0)) { | |
| id = columnIdentifiers.elementAt(column); | |
| } | |
| return (id == null) ? super.getColumnName(column) | |
| : id.toString(); | |
| } | |
| /** | |
| * Returns true regardless of parameter values. | |
| * | |
| * @param row the row whose value is to be queried | |
| * @param column the column whose value is to be queried | |
| * @return true | |
| * @see #setValueAt | |
| */ | |
| public boolean isCellEditable(int row, int column) { | |
| return true; | |
| } | |
| /** | |
| * Returns an attribute value for the cell at <code>row</code> | |
| * and <code>column</code>. | |
| * | |
| * @param row the row whose value is to be queried | |
| * @param column the column whose value is to be queried | |
| * @return the value Object at the specified cell | |
| * @throws 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); | |
| } | |
| /** | |
| * Sets the object value for the cell at <code>column</code> and | |
| * <code>row</code>. <code>aValue</code> is the new value. This method | |
| * will generate a <code>tableChanged</code> notification. | |
| * | |
| * @param aValue the new value; this can be null | |
| * @param row the row whose value is to be changed | |
| * @param column the column whose value is to be changed | |
| * @throws 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); | |
| } | |
| // | |
| // Protected Methods | |
| // | |
| /** | |
| * Returns a vector that contains the same objects as the array. | |
| * @param anArray the array to be converted | |
| * @return the new vector; if <code>anArray</code> is <code>null</code>, | |
| * returns <code>null</code> | |
| */ | |
| protected static Vector<Object> convertToVector(Object[] anArray) { | |
| if (anArray == null) { | |
| return null; | |
| } | |
| Vector<Object> v = new Vector<>(anArray.length); | |
| for (Object o : anArray) { | |
| v.addElement(o); | |
| } | |
| return v; | |
| } | |
| /** | |
| * Returns a vector of vectors that contains the same objects as the array. | |
| * @param anArray the double array to be converted | |
| * @return the new vector of vectors; if <code>anArray</code> is | |
| * <code>null</code>, returns <code>null</code> | |
| */ | |
| protected static Vector<Vector<Object>> convertToVector(Object[][] anArray) { | |
| if (anArray == null) { | |
| return null; | |
| } | |
| Vector<Vector<Object>> v = new Vector<>(anArray.length); | |
| for (Object[] o : anArray) { | |
| v.addElement(convertToVector(o)); | |
| } | |
| return v; | |
| } | |
| } // End of class DefaultTableModel |