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.jni;
 
 import java.util.List;
 
Provides implementation common to both ServiceParameterBufferImp and ServiceRequestBufferImp
 
 abstract class ParameterBufferBase implements java.io.Serializable {
 
     // 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();
         for (int i = 0, n = argumentsList.size(); i < ni++) {
             final Argument argument = (ArgumentargumentsList.get(i);
             if (argument.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();
 
         for (int i = 0, n = argumentsList.size(); i < ni++) {
             final Argument argument = (ArgumentargumentsList.get(i);
             if (argument.getType() == typereturn true;
         }
         return false;
     }
 
     public void removeArgument(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) {
                 argumentsList.remove(i);
                 return;
             }
         }
     }
 
     // Object Implementation
 
     public boolean equals(Object other) {
         if (other == null || other instanceof ParameterBufferBase == false)
             return false;
 
         final ParameterBufferBase otherServiceBufferBase = (ParameterBufferBaseother;
 
        return otherServiceBufferBase.getArgumentsList().equals(
                this.getArgumentsList());
    }
    public int hashCode() {
        return getArgumentsList().hashCode();
    }
    // Internal methods
    protected void writeArgumentsTo(ByteArrayOutputStream outputStream) {
        for (int i = 0, n = .size(); i < ni++) {
            final Argument currentArgument = ((Argument.get(i));
            currentArgument.writeTo(outputStream);
        }
    }
    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();
        String getValueAsString() {
            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(ByteArrayOutputStream outputStream);
    }
    // ---------------------------------------------------------------------------
    // StringArgument
    // ---------------------------------------------------------------------------
    protected static class StringArgument extends Argument {
        StringArgument(int typeString value) {
            this. = type;
            this. = value;
        }
        void writeTo(ByteArrayOutputStream outputStream) {
            outputStream.write();
            final byte[] valueBytes = this..getBytes();
            final int valueLength = valueBytes.length;
            writeLength(valueLengthoutputStream);
            for (int i = 0; i < valueLengthi++)
                outputStream.write(valueBytes[i]);
        }
        String getValueAsString() {
            return ;
        }
        int getValueAsInt() {
            return Integer.parseInt();
        }
        protected void writeLength(int length,
                ByteArrayOutputStream outputStream) {
            outputStream.write(length);
        }
        int getType() {
            return ;
        }
        public int hashCode() {
            return .hashCode();
        }
        public boolean equals(Object other) {
            if (other == null || other instanceof StringArgument == false)
                return false;
            final StringArgument otherStringArgument = (StringArgumentother;
            return  == otherStringArgument.type
                    && .equals(otherStringArgument.value);
        }
        private final int type;
        private final String value;
    }
    // ---------------------------------------------------------------------------
    // NumericArgument
    // ---------------------------------------------------------------------------
    protected static class NumericArgument extends Argument {
        NumericArgument(int typeint value) {
            this. = type;
            this. = value;
        }
        void writeTo(ByteArrayOutputStream outputStream) {
            outputStream.write();
            final int value = this.;
            writeValue(outputStreamvalue);
        }
        protected void writeValue(ByteArrayOutputStream outputStream,
                final int value) {
            outputStream.write(4);
            outputStream.write(value);
            outputStream.write(value >> 8);
            outputStream.write(value >> 16);
            outputStream.write(value >> 24);
        }
        int getType() {
            return ;
        }
        int getValueAsInt() {
            return ;
        }
        public int hashCode() {
            return ;
        }
        public boolean equals(Object other) {
            if (other == null || other instanceof NumericArgument == false)
                return false;
            final NumericArgument otherNumericArgument = (NumericArgumentother;
            return  == otherNumericArgument.type
                    &&  == otherNumericArgument.value;
        }
        private final int type;
        private final int value;
    }
    // ---------------------------------------------------------------------------
    // ByteArrayArgument
    // ---------------------------------------------------------------------------
    private static final class ByteArrayArgument extends Argument {
        ByteArrayArgument(int typebyte[] value) {
            this. = type;
            this. = value;
        }
        void writeTo(ByteArrayOutputStream outputStream) {
            outputStream.write();
            final int valueLength = .;
            writeLength(valueLengthoutputStream);
            for (int i = 0; i < valueLengthi++)
                outputStream.write([i]);
        }
        protected void writeLength(int length,
                ByteArrayOutputStream outputStream) {
            outputStream.write(length);
        }
        int getType() {
            return ;
        }
        int getValueAsInt() {
            if (. == 1)
                return [0];
            else
                throw new UnsupportedOperationException("This method is not "
                        + "supported for byte arrays with length > 1");
        }
        public int hashCode() {
            return ;
        }
        public boolean equals(Object other) {
            if (other == null || other instanceof ByteArrayArgument == false)
                return false;
            final ByteArrayArgument otherByteArrayArgument = (ByteArrayArgumentother;
            return  == otherByteArrayArgument.type
                    && Arrays.equals(otherByteArrayArgument.value);
        }
        private final int type;
        private final byte[] value;
    }
    // ---------------------------------------------------------------------------
    // SingleItem
    // ---------------------------------------------------------------------------
    private static final class SingleItem extends Argument {
        SingleItem(int item) {
            this. = item;
        }
        void writeTo(ByteArrayOutputStream outputStream) {
            outputStream.write();
        }
        int getType() {
            return ;
        }
        public int hashCode() {
            return ;
        }
        public boolean equals(Object other) {
            if (other == null || other instanceof SingleItem == false)
                return false;
            final SingleItem otherSingleItem = (SingleItemother;
            return  == otherSingleItem.item;
        }
        private final int item;
    }
New to GrepCode? Check out our FAQ X