KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > ubermq > jms > client > msg > AbstractStreamMessage


1 package com.ubermq.jms.client.msg;
2
3 import com.ubermq.*;
4 import com.ubermq.jms.client.*;
5 import com.ubermq.jms.client.impl.*;
6 import com.ubermq.jms.common.datagram.*;
7 import com.ubermq.util.*;
8
9 import java.io.*;
10 import java.nio.*;
11 import javax.jms.*;
12
13 /**
14  * An abstract base class to provide functionality for stream-oriented
15  * message subtypes. This includes <code>readXXX</code> and <code>writeXXX</code> methods
16  * as required by most stream oriented message subtypes.
17  */

18 abstract class AbstractStreamMessage
19     extends LocalMessage
20 {
21     final ByteArrayOutputStream baos;
22
23     final DataOutputStream out;
24     final DataInputStream in;
25
26     /**
27      * Creates a stream message on a message datagram and with a given
28      * acknowledgement handler.
29      * @param md the message datagram
30      * @param a the acknowledgement handler to use when acknowledge() is called
31      */

32     public AbstractStreamMessage(IMessageDatagram md, IAcknowledgeHandler a)
33     {
34         super(md, a);
35         in = new DataInputStream(new ByteArrayInputStream((byte[])super.getBody()));
36         baos = null;
37         out = null;
38     }
39
40     /**
41      * Constructs a new message using the given message datagram factory
42      * which will create the corresponding datagram.
43      */

44     public AbstractStreamMessage(IMessageDatagramFactory f)
45     {
46         super(f);
47         baos = new ByteArrayOutputStream();
48         out = new DataOutputStream(baos);
49         in = null;
50     }
51
52     public void prepareForPublish()
53     {
54         super.prepareForPublish();
55         if (baos != null)
56             super.setBody(baos.toByteArray());
57     }
58
59     public void writeInt(int param) throws javax.jms.JMSException JavaDoc
60     {
61         if (!isWriteable())
62             throw new MessageNotWriteableException("not writeable");
63
64         try
65         {
66             out.writeInt(param);
67         } catch(IOException iox)
68         {throw new javax.jms.JMSException JavaDoc(iox.toString() );}
69     }
70
71     public int readInt() throws javax.jms.JMSException JavaDoc
72     {
73         try
74         {
75             return in.readInt();
76         } catch(IOException iox)
77         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
78     }
79
80     public int readBytes(byte[] values, int param) throws javax.jms.JMSException JavaDoc
81     {
82         try
83         {
84             return in.read(values, 0, param);
85         } catch(IOException iox)
86         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
87     }
88
89     public void writeObject(Object JavaDoc obj) throws javax.jms.JMSException JavaDoc
90     {
91         if (!isWriteable())
92             throw new MessageNotWriteableException("not writeable");
93
94         try
95         {
96             ObjectOutputStream oos = new ObjectOutputStream(out);
97             oos.writeObject(obj);
98         } catch(IOException iox)
99         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
100     }
101
102     public float readFloat() throws javax.jms.JMSException JavaDoc
103     {
104         try
105         {
106             return in.readFloat();
107         } catch(IOException iox)
108         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
109     }
110
111     public void writeFloat(float param) throws javax.jms.JMSException JavaDoc
112     {
113         if (!isWriteable())
114             throw new MessageNotWriteableException("not writeable");
115
116         try
117         {
118             out.writeFloat(param);
119         } catch(IOException iox)
120         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
121     }
122
123     public void writeBoolean(boolean param) throws javax.jms.JMSException JavaDoc
124     {
125         if (!isWriteable())
126             throw new MessageNotWriteableException("not writeable");
127
128         try
129         {
130             out.writeBoolean(param);
131         } catch(IOException iox)
132         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
133     }
134
135     public int readUnsignedByte() throws javax.jms.JMSException JavaDoc
136     {
137         try
138         {
139             return in.readUnsignedByte();
140         } catch(IOException iox)
141         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
142     }
143
144     public void reset() throws javax.jms.JMSException JavaDoc
145     {
146         try
147         {
148             if (in != null) in.reset();
149             if (baos != null) baos.reset();
150         } catch(IOException iox)
151         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
152     }
153
154     public void writeBytes(byte[] values, int param, int param2) throws javax.jms.JMSException JavaDoc
155     {
156         if (!isWriteable())
157             throw new MessageNotWriteableException("not writeable");
158
159         try
160         {
161             out.write(values, param, param2);
162         } catch(IOException iox)
163         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
164     }
165
166     public void writeDouble(double param) throws javax.jms.JMSException JavaDoc
167     {
168         if (!isWriteable())
169             throw new MessageNotWriteableException("not writeable");
170
171         try
172         {
173             out.writeDouble(param);
174         } catch(IOException iox)
175         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
176     }
177
178     public byte readByte() throws javax.jms.JMSException JavaDoc
179     {
180         try
181         {
182             return in.readByte();
183         } catch(IOException iox)
184         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
185     }
186
187     public long readLong() throws javax.jms.JMSException JavaDoc
188     {
189         try
190         {
191             return in.readLong();
192         } catch(IOException iox)
193         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
194     }
195
196     public boolean readBoolean() throws javax.jms.JMSException JavaDoc
197     {
198         try
199         {
200             return in.readBoolean();
201         } catch(IOException iox)
202         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
203     }
204
205     public String JavaDoc readUTF() throws javax.jms.JMSException JavaDoc
206     {
207         try
208         {
209             return in.readUTF();
210         } catch(IOException iox)
211         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
212     }
213
214     public void writeUTF(String JavaDoc str) throws javax.jms.JMSException JavaDoc
215     {
216         if (!isWriteable())
217             throw new MessageNotWriteableException("not writeable");
218
219         try
220         {
221             out.writeUTF(str);
222         } catch(IOException iox)
223         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
224     }
225
226     public void writeBytes(byte[] values) throws javax.jms.JMSException JavaDoc
227     {
228         if (!isWriteable())
229             throw new MessageNotWriteableException("not writeable");
230
231         try
232         {
233             out.write(values);
234         } catch(IOException iox)
235         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
236     }
237
238     public void writeShort(short param) throws javax.jms.JMSException JavaDoc
239     {
240         if (!isWriteable())
241             throw new MessageNotWriteableException("not writeable");
242
243         try
244         {
245             out.writeShort(param);
246         } catch(IOException iox)
247         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
248     }
249
250     public int readBytes(byte[] values) throws javax.jms.JMSException JavaDoc
251     {
252         try
253         {
254             return in.read(values);
255         } catch(IOException iox)
256         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
257     }
258
259     public int readUnsignedShort() throws javax.jms.JMSException JavaDoc
260     {
261         try
262         {
263             return in.readUnsignedShort();
264         } catch(IOException iox)
265         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
266     }
267
268     public void writeByte(byte param) throws javax.jms.JMSException JavaDoc
269     {
270         if (!isWriteable())
271             throw new MessageNotWriteableException("not writeable");
272
273         try
274         {
275             out.writeByte(param);
276         } catch(IOException iox)
277         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
278     }
279
280     public char readChar() throws javax.jms.JMSException JavaDoc
281     {
282         try
283         {
284             return in.readChar();
285         } catch(IOException iox)
286         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
287     }
288
289     public void writeLong(long param) throws javax.jms.JMSException JavaDoc
290     {
291         if (!isWriteable())
292             throw new MessageNotWriteableException("not writeable");
293
294         try
295         {
296             out.writeLong(param);
297         } catch(IOException iox)
298         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
299     }
300
301     public double readDouble() throws javax.jms.JMSException JavaDoc
302     {
303         try
304         {
305             return in.readDouble();
306         } catch(IOException iox)
307         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
308     }
309
310     public short readShort() throws javax.jms.JMSException JavaDoc
311     {
312         try
313         {
314             return in.readShort();
315         } catch(IOException iox)
316         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
317     }
318
319     public void writeChar(char param) throws javax.jms.JMSException JavaDoc
320     {
321         if (!isWriteable())
322             throw new MessageNotWriteableException("not writeable");
323
324         try
325         {
326             out.writeChar(param);
327         } catch(IOException iox)
328         {throw new javax.jms.JMSException JavaDoc(iox.toString());}
329     }
330
331     protected String JavaDoc bodyToHtml()
332     {
333         byte[] body = (byte[])getBody();
334         StringBuffer JavaDoc sz = new StringBuffer JavaDoc();
335         if (body.length > 0)
336         {
337             sz.append("<b>Body Hexdump</b><br>");
338             sz.append("<pre><blockquote>");
339             sz.append(Utility.displayBuffer(ByteBuffer.wrap(body)));
340             sz.append("</blockquote></pre>");
341         }
342
343         return sz.toString();
344     }
345 }
346
Popular Tags