https://openjdk.java.net/ 
/*
 * Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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 GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package java.awt.image.renderable;
import java.awt.image.RenderedImage;
import java.io.Serializable;
import java.util.Vector;


A ParameterBlock encapsulates all the information about sources and parameters (Objects) required by a RenderableImageOp, or other classes that process images. 
 Although it is possible to place arbitrary objects in the source Vector, users of this class may impose semantic constraints such as requiring all sources to be RenderedImages or RenderableImage. ParameterBlock itself is merely a container and performs no checking on source or parameter types. 
 All parameters in a ParameterBlock are objects; convenience add and set methods are available that take arguments of base type and construct the appropriate subclass of Number (such as Integer or Float). Corresponding get methods perform a downward cast and have return values of base type; an exception will be thrown if the stored values do not have the correct type. There is no way to distinguish between the results of "short s; add(s)" and "add(new Short(s))". 
 Note that the get and set methods operate on references. Therefore, one must be careful not to share references between ParameterBlocks when this is inappropriate. For example, to create a new ParameterBlock that is equal to an old one except for an added source, one might be tempted to write: 
ParameterBlock addSource(ParameterBlock pb, RenderableImage im) {
    ParameterBlock pb1 = new ParameterBlock(pb.getSources());
    pb1.addSource(im);
    return pb1;
}



 This code will have the side effect of altering the original ParameterBlock, since the getSources operation returned a reference to its source Vector. Both pb and pb1 share their source Vector, and a change in either is visible to both. 
 A correct way to write the addSource function is to clone
the source Vector:

ParameterBlock addSource (ParameterBlock pb, RenderableImage im) {
    ParameterBlock pb1 = new ParameterBlock(pb.getSources().clone());
    pb1.addSource(im);
    return pb1;
}



 The clone method of ParameterBlock has been defined to perform a clone of both the source and parameter Vectors for this reason. A standard, shallow clone is available as shallowClone. 
 The addSource, setSource, add, and set methods are
defined to return 'this' after adding their argument.  This allows
use of syntax like:

ParameterBlock pb = new ParameterBlock();
op = new RenderableImageOp("operation", pb.add(arg1).add(arg2));



/**
 * A {@code ParameterBlock} encapsulates all the information about sources and
 * parameters (Objects) required by a RenderableImageOp, or other
 * classes that process images.
 *
 * <p> Although it is possible to place arbitrary objects in the
 * source Vector, users of this class may impose semantic constraints
 * such as requiring all sources to be RenderedImages or
 * RenderableImage.  {@code ParameterBlock} itself is merely a container and
 * performs no checking on source or parameter types.
 *
 * <p> All parameters in a {@code ParameterBlock} are objects; convenience
 * add and set methods are available that take arguments of base type and
 * construct the appropriate subclass of Number (such as
 * Integer or Float).  Corresponding get methods perform a
 * downward cast and have return values of base type; an exception
 * will be thrown if the stored values do not have the correct type.
 * There is no way to distinguish between the results of
 * "short s; add(s)" and "add(new Short(s))".
 *
 * <p> Note that the get and set methods operate on references.
 * Therefore, one must be careful not to share references between
 * {@code ParameterBlock}s when this is inappropriate.  For example, to create
 * a new {@code ParameterBlock} that is equal to an old one except for an
 * added source, one might be tempted to write:
 *
 * <pre>
 * ParameterBlock addSource(ParameterBlock pb, RenderableImage im) {
 *     ParameterBlock pb1 = new ParameterBlock(pb.getSources());
 *     pb1.addSource(im);
 *     return pb1;
 * }
 * </pre>
 *
 * <p> This code will have the side effect of altering the original
 * {@code ParameterBlock}, since the getSources operation returned a reference
 * to its source Vector.  Both pb and pb1 share their source Vector,
 * and a change in either is visible to both.
 *
 * <p> A correct way to write the addSource function is to clone
 * the source Vector:
 *
 * <pre>
 * ParameterBlock addSource (ParameterBlock pb, RenderableImage im) {
 *     ParameterBlock pb1 = new ParameterBlock(pb.getSources().clone());
 *     pb1.addSource(im);
 *     return pb1;
 * }
 * </pre>
 *
 * <p> The clone method of {@code ParameterBlock} has been defined to
 * perform a clone of both the source and parameter Vectors for
 * this reason.  A standard, shallow clone is available as
 * shallowClone.
 *
 * <p> The addSource, setSource, add, and set methods are
 * defined to return 'this' after adding their argument.  This allows
 * use of syntax like:
 *
 * <pre>
 * ParameterBlock pb = new ParameterBlock();
 * op = new RenderableImageOp("operation", pb.add(arg1).add(arg2));
 * </pre>
 * */
public class ParameterBlock implements Cloneable, Serializable {
    private static final long serialVersionUID = -7577115551785240750L;

    
A Vector of sources, stored as arbitrary Objects. 
/** A Vector of sources, stored as arbitrary Objects. */
    protected Vector<Object> sources = new Vector<Object>();

    
A Vector of non-source parameters, stored as arbitrary Objects. 
/** A Vector of non-source parameters, stored as arbitrary Objects. */
    protected Vector<Object> parameters = new Vector<Object>();

    
A dummy constructor. 
/** A dummy constructor. */
    public ParameterBlock() {}

    
Constructs a ParameterBlock with a given Vector of sources. 
Params:
  • sources – a Vector of source images
/**
     * Constructs a {@code ParameterBlock} with a given Vector
     * of sources.
     * @param sources a {@code Vector} of source images
     */
    public ParameterBlock(Vector<Object> sources) {
        setSources(sources);
    }

    
Constructs a ParameterBlock with a given Vector of sources and Vector of parameters. 
Params:
  • sources – a Vector of source images
  • parameters – a Vector of parameters to be used in the rendering operation
/**
     * Constructs a {@code ParameterBlock} with a given Vector of sources and
     * Vector of parameters.
     * @param sources a {@code Vector} of source images
     * @param parameters a {@code Vector} of parameters to be used in the
     *        rendering operation
     */
    public ParameterBlock(Vector<Object> sources,
                          Vector<Object> parameters)
    {
        setSources(sources);
        setParameters(parameters);
    }

    
Creates a shallow copy of a ParameterBlock. The source and parameter Vectors are copied by reference -- additions or changes will be visible to both versions. 
Returns:an Object clone of the ParameterBlock.
/**
     * Creates a shallow copy of a {@code ParameterBlock}.  The source and
     * parameter Vectors are copied by reference -- additions or
     * changes will be visible to both versions.
     *
     * @return an Object clone of the {@code ParameterBlock}.
     */
    public Object shallowClone() {
        try {
            return super.clone();
        } catch (Exception e) {
            // We can't be here since we implement Cloneable.
            return null;
        }
    }

    
Creates a copy of a ParameterBlock. The source and parameter Vectors are cloned, but the actual sources and parameters are copied by reference. This allows modifications to the order and number of sources and parameters in the clone to be invisible to the original ParameterBlock. Changes to the shared sources or parameters themselves will still be visible. 
Returns:an Object clone of the ParameterBlock.
/**
     * Creates a copy of a {@code ParameterBlock}.  The source and parameter
     * Vectors are cloned, but the actual sources and parameters are
     * copied by reference.  This allows modifications to the order
     * and number of sources and parameters in the clone to be invisible
     * to the original {@code ParameterBlock}.  Changes to the shared sources or
     * parameters themselves will still be visible.
     *
     * @return an Object clone of the {@code ParameterBlock}.
     */
    @SuppressWarnings("unchecked") // casts from clone
    public Object clone() {
        ParameterBlock theClone;

        try {
            theClone = (ParameterBlock) super.clone();
        } catch (Exception e) {
            // We can't be here since we implement Cloneable.
            return null;
        }

        if (sources != null) {
            theClone.setSources((Vector<Object>)sources.clone());
        }
        if (parameters != null) {
            theClone.setParameters((Vector<Object>)parameters.clone());
        }
        return (Object) theClone;
    }

    
Adds an image to end of the list of sources.  The image is
stored as an object in order to allow new node types in the
future.

Params:
  • source – an image object to be stored in the source list.
Returns:a new ParameterBlock containing the specified source.
/**
     * Adds an image to end of the list of sources.  The image is
     * stored as an object in order to allow new node types in the
     * future.
     *
     * @param source an image object to be stored in the source list.
     * @return a new {@code ParameterBlock} containing the specified
     *         {@code source}.
     */
    public ParameterBlock addSource(Object source) {
        sources.addElement(source);
        return this;
    }

    
Returns a source as a general Object.  The caller must cast it into
an appropriate type.

Params:
  • index – the index of the source to be returned.
See Also:
Returns:an Object that represents the source located at the specified index in the sources Vector.
/**
     * Returns a source as a general Object.  The caller must cast it into
     * an appropriate type.
     *
     * @param index the index of the source to be returned.
     * @return an {@code Object} that represents the source located
     *         at the specified index in the {@code sources}
     *         {@code Vector}.
     * @see #setSource(Object, int)
     */
    public Object getSource(int index) {
        return sources.elementAt(index);
    }

    
Replaces an entry in the list of source with a new source.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • source – the specified source image
  • index – the index into the sources Vector at which to insert the specified source
See Also:
Returns:a new ParameterBlock that contains the specified source at the specified index.
/**
     * Replaces an entry in the list of source with a new source.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param source the specified source image
     * @param index the index into the {@code sources}
     *              {@code Vector} at which to
     *              insert the specified {@code source}
     * @return a new {@code ParameterBlock} that contains the
     *         specified {@code source} at the specified
     *         {@code index}.
     * @see #getSource(int)
     */
    public ParameterBlock setSource(Object source, int index) {
        int oldSize = sources.size();
        int newSize = index + 1;
        if (oldSize < newSize) {
            sources.setSize(newSize);
        }
        sources.setElementAt(source, index);
        return this;
    }

    
Returns a source as a RenderedImage. This method is a convenience method. An exception will be thrown if the source is not a RenderedImage. 
Params:
  • index – the index of the source to be returned
Returns:a RenderedImage that represents the source image that is at the specified index in the sources Vector.
/**
     * Returns a source as a {@code RenderedImage}.  This method is
     * a convenience method.
     * An exception will be thrown if the source is not a RenderedImage.
     *
     * @param index the index of the source to be returned
     * @return a {@code RenderedImage} that represents the source
     *         image that is at the specified index in the
     *         {@code sources Vector}.
     */
    public RenderedImage getRenderedSource(int index) {
        return (RenderedImage) sources.elementAt(index);
    }

    
Returns a source as a RenderableImage.  This method is a
convenience method.
An exception will be thrown if the sources is not a RenderableImage.

Params:
  • index – the index of the source to be returned
Returns:a RenderableImage that represents the source image that is at the specified index in the sources Vector.
/**
     * Returns a source as a RenderableImage.  This method is a
     * convenience method.
     * An exception will be thrown if the sources is not a RenderableImage.
     *
     * @param index the index of the source to be returned
     * @return a {@code RenderableImage} that represents the source
     *         image that is at the specified index in the
     *         {@code sources Vector}.
     */
    public RenderableImage getRenderableSource(int index) {
        return (RenderableImage) sources.elementAt(index);
    }

    
Returns the number of source images.

Returns:the number of source images in the sources Vector.
/**
     * Returns the number of source images.
     * @return the number of source images in the {@code sources}
     *         {@code Vector}.
     */
    public int getNumSources() {
        return sources.size();
    }

    
Returns the entire Vector of sources.

See Also:
Returns:the sources Vector.
/**
     * Returns the entire Vector of sources.
     * @return the {@code sources Vector}.
     * @see #setSources(Vector)
     */
    public Vector<Object> getSources() {
        return sources;
    }

    
Sets the entire Vector of sources to a given Vector.

Params:
  • sources – the Vector of source images
See Also:
/**
     * Sets the entire Vector of sources to a given Vector.
     * @param sources the {@code Vector} of source images
     * @see #getSources
     */
    public void setSources(Vector<Object> sources) {
        this.sources = sources;
    }

    
Clears the list of source images. 
/** Clears the list of source images. */
    public void removeSources() {
        sources = new Vector<>();
    }

    
Returns the number of parameters (not including source images).

Returns:the number of parameters in the parameters Vector.
/**
     * Returns the number of parameters (not including source images).
     * @return the number of parameters in the {@code parameters}
     *         {@code Vector}.
     */
    public int getNumParameters() {
        return parameters.size();
    }

    
Returns the entire Vector of parameters.

See Also:
Returns:the parameters Vector.
/**
     * Returns the entire Vector of parameters.
     * @return the {@code parameters Vector}.
     * @see #setParameters(Vector)
     */
    public Vector<Object> getParameters() {
        return parameters;
    }

    
Sets the entire Vector of parameters to a given Vector.

Params:
  • parameters – the specified Vector of parameters
See Also:
/**
     * Sets the entire Vector of parameters to a given Vector.
     * @param parameters the specified {@code Vector} of
     *        parameters
     * @see #getParameters
     */
    public void setParameters(Vector<Object> parameters) {
        this.parameters = parameters;
    }

    
Clears the list of parameters. 
/** Clears the list of parameters. */
    public void removeParameters() {
        parameters = new Vector<>();
    }

    
Adds an object to the list of parameters.

Params:
  • obj – the Object to add to the parameters Vector
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Adds an object to the list of parameters.
     * @param obj the {@code Object} to add to the
     *            {@code parameters Vector}
     * @return a new {@code ParameterBlock} containing
     *         the specified parameter.
     */
    public ParameterBlock add(Object obj) {
        parameters.addElement(obj);
        return this;
    }

    
Adds a Byte to the list of parameters.

Params:
  • b – the byte to add to the parameters Vector
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Adds a Byte to the list of parameters.
     * @param b the byte to add to the
     *            {@code parameters Vector}
     * @return a new {@code ParameterBlock} containing
     *         the specified parameter.
     */
    public ParameterBlock add(byte b) {
        return add(Byte.valueOf(b));
    }

    
Adds a Character to the list of parameters.

Params:
  • c – the char to add to the parameters Vector
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Adds a Character to the list of parameters.
     * @param c the char to add to the
     *            {@code parameters Vector}
     * @return a new {@code ParameterBlock} containing
     *         the specified parameter.
     */
    public ParameterBlock add(char c) {
        return add(Character.valueOf(c));
    }

    
Adds a Short to the list of parameters.

Params:
  • s – the short to add to the parameters Vector
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Adds a Short to the list of parameters.
     * @param s the short to add to the
     *            {@code parameters Vector}
     * @return a new {@code ParameterBlock} containing
     *         the specified parameter.
     */
    public ParameterBlock add(short s) {
        return add(Short.valueOf(s));
    }

    
Adds a Integer to the list of parameters.

Params:
  • i – the int to add to the parameters Vector
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Adds a Integer to the list of parameters.
     * @param i the int to add to the
     *            {@code parameters Vector}
     * @return a new {@code ParameterBlock} containing
     *         the specified parameter.
     */
    public ParameterBlock add(int i) {
        return add(Integer.valueOf(i));
    }

    
Adds a Long to the list of parameters.

Params:
  • l – the long to add to the parameters Vector
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Adds a Long to the list of parameters.
     * @param l the long to add to the
     *            {@code parameters Vector}
     * @return a new {@code ParameterBlock} containing
     *         the specified parameter.
     */
    public ParameterBlock add(long l) {
        return add(Long.valueOf(l));
    }

    
Adds a Float to the list of parameters.

Params:
  • f – the float to add to the parameters Vector
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Adds a Float to the list of parameters.
     * @param f the float to add to the
     *            {@code parameters Vector}
     * @return a new {@code ParameterBlock} containing
     *         the specified parameter.
     */
    public ParameterBlock add(float f) {
        return add(Float.valueOf(f));
    }

    
Adds a Double to the list of parameters.

Params:
  • d – the double to add to the parameters Vector
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Adds a Double to the list of parameters.
     * @param d the double to add to the
     *            {@code parameters Vector}
     * @return a new {@code ParameterBlock} containing
     *         the specified parameter.
     */
    public ParameterBlock add(double d) {
        return add(Double.valueOf(d));
    }

    
Replaces an Object in the list of parameters.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • obj – the parameter that replaces the parameter at the specified index in the parameters Vector
  • index – the index of the parameter to be
       replaced with the specified parameter
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Replaces an Object in the list of parameters.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param obj the parameter that replaces the
     *        parameter at the specified index in the
     *        {@code parameters Vector}
     * @param index the index of the parameter to be
     *        replaced with the specified parameter
     * @return a new {@code ParameterBlock} containing
     *        the specified parameter.
     */
    public ParameterBlock set(Object obj, int index) {
        int oldSize = parameters.size();
        int newSize = index + 1;
        if (oldSize < newSize) {
            parameters.setSize(newSize);
        }
        parameters.setElementAt(obj, index);
        return this;
    }

    
Replaces an Object in the list of parameters with a Byte.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • b – the parameter that replaces the parameter at the specified index in the parameters Vector
  • index – the index of the parameter to be
       replaced with the specified parameter
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Replaces an Object in the list of parameters with a Byte.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param b the parameter that replaces the
     *        parameter at the specified index in the
     *        {@code parameters Vector}
     * @param index the index of the parameter to be
     *        replaced with the specified parameter
     * @return a new {@code ParameterBlock} containing
     *        the specified parameter.
     */
    public ParameterBlock set(byte b, int index) {
        return set(Byte.valueOf(b), index);
    }

    
Replaces an Object in the list of parameters with a Character.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • c – the parameter that replaces the parameter at the specified index in the parameters Vector
  • index – the index of the parameter to be
       replaced with the specified parameter
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Replaces an Object in the list of parameters with a Character.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param c the parameter that replaces the
     *        parameter at the specified index in the
     *        {@code parameters Vector}
     * @param index the index of the parameter to be
     *        replaced with the specified parameter
     * @return a new {@code ParameterBlock} containing
     *        the specified parameter.
     */
    public ParameterBlock set(char c, int index) {
        return set(Character.valueOf(c), index);
    }

    
Replaces an Object in the list of parameters with a Short.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • s – the parameter that replaces the parameter at the specified index in the parameters Vector
  • index – the index of the parameter to be
       replaced with the specified parameter
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Replaces an Object in the list of parameters with a Short.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param s the parameter that replaces the
     *        parameter at the specified index in the
     *        {@code parameters Vector}
     * @param index the index of the parameter to be
     *        replaced with the specified parameter
     * @return a new {@code ParameterBlock} containing
     *        the specified parameter.
     */
    public ParameterBlock set(short s, int index) {
        return set(Short.valueOf(s), index);
    }

    
Replaces an Object in the list of parameters with an Integer.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • i – the parameter that replaces the parameter at the specified index in the parameters Vector
  • index – the index of the parameter to be
       replaced with the specified parameter
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Replaces an Object in the list of parameters with an Integer.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param i the parameter that replaces the
     *        parameter at the specified index in the
     *        {@code parameters Vector}
     * @param index the index of the parameter to be
     *        replaced with the specified parameter
     * @return a new {@code ParameterBlock} containing
     *        the specified parameter.
     */
    public ParameterBlock set(int i, int index) {
        return set(Integer.valueOf(i), index);
    }

    
Replaces an Object in the list of parameters with a Long.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • l – the parameter that replaces the parameter at the specified index in the parameters Vector
  • index – the index of the parameter to be
       replaced with the specified parameter
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Replaces an Object in the list of parameters with a Long.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param l the parameter that replaces the
     *        parameter at the specified index in the
     *        {@code parameters Vector}
     * @param index the index of the parameter to be
     *        replaced with the specified parameter
     * @return a new {@code ParameterBlock} containing
     *        the specified parameter.
     */
    public ParameterBlock set(long l, int index) {
        return set(Long.valueOf(l), index);
    }

    
Replaces an Object in the list of parameters with a Float.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • f – the parameter that replaces the parameter at the specified index in the parameters Vector
  • index – the index of the parameter to be
       replaced with the specified parameter
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Replaces an Object in the list of parameters with a Float.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param f the parameter that replaces the
     *        parameter at the specified index in the
     *        {@code parameters Vector}
     * @param index the index of the parameter to be
     *        replaced with the specified parameter
     * @return a new {@code ParameterBlock} containing
     *        the specified parameter.
     */
    public ParameterBlock set(float f, int index) {
        return set(Float.valueOf(f), index);
    }

    
Replaces an Object in the list of parameters with a Double.
If the index lies beyond the current source list,
the list is extended with nulls as needed.

Params:
  • d – the parameter that replaces the parameter at the specified index in the parameters Vector
  • index – the index of the parameter to be
       replaced with the specified parameter
Returns:a new ParameterBlock containing the specified parameter.
/**
     * Replaces an Object in the list of parameters with a Double.
     * If the index lies beyond the current source list,
     * the list is extended with nulls as needed.
     * @param d the parameter that replaces the
     *        parameter at the specified index in the
     *        {@code parameters Vector}
     * @param index the index of the parameter to be
     *        replaced with the specified parameter
     * @return a new {@code ParameterBlock} containing
     *        the specified parameter.
     */
    public ParameterBlock set(double d, int index) {
        return set(Double.valueOf(d), index);
    }

    
Gets a parameter as an object.

Params:
  • index – the index of the parameter to get
Returns:an Object representing the the parameter at the specified index into the parameters Vector.
/**
     * Gets a parameter as an object.
     * @param index the index of the parameter to get
     * @return an {@code Object} representing the
     *         the parameter at the specified index
     *         into the {@code parameters}
     *         {@code Vector}.
     */
    public Object getObjectParameter(int index) {
        return parameters.elementAt(index);
    }

    
A convenience method to return a parameter as a byte. An exception is thrown if the parameter is null or not a Byte. 
Params:
  • index – the index of the parameter to be returned.
Throws:
Returns:the parameter at the specified index as a byte value.
/**
     * A convenience method to return a parameter as a byte.  An
     * exception is thrown if the parameter is
     * {@code null} or not a {@code Byte}.
     *
     * @param index the index of the parameter to be returned.
     * @return the parameter at the specified index
     *         as a {@code byte} value.
     * @throws ClassCastException if the parameter at the
     *         specified index is not a {@code Byte}
     * @throws NullPointerException if the parameter at the specified
     *         index is {@code null}
     * @throws ArrayIndexOutOfBoundsException if {@code index}
     *         is negative or not less than the current size of this
     *         {@code ParameterBlock} object
     */
    public byte getByteParameter(int index) {
        return ((Byte)parameters.elementAt(index)).byteValue();
    }

    
A convenience method to return a parameter as a char. An exception is thrown if the parameter is null or not a Character. 
Params:
  • index – the index of the parameter to be returned.
Throws:
Returns:the parameter at the specified index as a char value.
/**
     * A convenience method to return a parameter as a char.  An
     * exception is thrown if the parameter is
     * {@code null} or not a {@code Character}.
     *
     * @param index the index of the parameter to be returned.
     * @return the parameter at the specified index
     *         as a {@code char} value.
     * @throws ClassCastException if the parameter at the
     *         specified index is not a {@code Character}
     * @throws NullPointerException if the parameter at the specified
     *         index is {@code null}
     * @throws ArrayIndexOutOfBoundsException if {@code index}
     *         is negative or not less than the current size of this
     *         {@code ParameterBlock} object
     */
    public char getCharParameter(int index) {
        return ((Character)parameters.elementAt(index)).charValue();
    }

    
A convenience method to return a parameter as a short. An exception is thrown if the parameter is null or not a Short. 
Params:
  • index – the index of the parameter to be returned.
Throws:
Returns:the parameter at the specified index as a short value.
/**
     * A convenience method to return a parameter as a short.  An
     * exception is thrown if the parameter is
     * {@code null} or not a {@code Short}.
     *
     * @param index the index of the parameter to be returned.
     * @return the parameter at the specified index
     *         as a {@code short} value.
     * @throws ClassCastException if the parameter at the
     *         specified index is not a {@code Short}
     * @throws NullPointerException if the parameter at the specified
     *         index is {@code null}
     * @throws ArrayIndexOutOfBoundsException if {@code index}
     *         is negative or not less than the current size of this
     *         {@code ParameterBlock} object
     */
    public short getShortParameter(int index) {
        return ((Short)parameters.elementAt(index)).shortValue();
    }

    
A convenience method to return a parameter as an int. An exception is thrown if the parameter is null or not an Integer. 
Params:
  • index – the index of the parameter to be returned.
Throws:
Returns:the parameter at the specified index as an int value.
/**
     * A convenience method to return a parameter as an int.  An
     * exception is thrown if the parameter is
     * {@code null} or not an {@code Integer}.
     *
     * @param index the index of the parameter to be returned.
     * @return the parameter at the specified index
     *         as an {@code int} value.
     * @throws ClassCastException if the parameter at the
     *         specified index is not an {@code Integer}
     * @throws NullPointerException if the parameter at the specified
     *         index is {@code null}
     * @throws ArrayIndexOutOfBoundsException if {@code index}
     *         is negative or not less than the current size of this
     *         {@code ParameterBlock} object
     */
    public int getIntParameter(int index) {
        return ((Integer)parameters.elementAt(index)).intValue();
    }

    
A convenience method to return a parameter as a long. An exception is thrown if the parameter is null or not a Long. 
Params:
  • index – the index of the parameter to be returned.
Throws:
Returns:the parameter at the specified index as a long value.
/**
     * A convenience method to return a parameter as a long.  An
     * exception is thrown if the parameter is
     * {@code null} or not a {@code Long}.
     *
     * @param index the index of the parameter to be returned.
     * @return the parameter at the specified index
     *         as a {@code long} value.
     * @throws ClassCastException if the parameter at the
     *         specified index is not a {@code Long}
     * @throws NullPointerException if the parameter at the specified
     *         index is {@code null}
     * @throws ArrayIndexOutOfBoundsException if {@code index}
     *         is negative or not less than the current size of this
     *         {@code ParameterBlock} object
     */
    public long getLongParameter(int index) {
        return ((Long)parameters.elementAt(index)).longValue();
    }

    
A convenience method to return a parameter as a float. An exception is thrown if the parameter is null or not a Float. 
Params:
  • index – the index of the parameter to be returned.
Throws:
Returns:the parameter at the specified index as a float value.
/**
     * A convenience method to return a parameter as a float.  An
     * exception is thrown if the parameter is
     * {@code null} or not a {@code Float}.
     *
     * @param index the index of the parameter to be returned.
     * @return the parameter at the specified index
     *         as a {@code float} value.
     * @throws ClassCastException if the parameter at the
     *         specified index is not a {@code Float}
     * @throws NullPointerException if the parameter at the specified
     *         index is {@code null}
     * @throws ArrayIndexOutOfBoundsException if {@code index}
     *         is negative or not less than the current size of this
     *         {@code ParameterBlock} object
     */
    public float getFloatParameter(int index) {
        return ((Float)parameters.elementAt(index)).floatValue();
    }

    
A convenience method to return a parameter as a double. An exception is thrown if the parameter is null or not a Double. 
Params:
  • index – the index of the parameter to be returned.
Throws:
Returns:the parameter at the specified index as a double value.
/**
     * A convenience method to return a parameter as a double.  An
     * exception is thrown if the parameter is
     * {@code null} or not a {@code Double}.
     *
     * @param index the index of the parameter to be returned.
     * @return the parameter at the specified index
     *         as a {@code double} value.
     * @throws ClassCastException if the parameter at the
     *         specified index is not a {@code Double}
     * @throws NullPointerException if the parameter at the specified
     *         index is {@code null}
     * @throws ArrayIndexOutOfBoundsException if {@code index}
     *         is negative or not less than the current size of this
     *         {@code ParameterBlock} object
     */
    public double getDoubleParameter(int index) {
        return ((Double)parameters.elementAt(index)).doubleValue();
    }

    
Returns an array of Class objects describing the types
of the parameters.

Returns:an array of Class objects.
/**
     * Returns an array of Class objects describing the types
     * of the parameters.
     * @return an array of {@code Class} objects.
     */
    public Class<?>[] getParamClasses() {
        int numParams = getNumParameters();
        Class<?>[] classes = new Class<?>[numParams];
        int i;

        for (i = 0; i < numParams; i++) {
            Object obj = getObjectParameter(i);
            if (obj instanceof Byte) {
              classes[i] = byte.class;
            } else if (obj instanceof Character) {
              classes[i] = char.class;
            } else if (obj instanceof Short) {
              classes[i] = short.class;
            } else if (obj instanceof Integer) {
              classes[i] = int.class;
            } else if (obj instanceof Long) {
              classes[i] = long.class;
            } else if (obj instanceof Float) {
              classes[i] = float.class;
            } else if (obj instanceof Double) {
              classes[i] = double.class;
            } else {
              classes[i] = obj.getClass();
            }
        }

        return classes;
    }
}