Question : How to solve incompatible types error in TableSorter.java?

hi all,
i am trying to fix a bug in our existing j2ee application. it is a desktop GUI app. i opened it in Jdeveloper and try to complie it but i got the error like the following:
Error(148,74): incompatible types; found: class java.lang.Class<java.lang.Number>, required: class java.lang.Class<? super ? extends java.lang.Object>
Error(169,74): incompatible types; found: class java.lang.Class<java.lang.Number>, required: class java.lang.Class<? super ? extends java.lang.Object>

those errors occur in TableSorter.java, which is from Sun, the copyright is 2002.

how can i solve this issue? maybe i miss a library?

thanks a lot
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
/*
 * TableSorter.java
 *
 * Created on 29 February 2004, 10:01
 */

package au.com.ords.commission.client.util.table;

/*
 * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistribution in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
 * EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
 * OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
 * FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
 * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that Software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of
 * any nuclear facility.
 */

/**
 * A sorter for TableModels. The sorter has a model (conforming to TableModel)
 * and itself implements TableModel. TableSorter does not store or copy
 * the data in the TableModel, instead it maintains an array of
 * integers which it keeps the same size as the number of rows in its
 * model. When the model changes it notifies the sorter that something
 * has changed eg. "rowsAdded" so that its internal array of integers
 * can be reallocated. As requests are made of the sorter (like
 * getValueAt(row, col) it redirects them to its model via the mapping
 * array. That way the TableSorter appears to hold another copy of the table
 * with the rows in a different order. The sorting algorthm used is stable
 * which means that it does not move around rows when its comparison
 * function returns 0 to denote that they are equivalent.
 *
 * @version 1.8 04/23/99
 * @author Philip Milne
 */
import java.awt.Component;
import java.util.*;

import javax.swing.ImageIcon;
import javax.swing.SwingConstants;
import javax.swing.table.TableModel;
import javax.swing.event.TableModelEvent;

// Imports for picking up mouse events from the JTable.

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.InputEvent;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.UIManager;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.DefaultTableCellRenderer;

import au.com.ords.commission.client.util.table.TableMap;

public class TableSorter extends TableMap
{
    int             indexes[];
    Vector          sortingColumns = new Vector();
    boolean         ascending = true;
    int             sortingColumn = -1;
    int compares;
    boolean modifying = false;
    
    public TableSorter()
    {
        indexes = new int[0]; // For consistency.
    }
    
    public TableSorter(TableModel model)
    {
        setModel(model);
    }
    
    public void setModel(TableModel model)
    {
        sortingColumn = -1;
        super.setModel(model);
        reallocateIndexes();
    }
    
    public int compareRowsByColumn(int row1, int row2, int column)
    {
        Class type = model.getColumnClass(column);
        TableModel data = model;
        
        // Check for nulls
        
        Object o1 = data.getValueAt(row1, column);
        Object o2 = data.getValueAt(row2, column);
        
        // If both values are null return 0
        if (o1 == null && o2 == null)
        {
            return 0;
        }
        else if (o1 == null)
        { // Define null less than everything.
            return -1;
        }
        else if (o2 == null)
        {
            return 1;
        }
        
        /* We copy all returned values from the getValue call in case
        an optimised model is reusing one object to return many values.
        The Number subclasses in the JDK are immutable and so will not be used in
        this way but other subclasses of Number might want to do this to save
        space and avoid unnecessary heap allocation.
         */
        if (type.getSuperclass() == java.lang.Number.class)
        {
            Number n1;
            Number n2;
******error occurs below*********            
            if (data.getValueAt(row1, column).getClass().getSuperclass() == java.lang.Number.class)
**************************************************
            {
                n1 = (Number)data.getValueAt(row1, column);
            }
            else
            {
                try
                {
                    n1 = Double.valueOf(data.getValueAt(row1, column).toString());
                }
                catch (NumberFormatException nexc)
                {
                    //n1 = new Double(0);
                    throw new ClassCastException("Column " + model.getColumnName(column) + " cannot be sorted. +" +
                    "\nTrying to compare a Number when row " + row1 + " is a " + data.getValueAt(row1, column).getClass() +
                    "\nand row " + row2 + " is a " + data.getValueAt(row2, column).getClass() + ".");
                }
            }
            
            double d1 = n1.doubleValue();
************error occurs below***************            
            if (data.getValueAt(row2, column).getClass().getSuperclass() == java.lang.Number.class)
******************************************************
            {
                n2 = (Number)data.getValueAt(row2, column);
            }
            else
            {
                try
                {
                    n2 = Double.valueOf(data.getValueAt(row2, column).toString());
                }
                catch (NumberFormatException nexc)
                {
                    //n2 = new Double(0);
                    throw new ClassCastException("Column " + model.getColumnName(column) + " cannot be sorted. +" +
                    "\nTrying to compare a Number when row " + row1 + " is a " + data.getValueAt(row1, column).getClass() +
                    "\nand row " + row2 + " is a " + data.getValueAt(row2, column).getClass() + ".");
                }

            }
            
            double d2 = n2.doubleValue();
            
            if (d1 < d2)
                return -1;
            else if (d1 > d2)
                return 1;
            else
                return 0;
        }
        else if (type == java.util.Date.class)
        {
            Date d1 = (Date)data.getValueAt(row1, column);
            long n1 = d1.getTime();
            Date d2 = (Date)data.getValueAt(row2, column);
            long n2 = d2.getTime();
            
            if (n1 < n2)
                return -1;
            else if (n1 > n2)
                return 1;
            else return 0;
        }
        else if (type == String.class)
        {
            String s1 = ((String)data.getValueAt(row1, column)).toLowerCase();
            String s2    = ((String)data.getValueAt(row2, column)).toLowerCase();
            int result = s1.compareTo(s2);
            if (result < 0)
                return -1;
            else if (result > 0)
                return 1;
            else return 0;
        }
        else if (type == Boolean.class)
        {
            Boolean bool1 = (Boolean)data.getValueAt(row1, column);
            boolean b1 = bool1.booleanValue();
            Boolean bool2 = (Boolean)data.getValueAt(row2, column);
            boolean b2 = bool2.booleanValue();
            
            if (b1 == b2)
                return 0;
            else if (b1) // Define false < true
                return 1;
            else
                return -1;
        }
        else
        {
            Object v1 = data.getValueAt(row1, column);
            String s1 = v1.toString().toLowerCase();
            Object v2 = data.getValueAt(row2, column);
            String s2 = v2.toString().toLowerCase();
            int result = s1.compareTo(s2);
            
            if (result < 0)
                return -1;
            else if (result > 0)
                return 1;
            else return 0;
        }
    }
    
    public int compare(int row1, int row2)
    {
        compares++;
        for(int level = 0; level < sortingColumns.size(); level++)
        {
            Integer column = (Integer)sortingColumns.elementAt(level);
            int result = compareRowsByColumn(row1, row2, column.intValue());
            if (result != 0)
                return ascending ? result : -result;
        }
        return 0;
    }
    
    public void  reallocateIndexes()
    {
        int rowCount = model.getRowCount();
        
        // Set up a new array of indexes with the right number of elements
        // for the new data model.
        indexes = new int[rowCount];
        
        // Initialise with the identity mapping.
        for(int row = 0; row < rowCount; row++)
            indexes[row] = row;
    }
    
    public void tableChanged(TableModelEvent e)
    {
        if (!modifying)
        {
            reallocateIndexes();
            // Table data has changed.  Force a resort.
            sort(this);
            super.tableChanged(e);
        }
    }
    
    public void checkModel()
    {
        if (indexes.length != model.getRowCount())
        {
            System.err.println("Sorter not informed of a change in model.");
        }
    }
    
    public void  sort(Object sender)
    {
        checkModel();
        
        compares = 0;
        //n2sort();
        // qsort(0, indexes.length-1);
        shuttlesort((int[])indexes.clone(), indexes, 0, indexes.length);
        //mysort();
    }
    
    public void n2sort()
    {
        for(int i = 0; i < getRowCount(); i++)
        {
            for(int j = i+1; j < getRowCount(); j++)
            {
                if (compare(indexes[i], indexes[j]) == -1)
                {
                    swap(i, j);
                }
            }
        }
    }
    
    // This is a home-grown implementation which we have not had time
    // to research - it may perform poorly in some circumstances. It
    // requires twice the space of an in-place algorithm and makes
    // NlogN assigments shuttling the values between the two
    // arrays. The number of compares appears to vary between N-1 and
    // NlogN depending on the initial order but the main reason for
    // using it here is that, unlike qsort, it is stable.
    public void shuttlesort(int from[], int to[], int low, int high)
    {
        if (high - low < 2)
        {
            return;
        }
        int middle = (low + high)/2;
        shuttlesort(to, from, low, middle);
        shuttlesort(to, from, middle, high);
        
        int p = low;
        int q = middle;
        
        /* This is an optional short-cut; at each recursive call,
        check to see if the elements in this subset are already
        ordered.  If so, no further comparisons are needed; the
        sub-array can just be copied.  The array must be copied rather
        than assigned otherwise sister calls in the recursion might
        get out of sinc.  When the number of elements is three they
        are partitioned so that the first set, [low, mid), has one
        element and and the second, [mid, high), has two. We skip the
        optimisation when the number of elements is three or less as
        the first compare in the normal merge will produce the same
        sequence of steps. This optimisation seems to be worthwhile
        for partially ordered lists but some analysis is needed to
        find out how the performance drops to Nlog(N) as the initial
        order diminishes - it may drop very quickly.  */
        /*
        if (high - low >= 4 && compare(from[middle-1], from[middle]) <= 0)
        {
            for (int i = low; i < high; i++)
            {
                to[i] = from[i];
            }
            return;
        }
         **/
        
        // A normal merge.
        
        for(int i = low; i < high; i++)
        {
            if (q >= high || (p < middle && compare(from[p], from[q]) <= 0))
            {
                to[i] = from[p++];
            }
            else
            {
                to[i] = from[q++];
            }
        }
    }
    
    public void mysort()
    {
        for (int i = 0; i < indexes.length - 1; i++)
        {
            for (int j = i + 1; j < indexes.length; j++)
            {
                if (ascending)
                {
                    if (compare(indexes[i], indexes[j]) < 0)
                    {
                        swap(i, j);
                    }
                }
                else
                {
                    if (compare(indexes[i], indexes[j]) > 0)
                    {
                         swap(i, j);
                    }
                }
            }
        }
    }
    
    public void swap(int i, int j)
    {
        int tmp = indexes[i];
        indexes[i] = indexes[j];
        indexes[j] = tmp;
    }
    
    public int[] getIndex()
    {
        return indexes;
    }
    
    // The mapping only affects the contents of the data rows.
    // Pass all requests to these rows through the mapping array: "indexes".
    
    public Object getValueAt(int aRow, int aColumn)
    {
        checkModel();
        return model.getValueAt(indexes[aRow], aColumn);
    }
    
    public void setValueAt(Object aValue, int aRow, int aColumn)
    {
        checkModel();
        model.setValueAt(aValue, indexes[aRow], aColumn);
    }
    
    public void sortByColumn(int column)
    {
        sortByColumn(column, true);
    }
    
    public void sortByColumn(int column, boolean ascending)
    {
        sortingColumn = column;
        this.ascending = ascending;
        sortingColumns.removeAllElements();
        sortingColumns.addElement(new Integer(column));
        sort(this);
        super.tableChanged(new TableModelEvent(this));
    }
    
    // There is no-where else to put this.
    // Add a mouse listener to the Table to trigger a table sort
    // when a column heading is clicked in the JTable.
    public void addMouseListenerToHeaderInTable(JTable table)
    {
        final TableSorter sorter = this;
        final JTable tableView = table;
        tableView.setColumnSelectionAllowed(false);
        MouseAdapter listMouseListener = new MouseAdapter()
        {
            public void mouseClicked(MouseEvent e)
            {
                tableView.setCursor(new java.awt.Cursor(java.awt.Cursor.WAIT_CURSOR));
                tableView.getTableHeader().setCursor(new java.awt.Cursor(java.awt.Cursor.WAIT_CURSOR));
                TableColumnModel columnModel = tableView.getColumnModel();
                int viewColumn = columnModel.getColumnIndexAtX(e.getX());
                int column = tableView.convertColumnIndexToModel(viewColumn);
                //if(e.getClickCount() == 1 && column != -1)
                if(e.getClickCount() >= 1 && column != -1)
                {
                    int shiftPressed = e.getModifiers()&InputEvent.SHIFT_MASK;
                    //boolean ascending = (shiftPressed == 0);
                    boolean ascending = (e.getClickCount() == 1);
                    boolean editable = true;
                    modifying = true;
                    if (tableView.getModel() instanceof DataTableModel)
                    {
                        editable = ((DataTableModel)tableView.getModel()).getCellEditable();
                        ((DataTableModel)tableView.getModel()).setCellEditable(true);
                    }
                    
                    // retrieve data from model
                    Object[][] rowData = new Object[tableView.getModel().getRowCount()][tableView.getModel().getColumnCount()];
                    for (int i = 0; i < tableView.getModel().getRowCount(); i++)
                    {
                        for (int j = 0; j < tableView.getModel().getColumnCount(); j++)
                        {
                            rowData[i][j] = tableView.getModel().getValueAt(i, j);
                            //System.out.print(rowData[i][j] + " ");
                        }
                        System.out.println();
                    }
                    reallocateIndexes();
                    int selectedRow = tableView.getSelectedRow();
                    sorter.sortByColumn(column, ascending);
                    
                    // now set data in model by index
                    for (int i = 0; i < tableView.getModel().getRowCount(); i++)
                    {
                        for (int j = 0; j < tableView.getModel().getColumnCount(); j++)
                        {
                            tableView.getModel().setValueAt(rowData[indexes[i]][j], i, j);
                        }
                        if (indexes[i] == selectedRow)
                        {
                            try
                            {
                                tableView.setRowSelectionInterval(i , i);
                                
                                
                            }
                            catch (IllegalArgumentException exc)
                            {
                                // do nothing
                            }
                        }
                    }
                    
                    if (tableView.getModel() instanceof DataTableModel)
                    {
                        ((DataTableModel)tableView.getModel()).setCellEditable(editable);
                    }
                    modifying = false;
                    tableView.validate();
                    
                }
                tableView.getTableHeader().repaint();
                tableView.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.DEFAULT_CURSOR));
                tableView.getTableHeader().setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.DEFAULT_CURSOR));
            }
        };
        JTableHeader th = tableView.getTableHeader();
        th.addMouseListener(listMouseListener);
        th.setDefaultRenderer(createDefaultRenderer());
    }
    
    protected TableCellRenderer createDefaultRenderer()
    {
        DefaultTableCellRenderer label =
        new DefaultTableCellRenderer()
        {
            public Component getTableCellRendererComponent(JTable table,
            Object value, boolean isSelected, boolean hasFocus,
            int row, int column)
            {
                if (table != null)
                {
                    JTableHeader header = table.getTableHeader();
                    if (header != null)
                    {
                        setForeground(header.getForeground());
                        setBackground(header.getBackground());
                        setFont(header.getFont());
                        if (column == sortingColumn)
                        {
                            if (ascending)
                            {
                                try
                                {
                                    //setIcon(new ImageIcon(getClass().getResource(
                                    //"/resources/arrowDown.gif")));
                                    setIcon(TableHeaderIcon.getArrowDown());
                                }
                                catch (Exception exc)
                                {
                                }
                            } else
                            {
                                try
                                {
                                    //setIcon(new ImageIcon(getClass().getResource(
                                    //"/resources/arrowUp.gif")));
                                    setIcon(TableHeaderIcon.getArrowUp());
                                }
                                catch (Exception exc)
                                {
                                }
                            }
                        } else
                        {
                            setIcon(null);
                        }
                    }
                    
                }
                
                setText((value == null) ? "" : value.toString());
                setBorder(UIManager.getBorder("TableHeader.cellBorder"));
                return this;
            }
        };
        label.setHorizontalAlignment(JLabel.CENTER);
        label.setHorizontalTextPosition(SwingConstants.LEFT);
        return label;
    }
}

Answer : How to solve incompatible types error in TableSorter.java?

that can be accomplished as below,

if( data.getValueAt(row2, column) instanceof Number )
Random Solutions  
 
programming4us programming4us