@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 leftover carry, then we need to
                // do manual processing 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);
 
                // Just push the bytes and let the serialization happen later.
                messages.add(current);
 
                current = null;
                
                // Note: I originally thought that lazy deserialization was
                // going to be tricky/fancy because I'd imagined having to
                // collect partial buffers, leave data in working buffers, etcetera.
                // However, the buffer we are passed is reused by the caller
                // (it's part of the API contract) and so we MUST copy the
                // data into "something" before returning.  We already know
                // what size buffer the message is going to need.  That can't
                // change.  We are already creating per-message byte buffers.
                // ...so we might as well just buffer this in our queue instead.
                // The alternative is to somehow have an open-ended working buffer
                // that expands/shrinks as needed to accommodate the 'unknown' number
                // of messages that must be buffered before the caller asks for
                // one.  Obviously, that's way more wasteful than just keeping
                // per-message byte buffers around.  We already had them anyway.
                // So in the end, I probably could have just altered the original 
                // buffering code and called it a day... but I had to do the refactoring
                // before I figured that out, and now we have the ability to more easily
                // swap out protocol implementations.  -pspeed:2019-09-08                                    
            } 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/LazyMessageBuffer.java