001/* ParameterBlock.java --
002   Copyright (C) 2002 Free Software Foundation, Inc.
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038
039package java.awt.image.renderable;
040
041import java.awt.image.RenderedImage;
042import java.io.Serializable;
043import java.util.Vector;
044
045public class ParameterBlock implements Cloneable, Serializable
046{
047  private static final long serialVersionUID = -7577115551785240750L;
048  protected Vector<Object> sources;
049  protected Vector<Object> parameters;
050
051  public ParameterBlock()
052  {
053    this(new Vector<Object>(), new Vector<Object>());
054  }
055
056  public ParameterBlock(Vector<Object> sources)
057  {
058    this(sources, new Vector<Object>());
059  }
060
061  public ParameterBlock(Vector<Object> sources, Vector<Object> parameters)
062  {
063    this.sources = sources;
064    this.parameters = parameters;
065  }
066
067  public Object shallowClone()
068  {
069    try
070      {
071        return super.clone();
072      }
073    catch (CloneNotSupportedException e)
074      {
075        throw (Error) new InternalError().initCause(e); // impossible
076      }
077  }
078
079  public Object clone()
080  {
081    ParameterBlock pb = (ParameterBlock) shallowClone();
082    if (sources != null)
083      pb.sources = (Vector<Object>) sources.clone();
084    if (parameters != null)
085      pb.parameters = (Vector<Object>) parameters.clone();
086    return pb;
087  }
088
089  public ParameterBlock addSource(Object source)
090  {
091    sources.add(source);
092    return this;
093  }
094
095  public Object getSource(int index)
096  {
097    return sources.get(index);
098  }
099
100  public ParameterBlock setSource(Object source, int index)
101  {
102    sources.ensureCapacity(index);
103    sources.set(index, source);
104    return this;
105  }
106
107  public RenderedImage getRenderedSource(int index)
108  {
109    return (RenderedImage) sources.get(index);
110  }
111
112  public RenderableImage getRenderableSource(int index)
113  {
114    return (RenderableImage) sources.get(index);
115  }
116
117  public int getNumSources()
118  {
119    return sources.size();
120  }
121
122  public Vector<Object> getSources()
123  {
124    return sources;
125  }
126
127  public void setSources(Vector<Object> sources)
128  {
129    this.sources = sources;
130  }
131
132  public void removeSources()
133  {
134    if (sources != null)
135      sources.clear();
136  }
137
138  public int getNumParameters()
139  {
140    return parameters.size();
141  }
142
143  public Vector<Object> getParameters()
144  {
145    return parameters;
146  }
147
148  public void setParameters(Vector<Object> parameters)
149  {
150    this.parameters = parameters;
151  }
152
153  public void removeParameters()
154  {
155    if (parameters != null)
156      parameters.clear();
157  }
158
159  public ParameterBlock add(Object o)
160  {
161    parameters.add(o);
162    return this;
163  }
164
165  public ParameterBlock add(byte b)
166  {
167    return add(new Byte(b));
168  }
169
170  public ParameterBlock add(char c)
171  {
172    return add(new Character(c));
173  }
174
175  public ParameterBlock add(short s)
176  {
177    return add(new Short(s));
178  }
179
180  public ParameterBlock add(int i)
181  {
182    return add(new Integer(i));
183  }
184
185  public ParameterBlock add(long l)
186  {
187    return add(new Long(l));
188  }
189
190  public ParameterBlock add(float f)
191  {
192    return add(new Float(f));
193  }
194
195  public ParameterBlock add(double d)
196  {
197    return add(new Double(d));
198  }
199
200  public ParameterBlock set(Object o, int index)
201  {
202    parameters.ensureCapacity(index);
203    parameters.set(index, o);
204    return this;
205  }
206
207  public ParameterBlock set(byte b, int index)
208  {
209    return set(new Byte(b), index);
210  }
211
212  public ParameterBlock set(char c, int index)
213  {
214    return set(new Character(c), index);
215  }
216
217  public ParameterBlock set(short s, int index)
218  {
219    return set(new Short(s), index);
220  }
221
222  public ParameterBlock set(int i, int index)
223  {
224    return set(new Integer(i), index);
225  }
226
227  public ParameterBlock set(long l, int index)
228  {
229    return set(new Long(l), index);
230  }
231
232  public ParameterBlock set(float f, int index)
233  {
234    return set(new Float(f), index);
235  }
236
237  public ParameterBlock set(double d, int index)
238  {
239    return set(new Double(d), index);
240  }
241
242  public Object getObjectParameter(int index)
243  {
244    return parameters.get(index);
245  }
246
247  public byte getByteParameter(int index)
248  {
249    return ((Byte) parameters.get(index)).byteValue();
250  }
251
252  public char getCharParameter(int index)
253  {
254    return ((Character) parameters.get(index)).charValue();
255  }
256
257  public short getShortParameter(int index)
258  {
259    return ((Short) parameters.get(index)).shortValue();
260  }
261
262  public int getIntParameter(int index)
263  {
264    return ((Integer) parameters.get(index)).intValue();
265  }
266
267  public long getLongParameter(int index)
268  {
269    return ((Long) parameters.get(index)).longValue();
270  }
271
272  public float getFloatParameter(int index)
273  {
274    return ((Float) parameters.get(index)).floatValue();
275  }
276
277  public double getDoubleParameter(int index)
278  {
279    return ((Double) parameters.get(index)).doubleValue();
280  }
281
282  public Class[] getParamClasses()
283  {
284    int i = parameters.size();
285    Class[] result = new Class[i];
286    while (--i >= 0)
287      {
288        Class c = parameters.get(i).getClass();
289        if (c == Byte.class)
290          result[i] = byte.class;
291        else if (c == Character.class)
292          result[i] = char.class;
293        else if (c == Short.class)
294          result[i] = short.class;
295        else if (c == Integer.class)
296          result[i] = int.class;
297        else if (c == Long.class)
298          result[i] = long.class;
299        else if (c == Float.class)
300          result[i] = float.class;
301        else if (c == Double.class)
302          result[i] = double.class;
303        else
304          result[i] = c;
305      }
306    return result;
307  }
308} // class ParameterBlock