Table

From Minor Miracle Software
Jump to: navigation, search
/**   %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