for idx, pool := range z.serverPools {
		var skip bool
		for _, currentPool := range prevMeta.Pools {
			// Preserve any current pool status.
			if currentPool.CmdLine == pool.endpoints.CmdLine {
				currentPool.ID = idx
				newMeta.Pools = append(newMeta.Pools, currentPool)
				skip = true
				break
			}
		}
		if skip {
			continue
		}
		newMeta.Pools = append(newMeta.Pools, PoolStatus{

    )
    for lang_path in get_lang_paths():
        if lang_path.name in {"en", "em"} or not lang_path.is_dir():
            continue
        if lang_path.name not in SUPPORTED_LANGS:
            # Skip languages that are not yet ready
            continue
        code = lang_path.name
        languages.append({code: f"/{code}/"})
    for lang_dict in languages:
        code = list(lang_dict.keys())[0]

            m.ptype = 0;
            m.flags = flag;

            NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
            m.encode(buf);

            // Reset and skip to flags field
            buf.setIndex(3);
            assertEquals(flag, buf.dec_ndr_small());
        }
    }

For example, if you want to read or manipulate the request body before it is processed by your application.

/// danger

This is an "advanced" feature.

If you are just starting with **FastAPI** you might want to skip this section.

///

## Use cases { #use-cases }

Some use cases include:

}

// NewDummyDataGen returns a ReadSeeker over the first `totalLength`
// bytes from the infinite stream consisting of repeated
// concatenations of `alphabets`.
//
// The skipOffset (generally = 0) can be used to skip a given number
// of bytes from the beginning of the infinite stream. This is useful
// to compare such streams of bytes that may be split up, because:
//
// Given the function:
//
//	f := func(r io.Reader) string {

        if (commitId.isBlank() || commitId.toLowerCase(Locale.ROOT).contains("unknown")) {
            // we can't figure out the commit ID (probably this is a source distribution build), let's skip adding source links
            return;
        }

        extension.getSourceRoots().getFiles()
            .forEach(
                file -> {

    void withFilter_acceptsSome_skipsOthers_andVerifiesInteractions() throws Exception {
        SmbFile parent = newParent();
        List<FileEntry> entries = Arrays.asList(entry("keep1", SmbConstants.TYPE_SHARE), entry("skip1", SmbConstants.TYPE_SHARE),
                entry("keep2", SmbConstants.TYPE_SHARE));

        // Filter accepts names starting with "keep"
        when(filter.accept(any())).thenAnswer(inv -> {

        // Validate compression count
        if (compressionCount < 0 || compressionCount > 16) {
            throw new SMBProtocolDecodingException("Invalid compression count: " + compressionCount);
        }

        // Skip padding
        bufferIndex += 2;

        // Read flags
        this.flags = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // Validate remaining buffer size for algorithms

        });

        // When: Create iterator with throwing filter
        NetServerEnumIterator iterator = new NetServerEnumIterator(parent, treeHandle, "*", 0, nameFilter);

        // Then: Iterator should skip the entry (log error and continue)
        assertFalse(iterator.hasNext());

        // Cleanup
        iterator.close();
    }

    @Test

            fos.write("0123456789".getBytes());
        }

        try (TemporaryFileInputStream stream = new TemporaryFileInputStream(tempFile)) {
            long skipped = stream.skip(5);
            assertEquals(5, skipped);
            assertEquals('5', stream.read());
            assertEquals('6', stream.read());
        }
    }

    public void test_markAndReset() throws Exception {