@Override
    public boolean addBytes( ByteBuffer buffer ) {
        // push the data from the buffer into as
        // many messages as we can
        while( buffer.remaining() > 0 ) {

            if( current == null ) {

                // If we have a left-over carry,
                // extra processing is needed to get the short value.
                if( carry != null ) {
                    byte high = carry;
                    byte low = buffer.get();
                    
                    size = (high & 0xff) << 8 | (low & 0xff);
                    carry = null;
                }
                else if( buffer.remaining() < 2 ) {
                    // It's possible that the supplied buffer only has one
                    // byte in it... and in that case we will get an underflow
                    // when attempting to read the short below.
                    
                    // It has to be 1, or we'd never get here... but one
                    // isn't enough, so we stash it away.
                    carry = buffer.get();
                    break;
                } else {
                    // We are not currently reading an object so
                    // grab the size.
                    // Note: this is somewhat limiting... int would
                    // be better.
                    size = buffer.getShort();
                }               
 
                // Allocate the buffer into which we'll feed the
                // data as we get it               
                current = ByteBuffer.allocate(size);
            } 

            if( current.remaining() <= buffer.remaining() ) {
                // We have at least one complete object so
                // copy what we can into current, create a message,
                // and then continue pulling from buffer.
                    
                // Artificially set the limit so we don't overflow
                int extra = buffer.remaining() - current.remaining();
                buffer.limit(buffer.position() + current.remaining());
 
                // Now copy the data                   
                current.put(buffer);
                current.flip();
                    
                // Now set the limit back to a good value
                buffer.limit(buffer.position() + extra);
 
                messages.add(protocol.toMessage(current));
 
                current = null;                    
            } else {                
                // Not yet a complete object so just copy what we have
                current.put(buffer); 
            }            
        }            
        
        return hasMessages();        
    }
Adds byte data to the message buffer.  Returns true if there is
 a message waiting after this call.
jme3-networking/src/main/java/com/jme3/network/base/protocol/GreedyMessageBuffer.java