| /* ParameterBlock.java -- |
| Copyright (C) 2002 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package java.awt.image.renderable; |
| |
| import java.awt.image.RenderedImage; |
| import java.io.Serializable; |
| import java.util.Vector; |
| |
| public class ParameterBlock implements Cloneable, Serializable |
| { |
| private static final long serialVersionUID = -7577115551785240750L; |
| protected Vector<Object> sources; |
| protected Vector<Object> parameters; |
| |
| public ParameterBlock() |
| { |
| this(new Vector<Object>(), new Vector<Object>()); |
| } |
| |
| public ParameterBlock(Vector<Object> sources) |
| { |
| this(sources, new Vector<Object>()); |
| } |
| |
| public ParameterBlock(Vector<Object> sources, Vector<Object> parameters) |
| { |
| this.sources = sources; |
| this.parameters = parameters; |
| } |
| |
| public Object shallowClone() |
| { |
| try |
| { |
| return super.clone(); |
| } |
| catch (CloneNotSupportedException e) |
| { |
| throw (Error) new InternalError().initCause(e); // impossible |
| } |
| } |
| |
| public Object clone() |
| { |
| ParameterBlock pb = (ParameterBlock) shallowClone(); |
| if (sources != null) |
| pb.sources = (Vector<Object>) sources.clone(); |
| if (parameters != null) |
| pb.parameters = (Vector<Object>) parameters.clone(); |
| return pb; |
| } |
| |
| public ParameterBlock addSource(Object source) |
| { |
| sources.add(source); |
| return this; |
| } |
| |
| public Object getSource(int index) |
| { |
| return sources.get(index); |
| } |
| |
| public ParameterBlock setSource(Object source, int index) |
| { |
| sources.ensureCapacity(index); |
| sources.set(index, source); |
| return this; |
| } |
| |
| public RenderedImage getRenderedSource(int index) |
| { |
| return (RenderedImage) sources.get(index); |
| } |
| |
| public RenderableImage getRenderableSource(int index) |
| { |
| return (RenderableImage) sources.get(index); |
| } |
| |
| public int getNumSources() |
| { |
| return sources.size(); |
| } |
| |
| public Vector<Object> getSources() |
| { |
| return sources; |
| } |
| |
| public void setSources(Vector<Object> sources) |
| { |
| this.sources = sources; |
| } |
| |
| public void removeSources() |
| { |
| if (sources != null) |
| sources.clear(); |
| } |
| |
| public int getNumParameters() |
| { |
| return parameters.size(); |
| } |
| |
| public Vector<Object> getParameters() |
| { |
| return parameters; |
| } |
| |
| public void setParameters(Vector<Object> parameters) |
| { |
| this.parameters = parameters; |
| } |
| |
| public void removeParameters() |
| { |
| if (parameters != null) |
| parameters.clear(); |
| } |
| |
| public ParameterBlock add(Object o) |
| { |
| parameters.add(o); |
| return this; |
| } |
| |
| public ParameterBlock add(byte b) |
| { |
| return add(new Byte(b)); |
| } |
| |
| public ParameterBlock add(char c) |
| { |
| return add(new Character(c)); |
| } |
| |
| public ParameterBlock add(short s) |
| { |
| return add(new Short(s)); |
| } |
| |
| public ParameterBlock add(int i) |
| { |
| return add(new Integer(i)); |
| } |
| |
| public ParameterBlock add(long l) |
| { |
| return add(new Long(l)); |
| } |
| |
| public ParameterBlock add(float f) |
| { |
| return add(new Float(f)); |
| } |
| |
| public ParameterBlock add(double d) |
| { |
| return add(new Double(d)); |
| } |
| |
| public ParameterBlock set(Object o, int index) |
| { |
| parameters.ensureCapacity(index); |
| parameters.set(index, o); |
| return this; |
| } |
| |
| public ParameterBlock set(byte b, int index) |
| { |
| return set(new Byte(b), index); |
| } |
| |
| public ParameterBlock set(char c, int index) |
| { |
| return set(new Character(c), index); |
| } |
| |
| public ParameterBlock set(short s, int index) |
| { |
| return set(new Short(s), index); |
| } |
| |
| public ParameterBlock set(int i, int index) |
| { |
| return set(new Integer(i), index); |
| } |
| |
| public ParameterBlock set(long l, int index) |
| { |
| return set(new Long(l), index); |
| } |
| |
| public ParameterBlock set(float f, int index) |
| { |
| return set(new Float(f), index); |
| } |
| |
| public ParameterBlock set(double d, int index) |
| { |
| return set(new Double(d), index); |
| } |
| |
| public Object getObjectParameter(int index) |
| { |
| return parameters.get(index); |
| } |
| |
| public byte getByteParameter(int index) |
| { |
| return ((Byte) parameters.get(index)).byteValue(); |
| } |
| |
| public char getCharParameter(int index) |
| { |
| return ((Character) parameters.get(index)).charValue(); |
| } |
| |
| public short getShortParameter(int index) |
| { |
| return ((Short) parameters.get(index)).shortValue(); |
| } |
| |
| public int getIntParameter(int index) |
| { |
| return ((Integer) parameters.get(index)).intValue(); |
| } |
| |
| public long getLongParameter(int index) |
| { |
| return ((Long) parameters.get(index)).longValue(); |
| } |
| |
| public float getFloatParameter(int index) |
| { |
| return ((Float) parameters.get(index)).floatValue(); |
| } |
| |
| public double getDoubleParameter(int index) |
| { |
| return ((Double) parameters.get(index)).doubleValue(); |
| } |
| |
| public Class[] getParamClasses() |
| { |
| int i = parameters.size(); |
| Class[] result = new Class[i]; |
| while (--i >= 0) |
| { |
| Class c = parameters.get(i).getClass(); |
| if (c == Byte.class) |
| result[i] = byte.class; |
| else if (c == Character.class) |
| result[i] = char.class; |
| else if (c == Short.class) |
| result[i] = short.class; |
| else if (c == Integer.class) |
| result[i] = int.class; |
| else if (c == Long.class) |
| result[i] = long.class; |
| else if (c == Float.class) |
| result[i] = float.class; |
| else if (c == Double.class) |
| result[i] = double.class; |
| else |
| result[i] = c; |
| } |
| return result; |
| } |
| } // class ParameterBlock |