/*

 * 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

     * @exception  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

     * @exception  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

     * @exception  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

     * @exception  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 #setColumnCount

     * @since 1.3

     */