Java example source code file (ParameterBlock.java)
This example Java source code file (ParameterBlock.java) is included in the alvinalexander.com
"Java Source Code
Warehouse " project. The intent of this project is to help you "Learn
Java by Example " TM
Learn more about this Java project at its project page .
The ParameterBlock.java Java example source code
/*
* Copyright (c) 1998, 2004, 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 <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 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>ParameterBlocks 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 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 {
/** A Vector of sources, stored as arbitrary Objects. */
protected Vector<Object> sources = new Vector();
/** A Vector of non-source parameters, stored as arbitrary Objects. */
protected Vector<Object> parameters = new Vector();
/** A dummy constructor. */
public ParameterBlock() {}
/**
* 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 <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 <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 <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.
*/
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)sources.clone());
}
if (parameters != null) {
theClone.setParameters((Vector)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.
*
* @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.
*
* @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.
* @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 <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.
*
* @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.
* @return the number of source images in the <code>sources
* <code>Vector.
*/
public int getNumSources() {
return sources.size();
}
/**
* 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.
* @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. */
public void removeSources() {
sources = new 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.
* @return the <code>parameters Vector.
* @see #setParameters(Vector)
*/
public Vector<Object> getParameters() {
return parameters;
}
/**
* 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. */
public void removeParameters() {
parameters = new Vector();
}
/**
* 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.
* @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(new Byte(b));
}
/**
* 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(new Character(c));
}
/**
* 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(new Short(s));
}
/**
* 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(new Integer(i));
}
/**
* 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(new Long(l));
}
/**
* 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(new Float(f));
}
/**
* 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(new Double(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.
* @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.
* @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(new Byte(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.
* @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(new Character(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.
* @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(new Short(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.
* @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(new Integer(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.
* @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(new Long(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.
* @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(new Float(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.
* @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(new Double(d), index);
}
/**
* 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
* <code>null or not a 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
* <code>null or not a 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
* <code>null or not a 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
* <code>null or not an Integer.
*
* @param index the index of the parameter to be returned.
* @return the parameter at the specified index
* as a <code>int value.
* @throws ClassCastException if the parameter at the
* specified index is not a <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
* <code>null or not a 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
* <code>null or not a 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
* <code>null or not a 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.
* @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;
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java ParameterBlock.java source code file:
