Table
/** %W% %E% Jesse Dooley * Java(tm) Development Kit * Version JDK 1.1.5 * * This software and documentation is the confidential and proprietary * information of Sun Microsystems, Inc. ("Confidential Information"). * You shall not disclose such Confidential Information and shall use * it only in accordance with the terms of the license agreement you * entered into with Sun. * * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING * THIS SOFTWARE OR ITS DERIVATIVES. * * Developed by Sun Microsystems, Inc. * 901 San Antonio Rd., Palo Alto, CA 94303 USA * Copyright (c) 1994, 1995, 1996, 1999 Sun Microsystems, Inc. */ // Java 1.1.4 or greater import java.io.*; import java.util.*; /** * Table class * * ELF Project * University of Maryland at College Park * * * Date: March 23,1998 * * Purpose: * Holds java objects in table format. * * Dependencies: * Java 1.1.4 or greater * * Defaults:<BR> * The default size for each dimension is two. Therefore the smallest * Table is a 4x4 table. * * Notes: * One is added to each dimension to allow space for column and row names. * * Column names should be stored as Strings in the zero row starting at * column one. * * Table is Serialized with no special methods. * * @version 1.0 23 MAR 1998 * @author Jesse B. Dooley * */ /* * Programmer Notes * Table class is implemented as an uneven Vector array. Rows and Columns * can be cut, copied and inserted anywhere. Row and Column counts start * at zero, not one. */ public class Table implements Serializable { private int i_Rows = 1; // longest Column length private int i_Columns = 1; private Vector Vector_Table[]; public String String_ResultName; public Table( int Column ) { i_Columns = Column + 1; Vector_Table = new Vector[i_Columns + 1]; for(int i = 0; i < I_COLUMNS; I++) { VECTOR_TABLE[I] = NEW VECTOR( 2 ); } } // TABLE( INT COLUMN ) PUBLIC BOOLEAN SETCELL( OBJECT RESULT, INT ROW, INT COLUMN ) { IF( ROW < 0 || COLUMN < 0 || I_COLUMNS - 1 < COLUMN ) RETURN FALSE; INT I_SIZE = VECTOR_TABLE[COLUMN].SIZE(); // PAD THE COLUMN WITH NULLS IF( I_SIZE < ROW ) { FOR( INT I = ROW - I_SIZE; I < ROW; I++ ) { OBJECT OB = NEW OBJECT(); VECTOR_TABLE[COLUMN].ADDELEMENT( OB ); } } VECTOR_TABLE[COLUMN].INSERTELEMENTAT( RESULT, ROW ); I_SIZE = VECTOR_TABLE[COLUMN].SIZE(); IF( I_SIZE > i_Rows ) i_Rows = i_Size; return true; } // setCell( Object Result, int Row, int Column ) public boolean setCell( Object Result, int Row, String Column ) { return setCell( Result, Row, ColumnNumber( Column ) ); } // setCell( Object Result, int Row, int Column ) public Object getCell( int Row, int Column ) { if( Row < 0 || COLUMN < 0 || I_COLUMNS - 1 < COLUMN ) RETURN NULL; IF( ROW < VECTOR_TABLE[COLUMN].SIZE() ) { RETURN VECTOR_TABLE[COLUMN].ELEMENTAT( ROW ); } RETURN NULL; } // GETCELL( INT ROW, INT COLUMN ) PUBLIC OBJECT GETCELL( INT ROW, STRING COLUMN ) { RETURN GETCELL( ROW, COLUMNNUMBER( COLUMN ) ); } // GETCELL( INT ROW, STRING COLUMN ) PUBLIC VECTOR GETCOLUMN( INT COLUMN ) { IF( COLUMN < 0 || I_COLUMNS - 1 < COLUMN ) RETURN NULL; RETURN VECTOR_TABLE[COLUMN]; } // RETURNS A COLUMN AS A VECTOR PUBLIC VECTOR GETCOLUMN( STRING STRING_COLUMN ) { RETURN GETCOLUMN( COLUMNNUMBER( STRING_COLUMN ) ); } // RETURNS A COLUMN AS A VECTOR PUBLIC VECTOR GETROW( INT ROW ) { IF( ROW < 0 || ROW > i_Rows ) return null; Vector V = new Vector( i_Columns + 1 ); for( int i = 0; i < I_COLUMNS; I++ ) { IF( VECTOR_TABLE[I].SIZE() - 1 < ROW ) V.ADDELEMENT( NULL ); ELSE V.ADDELEMENT( VECTOR_TABLE[I].ELEMENTAT( ROW ) ); } RETURN V; } // RETURNS A ROW AS A VECTOR PUBLIC VECTOR GETROW( STRING STRING_ROW ) { RETURN GETROW( COLUMNNUMBER( STRING_ROW ) ); } // RETURNS A ROW AS A VECTOR PUBLIC INT GETROWCOUNT() // RETURNS HOW MANY ROWS { RETURN I_ROWS; } // GETROWS() PUBLIC INT GETCOLUMNCOUNT() // RETURNS HOW MANY COLUMNS { RETURN I_COLUMNS; } // GETCOLUMNS() PUBLIC VECTOR CUTCOLUMN( INT COLUMN ) { IF( COLUMN < 0 || I_COLUMNS - 1 < COLUMN ) RETURN NULL; VECTOR V = NEW VECTOR(); V = GETCOLUMN( COLUMN ); DELETECOLUMN( COLUMN ); RETURN V; } // CUTCOLUMN( INT COLUMN ) PUBLIC VECTOR CUTCOLUMN( STRING COLUMN ) { RETURN CUTCOLUMN( COLUMNNUMBER( COLUMN) ); } // CUTCOLUMN( STRING COLUMN ) PUBLIC VECTOR CUTROW( INT ROW ) { VECTOR V = NEW VECTOR(); V = GETROW( ROW ); DELETEROW( ROW ); RETURN V; } // CUTROW( INT ROW ) PUBLIC INT DELETEROW( INT ROW ) { IF( ROW < 0 || ROW > i_Rows ) return -1; for( int i = 0; i < I_COLUMNS; I++ ) { TRY { VECTOR_TABLE[I].REMOVEELEMENTAT( ROW ); } CATCH( ARRAYINDEXOUTOFBOUNDSEXCEPTION E ){} } RETURN --i_Rows; } // deleteRow( int Row ) public int deleteColumn( int Column ) { if( Column < 0 || I_COLUMNS - 1 < COLUMN ) RETURN -1; // COPY VECTORS BETWEEN COLUMN + 1 AND I_COLUMNS TRY { FOR(INT J = COLUMN;; J++) { VECTOR_TABLE[J] = VECTOR_TABLE[J + 1]; } } CATCH( ARRAYINDEXOUTOFBOUNDSEXCEPTION E ){} I_COLUMNS--; return i_Columns; } // deleteColumn( int Column ) public void deleteColumn( String String_Column ) { deleteColumn( ColumnNumber( String_Column ) ); } // deleteColumn( String String_Column ) /** * Inserts a Vector as a column, shifting other * columns over. The new column index must be * <= OLD COLUMN COUNT + 1. */ PUBLIC BOOLEAN INSERTCOLUMN( VECTOR V, INT COLUMN ) { IF( COLUMN > i_Columns + 1 || Column < 0 ) RETURN FALSE; INT INDEX = 0; VECTOR VT[]; VT = NEW VECTOR[I_COLUMNS + 2]; VT[ COLUMN ] = V; // ADD COLUMNS BELOW COLUMN WHILE( INDEX < COLUMN ) { VT[INDEX] = VECTOR_TABLE[INDEX]; } // SHIFT COLUMN AT COLUMN IF( !VECTOR_TABLE[COLUMN].ISEMPTY() ) // COLUMN INDEX IS OCCUPIED INDEX++; // ADD COLUMNS ABOVE COLUMN // COPY BACK VECTOR_TABLE = NEW VECTOR[I_COLUMNS + 2]; VECTOR_TABLE = VT; RETURN TRUE; } // INSERTCOLUMN( VECTOR V, INT COLUMN ) /** * INSERTS A VECTOR AS A ROW, SHIFTING OTHER * ROWS DOWN. THE VECTOR MUST HAVE AN ELEMENT * FOR EACH COLUMN. */ PUBLIC BOOLEAN INSERTROW( VECTOR V, INT ROW ) { IF( V.SIZE() == I_COLUMNS ) { FOR( INT I = 0; I < I_COLUMNS; I++) { IF( VECTOR_TABLE[I].SIZE() > Row ) Vector_Table[i].insertElementAt( V.elementAt(i), Row ); else setCell( V.elementAt(i), Row, i ); } return true; } return false; } // insertRow( Vector V, int Row ) /** * Squares' the table so all column are the * same length. */ public void SquareTable() { for( int i = 0; i < I_COLUMNS; I++) { WHILE( VECTOR_TABLE[I].SIZE() < I_ROWS ) { OBJECT OB = NEW OBJECT(); VECTOR_TABLE[I].ADDELEMENT( OB ); } } } // SQUARETABLE() // HASHTABLE CONTROLS - TO ADD A TABLE OBJECT TO A HASHTABLE PUBLIC STRING TOSTRING() { RETURN STRING_RESULTNAME; } // TOSTRING() PUBLIC INT HASHCODE() { RETURN STRING_RESULTNAME.HASHCODE(); } // HASHCODE() PUBLIC BOOLEAN EQUALS( OBJECT OBJECT ) { RETURN OBJECT INSTANCEOF TABLE && STRING_RESULTNAME.EQUALS( ( (TABLE)OBJECT ).STRING_RESULTNAME ); } // EQUALS( OBJECT ) // END HASHTABLE CONTROLS // CLASS UTILITIES /* * RETURNS COLUMN NUMBER BY COLUMN NAME. RETURNS -1 IF NOT FOUND. */ PRIVATE INT COLUMNNUMBER( STRING STRING_COLUMNNAME ) { INT COLUMN = 0; WHILE( COLUMN < I_COLUMNS ) { IF( STRING_COLUMNNAME.COMPARETO( (STRING) VECTOR_TABLE[COLUMN].ELEMENTAT(0) ) == 0 ) RETURN COLUMN; COLUMN++; } RETURN -1; } // COLUMNNUMBER( STRING STRING_COLUMNNAME ) } // TABLE
Internal Links
Parent Article: Programming Portfolio