Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
   * Firebird Open Source J2ee connector - jdbc driver
   *
   * Distributable under LGPL license.
   * You may obtain a copy of the License at http://www.gnu.org/copyleft/lgpl.html
   *
   * This program 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
  * LGPL License for more details.
  *
  * This file was created by members of the firebird development team.
  * All individual contributions remain the Copyright (C) of those
  * individuals.  Contributors to this file are either listed here or
  * can be obtained from a CVS history command.
  *
  * All rights reserved.
  */
 
 package org.firebirdsql.gds.impl.wire;
 
 
 import java.util.List;
Base class for BlobParameterBufferImp and DatabaseParameterBufferImp and perhaps eventualy TransactionParameterBuffer.
 
 public class ParameterBufferBase  implements java.io.SerializableXdrable
     {
 	// Parameter Buffer Implementation 
 	
     public void addArgument(int argumentTypeString value)
         {
         getArgumentsList().add(new StringArgument(argumentTypevalue ));
         }
 
     public void addArgument(int argumentTypeint value)
         {
         getArgumentsList().add(new NumericArgument(argumentTypevalue));
         }
 
     public void addArgument(int argumentType)
         {
         getArgumentsList().add(new SingleItem(argumentType));
         }
 
     public void addArgument(int typebyte[] content)
         {
         getArgumentsList().add(new ByteArrayArgument(typecontent));
         }
 
     public String getArgumentAsString(int type)
         {
         final List argumentsList = getArgumentsList();
         forint i = 0, n = argumentsList.size(); i<ni++ )
             {
             final Argument argument = (Argument)argumentsList.get(i);
             ifargument.getType() == type )
                 {
                 return argument.getValueAsString();
                 }
             }
         return null;
         }
 
     public int getArgumentAsInt(int type) {
         final List argumentsList = getArgumentsList();
         for (int i = 0, n = argumentsList.size(); i < ni++) {
             final Argument argument = (ArgumentargumentsList.get(i);
             if (argument.getType() == type) { 
                 return argument.getValueAsInt(); }
         }
         return 0;
     }
 
     public boolean hasArgument(int type) {
         final List argumentsList = getArgumentsList();
         
         forint i = 0, n = argumentsList.size(); i<ni++ ) {
             final Argument argument = (Argument)argumentsList.get(i);
             ifargument.getType() == type )
                 return true;
         }
         return false;
     }
 	
 	public void removeArgument(int type)
 		{
 		final List argumentsList = getArgumentsList();
         forint i = 0, n = argumentsList.size(); i<ni++ )
             {
             final Argument argument = (Argument)argumentsList.get(i);
             ifargument.getType() == type )
                 {
 				argumentsList.remove(i);
                return;
                }
            }
		}
	// Xdrable Implementation  
    public int getLength()
        {
        final List argumentsList = getArgumentsList();
        int length = 0;
        forint i = 0, n = argumentsList.size(); i<ni++)
            {
            final Argument currentArgument = ((Argument)argumentsList.get(i));
            length += currentArgument.getLength();
            }
        return length;
        }
    public void read(XdrInputStream inputStreamint lengththrows IOException
        {
        }
    public void write(XdrOutputStream outputStreamthrows IOException
        {
        final List argumentsList = getArgumentsList();
        forint i = 0, n = argumentsList.size(); i<ni++)
            {
            final Argument currentArgument = ((Argument)argumentsList.get(i));
            currentArgument.writeTo(outputStream);
            }
        }
	// Object Implementation  
	public boolean equals(Object other)
        {
        ifother == null || other instanceof ParameterBufferBase == false )
            return false;
        final ParameterBufferBase otherServiceBufferBase = (ParameterBufferBase)other;
        return otherServiceBufferBase.getArgumentsList().equals(this.getArgumentsList());
        }
    public int hashCode()
        {
        return getArgumentsList().hashCode();
        }
   // Internal methods
   protected List getArgumentsList()
        {
        return ;
        }
    // PRIVATE MEMBERS
    private final List arguments = new ArrayList();
	//---------------------------------------------------------------------------
	// Inner Classes
	//---------------------------------------------------------------------------
	//---------------------------------------------------------------------------
	// Argument - Abstract base 
	//---------------------------------------------------------------------------
	protected abstract static class Argument implements java.io.Serializable
		{
		abstract int  getType();
			{
			throw new RuntimeException("Cannot get the value for this argument type as a string");
			}
        
        int getValueAsInt()
        {
            throw new RuntimeException("Cannot get the value of this argument type as int");
        }
		abstract void writeTo(XdrOutputStream outputStreamthrows IOException;
		abstract int getLength();
		}
	//---------------------------------------------------------------------------
	// StringArgument
	//---------------------------------------------------------------------------
	protected static class StringArgument extends Argument
        {
        StringArgumentint typeString value )
            {
            this. = type;
            this. = value;
            }
        void writeTo(XdrOutputStream outputStreamthrows IOException
            {
            outputStream.write();
            final byte[] valueBytes = this..getBytes();
            final int valueLength = valueBytes.length;
            writeLength(valueLengthoutputStream);
            for(int i = 0; i<valueLengthi++)
                outputStream.write(valueBytes[i]);
            }
        int getLength()
            {
            return .getBytes().length + 2;
            }
       String getValueAsString()
            {
            return ;
            }
       
       int getValueAsInt() {
           return Integer.parseInt();
       }
        protected void writeLength(int lengthXdrOutputStream outputStreamthrows IOException
            {
            outputStream.write(length);
            }
        int  getType()
            {
            return ;
            }
        public int hashCode()
            {
            return .hashCode();
            }
        public boolean equals(Object other)
            {
            ifother == null || other instanceof StringArgument == false )
                return false;
            final StringArgument otherStringArgument = (StringArgument)other;
            return   == otherStringArgument.type &&
                   .equals(otherStringArgument.value);
            }
        private final int type;
        private final String value;
        }
    //---------------------------------------------------------------------------
	// NumericArgument 
	//---------------------------------------------------------------------------
	protected static class NumericArgument extends Argument
        {
        NumericArgumentint typeint value )
            {
            this. = type;
            this. = value;
            }
        void writeTo(XdrOutputStream outputStreamthrows IOException
            {
            outputStream.write();
            final int value = this.;
            writeValue(outputStreamvalue);
            }
        int getLength()
            {
            return 6;
            }
        int getValueAsInt() {
            return ;
        }
        protected void writeValue(XdrOutputStream outputStreamfinal int valuethrows IOException
            {
            outputStream.write(4);
            outputStream.write(value);
            outputStream.write(value>>8);
            outputStream.write(value>>16);
            outputStream.write(value>>24);
            }
        int  getType()
            {
            return ;
            }
        public int hashCode()
            {
            return ;
            }
        public boolean equals(Object other)
            {
            ifother == null || other instanceof NumericArgument == false )
                return false;
            final NumericArgument otherNumericArgument = (NumericArgument)other;
            return   == otherNumericArgument.type &&
                    == otherNumericArgument.value;
            }
        private final int type;
        private final int value;
        }
	//---------------------------------------------------------------------------
	// ByteArrayArgument
	//---------------------------------------------------------------------------
	private static final class ByteArrayArgument extends Argument
        {
        ByteArrayArgumentint typebyte[] value )
            {
            this. = type;
            this. = value;
            }
        void writeTo(XdrOutputStream outputStreamthrows IOException
            {
            outputStream.write();
            final int valueLength = .;
            writeLength(valueLengthoutputStream);
            for(int i = 0; i<valueLengthi++)
                outputStream.write([i]);
            }
        int getLength()
            {
            return . + 2;
            }
        int getValueAsInt() {
            if (. == 1)
                return [0];
            else
                throw new UnsupportedOperationException("This method is not " +
                    "supported for byte arrays with length > 1");
        }
        
        protected void writeLength(int lengthXdrOutputStream outputStreamthrows IOException
            {
            outputStream.write(length);
            }
        int  getType()
            {
            return ;
            }
        public int hashCode()
            {
            return ;
            }
        public boolean equals(Object other)
            {
            ifother == null || other instanceof ByteArrayArgument == false )
                return false;
            final ByteArrayArgument otherByteArrayArgument = (ByteArrayArgument)other;
            return   == otherByteArrayArgument.type &&
                   Arrays.equals( , otherByteArrayArgument.value);
            }
        private final int type;
        private final byte[] value;
        }
	//---------------------------------------------------------------------------
	// SingleItem
	//---------------------------------------------------------------------------
	private static final class SingleItem extends Argument
        {
        SingleItemint item )
            {
            this. = item;
            }
        void writeTo(XdrOutputStream outputStreamthrows IOException
            {
            outputStream.write();
            }
        int getLength()
            {
            return 1;
            }
        int  getType()
            {
            return ;
            }
        public int hashCode()
            {
            return ;
            }
        public boolean equals(Object other)
            {
            ifother == null || other instanceof SingleItem == false )
                return false;
            final SingleItem otherSingleItem = (SingleItem)other;
            return   == otherSingleItem.item;
            }
        private final int item;
        }
    }
New to GrepCode? Check out our FAQ X