* }
 * </pre>
 *
 * <pre>
 * import static org.codelibs.core.collection.IndexedIterator.*;
 * import static org.codelibs.core.io.LineIterator.*;
 *
 * BufferedReader reader = ...;
 * for (Indexed&lt;String&gt; indexed : indexed(iterable(reader))) {
 *     System.out.println(indexed.getIndex());
 *     System.out.println(indexed.getElement());
 * }
 * </pre>
 *
 * @author wyukawa
 * @param <T> the element type

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.Hashtable;

import jcifs.smb1.Config;
import jcifs.smb1.smb1.SmbFileInputStream;
import jcifs.smb1.util.LogStream;

/**
 * Lmhosts file handling for NetBIOS name resolution.
 */

	}

	for i, v := range vectors {
		for j := 0; j < 6; j++ {
			var tr *Reader
			var s1, s2 string

			switch j {
			case 0:
				tr = NewReader(&reader{strings.NewReader(v.input)})
				s1, s2 = "io.Reader", "auto"
			case 1:
				tr = NewReader(&reader{strings.NewReader(v.input)})
				s1, s2 = "io.Reader", "manual"
			case 2:
				tr = NewReader(&readSeeker{strings.NewReader(v.input)})

The reader thread must never run application-layer code. Otherwise one slow stream can hold up the entire connection.

// A Decompressor returns a new decompressing reader, reading from r.
// The [io.ReadCloser]'s Close method must be used to release associated resources.
// The Decompressor itself must be safe to invoke from multiple goroutines
// simultaneously, but each returned reader will be used only by
// one goroutine at a time.
type Decompressor func(r io.Reader) io.ReadCloser

var flateWriterPool sync.Pool

			return s2w.Close()
		}
		return nil
	}
}

var s2DecPool = bpool.Pool[*s2.Reader]{New: func() *s2.Reader {
	// Default alloc block for network transfer.
	return s2.NewReader(nil, s2.ReaderAllocBlock(16<<10))
}}

// metacacheReader allows reading a cache stream.
type metacacheReader struct {
	mr      *msgp.Reader
	current metaCacheEntry
	err     error // stateful error
	closer  func()

pkg bytes, func ContainsAny([]uint8, string) bool
pkg bytes, func ContainsRune([]uint8, int32) bool
pkg bytes, method (*Reader) Reset([]uint8)
pkg compress/flate, const HuffmanOnly = -2
pkg compress/flate, const HuffmanOnly ideal-int
pkg context, func Background() Context
pkg context, func TODO() Context
pkg context, func WithCancel(Context) (Context, CancelFunc)
pkg context, func WithDeadline(Context, time.Time) (Context, CancelFunc)

}

func (d *naughtyDisk) CreateFile(ctx context.Context, origvolume, volume, path string, size int64, reader io.Reader) error {
	if err := d.calcError(); err != nil {
		return err
	}
	return d.disk.CreateFile(ctx, origvolume, volume, path, size, reader)
}

func (d *naughtyDisk) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {

        if (truncated) {
          socket.close()
        }
      } else {
        // read a frame
        val inFrame = InFrame(i, reader)
        reader.nextFrame(false, inFrame)
        inFrames.add(inFrame)
      }
    }
  }

  fun openSocket(): Socket = Socket("localhost", port)

  @Synchronized override fun close() {

	// baseDir is not honored in windows platform
	return os.MkdirAll(dirPath, perm)
}

// readDirFn applies the fn() function on each entries at dirPath, doesn't recurse into
// the directory itself, if the dirPath doesn't exist this function doesn't return
// an error.
func readDirFn(dirPath string, filter func(name string, typ os.FileMode) error) error {
	// Ensure we don't pick up files as directories.