gt:         if (buffer != null) {
context: /**
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.activemq.transport.udp;
  
  import java.io.DataInputStream;
  import java.io.DataOutputStream;
  import java.io.IOException;
  import java.net.SocketAddress;
  import java.nio.ByteBuffer;
  import java.nio.channels.DatagramChannel;
  
  import org.apache.activemq.command.Command;
  import org.apache.activemq.command.Endpoint;
  import org.apache.activemq.command.LastPartialCommand;
  import org.apache.activemq.command.PartialCommand;
  import org.apache.activemq.openwire.BooleanStream;
  import org.apache.activemq.openwire.OpenWireFormat;
  import org.apache.activemq.transport.reliable.ReplayBuffer;
  import org.apache.activemq.util.ByteArrayInputStream;
  import org.apache.activemq.util.ByteArrayOutputStream;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * A strategy for reading datagrams and de-fragmenting them together.
   * 
   * 
   */
  public class CommandDatagramChannel extends CommandChannelSupport {
  
      private static final Logger LOG = LoggerFactory.getLogger(CommandDatagramChannel.class);
  
      private DatagramChannel channel;
      private ByteBufferPool bufferPool;
  
      // reading
      private Object readLock = new Object();
      private ByteBuffer readBuffer;
  
      // writing
      private Object writeLock = new Object();
      private int defaultMarshalBufferSize = 64 * 1024;
      private volatile int receiveCounter;
  
      public CommandDatagramChannel(UdpTransport transport, OpenWireFormat wireFormat, int datagramSize, SocketAddress targetAddress, DatagramHeaderMarshaller headerMarshaller,
                                    DatagramChannel channel, ByteBufferPool bufferPool) {
          super(transport, wireFormat, datagramSize, targetAddress, headerMarshaller);
          this.channel = channel;
          this.bufferPool = bufferPool;
      }
  
      public void start() throws Exception {
          bufferPool.setDefaultSize(datagramSize);
          bufferPool.start();
          readBuffer = bufferPool.borrowBuffer();
      }
  
      public void stop() throws Exception {
          bufferPool.stop();
      }
  
      public Command read() throws IOException {
          Command answer = null;
          Endpoint from = null;
          synchronized (readLock) {
              while (true) {
                  readBuffer.clear();
                  SocketAddress address = channel.receive(readBuffer);
  
                  readBuffer.flip();
  
                  if (readBuffer.limit() == 0) {
                      continue;
                  }
                  
                  receiveCounter++;
                  from = headerMarshaller.createEndpoint(readBuffer, address);
  
                  int remaining = readBuffer.remaining();
                  byte[] data = new byte[remaining];
                  readBuffer.get(data);
  
                  // TODO could use a DataInput implementation that talks direct
                  // to
                  // the ByteBuffer to avoid object allocation and unnecessary
                  // buffering?
                  DataInputStream dataIn = new DataInputStream(new ByteArrayInputStream(data));
                  answer = (Command)wireFormat.unmarshal(dataIn);
                  break;
              }
          }
          if (answer != null) {
              answer.setFrom(from);
  
              if (LOG.isDebugEnabled()) {
                  LOG.debug("Channel: " + name + " received from: " + from + " about to process: " + answer);
              }
          }
          return answer;
      }
  
      public void write(Command command, SocketAddress address) throws IOException {
          synchronized (writeLock) {
  
              ByteArrayOutputStream largeBuffer = new ByteArrayOutputStream(defaultMarshalBufferSize);
              wireFormat.marshal(command, new DataOutputStream(largeBuffer));
              byte[] data = largeBuffer.toByteArray();
              int size = data.length;
  
              ByteBuffer writeBuffer = bufferPool.borrowBuffer();
              writeBuffer.clear();
              headerMarshaller.writeHeader(command, writeBuffer);
  
              if (size > writeBuffer.remaining()) {
                  // lets split the command up into chunks
                  int offset = 0;
                  boolean lastFragment = false;
                  int length = data.length;
                  for (int fragment = 0; !lastFragment; fragment++) {
                      // write the header
                      if (fragment > 0) {
                          writeBuffer = bufferPool.borrowBuffer();
                          writeBuffer.clear();
                          headerMarshaller.writeHeader(command, writeBuffer);
                      }
  
                      int chunkSize = writeBuffer.remaining();
  
                      // we need to remove the amount of overhead to write the
                      // partial command
  
                      // lets write the flags in there
                      BooleanStream bs = null;
                      if (wireFormat.isTightEncodingEnabled()) {
                          bs = new BooleanStream();
                          bs.writeBoolean(true); // the partial data byte[] is
                          // never null
                      }
  
                      // lets remove the header of the partial command
                      // which is the byte for the type and an int for the size of
                      // the byte[]
  
                      // data type + the command ID + size of the partial data
                      chunkSize -= 1 + 4 + 4;
  
                      // the boolean flags
                      if (bs != null) {
                          chunkSize -= bs.marshalledSize();
                      } else {
                          chunkSize -= 1;
                      }
  
                      if (!wireFormat.isSizePrefixDisabled()) {
                          // lets write the size of the command buffer
                          writeBuffer.putInt(chunkSize);
                          chunkSize -= 4;
                      }
  
                      lastFragment = offset + chunkSize >= length;
                      if (chunkSize + offset > length) {
                          chunkSize = length - offset;
                      }
  
                      if (lastFragment) {
                          writeBuffer.put(LastPartialCommand.DATA_STRUCTURE_TYPE);
                      } else {
                          writeBuffer.put(PartialCommand.DATA_STRUCTURE_TYPE);
                      }
  
                      if (bs != null) {
                          bs.marshal(writeBuffer);
                      }
  
                      int commandId = command.getCommandId();
                      if (fragment > 0) {
                          commandId = sequenceGenerator.getNextSequenceId();
                      }
                      writeBuffer.putInt(commandId);
                      if (bs == null) {
                          writeBuffer.put((byte)1);
                      }
  
                      // size of byte array
                      writeBuffer.putInt(chunkSize);
  
                      // now the data
                      writeBuffer.put(data, offset, chunkSize);
  
                      offset += chunkSize;
                      sendWriteBuffer(commandId, address, writeBuffer, false);
                  }
              } else {
                  writeBuffer.put(data);
                  sendWriteBuffer(command.getCommandId(), address, writeBuffer, false);
              }
          }
      }
  
      // Properties
      // -------------------------------------------------------------------------
  
      public ByteBufferPool getBufferPool() {
          return bufferPool;
      }
  
      /**
       * Sets the implementation of the byte buffer pool to use
       */
      public void setBufferPool(ByteBufferPool bufferPool) {
          this.bufferPool = bufferPool;
      }
  
      // Implementation methods
      // -------------------------------------------------------------------------
      protected void sendWriteBuffer(int commandId, SocketAddress address, ByteBuffer writeBuffer, boolean redelivery) throws IOException {
          // lets put the datagram into the replay buffer first to prevent timing
          // issues
          ReplayBuffer bufferCache = getReplayBuffer();
          if (bufferCache != null && !redelivery) {
              bufferCache.addBuffer(commandId, writeBuffer);
          }
  
          writeBuffer.flip();
  
          if (LOG.isDebugEnabled()) {
              String text = redelivery ? "REDELIVERING" : "sending";
              LOG.debug("Channel: " + name + " " + text + " datagram: " + commandId + " to: " + address);
          }
          channel.send(writeBuffer, address);
      }
  
      public void sendBuffer(int commandId, Object buffer) throws IOException {
  