57    const int64_t bytesToDiscard = std::min(bytes, 
size());
 
   58    if ( bytesToDiscard == 
size() ) {
 
   60      return bytesToDiscard;
 
   63    int64_t discardedSoFar = 0;
 
   67    while ( discardedSoFar < bytesToDiscard ) {
 
   69      const auto bytesInChunk = chunk.len();
 
   71      if ( discardedSoFar + bytesInChunk > bytesToDiscard ) {
 
   72        chunk.head += ( bytesToDiscard - discardedSoFar );
 
   73        discardedSoFar = bytesToDiscard;
 
   76        discardedSoFar += bytesInChunk;
 
   81    return bytesToDiscard;
 
 
   92    bytes = std::min( bytes, 
size() );
 
   93    if ( bytes == 
size() ) {
 
   98    int64_t choppedSoFar = 0;
 
   99    while ( choppedSoFar < bytes && 
_chunks.size() ) {
 
  100      auto bytesStillToChop =  bytes - choppedSoFar;
 
  103      if ( chunk.len() > bytesStillToChop ) {
 
  104        chunk.tail -= bytesStillToChop;
 
  107        choppedSoFar += chunk.len();
 
 
  135    const size_t bytesToRead = std::min( 
size(), max );
 
  136    size_t readSoFar = 0;
 
  138    while ( readSoFar < bytesToRead && 
_chunks.size() ) {
 
  141      const auto toRead   = std::min<size_t>( bytesToRead - readSoFar, chunk.len() );
 
  142      ::memcpy( buffer+readSoFar, chunk.data(), toRead );
 
  146      chunk.head += toRead;
 
  147      if( chunk.head >= chunk.tail )
 
 
  172    maxCount = std::min<size_t>( maxCount, 
size() );
 
  174    int64_t  scannedSoFar  = 0;
 
  175    for ( 
const auto &chunk : 
_chunks ) {
 
  178      if ( scannedSoFar+chunk.len() - 1 < pos ) {
 
  179        scannedSoFar += chunk.len();
 
  183      const char * 
const chunkBegin = chunk.data();
 
  184      const char *s = chunkBegin;
 
  186      size_t lengthToScan = std::min<size_t>( chunk.len() , maxCount - scannedSoFar );
 
  187      if ( pos > 0  && scannedSoFar < pos ) {
 
  188        const auto adjust = (pos-scannedSoFar);
 
  190        lengthToScan -= adjust;
 
  193      const char *ptr = 
reinterpret_cast<const char*
>(::memchr( s, c, lengthToScan ));
 
  195        return ( ( ptr - chunkBegin ) + scannedSoFar );
 
  198      scannedSoFar += chunk.len();
 
  199      if ( scannedSoFar >= maxCount )