View Javadoc

1   /*** 
2    * 
3    * Copyright 2004 Protique Ltd
4    * 
5    * Licensed under the Apache License, Version 2.0 (the "License"); 
6    * you may not use this file except in compliance with the License. 
7    * You may obtain a copy of the License at 
8    * 
9    * http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS, 
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
14   * See the License for the specific language governing permissions and 
15   * limitations under the License. 
16   * 
17   **/
18  
19  package org.codehaus.activemq.message;
20  
21  /***
22   * Abstract class for a transportable Packet
23   *
24   * @version $Revision: 1.10 $
25   */
26  public abstract class AbstractPacket implements Packet {
27  
28      private String id;
29      private boolean receiptRequired;
30      private transient int memoryUsage = 2048;
31      private transient int memoryUsageReferenceCount;
32  
33      /***
34       * @return the unique id for this Packet
35       */
36  
37      public String getId() {
38          return this.id;
39      }
40  
41  
42      /***
43       * Set the unique id for this Packet
44       *
45       * @param newId
46       */
47  
48      public void setId(String newId) {
49          this.id = newId;
50      }
51  
52  
53      /***
54       * @return true if a Recipt is required
55       */
56  
57      public boolean isReceiptRequired() {
58          return this.receiptRequired;
59      }
60  
61      /***
62       * @return false since most packets are not receipt packets
63       */
64      public boolean isReceipt() {
65          return false;
66      }
67  
68      /***
69       * Set if a Recipt if required on receiving this Packet
70       *
71       * @param value
72       */
73  
74      public void setReceiptRequired(boolean value) {
75          this.receiptRequired = value;
76      }
77  
78      /***
79       * Retrieve if a JMS Message type or not
80       *
81       * @return true if it is a JMS Message
82       */
83      public boolean isJMSMessage() {
84          return false;
85      }
86  
87      /***
88       * Tests equality with another instance
89       *
90       * @param obj - the other instance to test equality with
91       * @return Returns true if the objects are equilvant
92       */
93  
94      public boolean equals(Object obj) {
95          boolean result = this == obj;
96          if (!result && obj != null && obj instanceof AbstractPacket) {
97              AbstractPacket other = (AbstractPacket) obj;
98              result = other.getId().equals(this.getId());
99          }
100 
101         return result;
102     }
103 
104     /***
105      * @return Returns hash code for this instance
106      */
107 
108     public int hashCode() {
109         return this.id != null ? this.id.hashCode() : super.hashCode();
110     }
111     
112     /***
113      * Get a hint about how much memory this Packet is consuming
114      * @return an aproximation of the current memory used by this instance
115      */
116     public int getMemoryUsage(){
117         return memoryUsage;
118     }
119     
120     /***
121      * Set a hint about how mujch memory this packet is consuming
122      * @param newMemoryUsage
123      */
124     public void setMemoryUsage(int newMemoryUsage){
125         this.memoryUsage = newMemoryUsage;
126     }
127     
128     /***
129      * Increment reference count for bounded memory collections
130      * @return the incremented reference value
131      * @see org.codehaus.activemq.message.util.MemoryBoundedQueue
132      */
133     public synchronized int incrementMemoryReferenceCount(){
134         return ++memoryUsageReferenceCount;
135     }
136     
137     
138     /***
139      * Decrement reference count for bounded memory collections
140      * @return the decremented reference value
141      * @see org.codehaus.activemq.message.util.MemoryBoundedQueue
142      */
143     public synchronized int decrementMemoryReferenceCount(){
144         return --memoryUsageReferenceCount;
145     }
146     
147     
148     /***
149      * @return the current reference count for bounded memory collections
150      * @see org.codehaus.activemq.message.util.MemoryBoundedQueue
151      */
152     public synchronized int getMemoryUsageReferenceCount(){
153         return memoryUsageReferenceCount;
154     }
155 
156     /***
157      * @return pretty print of this Packet
158      */
159     public String toString() {
160         return getPacketTypeAsString(getPacketType()) + ": " + getId();
161     }
162 
163     protected static String getPacketTypeAsString(int type) {
164         String packetTypeStr = "";
165         switch (type) {
166             case ACTIVEMQ_MESSAGE:
167                 packetTypeStr = "ACTIVEMQ_MESSAGE";
168                 break;
169             case ACTIVEMQ_TEXT_MESSAGE:
170                 packetTypeStr = "ACTIVEMQ_TEXT_MESSAGE";
171                 break;
172             case ACTIVEMQ_OBJECT_MESSAGE:
173                 packetTypeStr = "ACTIVEMQ_OBJECT_MESSAGE";
174                 break;
175             case ACTIVEMQ_BYTES_MESSAGE:
176                 packetTypeStr = "ACTIVEMQ_BYTES_MESSAGE";
177                 break;
178             case ACTIVEMQ_STREAM_MESSAGE:
179                 packetTypeStr = "ACTIVEMQ_STREAM_MESSAGE";
180                 break;
181             case ACTIVEMQ_MAP_MESSAGE:
182                 packetTypeStr = "ACTIVEMQ_MAP_MESSAGE";
183                 break;
184             case ACTIVEMQ_MSG_ACK:
185                 packetTypeStr = "ACTIVEMQ_MSG_ACK";
186                 break;
187             case RECEIPT_INFO:
188                 packetTypeStr = "RECEIPT_INFO";
189                 break;
190             case CONSUMER_INFO:
191                 packetTypeStr = "CONSUMER_INFO";
192                 break;
193             case PRODUCER_INFO:
194                 packetTypeStr = "PRODUCER_INFO";
195                 break;
196             case TRANSACTION_INFO:
197                 packetTypeStr = "TRANSACTION_INFO";
198                 break;
199             case XA_TRANSACTION_INFO:
200                 packetTypeStr = "XA_TRANSACTION_INFO";
201                 break;
202             case ACTIVEMQ_BROKER_INFO:
203                 packetTypeStr = "ACTIVEMQ_BROKER_INFO";
204                 break;
205             case ACTIVEMQ_CONNECTION_INFO:
206                 packetTypeStr = "ACTIVEMQ_CONNECTION_INFO";
207                 break;
208             case SESSION_INFO:
209                 packetTypeStr = "SESSION_INFO";
210                 break;
211             default:
212                 packetTypeStr = "UNKNOWN PACKET TYPE: " + type;
213         }
214         return packetTypeStr;
215     }
216 
217 
218     /***
219      * A helper method used when implementing equals() which returns
220      * true if the objects are identical or equal handling nulls properly
221      *
222      * @return true if the objects are the same or equal or both null
223      */
224     protected boolean equals(Object left, Object right) {
225         return left == right || (left != null && left.equals(right));
226     }
227 }