code: private BlockedDelta compute(int numBlocks) {
  
          int contentSize = getValue(_next).remaining();
          _oldDelta = _next;
          UUID changeId = getChangeId(_next);
  
          if (_list == null) {
              _list = Lists.newArrayListWithCapacity(numBlocks);
          }
  
          _list.add(_next);
  
          for (int i = 1; i < numBlocks; i++) {
              if (_iterator.hasNext()) {
                  _next = _iterator.next();
                  if (getChangeId(_next).equals(changeId)) {
                      _list.add(_next);
                      contentSize += getValue(_next).remaining();
                  } else {
                      // fragmented delta encountered, we must skip over it
  
                      // We must also clear the list of the fragmented delta blocks to avoid them being stitched in with
                      // the next delta, which will cause a buffer overflow
                      _list.clear();
                      return null;
                  }
              } else {
                  // fragmented delta and no other deltas to skip to
                  throw new DeltaStitchingException(_rowKey, getChangeId(_next).toString(), numBlocks, i - 1);
              }
          }
  
          numBlocks += skipForward();
  
          return new BlockedDelta(numBlocks, stitchContent(contentSize));
      }
docs: stitch delta together and return it as one bytebuffer