# Blocking vs Non-blocking

The default behavior of the ring buffer is non-blocking, 
meaning that reads and writes will return immediately with an error if the operation cannot be completed.
If you want to block when reading or writing, you must enable it:

```go
	rb := ringbuffer.New(1024).SetBlocking(true)
```

Enabling blocking will cause the ring buffer to behave like a buffered [io.Pipe](https://pkg.go.dev/io#Pipe).

			//    https://blog.cloudflare.com/when-tcp-sockets-refuse-to-die/
			// This is a sensitive configuration, it is better to set it to high values, > 60 secs since it can
			// affect clients reading data with a very slow pace  (disappropriate with socket buffer sizes)
			if opts.UserTimeout > 0 {
				_ = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, unix.TCP_USER_TIMEOUT, opts.UserTimeout)
			}

     * @throws CIFSException if an error occurs retrieving the session key
     */
    byte[] getSessionKey() throws CIFSException;

    /**
     * Gets the input stream for reading from this pipe.
     *
     * @return this pipe's input stream
     * @throws CIFSException if an error occurs getting the input stream
     */
    @Override
    SmbPipeInputStream getInput() throws CIFSException;

 */
public class TemporaryFileInputStream extends InputStream {

    private final File tempFile;

    private final FileInputStream fileInputStream;

    /**
     * A class that provides an input stream for reading from a temporary file.
     * This class wraps a {@link FileInputStream} to read from the specified temporary file.
     *
     * @param tempFile the temporary file to be read

	readerIndex := 0
	var wg sync.WaitGroup
	// if readTrigger is true, it implies next disk.ReadAt() should be tried
	// if readTrigger is false, it implies previous disk.ReadAt() was successful and there is no need
	// to try reading the next disk.
	for readTrigger := range readTriggerCh {
		newBufLK.RLock()
		canDecode := p.canDecode(newBuf)
		newBufLK.RUnlock()
		if canDecode {
			break
		}
		if readerIndex == len(p.readers) {

        int bytesWritten = info.encode(buffer, 0);

        // Verify bytes written
        assertEquals(8, bytesWritten);

        // Verify encoded value
        long decodedValue = SMBUtil.readInt8(buffer, 0);
        assertEquals(endOfFile, decodedValue);
    }

    @Test
    @DisplayName("Test encode with offset")
    void testEncodeWithOffset() {
        long endOfFile = 0xFEDCBA9876543210L;

The **Advanced User Guide** builds on this one, uses the same concepts, and teaches you some extra features.

But you should first read the **Tutorial - User Guide** (what you are reading right now).

	Start *uint64 `xml:"Start"`
	// End is the offset of the last byte that should be returned when Start
	// is set, otherwise it is the offset from EOF to start reading.
	End *uint64 `xml:"End"`
}

// Validate if the scan range is valid.
func (s *ScanRange) Validate() error {
	if s == nil {
		return nil
	}
	if s.Start == nil && s.End == nil {

import jcifs.Configuration;

/**
 * SMB1 transaction subcommand for calling a named pipe.
 *
 * This class implements the TRANS_CALL_NAMED_PIPE transaction which allows
 * writing data to and reading data from a named pipe in a single operation.
 */
public class TransCallNamedPipe extends SmbComTransaction {

    private static final Logger log = LoggerFactory.getLogger(TransCallNamedPipe.class);

            doColumn("createdTime");
        }

        public void columnPermissions() {
            doColumn("permissions");
        }

        public void columnReading() {
            doColumn("reading");
        }

        public void columnSuggestWord() {
            doColumn("suggestWord");
        }

        public void columnUpdatedBy() {
            doColumn("updatedBy");
        }