package edu.vt.marian.uip;

import java.io.*;
import java.net.*;
import java.util.*;
import edu.vt.marian.common.*;



/**	
    class name: parameter
    class description: this class implement parameter related operations
    uses the services of class(es): xdr
    designer: Junni Fan (jfan@vt.edu)
    implementators: Junni Fan(jfan@vt.edu)
    finished time: 11/29/98
    known bugs:
    JDK version: 1.1.6
    side effects:
*/
public class parameter
{	
    // possible return values 
    public final static int OK = 0;
    public final static int ERROR = -4;
    public final static int INVALID_PARAMETER = -1;
    public final static int ERROR_IO = -2;
    public final static int CANNOT_HANDLE = -3;
    public final static int PROCESS_ERROR = -5;

	// this is the max possible number of elements in a vector
	private final static int MAX_NUMBER_ELEMENTS = 10000;

    // for the purpose of xdr related operation
    private xdr x;

    // only for debugging
    Debug debug;

    private String name;
    private String type;
    private Object value;

    private boolean valid;

    /**	 
        method description: parameter constructor
        uses the services of class(es): none
        input parameter(s): 
			debug -- only for debugging
            name -- parameter name
            type -- parameter type
            value -- parameter value
        output parameter(s): none
        return value: none
        synchronization consideration: none
    */    
    public parameter(String name, String type, Object value, Debug debug)
    {
        this.debug = debug;
        x = new xdr( debug );
        this.name = name;
		this.type = type;
        valid = true;

        if ( type == null )
        {
            this.type = "NULL";
            
            if ( value == null )
            {
                this.value = null;
                return;
            }
            else
            {
                valid = false;
                debug.dumpTrace( "parameter(constructor from name,type,value): null type but not null value" );
                return;
            }
        }

        if ( value == null )
        {
            valid = false;
            debug.dumpTrace( "parameter(constructor from name,type,value): null value but not null type" );
            return;
        }

        if ( type.equals( "OBJ_VECT" ) )
        {
            Vector v;
            try
            {
                v = (Vector) value;
            }
            catch (Exception e)
            {
                valid = false;
                debug.dumpTrace
                    ( "parameter(constructor from name,type,value): value is inconsistent with type" );
                return;
            }

            int num_items = v.size();
            Vector nv = new Vector(), v1 = null, nv1 = null;

            // check through the vector elements
            for ( int i=0; i<num_items; i++ )
            {
                try 
                {
                    v1 = (Vector) v.elementAt(i);
                }
                catch (Exception e)
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): obj_vect, element is not vector" );
                    return;
                }

                if ( v1 == null )
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): obj_vect, element is a null vector" );
                    return;
                }

                if ( v1.size() != 3 )
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): obj_vect, element does not have 3 integers" );
                    return;
                }		

                nv1 = new Vector();

                // check through the three integers
                for ( int j=0; j<3; j++)
                {
                    Integer I;

                    try
                    {
                        I = (Integer) v1.elementAt(j);
                    }
                    catch (Exception e)
                    {
                        valid = false;
                        debug.dumpTrace
							( "parameter(constructor from name,type,value): obj_vect, The subelement is not an Integer" );
                        return;
                    }

                    if (  I== null )
                    {
                        valid = false;
                        debug.dumpTrace
                            ( "parameter(constructor from name,type,value): obj_vect, The subelement is a null Integer" );
                        return;
                    }

                    nv1.addElement( new Integer( I.intValue() ) );
                }

                nv.addElement( nv1 );
            }

            this.value = nv;
            return;
        }

        if ( type.equals( "INTEGER" ) )
        {
            Integer I;

            try
            {
                I = (Integer) value;
            }
            catch (Exception e)
            {
                valid = false;
                debug.dumpTrace
                    ( "parameter(constructor from name,type,value): value is inconsistent with type" );
                return;
            }

            this.value = new Integer( I.intValue() );
            return;
        }

        if ( type.equals( "STRING" ) )
        {
            String S;

            try
            {
                S = (String) value;
            }
            catch (Exception e)
            {
                valid = false;
                debug.dumpTrace
                    ( "parameter(constructor from name,type,value): value is inconsistent with type" );
                return;
            }

            this.value = S;
            return;
        }

        if ( type.equals( "BOOL" ) )
        {
            Boolean B;

            try
            {
                B = (Boolean) value;
            }
            catch (Exception e)
            {
                valid = false;
                debug.dumpTrace
                    ( "parameter(constructor from name,type,value): value is inconsistent with type" );
                return;
            }

            this.value = new Boolean( B.booleanValue() );
            return;
        }

        if ( type.equals( "DOC_VECT" ) )
        {
            Vector v;
            
            try
            {
                v = (Vector) value;
            }
            catch (Exception e)
            {
                valid = false;
                debug.dumpTrace
                    ( "parameter(constructor from name,type,value): value is inconsistent with type" );
                return;
            }

            int num_items = v.size();
            Vector nv = new Vector(), v1 = null, nv1 = null;

            // check through all the vector elements
            for ( int i=0; i<num_items; i++ )
            {
                try
                {
                    v1 = (Vector) v.elementAt(i);
                }
                catch (Exception e)
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): doc_vect, element is not vector" );
                    return;
                }

                if ( v1 == null )
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): doc_vect, element is a null vector" );
                    return;
                }

                if ( v1.size() != 4 )
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): doc_vect, element is not a vector with 4 elements" );
                    return;
                }

                nv1 = new Vector();

                // check through three integers for each vector element
                for ( int j=0; j<3; j++)
                {
                    Integer I;

                    try
                    {
                        I = (Integer) v1.elementAt(j);
                    }
                    catch (Exception e)
                    {
                        valid = false;
                        debug.dumpTrace
                            ( "parameter(constructor from name,type,value): doc_vect, The subelement is not an Integer" );
                        return;
                    }

                    if ( I == null )
                    {
                        valid = false;
                        debug.dumpTrace
                            ( "parameter(constructor from name,type,value): doc_vect, The subelement is a null Integer" );
                        return;
                    }

                    nv1.addElement( new Integer(I.intValue()) );
                } // end -- for j

                String S;

                try
                {
                    S = (String) v1.elementAt(3);
                }
                catch (Exception e)
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): doc_vect, The last subelement is not a String" );
                    return;
                }

                // check the string for each vector element
                if ( S == null )
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): doc_vect, The last subelement is a null String" );
                    return;
                }

                nv1.addElement( S );

                nv.addElement( nv1 );
            } // end -- for i

            this.value = nv;

            return;
        }
            
        if ( type.equals( "RAW_DOC_VECT" ) )
        {
            Vector v;

            try
            {
                v = (Vector) value;
            }
            catch (Exception e)
            {
                valid = false;
                debug.dumpTrace
                    ( "parameter(constructor from name,type,value): value is inconsistent with type" );
                return;
            }

            int num_items = v.size();
            Vector nv = new Vector();
            String s = null;

            // check through the vector elements
            for ( int i=0; i<num_items; i++ )
            {
                try
                {
                    s = (String) v.elementAt(i);
                }
                catch (Exception e)
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): raw_doc_vect, element is not vector" );
                    return;
                }

                if ( s == null )
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): raw_doc_vect, element is a null vector" );
                    return;
                }

                nv.addElement( s );
            }

            this.value = nv;
            return;
        }

        if ( type.equals( "DOC_ID_VECT" ) )
        {
            Vector v;
            try
            {
                v = (Vector) value;
            }
            catch (Exception e)
            {
                valid = false;
                debug.dumpTrace
                    ( "parameter(constructor from name,type,value): value is inconsistent with type" );
                return;
            }

            int num_items = v.size();
            Vector nv = new Vector(), v1 = null, nv1 = null;

            // check through the vector elements
            for ( int i=0; i<num_items; i++ )
            {
                try
                {
                    v1 = (Vector) v.elementAt(i);
                }
                catch (Exception e)
                {
                    valid = false;
                    debug.dumpTrace
                            ( "parameter(constructor from name,type,value): doc_id_vect, element is not vector" );
                    return;
                }

                if ( v1 == null )
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): doc_id_vect, element is a null vector" );
                    return;
                }

                if ( v1.size() != 2 )
                {
                    valid = false;
                    debug.dumpTrace
                        ( "parameter(constructor from name,type,value): doc_id_vect, element is not a 2 element vector" );
                    return;
                }

                nv1 = new Vector();

                // check through the two integers
                for ( int j=0; j<2; j++)
                {
                    Integer I;

                    try
                    {
                        I = (Integer) v1.elementAt(j);
                    }
                    catch (Exception e)
                    {
                        valid = false;
                        debug.dumpTrace
                            ( "parameter(constructor from name,type,value): doc_id_vect, The subelement is not an Integer" );
                        return;
                    }

                    if ( I == null )
                    {
                        valid = false;
                        debug.dumpTrace
                            ( "parameter(constructor from name,type,value): doc_id_vect, The subelement is a null Integer" );
                        return;
                    }

                    nv1.addElement( new Integer(I.intValue()) );
                }

                nv.addElement( nv1 );
            }

            this.value = nv;
            return;
        }

        valid = false;
        debug.dumpTrace( "parameter(constructor from name,type,value): invalud type" );
        return;
    }


    /** 
        method description: parameter constructor, create a parameter object from a stream
        uses the services of class(es): none
        input parameter(s): 
			debug -- only for debugging
            bis -- input stream
            version -- now can only handle version 2
        output parameter(s): none
        return value: none
        synchronization consideration: none
    */    
    public parameter( BufferedInputStream bis, int version, Debug debug )
    {
        this.debug = debug;
        x = new xdr( debug );
        valid = true;
    
        // error checking
        if ( version != 2 )
        {
            valid = false;
            debug.dumpTrace( "parameter(constructor from bis): wrong version" );
            return;
        }

        if ( bis == null )
        {
            valid = false;
            debug.dumpTrace( "parameter(constructor from bis): null BufferedInputStream" );
            return;
        }
    
        name = x.read_string_from_stream( bis );
        if ( name == null )
        {
            valid = false;
            debug.dumpTrace( "parameter(constructor from bis): error when read name" );
            return;
        }
    
        if ( name.equals( "NULL" ) )
        {
                name = null;
        }
    
        type = x.read_string_from_stream( bis );
        if ( type == null )
        {
            valid = false;
            debug.dumpTrace( "parameter(constructor from bis): error when read type" );
            return;
        }
    
        if ( type.equals( "NULL" ) )
        {
            value = null;
            return;
        }
    
        if ( type.equals( "OBJ_VECT" ) )
        {
            Vector v = read_obj_vect_from_stream_in_xdr( bis );

            if ( v == null )
            {
                valid = false;
                debug.dumpTrace( "parameter(constructor from bis): error when read value, obj_vect" );
                return;
            }

            this.value = v;
            return;
        }
    
        if ( type.equals( "INTEGER" ) )
        {
			int i;
			try
			{
				i = x.read_integer_from_stream( bis );
			}
			catch (Exception e)
			{
				debug.dumpTrace("class parameter, second constructor, error reading integer from stream");
				valid = false;
				return;
			}

            this.value = new Integer(i);
            return;
        }
    
        if ( type.equals( "STRING" ) )
        {
            String s = x.read_string_from_stream( bis );

            if ( s == null )
            {
                valid = false;
                debug.dumpTrace( "parameter(constructor from bis): error when read value, string" );
                return;
            }
    
            this.value = s;
            return;
        }
    
        if ( type.equals( "DOC_VECT" ) )
        {
            Vector v = read_doc_vect_from_stream_in_xdr( bis );

            if ( v == null )
            {
                valid = false;
                debug.dumpTrace( "parameter(constructor from bis): error when read value, doc_vect" );
                return;
            }
    
            this.value = v;
            return;
        }
    
        if ( type.equals( "BOOL" ) )
        {
			boolean b;
			try
			{
                b = x.read_bool_from_stream( bis );
			}
			catch (Exception e)
			{
				valid = false;
				debug.dumpTrace("class parameter, second constructor, erro reading bool from stream");
				return;
			}

            this.value = new Boolean(b);
            return;
        }
    
        if ( type.equals( "RAW_DOC_VECT" ) )
        {
            Vector v = read_raw_doc_vect_from_stream_in_xdr( bis );

            if ( v == null )
            {
                valid = false;
                debug.dumpTrace( "parameter(constructor from bis): error when read value, raw_doc_vect" );
                return;
            }
    
            this.value = v;
            return;
        }

        if ( type.equals( "DOC_ID_VECT" ) )
        {
            Vector v = read_doc_id_vect_from_stream_in_xdr( bis );

            if ( v == null )
            {
                valid = false;
                debug.dumpTrace( "parameter(constructor from bis): error when read value, doc_id_vect" );
                return;
            }

            this.value = v;
            return;
        }

        valid = false;
        debug.dumpTrace( "parameter(constructor from stream): invalid type" + type );
        return;
    }


    /** 
        method description: return name of this parameter
        uses the services of class(es): none
        input parameter(s): none
        output parameter(s): none
        return value:
			this parameter's name
        synchronization consideration: none
    */
    public String get_name()
    {
        return name;
    }


    /** 
        method description: caculate size in xdr
        uses the services of class(es): xdr
        input parameter(s): none
        output parameter(s): none
        return value:
			this parameter's size in xdr
        synchronization consideration: none
    */
    public int get_size_in_xdr()
    {
		if (! valid)
		{
			// size doesn't make sense in this case
			debug.dumpTrace("class parameter, method get_size_in_xdr, parameter is not valid");
			return INVALID_PARAMETER;
		}

		// this is a valid parameter
        if ( type.equals("NULL") )
        {
            return 0;
        }

        if ( type.equals("INTEGER") )
        {
            return x.get_integer_size();
        }

        if ( type.equals("BOOL") )
        {
            return x.get_bool_size();
        }

        if ( type.equals("STRING") )
        {
            return x.get_string_size( (String) this.value );
        }

        // size of doc_vect equals integer_size+number_of_elements*(size_of_integer_in_xdr*3+string_size)
        // where integer_size is for number of elements.
        if ( type.equals("DOC_VECT") )
        {
            Vector v = (Vector) value;
            int size = x.get_integer_size(), num_elements = v.size();
            Vector v1 = null;
            String s = null;

            for ( int i=0; i < num_elements; i++ )
            {
                v1 = (Vector) v.elementAt(i);
                s = (String) v1.elementAt(3);
                size += 3 * x.get_integer_size() + x.get_string_size(s);
            }

            return size;
        }

        // size of raw_doc_vect equals integer_size+number_of_elements*(string_size)
        // where integer_size is for number of elements.
        if ( type.equals("RAW_DOC_VECT") )
        {
            Vector v = (Vector) value;
            int size = x.get_integer_size(), num_elements = v.size();
            Vector v1 = null;
            String s = null;

            for ( int i=0; i < num_elements; i++ )
            {
                s = (String) v.elementAt(i);
                size += x.get_string_size(s);
            }

            return size;
        }

        // size of doc_vect equals integer_size+number_of_elements*(size_of_integer_in_xdr*3+string_size)
        // where integer_size is for number of elements.
        if ( type.equals("OBJ_VECT" ) )
        {
            Vector v = (Vector) value;
            int size = x.get_integer_size() + x.get_integer_size() * 3 * v.size();
            return size;
        }

        // size of doc_vect equals integer_size+number_of_elements*(size_of_integer_in_xdr*2)
        // where integer_size is for number of elements.
        if ( type.equals("DOC_ID_VECT") )
        {
            Vector v = (Vector) value;
            int size = x.get_integer_size() + x.get_integer_size() * 2 * v.size();
            return size;
        }

		// should not reach here
		debug.dumpTrace("class parameter, method get_size_in_xdr, unknown type");
		return -1;
    }

    /** 
         method description: get type
         uses the services of class(es): none
         input parameter(s): none
         output parameter(s): none
         return value:
                        this parameter's type
         synchronization consideration: none
    */
        public String get_type()
        {
                return type;
        }

    /** 
        method description: get value
        uses the services of class(es): none
        input parameter(s): none
        output parameter(s): none
        return value:
			this parameter's value
        synchronization consideration: none
    */
    public Object get_value()
    {
		if (! valid)
		{
			// this is not a valid parameter, can't get it's value
			debug.dumpTrace("class parameter, method get_value, parameter is not valid");
			return null;
		}

		// this is a valid parameter
		if ( type.equals("NULL") )
        {
            return null;
        }

        if ( type.equals("INTEGER") )
        {
            return ( new Integer( ((Integer) value).intValue() ) );
        }

        if ( type.equals("STRING") )
        {
            return ( value );
        }

        if ( type.equals("BOOL") )
        {
            return ( new Boolean( ((Boolean) value).booleanValue() ) );
        }

        if ( type.equals("DOC_VECT") )
        {
            Vector v = (Vector) value, nv = new Vector(), v1 = null, nv1 = null;
            int num_elements = v.size();

            for ( int i = 0; i < num_elements; i++ )
            {
                v1 = (Vector) v.elementAt(i);
                nv1 = new Vector();

                for ( int j = 0; j < 3; j++ )
                {
                    nv1.addElement( new Integer( ((Integer) v1.elementAt(j)).intValue() ) );
                }

                nv1.addElement( (String) v1.elementAt(3) );

                nv.addElement( nv1 );
            }

            return nv;
        }

        if ( type.equals("RAW_DOC_VECT") )
        {
                Vector v = (Vector) value, nv = new Vector();
            int num_elements = v.size();

            for ( int i = 0; i < num_elements; i++ )
            {
                nv.addElement(v.elementAt(i) );
            }

            return nv;
        }

        if ( type.equals("OBJ_VECT") )
        {
            Vector v = (Vector) value, nv = new Vector(), v1 = null, nv1 = null;
            int num_elements = v.size();

            for ( int i = 0; i < num_elements; i++ )
            {
                v1 = (Vector) v.elementAt(i);
                nv1 = new Vector();

                for ( int j = 0; j < 3; j++ )
                {
                    nv1.addElement( new Integer( ((Integer) v1.elementAt(j)).intValue() ) );
                }

                nv.addElement( nv1 );
            }

            return nv;
        }

        if ( type.equals("DOC_ID_VECT") )
        {
            Vector v = (Vector) value, nv = new Vector(), v1 = null, nv1 = null;
            int num_elements = v.size();

            for ( int i = 0; i < num_elements; i++ )
            {
                v1 = (Vector) v.elementAt(i);
                nv1 = new Vector();

                for ( int j = 0; j < 2; j++ )
                {
                    nv1.addElement( new Integer( ((Integer) v1.elementAt(j)).intValue() ) );
                }

                nv.addElement( nv1 );
            }
            return nv;
        }

		// should not reach here
		debug.dumpTrace("class parameter, method get_value, unknown type");
		return null;
    }


    /** 
		method description: write this parameter to the output stream
		uses the services of class(es): xdr
		input parameter(s): 
			version -- different version has different format
				1 -- only write out value
				2 -- name, type and value
			bos -- output stream
		output parameter(s): none
		return value:
			OK -- success
			INVALID_PARAMETER -- parameter is wrong
			ERROR_IO -- wrong in IO operation
			PROCESS_ERROR -- wrong when call other classes' method
		synchronization consideration: none
             
			 **note: flush is not done here to save time, any class use this method
				 must take care of flush.
    */
    public int to_stream_in_xdr( int version, BufferedOutputStream bos )
    {
        // error checking
        if ( bos == null )
        {
            debug.dumpTrace( "parameter(to_stream_in_xdr): bos is null" );
            return INVALID_PARAMETER;
        }

		if (! valid)
		{
			// this is not a valid parameter, can't write it to stream
			debug.dumpTrace("class parameter, method to_stream_in_xdr, parameter is not valid");
			return PROCESS_ERROR;
		}

		// this is a valid parameter
        if ( version == 1 )
        {
            if ( type.equals("NULL") )
            {
                return OK;
            }

            if ( type.equals("INTEGER") )
            {
                int i = ( (Integer) value ).intValue();
                if ( x.integer_to_stream_in_xdr( i, bos ) == x.OK )
                {
                    return OK;
                }
                else
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write integer" );
                    return PROCESS_ERROR;
                }
            }

            if ( type.equals("BOOL") )
            {
                boolean b = ( (Boolean) value ).booleanValue();

                if ( x.bool_to_stream_in_xdr( b, bos ) == x.OK )
                {
                    return OK;
                }
                else
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write boolean" );
                    return PROCESS_ERROR;
                }
            }

            if ( type.equals("STRING") )
            {
                if ( x.string_to_stream_in_xdr( (String) value, bos ) == x.OK )
                {
                    return OK;
                }
                else
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write string" );
                    return PROCESS_ERROR;
                }
            }

            if ( type.equals("DOC_VECT") )
            {
                if ( doc_vect_to_stream_in_xdr( (Vector) value, bos ) == OK )
                {
                    return OK;
                }
                else
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write doc_vect" );
                    return PROCESS_ERROR;
                }
            }

            if ( type.equals("RAW_DOC_VECT") )
            {
                if ( raw_doc_vect_to_stream_in_xdr( (Vector) value, bos ) == OK )
                {
                    return OK;
                }
                else
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write raw_doc_vect" );
                    return PROCESS_ERROR;
                }
            }

            if ( type.equals("OBJ_VECT") )
            {
                if ( obj_vect_to_stream_in_xdr( (Vector) value, bos ) == OK )
                {
                    return OK;
                }
                else
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write obj_vect" );
                    return PROCESS_ERROR;
                }
            }

            if ( type.equals("DOC_ID_VECT") )
            {
                if ( doc_id_vect_to_stream_in_xdr( (Vector) value, bos ) == OK )
                {
					return OK;
                }
                else
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write doc_id_vect" );
                    return PROCESS_ERROR;
                }
            }

			// should not reach here
			debug.dumpTrace("class parameter, method to_stream_in_xdr, unknown type");
			return PROCESS_ERROR;
        } // end_if (version == 1)

        if ( version == 2 )
        {
            if ( name == null )
            {
                if ( x.string_to_stream_in_xdr( "NULL", bos ) != x.OK )
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write name(null)" );
                    return PROCESS_ERROR;
                }
            }
            else
            {
                if ( x.string_to_stream_in_xdr( name, bos ) != x.OK )
                {
                    debug.dumpTrace( "parameter(to_stream_in_xdr): error when write name" );
                    return PROCESS_ERROR;
                }
            }

            if ( x.string_to_stream_in_xdr( type, bos ) != x.OK )
            {
                debug.dumpTrace( "parameter(to_stream_in_xdr): error when write type" );
                return PROCESS_ERROR;
            }

            // use code in part version == 1 to write out value
            return to_stream_in_xdr(1,bos);
        }

        debug.dumpTrace( "parameter(to_stream_in_xdr): version is invalid: " + Integer.toString(version) );
        return CANNOT_HANDLE;
    }


    /** 
        method description: write this parameter to pw
        uses the services of class(es): xdr
        input parameter(s): 
			detail_level -- how much will be written out
			pw -- output writer
        output parameter(s): none
        return value:
			OK -- success
			INVALID_PARAMETER -- parameter is wrong
			ERROR_IO -- wrong in IO operation
        synchronization consideration: none

         **note: flush is not done here to save time, any class use this method
                 must take care of flush.
    */
    public int to_stream( int detail_level, PrintWriter pw )
    {
        // error checking
        if ( pw == null )
        {
            debug.dumpTrace( "parameter(to_stream): pw is null" );
            return INVALID_PARAMETER;
        }

		if (! valid)
		{
			// this is not a valid parameter, cann't print it to stream
			debug.dumpTrace("class parameter, method to_stream, parameter is not valid");
			return PROCESS_ERROR;
		}

        if ( detail_level < 3 )
        {
            return OK;
        }

        pw.println( "name = " + name );
        pw.println( "type = " + type );

		if ( detail_level < 4 )
		{
			return OK;
		}

        if ( type.equals("NULL") )
        {
            return OK;
        }

        if ( type.equals("INTEGER") )
        {
            pw.println( ((Integer) value).intValue() );
            return OK;
        }

        if ( type.equals("BOOL") )
        {
            pw.println( ((Boolean) value).booleanValue() );
            return OK;
        }

        if ( type.equals("STRING") )
        {
            pw.println( (String) value );
            return OK;
        }

        if ( type.equals("DOC_VECT") )
        {
            Vector v = (Vector) value, v1 = null;
            int num_elements = v.size();

            // write out number of elements of the vector
            pw.print( "number of elements = " );
            pw.println( num_elements );

            // write out value of doc_vect
            for ( int i = 0; i < num_elements; i++ )
            {
                v1 = (Vector) v.elementAt(i);

                for ( int j = 0; j < 3; j++ )
                {
                    pw.print( ((Integer) v1.elementAt(j)).intValue() + ", ");
                }
				pw.println();
                pw.println( (String) v1.elementAt(3) );
            }

            return OK;
        }

        if ( type.equals("RAW_DOC_VECT") )
        {
            Vector v = (Vector) value;
            int num_elements = v.size();

            pw.print( "number of elements = " );
            pw.println( num_elements );

            for ( int i = 0; i < num_elements; i++ )
            {
                pw.println( (String) v.elementAt(i) );
            }

            return OK;
        }

        if ( type.equals("OBJ_VECT") )
        {
            Vector v = (Vector) value, v1;
            int num_elements = v.size();

            pw.print( "number of elements = " );
            pw.println( num_elements );

            for ( int i = 0; i < num_elements; i++ )
            {
                v1 = (Vector) v.elementAt(i);

                for ( int j = 0; j < 3; j++ )
                {
                    pw.print( ((Integer) v1.elementAt(j)).intValue() );
                    pw.print( ", " );
                }

                pw.println();
            }

            return OK;
        }

        if ( type.equals("DOC_ID_VECT" ) )
        {
            Vector v = (Vector) value, v1 = null;
            int num_elements = v.size();

            pw.print( "number of elements = ");
            pw.println( num_elements );

            for ( int i = 0; i < num_elements; i++ )
            {
                v1 = (Vector) v.elementAt(i);

                pw.print( ((Integer) v1.elementAt(0)).intValue() );
                pw.print( ", " );
                pw.println( ((Integer) v1.elementAt(1)).intValue() );
            }

            return OK;
        }

		// should not reach here
		debug.dumpTrace("class parameter, method to_stream, unknown type");
		return PROCESS_ERROR;
    }

    
	/** 
        method description: read an object_vect from the input stream
        uses the services of class(es): xdr
        input parameter(s):
			bis -- input stream
        output parameter(s): none
        return value: the desired object_vect, null if error occurred
        synchronization consideration: none
    */    
    public Vector read_obj_vect_from_stream_in_xdr( BufferedInputStream bis )
    {
        // error checking
        if ( bis == null )
        {
                debug.dumpTrace( "parameter(read_obj_vect_from_stream_in_xdr): bis is null" );
                return null;
        }

        int num_elements;
		try
		{
			num_elements = x.read_integer_from_stream( bis );

			if ( num_elements < 0 )
			{
				debug.dumpTrace( "parameter(read_obj_vect_from_stream_in_xdr): error when read number of elements" );
				return null;
			}
			if (num_elements > MAX_NUMBER_ELEMENTS)
			{
				// vector has too many elements, probably sth goes wrong
				debug.dumpTrace("class parameter method read_obj_vect_from_stream_in_xdr, vector over sized");
				return null;
			}

			Vector v = new Vector(), v1 = null;

			for ( int i = 0; i < num_elements; i++ )
			{
				v1 = new Vector();

				for ( int j = 0; j < 3; j++ )
				{
					v1.addElement( new Integer(x.read_integer_from_stream( bis )) );
				}
				v.addElement( v1 );
			}

			return v;
		}
		catch (Exception e)
		{
			debug.dumpTrace("class parameter, method read_obj_vect_from_stream_in_xdr, error reading integer from stream");
			return null;
		}
    }


    /** 
        method description: read a doc_vect from the input stream
        uses the services of class(es): xdr
        input parameter(s):
            bis -- input stream
        output parameter(s): none
        return value: the desired doc_vect, null if error occurred
        synchronization consideration: none
    */    
    public Vector read_doc_vect_from_stream_in_xdr( BufferedInputStream bis )
    {
        // error checking
        if ( bis == null )
        {
            debug.dumpTrace( "parameter(read_doc_vect_from_stream_in_xdr): bis is null" );
            return null;
        }

        int num_elements;
		try
		{
			num_elements = x.read_integer_from_stream( bis );

			if ( num_elements < 0 )
			{
				debug.dumpTrace( "parameter(read_doc_vect_from_stream_in_xdr): error when read number of elements" );
				return null;
			}
			if (num_elements > MAX_NUMBER_ELEMENTS)
			{
				// vector has too many elements, probably sth goes wrong
				debug.dumpTrace("class parameter method read_doc_vect_from_stream_in_xdr, vector over sized");
				return null;
			}

			Vector v = new Vector(), v1 = null;
			String s = null;

			for ( int i = 0; i < num_elements; i++ )
			{
				v1 = new Vector();

				for ( int j = 0; j < 3; j++ )
				{
					v1.addElement( new Integer(x.read_integer_from_stream( bis )) );
				}

				s = x.read_string_from_stream( bis );
				if ( s == null )
				{
					debug.dumpTrace( "parameter(read_doc_vect_from_stream_in_xdr): error in reading string" );
					return null;
				}

				v1.addElement( s );

				v.addElement( v1 );
			}

			return v;
		}
		catch (Exception e)
		{
			debug.dumpTrace("class parameter, method read_doc_vect_from_stream_in_xdr, error reading integer from stream");
			return null;
		}
    }


    /** 
        method description: read a raw_doc_vect from the input stream
        uses the services of class(es): xdr
        input parameter(s):
            bis -- input stream
        output parameter(s): none
        return value: the desired raw_doc_vect, null if error occurred
        synchronization consideration: none
    */    
    public Vector read_raw_doc_vect_from_stream_in_xdr( BufferedInputStream bis )
    {
        // error checking
        if ( bis == null )
        {
            debug.dumpTrace( "parameter(read_raw_doc_vect_from_stream_in_xdr): bis is null" );
            return null;
        }

		int num_elements;
		try
		{
			num_elements = x.read_integer_from_stream( bis );
		}
		catch (Exception e)
		{
			debug.dumpTrace("class parameter, method read_raw_doc_vect_from_stream_in_xdr, error reading number elements from stream");
			return null;
		}

        if ( num_elements < 0 )
        {
            debug.dumpTrace( "parameter(read_raw_doc_vect_from_stream_in_xdr): error when read number of elements" );
            return null;
        }
		if (num_elements > MAX_NUMBER_ELEMENTS)
		{
			// vector has too many elements, probably sth goes wrong
			debug.dumpTrace("class parameter method read_raw_doc_vect_from_stream_in_xdr, vector over sized");
			return null;
		}

        Vector v = new Vector();
        String s = null;

        for ( int i = 0; i < num_elements; i++ )
        {
            s = x.read_string_from_stream( bis );
            if ( s == null )
            {
                debug.dumpTrace( "parameter(read_raw_doc_vect_from_stream_in_xdr): error in reading string" );
                return null;
            }

            v.addElement( s );
        }

        return v;
    }


    /** 
        method description: read a doc_id_vect from the input stream
        uses the services of class(es): xdr
        input parameter(s):
            bis -- input stream
        output parameter(s): none
        return value: the desired doc_id_vect, null if error occurred
        synchronization consideration: none
    */    
    public Vector read_doc_id_vect_from_stream_in_xdr( BufferedInputStream bis )
    {
        // error checking
        if ( bis == null )
        {
                debug.dumpTrace( "parameter(read_doc_id_vect_from_stream_in_xdr): bis is null" );
                return null;
        }

        int num_elements;
		try
		{
			num_elements = x.read_integer_from_stream( bis );
			if ( num_elements < 0 )
			{
				debug.dumpTrace( "parameter(read_doc_id_vect_from_stream_in_xdr): error when read number of elements" );
				return null;
			}
			if (num_elements > MAX_NUMBER_ELEMENTS)
			{
				// vector has too many elements, probably sth goes wrong
				debug.dumpTrace("class parameter method read_doc_id_vect_from_stream_in_xdr, vector over sized");
				return null;
			}

			Vector v = new Vector(), v1 = null;

			for ( int i = 0; i < num_elements; i++ )
			{
				v1 = new Vector();

				for ( int j = 0; j < 2; j++ )
				{
						v1.addElement( new Integer(x.read_integer_from_stream( bis )) );
				}
				v.addElement( v1 );
			}

			return v;
		}
		catch (Exception e)
		{
			debug.dumpTrace("class parameter, method read_doc_id_vector_from_stream_in_xdr, error reading integer from stream");
			return null;
		}
    }


    /** 
        method description: write an object_vect to the output stream
        uses the services of class(es): xdr
        input parameter(s):
            bos -- output stream
        output parameter(s): none
        return value: 
            OK -- if success
            ERROR_IO -- wrong in io operations
            INVALID_PARAMETER -- wrong parameter
        synchronization consideration: none
    */    
    private int obj_vect_to_stream_in_xdr( Vector v, BufferedOutputStream bos )
    {
        // error checking
        if ( bos == null )
        {
            debug.dumpTrace( "parameter(obj_vect_to_stream_in_xdr): bos is null" );
            return INVALID_PARAMETER;
        }

        if ( v == null )
        {
            debug.dumpTrace( "parameter(obj_vect_to_stream_in_xdr): vector is null" );
            return INVALID_PARAMETER;
        }

        int num_elements = v.size();

        if ( x.integer_to_stream_in_xdr( num_elements, bos ) != x.OK )
        {
            debug.dumpTrace( "parameter(obj_vect_to_stream_in_xdr): error in writing number of elements" );
            return PROCESS_ERROR;
        }

        Vector v1 = null;
        for ( int i = 0; i < num_elements; i++ )
        {
            v1 = (Vector) v.elementAt(i);

            for ( int j = 0; j < 3; j++ )
            {
                int elem;
                elem = ((Integer) v1.elementAt(j)).intValue();

                if ( x.integer_to_stream_in_xdr( elem, bos ) != x.OK )
                {
                    debug.dumpTrace( "parameter(obj_vect_to_stream_in_xdr): error in writing parameter value" );
                    return PROCESS_ERROR;
                }
            }
        }

        return OK;
    }


    /** 
        method description: write an doc_vect to the output stream
        uses the services of class(es): xdr
        input parameter(s):
            bos -- output stream
        output parameter(s): none
        return value: 
            OK -- if success
            ERROR_IO -- wrong in io operations
            INVALID_PARAMETER -- wrong parameter
        synchronization consideration: none
    */    
    private int doc_vect_to_stream_in_xdr( Vector v, BufferedOutputStream bos )
    {
        // error checking
        if ( bos == null )
        {
            debug.dumpTrace( "parameter(doc_vect_to_stream_in_xdr): bos is null" );
            return INVALID_PARAMETER;
        }

        if ( v == null )
        {
            debug.dumpTrace( "parameter(doc_vect_to_stream_in_xdr): vector is null" );
            return INVALID_PARAMETER;
        }

        int num_elements = v.size();

        if ( x.integer_to_stream_in_xdr( num_elements, bos ) != x.OK )
        {
            debug.dumpTrace( "parameter(doc_vect_to_stream_in_xdr): error in writing number of elements" );
            return PROCESS_ERROR;
        }

        Vector v1 = null;
        for ( int i = 0; i < num_elements; i++ )
        {
            v1 = (Vector) v.elementAt(i);

            for ( int j = 0; j < 3; j++ )
            {
                int elem;
                elem = ((Integer) v1.elementAt(j)).intValue();

                if ( x.integer_to_stream_in_xdr( elem, bos ) != x.OK )
                {
                    debug.dumpTrace( "parameter(doc_vect_to_stream_in_xdr): error in writing integers" );
                    return PROCESS_ERROR;
                }
            }

            if ( x.string_to_stream_in_xdr( (String) v1.elementAt(3), bos ) != x.OK )
            {
                debug.dumpTrace( "parameter(doc_vect_to_stream_in_xdr): error in writing string" );
                return PROCESS_ERROR;
            }
        }

        return OK;
    }


    /** 
        method description: write a raw_doc_vect to the output stream
        uses the services of class(es): xdr
        input parameter(s):
            bos -- output stream
        output parameter(s): none
        return value: 
            OK -- if success
            ERROR_IO -- wrong in io operations
            INVALID_PARAMETER -- wrong parameter
        synchronization consideration: none
    */    
    private int raw_doc_vect_to_stream_in_xdr( Vector v, BufferedOutputStream bos )
    {
        // error checking
        if ( bos == null )
        {
            debug.dumpTrace( "parameter(raw_doc_vect_to_stream_in_xdr): bos is null" );
            return INVALID_PARAMETER;
        }

        if ( v == null )
        {
            debug.dumpTrace( "parameter(doc_vect_to_stream_in_xdr): vector is null" );
            return INVALID_PARAMETER;
        }

        int num_elements = v.size();

        if ( x.integer_to_stream_in_xdr( num_elements, bos ) != x.OK )
        {
            debug.dumpTrace( "parameter(raw_doc_vect_to_stream_in_xdr): error in writing number of elements" );
            return PROCESS_ERROR;
        }

        for ( int i = 0; i < num_elements; i++ )
        {
            if ( x.string_to_stream_in_xdr( (String) v.elementAt(i), bos ) != x.OK )
            {
                debug.dumpTrace( "parameter(raw_doc_vect_to_stream_in_xdr): error in writing string" );
                return PROCESS_ERROR;
            }
        }

        return OK;
    }


    /** 
        method description: write an doc_id_vect to the output stream
        uses the services of class(es): xdr
        input parameter(s):
            bos -- output stream
        output parameter(s): none
        return value: 
            OK -- if success
            ERROR_IO -- wrong in io operations
            INVALID_PARAMETER -- wrong parameter
        synchronization consideration: none
    */    
    private int doc_id_vect_to_stream_in_xdr( Vector v, BufferedOutputStream bos )
    {
        // error checking
        if ( bos == null )
        {
            debug.dumpTrace( "parameter(doc_id_vect_to_stream_in_xdr): bos is null" );
            return INVALID_PARAMETER;
        }

        if ( v == null )
        {
            debug.dumpTrace( "parameter(doc_id_vect_to_stream_in_xdr): vector is null" );
            return INVALID_PARAMETER;
        }

        int num_elements = v.size();

        if ( x.integer_to_stream_in_xdr( num_elements, bos ) != x.OK )
        {
            debug.dumpTrace( "parameter(doc_id_vect_to_stream_in_xdr): error in writing number of elements" );
            return PROCESS_ERROR;
        }

        Vector v1 = null;
        for ( int i = 0; i < num_elements; i++ )
        {
            v1 = (Vector) v.elementAt(i);

            for ( int j = 0; j < 2; j++ )
            {
                int elem;
                elem = ((Integer) v1.elementAt(j)).intValue();

                if ( x.integer_to_stream_in_xdr( elem, bos ) != x.OK )
                {
                    debug.dumpTrace( "parameter(doc_id_vect_to_stream_in_xdr): error in writing parameter value" );
                    return PROCESS_ERROR;
                }
            }
        }

        return OK;
    }


    /** 
        method description: tell whether or not this object is a valid
			parameter
        uses the services of class(es): none
        input parameter(s): none
        output parameter(s): none
        return value: 
			true -- this is a valid parameter
			false -- this is not a valid parameter
        synchronization consideration: none
    */    
    public boolean is_valid()
    {
            return valid;
    }
}