Skips all blocks that are completely before "initial_offset_".
<p/>
Handles reporting corruption

@return true on success.
557462
private boolean skipToInitialBlock()
    {
        int offsetInBlock = (int) (initialOffset % BLOCK_SIZE);
        long blockStartLocation = initialOffset - offsetInBlock;

        // Don't search a block if we'd be in the trailer
        if (offsetInBlock > BLOCK_SIZE - 6) {
            blockStartLocation += BLOCK_SIZE;
        }

        endOfBufferOffset = blockStartLocation;

        // Skip to start of first block that can contain the initial record
        if (blockStartLocation > 0) {
            try {
                fileChannel.position(blockStartLocation);
            }
            catch (IOException e) {
                reportDrop(blockStartLocation, e);
                return false;
            }
        }

        return true;
    }
621158
private byte[] skipBlocksNotInFilter() throws IOException {
		byte[] magicNo=new byte[4];
		byte[] blockSizeByte=new byte[4];
		// mark bytestream so we can peak into it
		this.bin.mark(8);
		// read magic
		int maxByteRead=4;
		int totalByteRead=0;
		int readByte;
		while ((readByte=this.bin.read(magicNo,totalByteRead,maxByteRead-totalByteRead))>-1) {
				totalByteRead+=readByte;
				if (totalByteRead>=maxByteRead) {
					break;
				}
		}
		if (totalByteRead!=maxByteRead) {
			return new byte[0];
		} 
		
		// read blocksize
	
		maxByteRead=4;
		totalByteRead=0;
		while ((readByte=this.bin.read(blockSizeByte,totalByteRead,maxByteRead-totalByteRead))>-1) {
				totalByteRead+=readByte;
				if (totalByteRead>=maxByteRead) {
					break;
				}
		}
		if (totalByteRead!=maxByteRead) {
			return new byte[0];
		} 
		
		long blockSize=BitcoinUtil.getSize(blockSizeByte)+8;
		// read the full block
		this.bin.reset();
		//filter by magic numbers?
		if (filterSpecificMagic) {
			for (int i=0;i<specificMagicByteArray.length;i++) {
				byte[] currentFilter=specificMagicByteArray[i];
				boolean doesMatchOneMagic=BitcoinUtil.compareMagics(currentFilter,magicNo);
				// correspond to filter? read it!
				if (doesMatchOneMagic) {
					return blockSizeByte;
				}
			}
			// Skip block if not found
			if (this.bin.skip(blockSize)!=blockSize) {
					LOG.error("Cannot skip block in InputStream");
			}
			return new byte[0];
		
		} else {
			return blockSizeByte;
		}
}
558464
public long skip(long bytesToSkip) throws IOException {
        checkForClosed();
        long bytesSkipped = 0;
        while (bytesToSkip > bytesLeftInBuffer()) {
            bytesSkipped += bytesLeftInBuffer();
            bytesToSkip -= bytesLeftInBuffer();
            _currentBufferPosition = _bytesInBuffer;
            if (_isEof) {
                break;
            }
            loadBytesAsNeeded();
        }
        if ((bytesToSkip > 0) && (bytesToSkip <= bytesLeftInBuffer())) {
            _currentBufferPosition += (int) bytesToSkip;
            bytesSkipped += (int) bytesToSkip;
        }
        return bytesSkipped;
    }
716849
def skip(self):
        """"""
        # Should we skip?
        if self.skip_list and isinstance(self.skip_list, list):
            for skip in self.skip_list:
                if request.path.startswith('/{0}'.format(skip)):
                    return True
        return False
1083413
@Override
	public long skip(long n) throws IOException {
		if (n < 0L) {
			throw new IllegalArgumentException("skip value is negative");
		}
		synchronized (lock) {
			ensureOpen();
			long r = n;
			while (r > 0) {
				if (nextChar >= nChars) {
					fill();
				}
				if (nextChar >= nChars) /* EOF */ {
					break;
				}
				if (skipLF) {
					skipLF = false;
					if (cb[nextChar] == '\n') {
						nextChar++;
					}
				}
				long d = nChars - nextChar;
				if (r <= d) {
					nextChar += r;
					r = 0;
					break;
				} else {
					r -= d;
					nextChar = nChars;
				}
			}
			bytesRead = bytesRead + (n - r);
			return n - r;
		}
	}
907639
private void flushBlock(boolean isClose)
    throws IOException
  {
    if (isClose) {
      if (! _isLargeBlob && _offset <= _table.getInlineBlobMax()) {
        return;
      }
    }

    _isLargeBlob = true;
    
    if (_blobOut == null) {
      _blobOut = _table.getTempStore().openWriter();
    }
    
    if (_offset != _bufferEnd && ! isClose) {
      throw new IllegalStateException();
    }
    
    _blobOut.write(_tempBuffer.buffer(), 0, _offset);
    _offset = 0;
    
    if (! isClose) {
      return;
    }
    
    StreamSource ss = _blobOut.getStreamSource();
    _blobOut = null;
      
    int len = (int) ss.getLength();
    int blobPageSizeMax = _table.getBlobPageSizeMax();

    int pid = -1;
    int nextPid = -1;
    int tailLen = len % blobPageSizeMax;
    // long seq = 0;

    PageServiceSync tableService = _table.getTableService();
    
    if (tailLen > 0) {
      int tailOffset = len - tailLen;
      
      pid = tableService.writeBlob(pid, ss.openChild(), 
                                  tailOffset, tailLen);
      
      len -= tailLen;
    }
      
    while (len > 0) {
      int sublen = blobPageSizeMax;
      int offset = len - blobPageSizeMax;
      
      pid = tableService.writeBlob(pid, ss.openChild(), offset, sublen);
      
      len -= sublen;
    }
      
    ss.close();
    
    _blobId = Math.max(pid, 0);
  }
1318505
public static boolean skipAll(Source source, int duration, TimeUnit timeUnit) throws IOException {
    long now = System.nanoTime();
    long originalDuration = source.timeout().hasDeadline()
        ? source.timeout().deadlineNanoTime() - now
        : Long.MAX_VALUE;
    source.timeout().deadlineNanoTime(now + Math.min(originalDuration, timeUnit.toNanos(duration)));
    try {
      Buffer skipBuffer = new Buffer();
      while (source.read(skipBuffer, 8192) != -1) {
        skipBuffer.clear();
      }
      return true; // Success! The source has been exhausted.
    } catch (InterruptedIOException e) {
      return false; // We ran out of time before exhausting the source.
    } finally {
      if (originalDuration == Long.MAX_VALUE) {
        source.timeout().clearDeadline();
      } else {
        source.timeout().deadlineNanoTime(now + originalDuration);
      }
    }
  }
1033155
public synchronized long skip(long n) {
        if (n < 0) {
            return 0;
        }
        if (n > count - pos) {
            n = count - pos;
        }
        pos += n;
        return n;
    }
890832
public boolean skipPreamble () throws IOException
  {
    // First delimiter may be not preceeded with a CRLF.
    System.arraycopy (m_aBoundary, 2, m_aBoundary, 0, m_aBoundary.length - 2);
    m_nBoundaryLength = m_aBoundary.length - 2;
    try
    {
      // Discard all data up to the delimiter.
      discardBodyData ();

      // Read boundary - if succeded, the stream contains an
      // encapsulation.
      return readBoundary ();
    }
    catch (final MultipartMalformedStreamException e)
    {
      return false;
    }
    finally
    {
      // Restore delimiter.
      System.arraycopy (m_aBoundary, 0, m_aBoundary, 2, m_aBoundary.length - 2);
      m_nBoundaryLength = m_aBoundary.length;
      m_aBoundary[0] = CR;
      m_aBoundary[1] = LF;
    }
  }
315192
@Override
	public long skip(long n) throws IOException {
		long result = stream.skip(n);
		update(result);
		return result;
	}
1294827
def clear(self):
        
        if self._bit_count == 0:
            return

        block = self._qpart.document().begin()
        while block.isValid():
            if self.getBlockValue(block):
                self.setBlockValue(block, 0)
            block = block.next()
968181
private boolean toBoundedFirst() throws FetchException {
        if (mStartBound == null) {
            if (!toFirst()) {
                return false;
            }
        } else {
            if (!toFirst(mStartBound.clone())) {
                return false;
            }
            if (!mInclusiveStart) {
                byte[] currentKey = getCurrentKey();
                if (currentKey == null) {
                    return false;
                }
                if (compareKeysPartially(mStartBound, currentKey) == 0) {
                    if (!toNextKey()) {
                        return false;
                    }
                }
            }
        }

        if (mEndBound != null) {
            byte[] currentKey = getCurrentKey();
            if (currentKey == null) {
                return false;
            }
            int result = compareKeysPartially(currentKey, mEndBound);
            if (result >= 0) {
                if (result > 0 || !mInclusiveEnd) {
                    return false;
                }
            }
        }

        return prefixMatches();
    }
1140066
public boolean previousPath() {
		// pre-decrement
		if (m_nextPathIndex == 0)
			return false;

		m_nextPathIndex--;
		m_currentSegmentIndex = -1;
		m_nextSegmentIndex = 0;
		m_segmentCount = _getSegmentCount(m_nextPathIndex);
		m_currentPathIndex = m_nextPathIndex;
		m_pathBegin = m_parent.getPathStart(m_currentPathIndex);
		resetToLastSegment();
		return true;
	}
234215
public synchronized void skip(int lengthToSkip)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "skip", lengthToSkip);

      checkReleased();

      if (receivedBuffer != null)
      {
         receivedBuffer.position(receivedBuffer.position() + lengthToSkip);
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "skip");
   }
1371758
private boolean skipCommaSpaces2() throws IOException {
        wsp1: for (;;) {
            switch (current) {
                default:
                    break wsp1;
                case 0x20:
                case 0x9:
                case 0xD:
                case 0xA:
                    break;
            }
            current = reader.read();
            appendToContext(current);
        }

        if (current != ',')
            return false; // no comma.

        wsp2: for (;;) {
            switch (current = reader.read()) {
                default:
                    appendToContext(current);
                    break wsp2;
                case 0x20:
                case 0x9:
                case 0xD:
                case 0xA:
                    appendToContext(current);
                    break;
            }
        }
        return true; // had comma
    }
675447
@Override
    public long skip(long n) throws IOException {
        final long skipped = super.skip(n);
        if (includeSkipped && skipped > 0) {
            dataLength += skipped;
            checkLength(false);
        }
        return skipped;
    }
627952
private boolean skipOneLine() {
        if (!undecodedChunk.isReadable()) {
            return false;
        }
        byte nextByte = undecodedChunk.readByte();
        if (nextByte == HttpConstants.CR) {
            if (!undecodedChunk.isReadable()) {
                undecodedChunk.readerIndex(undecodedChunk.readerIndex() - 1);
                return false;
            }
            nextByte = undecodedChunk.readByte();
            if (nextByte == HttpConstants.LF) {
                return true;
            }
            undecodedChunk.readerIndex(undecodedChunk.readerIndex() - 2);
            return false;
        }
        if (nextByte == HttpConstants.LF) {
            return true;
        }
        undecodedChunk.readerIndex(undecodedChunk.readerIndex() - 1);
        return false;
    }