private void initializeReading() throws JMSException {
   checkWriteOnlyBody();
   if (dataIn == null) {
     ByteSequence data = getContent();
     if (data == null) {
       data = new ByteSequence(new byte[] {}, 0, 0);
     }
     InputStream is = new ByteArrayInputStream(data);
     if (isCompressed()) {
       // keep track of the real length of the content if
       // we are compressed.
       try {
         DataInputStream dis = new DataInputStream(is);
         length = dis.readInt();
         dis.close();
       } catch (IOException e) {
         throw JMSExceptionSupport.create(e);
       }
       is = new InflaterInputStream(is);
     } else {
       length = data.getLength();
     }
     dataIn = new DataInputStream(is);
   }
 }
 /**
  * Writes a portion of a byte array to the bytes message stream.
  *
  * @param value the byte array value to be written
  * @param offset the initial offset within the byte array
  * @param length the number of bytes to use
  * @throws JMSException if the JMS provider fails to write the message due to some internal error.
  * @throws MessageNotWriteableException if the message is in read-only mode.
  */
 @Override
 public void writeBytes(byte[] value, int offset, int length) throws JMSException {
   initializeWriting();
   try {
     this.dataOut.write(value, offset, length);
   } catch (IOException ioe) {
     throw JMSExceptionSupport.create(ioe);
   }
 }
 /**
  * Writes a string to the bytes message stream using UTF-8 encoding in a machine-independent
  * manner.
  *
  * <p>For more information on the UTF-8 format, see "File System Safe UCS Transformation Format
  * (FSS_UTF)", X/Open Preliminary Specification, X/Open Company Ltd., Document Number: P316. This
  * information also appears in ISO/IEC 10646, Annex P.
  *
  * @param value the <code>String</code> value to be written
  * @throws JMSException if the JMS provider fails to write the message due to some internal error.
  * @throws MessageNotWriteableException if the message is in read-only mode.
  */
 @Override
 public void writeUTF(String value) throws JMSException {
   initializeWriting();
   try {
     this.dataOut.writeUTF(value);
   } catch (IOException ioe) {
     throw JMSExceptionSupport.create(ioe);
   }
 }
 @Override
 protected Message copy(Session session, Message m) throws JMSException {
   if (m instanceof ActiveMQBlobMessage) {
     ActiveMQBlobMessage b = (ActiveMQBlobMessage) m;
     ActiveMQBlobMessage copy =
         (ActiveMQBlobMessage) getAMQSession(session).createBlobMessage(b.getURL());
     try {
       copy.setProperties(b.getProperties());
     } catch (IOException e) {
       throw JMSExceptionSupport.create("Unable to copy message " + m, e);
     }
     return copy;
   } else {
     return super.copy(session, m);
   }
 }
  private void beforeEnd() throws JMSException {
    if (synchronizations == null) {
      return;
    }

    int size = synchronizations.size();
    try {
      for (; beforeEndIndex < size; ) {
        synchronizations.get(beforeEndIndex++).beforeEnd();
      }
    } catch (JMSException e) {
      throw e;
    } catch (Throwable e) {
      throw JMSExceptionSupport.create(e);
    }
  }
  private void initializeWriting() throws JMSException {
    checkReadOnlyBody();
    if (this.dataOut == null) {
      this.bytesOut = new ByteArrayOutputStream();
      OutputStream os = bytesOut;
      ActiveMQConnection connection = getConnection();
      if (connection != null && connection.isUseCompression()) {
        // keep track of the real length of the content if
        // we are compressed.
        try {
          os.write(new byte[4]);
        } catch (IOException e) {
          throw JMSExceptionSupport.create(e);
        }
        length = 0;
        compressed = true;
        final Deflater deflater = new Deflater(Deflater.BEST_SPEED);
        os =
            new FilterOutputStream(new DeflaterOutputStream(os, deflater)) {
              @Override
              public void write(byte[] arg0) throws IOException {
                length += arg0.length;
                out.write(arg0);
              }

              @Override
              public void write(byte[] arg0, int arg1, int arg2) throws IOException {
                length += arg2;
                out.write(arg0, arg1, arg2);
              }

              @Override
              public void write(int arg0) throws IOException {
                length++;
                out.write(arg0);
              }

              @Override
              public void close() throws IOException {
                super.close();
                deflater.end();
              }
            };
      }
      this.dataOut = new DataOutputStream(os);
    }
  }
 // DiscoveryAgent interface
 // -------------------------------------------------------------------------
 public void start() throws Exception {
   if (group == null) {
     throw new IOException("You must specify a group to discover");
   }
   String type = getType();
   if (!type.endsWith(".")) {
     LOG.warn("The type '" + type + "' should end with '.' to be a valid Rendezvous type");
     type += ".";
   }
   try {
     // force lazy construction
     getJmdns();
     if (listener != null) {
       LOG.info("Discovering service of type: " + type);
       jmdns.addServiceListener(type, this);
     }
   } catch (IOException e) {
     JMSExceptionSupport.create("Failed to start JmDNS service: " + e, e);
   }
 }
  private void afterCommit() throws JMSException {
    if (synchronizations == null) {
      return;
    }

    Throwable firstException = null;
    int size = synchronizations.size();
    for (int i = 0; i < size; i++) {
      try {
        synchronizations.get(i).afterCommit();
      } catch (Throwable t) {
        LOG.debug("Exception from afterCommit on {}", synchronizations.get(i), t);
        if (firstException == null) {
          firstException = t;
        }
      }
    }
    synchronizations = null;
    if (firstException != null) {
      throw JMSExceptionSupport.create(firstException);
    }
  }