SYMBOL INDEX (1901 symbols across 421 files)

FILE: python/riegeli/base/riegeli_error.py
  class RiegeliError (line 36) | class RiegeliError(Exception):
  class CancelledError (line 49) | class CancelledError(RiegeliError):
  class UnknownError (line 55) | class UnknownError(RiegeliError):
  class InvalidArgumentError (line 67) | class InvalidArgumentError(RiegeliError):
  class DeadlineExceededError (line 78) | class DeadlineExceededError(RiegeliError):
  class NotFoundError (line 90) | class NotFoundError(RiegeliError):
  class AlreadyExistsError (line 103) | class AlreadyExistsError(RiegeliError):
  class PermissionDeniedError (line 109) | class PermissionDeniedError(RiegeliError):
  class UnauthenticatedError (line 123) | class UnauthenticatedError(RiegeliError):
  class ResourceExhaustedError (line 129) | class ResourceExhaustedError(RiegeliError):
  class FailedPreconditionError (line 139) | class FailedPreconditionError(RiegeliError):
  class AbortedError (line 162) | class AbortedError(RiegeliError):
  class OutOfRangeError (line 175) | class OutOfRangeError(RiegeliError):
  class UnimplementedError (line 195) | class UnimplementedError(RiegeliError):
  class InternalError (line 204) | class InternalError(RiegeliError):
  class UnavailableError (line 214) | class UnavailableError(RiegeliError):
  class DataLossError (line 227) | class DataLossError(RiegeliError):

FILE: python/riegeli/base/utils.cc
  type riegeli::python (line 46) | namespace riegeli::python {
    function Exception (line 48) | Exception& Exception::operator=(const Exception& that) noexcept {
    function Exception (line 59) | Exception Exception::Fetch() {
    function PyObject (line 69) | PyObject* Exception::Restore() const& {
    function PyObject (line 78) | PyObject* Exception::Restore() && {
    function SetRiegeliError (line 109) | void SetRiegeliError(const absl::Status& status) {
    type py_internal (line 152) | namespace py_internal {
      function FreeStaticObjectsImpl (line 163) | void FreeStaticObjectsImpl() {
      function FreeStaticObjects (line 176) | static void FreeStaticObjects() { FreeStaticObjectsImpl(); }
    function ExportCapsule (line 224) | bool ExportCapsule(PyObject* module, const char* capsule_name,
    function PyObject (line 255) | PyObject* MemoryView::ToPython(absl::string_view value) {
    function PyObject (line 265) | PyObject* MemoryView::MutableToPython(absl::Span<char> value) {
    function PythonPtr (line 310) | PythonPtr ChainToPython(const Chain& value) {
    function ChainFromPython (line 318) | std::optional<Chain> ChainFromPython(PyObject* object) {
    function PythonPtr (line 330) | PythonPtr SizeToPython(size_t value) {
    function SizeFromPython (line 340) | std::optional<size_t> SizeFromPython(PyObject* object) {
    function PythonPtr (line 358) | PythonPtr PositionToPython(Position value) {
    function PositionFromPython (line 369) | std::optional<Position> PositionFromPython(PyObject* object) {
    function PythonPtr (line 388) | PythonPtr PartialOrderingToPython(PartialOrdering ordering) {
    function PartialOrderingFromPython (line 395) | std::optional<PartialOrdering> PartialOrderingFromPython(PyObject* obj...

FILE: python/riegeli/base/utils.h
  function class (line 50) | class PythonLock {
  function class (line 70) | class PythonUnlock {
  type Deleter (line 98) | struct Deleter {
  type LockingDeleter (line 110) | struct LockingDeleter {
  function ABSL_ATTRIBUTE_REINITIALIZES (line 146) | ABSL_ATTRIBUTE_REINITIALIZES void reset() {
  function T (line 155) | T* get() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function T (line 159) | const T* get() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function namespace (line 222) | namespace py_internal {
  function class (line 278) | class Identifier : public py_internal::StaticObject {
  function class (line 318) | class ImportedConstant : public py_internal::StaticObject {
  function T (line 379) | const T* get() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function PythonPtr (line 394) | inline PythonPtr IntToPython(long value) {
  function PythonPtr (line 401) | inline PythonPtr BytesToPython(absl::string_view value) {
  function class (line 410) | class MemoryView {
  function class (line 451) | class BytesLike {

FILE: python/riegeli/bytes/python_reader.cc
  type riegeli::python (line 45) | namespace riegeli::python {

FILE: python/riegeli/bytes/python_reader.h
  function namespace (line 39) | namespace riegeli::python {
  function Traverse (line 174) | inline int PythonReader::Traverse(visitproc visit, void* arg) {

FILE: python/riegeli/bytes/python_writer.cc
  type riegeli::python (line 44) | namespace riegeli::python {

FILE: python/riegeli/bytes/python_writer.h
  function namespace (line 37) | namespace riegeli::python {
  function Traverse (line 164) | inline int PythonWriter::Traverse(visitproc visit, void* arg) {

FILE: python/riegeli/records/examples/write_read_records.py
  function sample_string (line 22) | def sample_string(i, size):
  function sample_message (line 28) | def sample_message(i, size):
  function write_records (line 32) | def write_records(filename):
  function read_records (line 42) | def read_records(filename):
  function main (line 58) | def main():

FILE: python/riegeli/records/record_position.cc
  type riegeli::python (line 42) | namespace riegeli::python {
    type PyRecordPositionObject (line 46) | struct PyRecordPositionObject {
    function RecordPositionDestructor (line 62) | static void RecordPositionDestructor(PyRecordPositionObject* self) {
    function PyRecordPositionObject (line 67) | static PyRecordPositionObject* RecordPositionNew(PyTypeObject* cls,
    function PyObject (line 101) | static PyObject* RecordPositionChunkBegin(PyRecordPositionObject* self,
    function PyObject (line 108) | static PyObject* RecordPositionRecordIndex(PyRecordPositionObject* self,
    function PyObject (line 115) | static PyObject* RecordPositionNumeric(PyRecordPositionObject* self,
    function PyObject (line 122) | static PyObject* RecordPositionCompare(PyObject* a, PyObject* b, int o...
    function Py_hash_t (line 155) | static Py_hash_t RecordPositionHash(PyRecordPositionObject* self) {
    function PyObject (line 163) | static PyObject* RecordPositionStr(PyRecordPositionObject* self) {
    function PyRecordPositionObject (line 169) | static PyRecordPositionObject* RecordPositionFromStr(PyTypeObject* cls,
    function PyObject (line 195) | static PyObject* RecordPositionRepr(PyRecordPositionObject* self) {
    function PyObject (line 203) | static PyObject* RecordPositionToBytes(PyRecordPositionObject* self,
    function PyRecordPositionObject (line 210) | static PyRecordPositionObject* RecordPositionFromBytes(PyTypeObject* cls,
    function PythonPtr (line 380) | PythonPtr RecordPositionToPython(FutureRecordPosition value) {
    function RecordPositionFromPython (line 388) | std::optional<RecordPosition> RecordPositionFromPython(PyObject* objec...
    function PyObject (line 416) | PyObject* InitModule() {
    function PyMODINIT_FUNC (line 441) | PyMODINIT_FUNC PyInit_record_position() { return InitModule(); }

FILE: python/riegeli/records/record_position.h
  function namespace (line 30) | namespace riegeli::python {

FILE: python/riegeli/records/record_reader.cc
  type riegeli::python (line 46) | namespace riegeli::python {
    function PyObject (line 58) | static PyObject* GetRecordType(PyObject* self, PyObject* args,
    type PyRecordReaderObject (line 121) | struct PyRecordReaderObject {
    type PyRecordIterObject (line 134) | struct PyRecordIterObject {
    function RecordReaderHasException (line 147) | bool RecordReaderHasException(PyRecordReaderObject* self) {
    function SetExceptionFromRecordReader (line 151) | void SetExceptionFromRecordReader(PyRecordReaderObject* self) {
    function VerifyFieldNumber (line 166) | std::optional<int> VerifyFieldNumber(long field_number_value) {
    function FieldNumberFromPython (line 178) | std::optional<int> FieldNumberFromPython(PyObject* object) {
    function FieldProjectionFromPython (line 191) | std::optional<FieldProjection> FieldProjectionFromPython(PyObject* obj...
    function RecordReaderDestructor (line 218) | static void RecordReaderDestructor(PyRecordReaderObject* self) {
    function RecordReaderTraverse (line 232) | static int RecordReaderTraverse(PyRecordReaderObject* self, visitproc ...
    function RecordReaderClear (line 248) | static int RecordReaderClear(PyRecordReaderObject* self) {
    function RecordReaderInit (line 255) | static int RecordReaderInit(PyRecordReaderObject* self, PyObject* args,
    function PyObject (line 382) | static PyObject* RecordReaderSrc(PyRecordReaderObject* self, void* clo...
    function PyObject (line 390) | static PyObject* RecordReaderRepr(PyRecordReaderObject* self) {
    function PyObject (line 402) | static PyObject* RecordReaderEnter(PyObject* self, PyObject* args) {
    function PyObject (line 408) | static PyObject* RecordReaderExit(PyRecordReaderObject* self, PyObject...
    function PyObject (line 428) | static PyObject* RecordReaderClose(PyRecordReaderObject* self, PyObjec...
    function PyObject (line 440) | static PyObject* RecordReaderCheckFileFormat(PyRecordReaderObject* self,
    function PyObject (line 455) | static PyObject* RecordReaderReadMetadata(PyRecordReaderObject* self,
    function PyObject (line 504) | static PyObject* RecordReaderReadSerializedMetadata(PyRecordReaderObje...
    function PyObject (line 520) | static PyObject* RecordReaderReadRecord(PyRecordReaderObject* self,
    function PyObject (line 536) | static PyObject* RecordReaderReadMessage(PyRecordReaderObject* self,
    function PyRecordIterObject (line 592) | static PyRecordIterObject* RecordReaderReadRecords(PyRecordReaderObjec...
    function PyRecordIterObject (line 606) | static PyRecordIterObject* RecordReaderReadMessages(PyRecordReaderObje...
    function PyObject (line 629) | static PyObject* RecordReaderSetFieldProjection(PyRecordReaderObject* ...
    function PyObject (line 658) | static PyObject* RecordReaderLastPos(PyRecordReaderObject* self,
    function PyObject (line 671) | static PyObject* RecordReaderPos(PyRecordReaderObject* self, void* clo...
    function PyObject (line 678) | static PyObject* RecordReaderSupportsRandomAccess(PyRecordReaderObject...
    function PyObject (line 684) | static PyObject* RecordReaderSeek(PyRecordReaderObject* self, PyObject...
    function PyObject (line 706) | static PyObject* RecordReaderSeekNumeric(PyRecordReaderObject* self,
    function PyObject (line 727) | static PyObject* RecordReaderSeekBack(PyRecordReaderObject* self,
    function PyObject (line 742) | static PyObject* RecordReaderSize(PyRecordReaderObject* self, PyObject...
    function PyObject (line 753) | static PyObject* RecordReaderSearch(PyRecordReaderObject* self, PyObje...
    function PyObject (line 793) | static PyObject* RecordReaderSearchForRecord(PyRecordReaderObject* self,
    function PyObject (line 843) | static PyObject* RecordReaderSearchForMessage(PyRecordReaderObject* self,
    function RecordIterDestructor (line 1385) | static void RecordIterDestructor(PyRecordIterObject* self) {
    function RecordIterTraverse (line 1398) | static int RecordIterTraverse(PyRecordIterObject* self, visitproc visit,
    function RecordIterClear (line 1405) | static int RecordIterClear(PyRecordIterObject* self) {
    function PyObject (line 1411) | static PyObject* RecordIterNext(PyRecordIterObject* self) {
    function PyObject (line 1511) | PyObject* InitModule() {
    function PyMODINIT_FUNC (line 1537) | PyMODINIT_FUNC PyInit_record_reader() { return InitModule(); }

FILE: python/riegeli/records/record_writer.cc
  type riegeli::python (line 39) | namespace riegeli::python {
    function PythonPtr (line 48) | PythonPtr DefineFlushType() {
    function FlushTypeFromPython (line 61) | bool FlushTypeFromPython(PyObject* object, FlushType* value) {
    class FileDescriptorCollector (line 78) | class FileDescriptorCollector {
      method Init (line 80) | bool Init(PyObject* file_descriptors) {
      method AddFile (line 86) | bool AddFile(PyObject* file_descriptor) {
    function PyObject (line 133) | static PyObject* SetRecordType(PyObject* self, PyObject* args,
    type PyRecordWriterObject (line 190) | struct PyRecordWriterObject {
    function SetExceptionFromRecordWriter (line 201) | void SetExceptionFromRecordWriter(PyRecordWriterObject* self) {
    function RecordWriterDestructor (line 217) | static void RecordWriterDestructor(PyRecordWriterObject* self) {
    function RecordWriterTraverse (line 225) | static int RecordWriterTraverse(PyRecordWriterObject* self, visitproc ...
    function RecordWriterClear (line 233) | static int RecordWriterClear(PyRecordWriterObject* self) {
    function RecordWriterInit (line 238) | static int RecordWriterInit(PyRecordWriterObject* self, PyObject* args,
    function PyObject (line 347) | static PyObject* RecordWriterDest(PyRecordWriterObject* self, void* cl...
    function PyObject (line 355) | static PyObject* RecordWriterRepr(PyRecordWriterObject* self) {
    function PyObject (line 367) | static PyObject* RecordWriterEnter(PyObject* self, PyObject* args) {
    function PyObject (line 373) | static PyObject* RecordWriterExit(PyRecordWriterObject* self, PyObject...
    function PyObject (line 393) | static PyObject* RecordWriterClose(PyRecordWriterObject* self, PyObjec...
    function PyObject (line 405) | static PyObject* RecordWriterWriteRecord(PyRecordWriterObject* self,
    function PyObject (line 426) | static PyObject* RecordWriterWriteMessage(PyRecordWriterObject* self,
    function PyObject (line 454) | static PyObject* RecordWriterWriteRecords(PyRecordWriterObject* self,
    function PyObject (line 484) | static PyObject* RecordWriterWriteMessages(PyRecordWriterObject* self,
    function PyObject (line 518) | static PyObject* RecordWriterFlush(PyRecordWriterObject* self, PyObjec...
    function PyObject (line 543) | static PyObject* RecordWriterLastPos(PyRecordWriterObject* self,
    function PyObject (line 556) | static PyObject* RecordWriterPos(PyRecordWriterObject* self, void* clo...
    function PyObject (line 563) | static PyObject* RecordWriterEstimatedSize(PyRecordWriterObject* self,
    function PyObject (line 878) | PyObject* InitModule() {
    function PyMODINIT_FUNC (line 901) | PyMODINIT_FUNC PyInit_record_writer() { return InitModule(); }

FILE: python/riegeli/records/skipped_region.py
  class SkippedRegion (line 19) | class SkippedRegion:
    method __init__ (line 31) | def __init__(self, begin, end, message):
    method length (line 39) | def length(self):
    method __str__ (line 42) | def __str__(self):
    method __repr__ (line 45) | def __repr__(self):

FILE: python/riegeli/records/tests/records_test.py
  function combine_named_parameters (line 29) | def combine_named_parameters(*testcase_sets):
  class RandomAccess (line 45) | class RandomAccess(Enum):
  class FakeFile (line 51) | class FakeFile:
    method __init__ (line 54) | def __init__(self, random_access):
    method seekable (line 57) | def seekable(self):
    method tell (line 60) | def tell(self):
    method __getattr__ (line 65) | def __getattr__(self, name):
  class UnseekableWrapper (line 69) | class UnseekableWrapper:
    method __init__ (line 72) | def __init__(self, wrapped):
    method seekable (line 75) | def seekable(self):
    method tell (line 78) | def tell(self, *args):
    method seek (line 81) | def seek(self, *args):
    method __getattr__ (line 84) | def __getattr__(self, name):
  class FileSpecBase (line 88) | class FileSpecBase(metaclass=abc.ABCMeta):
    method __init__ (line 91) | def __init__(self, create_tempfile, random_access):
    method _open_for_writing (line 96) | def _open_for_writing(self):
    method writing_open (line 99) | def writing_open(self):
    method writing_should_close (line 108) | def writing_should_close(self):
    method writing_assumed_pos (line 112) | def writing_assumed_pos(self):
    method _open_for_reading (line 118) | def _open_for_reading(self):
    method reading_open (line 121) | def reading_open(self):
    method reading_should_close (line 130) | def reading_should_close(self):
    method reading_assumed_pos (line 134) | def reading_assumed_pos(self):
    method close (line 139) | def close(self):
  class BytesIOSpec (line 143) | class BytesIOSpec(FileSpecBase):
    method _open_for_writing (line 146) | def _open_for_writing(self):
    method writing_should_close (line 150) | def writing_should_close(self):
    method _open_for_reading (line 154) | def _open_for_reading(self):
  class LocalFileSpecBase (line 160) | class LocalFileSpecBase(FileSpecBase):
    method __init__ (line 163) | def __init__(self, create_tempfile, random_access):
  class FileIOSpec (line 168) | class FileIOSpec(LocalFileSpecBase):
    method _open_for_writing (line 171) | def _open_for_writing(self):
    method _open_for_reading (line 174) | def _open_for_reading(self):
  class BufferedIOSpec (line 178) | class BufferedIOSpec(LocalFileSpecBase):
    method _open_for_writing (line 181) | def _open_for_writing(self):
    method _open_for_reading (line 184) | def _open_for_reading(self):
  class BuiltinFileSpec (line 188) | class BuiltinFileSpec(LocalFileSpecBase):
    method _open_for_writing (line 191) | def _open_for_writing(self):
    method _open_for_reading (line 194) | def _open_for_reading(self):
  function sample_string (line 198) | def sample_string(i, size):
  function sample_message (line 204) | def sample_message(i, size):
  function sample_message_id_only (line 208) | def sample_message_id_only(i):
  function sample_invalid_message (line 212) | def sample_invalid_message(size):
  function record_writer_options (line 216) | def record_writer_options(parallelism, transpose=False, chunk_size=35000):
  class RecordsTest (line 261) | class RecordsTest(parameterized.TestCase):
    method corrupt_at (line 263) | def corrupt_at(self, files, index):
    method test_record_writer_exception_from_file (line 279) | def test_record_writer_exception_from_file(self, random_access, parall...
    method test_record_reader_exception_from_file (line 294) | def test_record_reader_exception_from_file(self, random_access):
    method test_write_read_record (line 309) | def test_write_read_record(self, file_spec, random_access, parallelism):
    method test_write_read_message (line 348) | def test_write_read_message(self, file_spec, random_access, parallelism):
    method test_write_read_records (line 390) | def test_write_read_records(self, file_spec, random_access, parallelism):
    method test_write_read_messages (line 412) | def test_write_read_messages(self, file_spec, random_access, paralleli...
    method test_write_read_messages_with_field_projection (line 434) | def test_write_read_messages_with_field_projection(
    method test_write_read_messages_with_field_projection_later (line 463) | def test_write_read_messages_with_field_projection_later(
    method test_write_read_metadata (line 507) | def test_write_read_metadata(self, file_spec, random_access, paralleli...
    method test_invalid_metadata_exception (line 547) | def test_invalid_metadata_exception(
    method test_invalid_metadata_recovery (line 570) | def test_invalid_metadata_recovery(
    method test_invalid_metadata_recovery_stop_iteration (line 597) | def test_invalid_metadata_recovery_stop_iteration(
    method test_field_projection (line 624) | def test_field_projection(self, file_spec, random_access, parallelism):
    method test_field_projection_existence_only (line 654) | def test_field_projection_existence_only(
    method test_seek (line 694) | def test_seek(self, file_spec, parallelism):
    method test_seek_numeric (line 758) | def test_seek_numeric(self, file_spec, parallelism):
    method test_seek_back (line 822) | def test_seek_back(self, file_spec):
    method test_search (line 849) | def test_search(self, file_spec):
    method test_search_for_record (line 890) | def test_search_for_record(self, file_spec):
    method test_search_for_record_stop_iteration (line 931) | def test_search_for_record_stop_iteration(self, file_spec):
    method test_search_for_message (line 957) | def test_search_for_message(self, file_spec):
    method test_search_for_message_stop_iteration (line 1018) | def test_search_for_message_stop_iteration(self, file_spec):
    method test_search_for_invalid_message_exception (line 1046) | def test_search_for_invalid_message_exception(self, file_spec):
    method test_search_for_invalid_message_recovery (line 1081) | def test_search_for_invalid_message_recovery(self, file_spec):
    method test_search_for_invalid_message_recovery_stop_iteration (line 1129) | def test_search_for_invalid_message_recovery_stop_iteration(self, file...
    method test_corruption_exception (line 1175) | def test_corruption_exception(self, file_spec, random_access, parallel...
    method test_corruption_recovery (line 1205) | def test_corruption_recovery(self, file_spec, random_access, paralleli...
    method test_corruption_recovery_stop_iteration (line 1241) | def test_corruption_recovery_stop_iteration(
    method test_corruption_recovery_exception (line 1281) | def test_corruption_recovery_exception(
    method test_invalid_message_exception (line 1316) | def test_invalid_message_exception(
    method test_invalid_message_recovery (line 1366) | def test_invalid_message_recovery(
    method test_invalid_message_recovery_stop_iteration (line 1428) | def test_invalid_message_recovery_stop_iteration(

FILE: python/riegeli/tensorflow/kernel_tests/riegeli_dataset_test.py
  class DatasetTestBase (line 33) | class DatasetTestBase(test.TestCase):
    method assertValuesEqual (line 36) | def assertValuesEqual(self, expected, actual):
    method getNext (line 45) | def getNext(self, dataset, requires_initialization=False, shared_name=...
    method _compareOutputToExpected (line 92) | def _compareOutputToExpected(
    method assertDatasetProduces (line 105) | def assertDatasetProduces(
  class RiegeliDatasetTest (line 181) | class RiegeliDatasetTest(DatasetTestBase):
    method setUp (line 183) | def setUp(self):
    method dataset_fn (line 190) | def dataset_fn(self, filenames, num_epochs=1, batch_size=None):
    method _record (line 198) | def _record(self, f, r):
    method _create_files (line 201) | def _create_files(self):
    method test_read_one_epoch (line 214) | def test_read_one_epoch(self):
    method test_read_ten_epochs (line 238) | def test_read_ten_epochs(self):
    method test_read_ten_epochs_of_batches (line 247) | def test_read_ten_epochs_of_batches(self):

FILE: python/riegeli/tensorflow/ops/riegeli_dataset_ops.py
  class RiegeliDataset (line 31) | class RiegeliDataset(dataset_ops.DatasetSource):
    method __init__ (line 36) | def __init__(
    method element_spec (line 78) | def element_spec(self):

FILE: python/setup.py
  class BinaryDistribution (line 23) | class BinaryDistribution(dist.Distribution):
    method has_ext_modules (line 26) | def has_ext_modules(self):

FILE: riegeli/base/any.h
  function namespace (line 48) | namespace riegeli {
  function friend (line 125) | friend void RiegeliRegisterSubobjects(const AnyBase* self,
  function namespace (line 554) | namespace any_internal {

FILE: riegeli/base/any_initializer.h
  function namespace (line 34) | namespace riegeli {

FILE: riegeli/base/any_internal.h
  function namespace (line 37) | namespace riegeli {
  function Handle (line 229) | Handle SentinelHandle() {
  function Move (line 240) | static void Move(ABSL_ATTRIBUTE_UNUSED Storage src,
  function IsOwning (line 246) | static bool IsOwning(ABSL_ATTRIBUTE_UNUSED const Storage self) {
  function RegisterSubobjects (line 249) | static void RegisterSubobjects(
  function Destroy (line 267) | static void Destroy(ABSL_ATTRIBUTE_UNUSED Storage self) {}
  function Move (line 268) | static void Move(Storage src, Storage dest,
  function IsOwning (line 274) | static bool IsOwning(const Storage self) { return dep_ptr(self)->IsOwnin...
  function TypeErasedRef (line 275) | static TypeErasedRef GetRawManager(const Storage self) {
  function RegisterSubobjects (line 278) | static void RegisterSubobjects(
  function Destroy (line 311) | static void Destroy(Storage self) { delete dep_ptr(self); }
  function Move (line 312) | static void Move(Storage src, Storage dest,
  function MakeReference (line 318) | static void MakeReference(Storage src, Storage dest,
  function IsOwning (line 325) | static bool IsOwning(const Storage self) { return dep_ptr(self)->IsOwnin...
  function TypeErasedRef (line 326) | static TypeErasedRef GetRawManager(const Storage self) {
  function RegisterSubobjects (line 329) | static void RegisterSubobjects(const Storage self,
  function Destroy (line 369) | static void Destroy(Storage self) {
  function Move (line 372) | static void Move(Storage src, Storage dest,
  function MoveToHeap (line 379) | static void MoveToHeap(Storage src, Storage dest,
  function MakeReference (line 388) | static void MakeReference(Storage src, Storage dest,
  function IsOwning (line 395) | static bool IsOwning(const Storage self) { return dep(self).IsOwning(); }
  function TypeErasedRef (line 396) | static TypeErasedRef GetRawManager(const Storage self) {
  function RegisterSubobjects (line 399) | static void RegisterSubobjects(const Storage self,

FILE: riegeli/base/arithmetic.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 30) | ABSL_POINTERS_DEFAULT_NONNULL
  function A (line 148) | A SignedMin(A a) {
  function A (line 173) | A SignedMax(A a) {
  function A (line 198) | A UnsignedMin(A a) {
  function A (line 223) | A UnsignedMax(A a) {
  function A (line 266) | A SaturatingIntCast(B value) {
  function A (line 276) | A SaturatingIntCast(B value) {
  function A (line 288) | A SaturatingIntCast(B value) {
  function A (line 299) | A SaturatingIntCast(B value) {
  function T (line 313) | T SaturatingAdd() {
  function T (line 318) | T SaturatingAdd(T a) {
  function T (line 323) | T SaturatingAdd(T a, T b) {
  function T (line 335) | T SaturatingAdd(T a, T b, Rest... rest) {
  function T (line 344) | T SaturatingSub(T a, U b) {
  function T (line 357) | T RoundDown(T value) {

FILE: riegeli/base/assert.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 23) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/assert.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 32) | ABSL_POINTERS_DEFAULT_NONNULL
  function AssertInitialized (line 506) | inline void AssertInitialized(ABSL_ATTRIBUTE_UNUSED const char* data,
  function MarkPoisoned (line 515) | inline void MarkPoisoned(ABSL_ATTRIBUTE_UNUSED const char* data,

FILE: riegeli/base/background_cleaning.cc
  type riegeli (line 25) | namespace riegeli {
    type Args (line 58) | struct Args {
    function ABSL_EXCLUSIVE_LOCKS_REQUIRED (line 114) | ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {

FILE: riegeli/base/background_cleaning.h
  function namespace (line 26) | namespace riegeli {

FILE: riegeli/base/binary_search.h
  function namespace (line 28) | namespace riegeli {
  function T (line 309) | T Next(T current) const { return current + 1; }
  function Empty (line 312) | bool Empty(T low, T high) const { return low >= high; }
  function namespace (line 325) | namespace binary_search_internal {
  function PartialOrdering (line 350) | static PartialOrdering DoCancel(ABSL_ATTRIBUTE_UNUSED const Pos& pos) {
  function PartialOrdering (line 353) | static PartialOrdering DoNotCancel(Ordering ordering) {
  function SearchGuide (line 363) | static SearchGuide<Pos> DoNotCancel(SearchGuide<OtherPos>&& guide) {

FILE: riegeli/base/buffer.cc
  type riegeli (line 22) | namespace riegeli {

FILE: riegeli/base/buffer.h
  function namespace (line 31) | namespace riegeli {
  function Reset (line 109) | inline void Buffer::Reset(size_t min_capacity) {
  function AllocateInternal (line 119) | inline void Buffer::AllocateInternal(size_t min_capacity) {

FILE: riegeli/base/buffering.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 27) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/byte_fill.cc
  type riegeli (line 41) | namespace riegeli {

FILE: riegeli/base/byte_fill.h
  function namespace (line 41) | namespace riegeli {
  function ExternalDelegate (line 563) | void ByteFill::Blocks::ExternalDelegate(absl::string_view substr,

FILE: riegeli/base/bytes_ref.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 35) | ABSL_POINTERS_DEFAULT_NONNULL
  function class (line 140) | class BytesInitializer : public Initializer<std::string> {

FILE: riegeli/base/c_string_ref.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 31) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/chain.cc
  type riegeli (line 53) | namespace riegeli {
    class FlatCordBlock (line 62) | class FlatCordBlock {
      method FlatCordBlock (line 66) | FlatCordBlock(FlatCordBlock&& that) = default;
      method FlatCordBlock (line 67) | FlatCordBlock& operator=(FlatCordBlock&& that) = default;
      method RiegeliDumpStructure (line 74) | void RiegeliDumpStructure(
      method RiegeliRegisterSubobjects (line 81) | void RiegeliRegisterSubobjects(const FlatCordBlock* self,
    type chain_internal (line 109) | namespace chain_internal {
      function DumpStructureDefault (line 111) | void DumpStructureDefault(std::ostream& dest) { dest << "[external] ...
    function RiegeliDumpStructure (line 115) | void RiegeliDumpStructure(const std::string* self, std::ostream& dest) {
    function Chain (line 355) | Chain& Chain::operator=(const Chain& that) {
    function swap (line 1942) | void swap(Chain& a, Chain& b) noexcept {
    function StrongOrdering (line 1958) | StrongOrdering Chain::Compare(const Chain& a, const Chain& b) {
    function StrongOrdering (line 1996) | StrongOrdering Chain::Compare(const Chain& a, absl::string_view b) {

FILE: riegeli/base/chain_base.h
  function namespace (line 51) | namespace riegeli {

FILE: riegeli/base/chain_details.h
  function namespace (line 54) | namespace riegeli {
  function DynamicSizeOf (line 506) | size_t Chain::ExternalMethodsFor<T>::DynamicSizeOf() {
  function kInternalAllocatedOffset (line 537) | constexpr size_t Chain::RawBlock::kInternalAllocatedOffset() {
  function kExternalObjectOffset (line 542) | size_t Chain::RawBlock::kExternalObjectOffset() {
  function kExternalAllocatedSize (line 548) | size_t Chain::RawBlock::kExternalAllocatedSize() {
  function Unref (line 559) | void Chain::RawBlock::Unref() {
  function T (line 599) | const T* Chain::RawBlock::checked_external_object() const {
  function TryClear (line 614) | inline bool Chain::RawBlock::TryClear() {
  function TryRemoveSuffix (line 622) | inline bool Chain::RawBlock::TryRemoveSuffix(size_t length) {
  function TryRemovePrefix (line 633) | inline bool Chain::RawBlock::TryRemovePrefix(size_t length) {
  function Chain (line 652) | inline const Chain::BlockPtr* Chain::BlockPtrPtr::as_ptr() const {
  function ExternalDelegate (line 719) | void Chain::BlockRef::ExternalDelegate(absl::string_view substr,
  function T (line 729) | const T* Chain::BlockRef::external_object() const {
  function Chain (line 746) | inline Chain::BlockIterator::BlockIterator(const Chain* chain, BlockPtrP...
  function else (line 752) | else if (ptr_ == kEndShortData) {
  function CharIndexInChain (line 759) | inline size_t Chain::BlockIterator::CharIndexInChain(

FILE: riegeli/base/closing_ptr.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 23) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/compact_string.cc
  type riegeli (line 30) | namespace riegeli {

FILE: riegeli/base/compact_string.h
  function namespace (line 41) | namespace riegeli {
  function StrongOrdering (line 302) | StrongOrdering RIEGELI_COMPARE(const CompactString& a, T&& b) {
  function HashState (line 307) | HashState AbslHashValue(HashState hash_state,
  function friend (line 324) | friend void AbslFormatFlush(CompactString* dest, absl::string_view src) {
  function friend (line 331) | friend void RiegeliSupportsExternalRef(CompactString*) {}
  function friend (line 334) | friend bool RiegeliExternalCopy(const CompactString* self) {
  function friend (line 339) | friend ExternalStorage RiegeliToExternalStorage(CompactString* self) {
  function friend (line 353) | friend void RiegeliDumpStructure(const CompactString* self,
  function RiegeliRegisterSubobjects (line 361) | void RiegeliRegisterSubobjects(const CompactString* self,
  type FromReprTag (line 367) | struct FromReprTag {
  function explicit (line 371) | explicit CompactString(FromReprTag, uintptr_t raw) : repr_(raw) {}
  function inline_size (line 406) | static size_t inline_size(uintptr_t repr) {
  function allocated_size_for_tag (line 428) | size_t allocated_size_for_tag(uintptr_t tag) const {
  function allocated_size_for_tag (line 432) | static size_t allocated_size_for_tag(uintptr_t tag, uintptr_t repr) {
  function allocated_size (line 445) | size_t allocated_size(uintptr_t repr) {
  function set_allocated_size (line 470) | void set_allocated_size(size_t size, uintptr_t repr) {
  function allocated_capacity_for_tag (line 481) | size_t allocated_capacity_for_tag(uintptr_t tag) const {
  function allocated_capacity_for_tag (line 485) | static size_t allocated_capacity_for_tag(uintptr_t tag, uintptr_t repr) {
  function allocated_capacity (line 498) | size_t allocated_capacity(uintptr_t repr) {
  function const (line 555) | struct CompactStringHash {
  function const (line 564) | struct CompactStringEq {
  function const (line 572) | bool operator()(absl::string_view a, const CompactString& b) const {
  function const (line 575) | bool operator()(absl::string_view a, absl::string_view b) const {
  function MakeRepr (line 582) | inline uintptr_t CompactString::MakeRepr(size_t size, size_t capacity) {
  function CompactString (line 628) | inline CompactString::CompactString(const CompactString& that) {
  function size (line 678) | inline size_t CompactString::size() const {
  function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 695) | inline char& CompactString::operator[](size_t index)
  function const (line 702) | inline const char& CompactString::operator[](size_t index) const
  function at (line 709) | inline char& CompactString::at(size_t index) ABSL_ATTRIBUTE_LIFETIME_BOU...
  function at (line 715) | inline const char& CompactString::at(size_t index) const
  function front (line 722) | inline char& CompactString::front() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function set_size (line 746) | inline void CompactString::set_size(size_t new_size) {
  function set_allocated_size_for_tag (line 757) | inline void CompactString::set_allocated_size_for_tag(uintptr_t tag,
  function resize (line 778) | inline void CompactString::resize(size_t new_size) {
  function reserve (line 811) | inline void CompactString::reserve(size_t min_capacity) {
  function shrink_to_fit (line 817) | inline void CompactString::shrink_to_fit() {
  function append (line 834) | inline void CompactString::append(absl::string_view src) {
  function RegisterSubobjects (line 889) | void CompactString::RegisterSubobjects(

FILE: riegeli/base/compare.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 26) | ABSL_POINTERS_DEFAULT_NONNULL
  function namespace (line 93) | namespace compare_internal {
  function PartialOrdering (line 126) | PartialOrdering AsPartialOrdering(T ordering) {
  function PartialOrdering (line 135) | PartialOrdering AsPartialOrdering(T ordering) {
  function StrongOrdering (line 149) | StrongOrdering AsStrongOrdering(T ordering) {
  function StrongOrdering (line 159) | StrongOrdering AsStrongOrdering(T ordering) {
  function StrongOrdering (line 173) | StrongOrdering RIEGELI_COMPARE(A a, B b) {
  function PartialOrdering (line 185) | PartialOrdering RIEGELI_COMPARE(A a, B b) {
  function StrongOrdering (line 196) | StrongOrdering RIEGELI_COMPARE(T a, T b) {
  function StrongOrdering (line 203) | StrongOrdering RIEGELI_COMPARE(T* a, T* b) {
  function StrongOrdering (line 209) | inline StrongOrdering RIEGELI_COMPARE(absl::string_view a,
  function Ordering (line 291) | Ordering NegateOrdering(Ordering ordering) {
  function Ordering (line 306) | Ordering NegateOrdering(Ordering ordering) {

FILE: riegeli/base/constexpr.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 21) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/cord_iterator_span.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 30) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/cord_iterator_span.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 34) | ABSL_POINTERS_DEFAULT_NONNULL
  function CordIteratorSpan (line 111) | const CordIteratorSpan& manager() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function Read (line 134) | inline void CordIteratorSpan::Read(absl::Cord::CharIterator& src, size_t...

FILE: riegeli/base/cord_utils.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 30) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/cord_utils.h
  function MaxBytesToCopyToCord (line 65) | inline size_t MaxBytesToCopyToCord(absl::Cord& dest) {
  function CordBufferSizeForCapacity (line 92) | inline size_t CordBufferSizeForCapacity(size_t capacity) {

FILE: riegeli/base/debug.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 29) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/debug.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 36) | ABSL_POINTERS_DEFAULT_NONNULL
  function Write (line 106) | void Write(char src) { dest_->write(&src, 1); }
  function Write (line 109) | void Write(absl::string_view src) {
  function else (line 139) | else if constexpr (debug_internal::HasOperatorOutput<T>::value) {
  function DebugStringQuote (line 161) | void DebugStringQuote() { Write('"'); }
  function RiegeliDebug (line 176) | inline void RiegeliDebug(signed char src, DebugStream& dest) {
  function src_ (line 269) | DebugType(const T& src) : src_(src) {}

FILE: riegeli/base/dependency.h
  function namespace (line 33) | namespace riegeli {
  function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 503) | const
  function namespace (line 649) | namespace dependency_internal {
  function namespace (line 681) | namespace dependency_internal {
  function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 721) | const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function AssertNotNull (line 763) | void AssertNotNull(Subhandle handle, absl::string_view message) {
  function AssertNotNull (line 770) | void AssertNotNull(ABSL_ATTRIBUTE_UNUSED Subhandle handle,
  function namespace (line 795) | namespace dependency_internal {

FILE: riegeli/base/dependency_base.h
  function namespace (line 28) | namespace riegeli {
  function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 154) | const ABSL_ATTRIBUTE_LIFETIME_BOUND { return manager_; }
  function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 164) | const ABSL_ATTRIBUTE_LIFETIME_BOUND {

FILE: riegeli/base/dependency_manager.h
  function namespace (line 28) | namespace riegeli {
  function T (line 134) | T* ptr() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return this->manager().ge...
  function T (line 159) | T* ptr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function namespace (line 165) | namespace dependency_manager_internal {
  function Manager (line 245) | Manager* ptr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function Manager (line 307) | Manager* ptr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function Manager (line 369) | Manager* ptr() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function namespace (line 374) | namespace dependency_manager_internal {

FILE: riegeli/base/errno_mapping.cc
  type riegeli (line 37) | namespace riegeli {
    function WindowsErrorToStatusCode (line 43) | absl::StatusCode WindowsErrorToStatusCode(DWORD error_number) {
    function StatusCodeToErrno (line 115) | int StatusCodeToErrno(absl::StatusCode status_code) {
    function WindowsErrorToStatus (line 168) | absl::Status WindowsErrorToStatus(uint32_t error_number,

FILE: riegeli/base/errno_mapping.h
  function namespace (line 27) | namespace riegeli {

FILE: riegeli/base/estimated_allocated_size.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 24) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/external_data.cc
  type riegeli (line 21) | namespace riegeli {
    function ExternalData (line 23) | ExternalData ExternalDataCopy(absl::string_view data) {

FILE: riegeli/base/external_data.h
  function namespace (line 23) | namespace riegeli {

FILE: riegeli/base/external_ref_base.h
  function namespace (line 41) | namespace riegeli {
  function CallOperatorWhole (line 293) | void CallOperatorWhole(ABSL_ATTRIBUTE_UNUSED T&& object) {}
  function CallOperatorSubstr (line 336) | void CallOperatorSubstr(
  function AssertSubstr (line 348) | void AssertSubstr(const T& object, absl::string_view substr) {
  function AssertSubstr (line 366) | static void AssertSubstr(ABSL_ATTRIBUTE_UNUSED const T& object,
  function string_view (line 516) | string_view data) {
  function string_view (line 526) | string_view substr) {
  function substr_ (line 1119) | object_(std::move(object)), substr_(substr) {
  function class (line 1468) | class StorageBase {
  function StorageWholeWithoutCallOperator (line 1509) | StorageWholeWithoutCallOperator final : public StorageBase {
  function StorageWholeWithCallOperator (line 1567) | StorageWholeWithCallOperator final : public StorageBase {
  function StorageSubstrWithoutCallOperator (line 1634) | StorageSubstrWithoutCallOperator final : public StorageBase {
  function StorageSubstrWithCallOperator (line 1686) | StorageSubstrWithCallOperator final : public StorageBase {
  function friend (line 1911) | friend void RiegeliReset(absl::Cord& dest, ExternalRef src) {
  function ExternalData (line 1943) | ExternalData result{ExternalStorage(nullptr, nullptr), absl::string_view()}
  function explicit (line 1958) | explicit ExternalRef(StorageBase* storage) : storage_(storage) {}
  function InitializeTo (line 1962) | void InitializeTo(Chain& dest) && {
  function Options (line 2012) | Options options) && {
  function Options (line 2038) | Options options) && {
  type ChainWithOptions (line 2053) | struct ChainWithOptions {

FILE: riegeli/base/external_ref_support.h
  function namespace (line 30) | namespace riegeli {

FILE: riegeli/base/global.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 24) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/hybrid_direct_common.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 27) | ABSL_POINTERS_DEFAULT_NONNULL
  function Key (line 100) | Key FromRawKey(RawKey raw_key) {
  function Key (line 125) | static Key FromRawKey(RawKey raw_key) {
  function Key (line 149) | static Key FromRawKey(RawKey raw_key) {

FILE: riegeli/base/hybrid_direct_internal.h
  function Abandon (line 68) | void Abandon() {}
  function explicit (line 94) | explicit SizedDeleter(size_t size) : size_(size) {}
  function const (line 104) | void operator()(T* ptr) const {
  function Index (line 249) | Index operator*() const { return index_; }

FILE: riegeli/base/hybrid_direct_map.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 43) | ABSL_POINTERS_DEFAULT_NONNULL
  function Key (line 273) | Key operator()(ElementTypeT<const Src&> entry) const { return entry.firs...
  function ABSL_ATTRIBUTE_REINITIALIZES (line 399) | ABSL_ATTRIBUTE_REINITIALIZES void Reset(
  function Reset (line 448) | void Reset(
  function namespace (line 462) | namespace hybrid_direct_internal {

FILE: riegeli/base/hybrid_direct_set.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 41) | ABSL_POINTERS_DEFAULT_NONNULL
  function Key (line 104) | Key operator()(ElementTypeT<const Src&> key) const { return key; }
  function Reset (line 196) | void Reset(
  function ABSL_ATTRIBUTE_REINITIALIZES (line 202) | ABSL_ATTRIBUTE_REINITIALIZES void Reset(
  function Reset (line 215) | void Reset(
  function Reset (line 228) | void Reset(
  function const_iterator (line 242) | const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function absl_nullable (line 274) | absl_nullable DirectSet CopyDirectSet() const;
  function explicit (line 358) | explicit iterator(const HybridDirectSet* set ABSL_ATTRIBUTE_LIFETIME_BOUND,

FILE: riegeli/base/initializer.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 35) | ABSL_POINTERS_DEFAULT_NONNULL
  type Methods (line 155) | struct Methods {
  function Methods (line 190) | const Methods* methods() const { return methods_; }
  type Methods (line 225) | struct Methods
  function explicit (line 258) | explicit InitializerAssignableBase(const Methods* methods)
  function Methods (line 269) | const Methods* methods() const {
  function T (line 287) | T Construct() && { return methods()->construct(context()); }
  type Methods (line 361) | struct Methods {
  function Methods (line 389) | const Methods* methods() const { return methods_; }
  function ABSL_NULLABILITY_COMPATIBLE (line 442) | ABSL_NULLABILITY_COMPATIBLE Initializer
  function namespace (line 608) | namespace initializer_internal {
  function namespace (line 654) | namespace initializer_internal {
  function namespace (line 694) | namespace initializer_internal {

FILE: riegeli/base/intrusive_shared_ptr.h
  function namespace (line 33) | namespace riegeli {
  function explicit (line 109) | explicit IntrusiveSharedPtr(T* ptr ABSL_ATTRIBUTE_LIFETIME_BOUND,
  function explicit (line 112) | explicit IntrusiveSharedPtr(T* ptr ABSL_ATTRIBUTE_LIFETIME_BOUND,
  function explicit (line 120) | explicit IntrusiveSharedPtr(Initializer<T> value) : ptr_(std::move(value...
  function ptr_ (line 160) | IntrusiveSharedPtr(const IntrusiveSharedPtr& that) noexcept
  function ABSL_ATTRIBUTE_REINITIALIZES (line 180) | ABSL_ATTRIBUTE_REINITIALIZES
  function T (line 246) | T* get() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return ptr_.get(); }
  type Unrefer (line 308) | struct Unrefer {
  function SubT (line 313) | SubT* Ref(SubT* ptr) {
  function ResetImpl (line 327) | void ResetImpl(Initializer<T> value) {

FILE: riegeli/base/invoker.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 29) | ABSL_POINTERS_DEFAULT_NONNULL
  function operator (line 136) | operator Result() && { return std::move(*this).Invoke(); }
  function operator (line 166) | operator Result() && { return std::move(*this).Invoke(); }
  function namespace (line 377) | namespace invoker_internal {

FILE: riegeli/base/iterable.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 28) | ABSL_POINTERS_DEFAULT_NONNULL
  function namespace (line 217) | namespace iterable_internal {
  function Reference (line 283) | const Reference* operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND {

FILE: riegeli/base/maker.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 31) | ABSL_POINTERS_DEFAULT_NONNULL
  function namespace (line 428) | namespace maker_internal {

FILE: riegeli/base/memory_estimator.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 32) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/memory_estimator.h
  function namespace (line 51) | namespace riegeli {
  function class (line 69) | class MemoryEstimator {
  function RegisterDynamicMemoryImpl (line 245) | void RegisterDynamicMemoryImpl(size_t memory) override {
  function RegisterUnknownTypeImpl (line 249) | void RegisterUnknownTypeImpl() override {}
  function RegisterUnknownTypeImpl (line 250) | void RegisterUnknownTypeImpl(
  function RegisterDynamicMemoryImpl (line 276) | void RegisterDynamicMemoryImpl(size_t memory) override {
  function RegisterNodeImpl (line 279) | bool RegisterNodeImpl(const void* absl_nullable ptr) override {
  function RegisterUnknownTypeImpl (line 282) | void RegisterUnknownTypeImpl() override {}
  function RegisterUnknownTypeImpl (line 283) | void RegisterUnknownTypeImpl(
  function class (line 295) | class MemoryEstimatorReportingUnknownTypes : public MemoryEstimatorDefau...
  function EstimateMemory (line 324) | size_t EstimateMemory(const T& object) {
  function EstimateMemorySimplified (line 334) | size_t EstimateMemorySimplified(const T& object) {
  type TotalMemoryWithUnknownTypes (line 345) | struct TotalMemoryWithUnknownTypes {
  function TotalMemoryWithUnknownTypes (line 351) | TotalMemoryWithUnknownTypes EstimateMemoryReportingUnknownTypes(

FILE: riegeli/base/moving_dependency.h
  function namespace (line 27) | namespace riegeli {
  function Done (line 160) | void Done(ABSL_ATTRIBUTE_UNUSED Mover& mover,

FILE: riegeli/base/new_aligned.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 31) | ABSL_POINTERS_DEFAULT_NONNULL
  function T (line 86) | T* NewAligned(size_t num_bytes, Args&&... args) {
  function DeleteAligned (line 101) | void DeleteAligned(T* ptr, size_t num_bytes) {
  function T (line 122) | T* SizeReturningNewAligned(size_t min_num_bytes,

FILE: riegeli/base/null_safe_memcpy.h
  function null_safe_memcpy (line 65) | __attribute__((no_sanitize("nonnull-attribute")))
  function null_safe_memmove (line 76) | __attribute__((no_sanitize("nonnull-attribute")))
  function null_safe_memset (line 87) | __attribute__((no_sanitize("nonnull-attribute")))

FILE: riegeli/base/object.cc
  type riegeli (line 26) | namespace riegeli {
    function ObjectState (line 28) | ObjectState& ObjectState::operator=(ObjectState&& that) noexcept {
    function TypeId (line 135) | TypeId Object::GetTypeId() const { return TypeId(); }

FILE: riegeli/base/object.h
  function namespace (line 29) | namespace riegeli {
  function Target (line 335) | const Target* Object::GetIf() const {

FILE: riegeli/base/optional_compact_string.h
  function namespace (line 33) | namespace riegeli {
  function explicit (line 66) | explicit OptionalCompactString(const CompactString& src)
  function explicit (line 77) | explicit OptionalCompactString(CompactString&& src)
  function repr_ (line 85) | OptionalCompactString(const OptionalCompactString& that) noexcept
  function CompactString (line 113) | CompactString Release() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 130) | const
  function StrongOrdering (line 187) | StrongOrdering RIEGELI_COMPARE(const OptionalCompactString& a, T&& b) {

FILE: riegeli/base/options_parser.cc
  type riegeli (line 36) | namespace riegeli {

FILE: riegeli/base/options_parser.h
  function namespace (line 34) | namespace riegeli {
  function Function (line 236) | Function ValueParser::And(Initializer<Function> function1,
  function Function (line 243) | Function ValueParser::FailIfSeen(StringInitializer key,
  function AddOption (line 249) | inline void OptionsParser::AddOption(

FILE: riegeli/base/ownership.h
  function namespace (line 20) | namespace riegeli {

FILE: riegeli/base/parallelism.cc
  type riegeli::internal (line 30) | namespace riegeli::internal {
    function ThreadPool (line 74) | ThreadPool& ThreadPool::global() {

FILE: riegeli/base/parallelism.h
  function namespace (line 27) | namespace riegeli::internal {

FILE: riegeli/base/recycling_pool.h
  function namespace (line 42) | namespace riegeli {

FILE: riegeli/base/ref_count.h
  function namespace (line 25) | namespace riegeli {

FILE: riegeli/base/reset.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 29) | ABSL_POINTERS_DEFAULT_NONNULL
  function else (line 135) | else if constexpr (reset_internal::HasAssignment<T, Args...>::value) {
  function else (line 138) | else if constexpr (std::conjunction_v<std::is_constructible<T, Args...>,

FILE: riegeli/base/shared_buffer.cc
  type riegeli (line 24) | namespace riegeli {

FILE: riegeli/base/shared_buffer.h
  function namespace (line 30) | namespace riegeli {

FILE: riegeli/base/shared_ptr.h
  function namespace (line 36) | namespace riegeli {
  function T (line 180) | T* get() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return ptr_.get(); }
  type Control (line 258) | struct Control {
  type Unrefer (line 265) | struct Unrefer {
  function DestroyMethod (line 272) | void DestroyMethod(void* ptr) {
  function T (line 281) | T* UpCast(SubT* ptr) {
  function ResetImpl (line 372) | void ResetImpl(Initializer<T> value) {

FILE: riegeli/base/sized_shared_buffer.cc
  type riegeli (line 30) | namespace riegeli {

FILE: riegeli/base/sized_shared_buffer.h
  function class (line 36) | class ABSL_ATTRIBUTE_TRIVIAL_ABI SizedSharedBuffer {

FILE: riegeli/base/stable_dependency.h
  function namespace (line 30) | namespace riegeli {
  function namespace (line 244) | namespace dependency_internal {

FILE: riegeli/base/status.cc
  type riegeli (line 22) | namespace riegeli {
    function SetMessage (line 24) | absl::Status SetMessage(const absl::Status& status, absl::string_view ...
    function Annotate (line 33) | absl::Status Annotate(const absl::Status& status, absl::string_view de...

FILE: riegeli/base/status.h
  function namespace (line 24) | namespace riegeli {
  function Status (line 106) | struct StatusOrMaker<absl::Status> {
  function type (line 126) | static type FromStatus(const absl::Status& status) { return status; }
  function type (line 127) | static type FromStatus(absl::Status&& status) { return std::move(status); }
  function Update (line 134) | static void Update(type& result, const absl::Status& status) {

FILE: riegeli/base/stream_utils.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 26) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/stream_utils.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 33) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/string_ref.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 36) | ABSL_POINTERS_DEFAULT_NONNULL
  function class (line 152) | class StringInitializer : public Initializer<std::string> {
  function at (line 201) | inline const char& StringRef::at(size_t index) const {
  function remove_prefix (line 219) | inline void StringRef::remove_prefix(size_t length) {
  function remove_suffix (line 226) | inline void StringRef::remove_suffix(size_t length) {

FILE: riegeli/base/string_utils.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 24) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/string_utils.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 27) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/temporary_storage.h
  type class (line 99) | enum class

FILE: riegeli/base/type_erased_ref.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 27) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/type_id.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 25) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/type_traits.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 31) | ABSL_POINTERS_DEFAULT_NONNULL
  function namespace (line 326) | namespace type_traits_internal {
  function false_type (line 404) | struct IsComparableAgainstNullptr<absl::string_view> : std::false_type {}

FILE: riegeli/base/types.h
  type class (line 39) | enum class
  function SyncType (line 53) | enum class SyncType {

FILE: riegeli/base/unicode.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 36) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/unicode.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 26) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/base/uninitialized_vector.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 27) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/brotli/brotli_allocator.cc
  type riegeli (line 19) | namespace riegeli {
    type brotli_internal (line 21) | namespace brotli_internal {
      function RiegeliBrotliFreeFunc (line 27) | void RiegeliBrotliFreeFunc(void* opaque, void* ptr) {

FILE: riegeli/brotli/brotli_allocator.h
  function namespace (line 31) | namespace brotli_internal {
  function class (line 46) | class BrotliAllocator {

FILE: riegeli/brotli/brotli_dictionary.cc
  type riegeli (line 29) | namespace riegeli {

FILE: riegeli/brotli/brotli_dictionary.h
  function class (line 60) | class BrotliDictionary {

FILE: riegeli/brotli/brotli_reader.cc
  type riegeli (line 38) | namespace riegeli {

FILE: riegeli/brotli/brotli_reader.h
  function namespace (line 36) | namespace riegeli {
  function explicit (line 200) | explicit BrotliReader(Closed) -> BrotliReader<DeleteCtad<Closed>>;
  function Reset (line 242) | inline void BrotliReaderBase::Reset(BrotliDictionary&& dictionary,

FILE: riegeli/brotli/brotli_writer.cc
  type riegeli (line 40) | namespace riegeli {
    type BrotliEncoderDictionaryDeleter (line 44) | struct BrotliEncoderDictionaryDeleter {
    function Reader (line 215) | Reader* BrotliWriterBase::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/brotli/brotli_writer.h
  function namespace (line 38) | namespace riegeli {
  function Done (line 172) | void Done() override;
  function Writer (line 237) | Writer* DestWriter() const ABSL_ATTRIBUTE_LIFETIME_BOUND override {
  function explicit (line 250) | explicit BrotliWriter(Closed) -> BrotliWriter<DeleteCtad<Closed>>;
  function Reset (line 295) | inline void BrotliWriterBase::Reset(BufferOptions buffer_options,

FILE: riegeli/bytes/array_backward_writer.cc
  type riegeli (line 26) | namespace riegeli {

FILE: riegeli/bytes/array_backward_writer.h
  function namespace (line 35) | namespace riegeli {
  function Done (line 208) | void Done(ArrayBackwardWriter& self) {

FILE: riegeli/bytes/array_writer.cc
  type riegeli (line 32) | namespace riegeli {
    function Reader (line 112) | Reader* ArrayWriterBase::ReadModeBehindScratch(Position initial_pos) {

FILE: riegeli/bytes/array_writer.h
  function namespace (line 36) | namespace riegeli {
  function Done (line 224) | void Done(ArrayWriter& self) {

FILE: riegeli/bytes/backward_writer.cc
  type riegeli (line 45) | namespace riegeli {
    function WriteUnsigned (line 50) | inline bool WriteUnsigned(T src, BackwardWriter& dest) {
    function WriteSigned (line 60) | inline bool WriteSigned(T src, BackwardWriter& dest) {

FILE: riegeli/bytes/backward_writer.h
  function WriteByte (line 149) | bool WriteByte(uint8_t src) { return Write(static_cast<char>(src)); }
  function Write (line 160) | bool Write(char8_t src) { return Write(static_cast<char>(src)); }
  function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 163) | ABSL_ATTRIBUTE_ALWAYS_INLINE
  function Position (line 279) | Position pos() const;
  function Done (line 324) | void Done() override;
  function WriteInternal (line 413) | bool WriteInternal(std::tuple<Srcs...>&& srcs) {
  function Reset (line 454) | inline void BackwardWriter::Reset(Closed) {
  function Reset (line 462) | inline void BackwardWriter::Reset() {
  function Close (line 470) | inline bool BackwardWriter::Close() {
  function Done (line 475) | inline void BackwardWriter::Done() {
  function SetWriteSizeHint (line 480) | inline void BackwardWriter::SetWriteSizeHint(
  function Push (line 486) | inline bool BackwardWriter::Push(size_t min_length, size_t recommended_l...
  function move_cursor (line 498) | inline void BackwardWriter::move_cursor(size_t length) {
  function set_cursor (line 505) | inline void BackwardWriter::set_cursor(char* cursor) {
  function set_buffer (line 515) | inline void BackwardWriter::set_buffer(char* limit, size_t start_to_limit,
  function Write (line 525) | inline bool BackwardWriter::Write(char src) {
  function Write (line 532) | inline bool BackwardWriter::Write(BytesRef src) {
  function Write (line 543) | inline bool BackwardWriter::Write(ExternalRef src) {
  function Write (line 556) | bool BackwardWriter::Write(Src&& src) {
  function Write (line 560) | inline bool BackwardWriter::Write(ByteFill src) {
  function Flush (line 591) | inline bool BackwardWriter::Flush(FlushType flush_type) {
  function move_start_pos (line 612) | inline void BackwardWriter::move_start_pos(Position length) {
  function set_start_pos (line 619) | inline void BackwardWriter::set_start_pos(Position start_pos) {
  function Truncate (line 623) | inline bool BackwardWriter::Truncate(Position new_size) {

FILE: riegeli/bytes/buffer_options.cc
  type riegeli (line 27) | namespace riegeli {
    function ApplySizeHintAndRoundPos (line 40) | inline size_t ApplySizeHintAndRoundPos(Position base_length, size_t mi...

FILE: riegeli/bytes/buffer_options.h
  function class (line 192) | class ReadBufferSizer {
  function class (line 282) | class WriteBufferSizer {
  function ReadBufferSizer (line 351) | inline ReadBufferSizer::ReadBufferSizer(BufferOptions buffer_options)
  function Reset (line 354) | inline void ReadBufferSizer::Reset() {
  function Reset (line 362) | inline void ReadBufferSizer::Reset(BufferOptions buffer_options) {
  function EndRun (line 370) | inline void ReadBufferSizer::EndRun(Position pos) {
  function WriteBufferSizer (line 382) | inline WriteBufferSizer::WriteBufferSizer(BufferOptions buffer_options)
  function Reset (line 385) | inline void WriteBufferSizer::Reset() {
  function Reset (line 392) | inline void WriteBufferSizer::Reset(BufferOptions buffer_options) {
  function EndRun (line 399) | inline void WriteBufferSizer::EndRun(Position pos) {

FILE: riegeli/bytes/buffered_reader.cc
  type riegeli (line 41) | namespace riegeli {
    function SizedSharedBuffer (line 610) | SizedSharedBuffer BufferedReader::SaveBuffer() {

FILE: riegeli/bytes/buffered_reader.h
  function namespace (line 31) | namespace riegeli {
  function Reset (line 235) | inline void BufferedReader::Reset(Closed) {
  function Reset (line 241) | inline void BufferedReader::Reset(BufferOptions buffer_options) {

FILE: riegeli/bytes/buffered_writer.cc
  type riegeli (line 36) | namespace riegeli {
    function Reader (line 132) | Reader* BufferedWriter::ReadModeBehindBuffer(Position initial_pos) {
    function Reader (line 211) | Reader* BufferedWriter::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/buffered_writer.h
  function namespace (line 31) | namespace riegeli {
  function Reset (line 162) | inline void BufferedWriter::Reset(Closed) {
  function Reset (line 169) | inline void BufferedWriter::Reset(BufferOptions buffer_options) {

FILE: riegeli/bytes/cfile_handle.cc
  type riegeli (line 47) | namespace riegeli {
    type cfile_internal (line 49) | namespace cfile_internal {
      class CFileBase<UnownedCFileDeleter> (line 51) | class CFileBase<UnownedCFileDeleter>
      class CFileBase<OwnedCFileDeleter> (line 52) | class CFileBase<OwnedCFileDeleter>
    function FILE (line 56) | FILE* CFileHandle::GetMethodDefault(

FILE: riegeli/bytes/cfile_handle.h
  function namespace (line 40) | namespace riegeli {
  function class (line 112) | class CFileHandle : public WithEqual<CFileHandle> {
  type Methods (line 164) | struct Methods {
  function FILE (line 204) | FILE* GetMethod(TypeErasedRef target) {
  function IsOwningMethod (line 209) | bool IsOwningMethod(TypeErasedRef target) {
  function namespace (line 245) | namespace cfile_internal {
  function FILE (line 450) | FILE* get() const { return file_; }
  function FILE (line 486) | FILE* Release() { return std::exchange(file_, nullptr); }
  function Destroy (line 492) | void Destroy() {
  function CFileBase (line 516) | CFileBase(file) {}
  function explicit (line 519) | explicit UnownedCFile(CFileHandle file)
  function ABSL_ATTRIBUTE_REINITIALIZES (line 530) | ABSL_ATTRIBUTE_REINITIALIZES void Reset(CFileHandle file) {
  function FILE (line 556) | FILE* get() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return CFileBase::get(...

FILE: riegeli/bytes/cfile_internal.cc
  type riegeli::cfile_internal (line 24) | namespace riegeli::cfile_internal {
    function FilenameForCFile (line 26) | std::string FilenameForCFile(FILE* file) {

FILE: riegeli/bytes/cfile_internal.h
  function namespace (line 22) | namespace riegeli::cfile_internal {

FILE: riegeli/bytes/cfile_internal_for_cc.h
  function namespace (line 32) | namespace riegeli::cfile_internal {

FILE: riegeli/bytes/cfile_reader.cc
  type riegeli (line 57) | namespace riegeli {
    type HasAvailableLength (line 70) | struct HasAvailableLength : std::false_type {}
    function AvailableLength (line 80) | inline size_t AvailableLength(DependentFILE* src) {
  type HasAvailableLength<
    DependentFILE,
    std::void_t<decltype(std::declval<DependentFILE>()._IO_read_end -
                         std::declval<DependentFILE>()._IO_read_ptr)>> (line 73) | struct HasAvailableLength<

FILE: riegeli/bytes/cfile_reader.h
  function namespace (line 43) | namespace riegeli {
  function virtual (line 171) | virtual CFileHandle SrcCFileHandle() const ABSL_ATTRIBUTE_LIFETIME_BOUND...
  function FILE (line 313) | FILE* SrcFile() const ABSL_ATTRIBUTE_LIFETIME_BOUND override {
  function explicit (line 334) | explicit CFileReader(Closed) -> CFileReader<DeleteCtad<Closed>>;

FILE: riegeli/bytes/cfile_writer.cc
  type riegeli (line 63) | namespace riegeli {
    function Reader (line 509) | Reader* CFileWriterBase::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/bytes/cfile_writer.h
  function namespace (line 45) | namespace riegeli {
  function read (line 120) | bool read() const { return file_internal::GetRead(mode_); }
  function append (line 145) | bool append() const { return file_internal::GetAppend(mode_); }
  function exclusive (line 169) | bool exclusive() const { return file_internal::GetExclusive(mode_); }
  function inheritable (line 194) | bool inheritable() const { return file_internal::GetInheritable(mode_); }
  function virtual (line 254) | virtual CFileHandle DestCFileHandle() const ABSL_ATTRIBUTE_LIFETIME_BOUN...
  function FILE (line 416) | FILE* DestFile() const ABSL_ATTRIBUTE_LIFETIME_BOUND override {
  function explicit (line 438) | explicit CFileWriter(Closed) -> CFileWriter<DeleteCtad<Closed>>;
  function Reset (line 484) | inline void CFileWriterBase::Reset(Closed) {
  function Reset (line 497) | inline void CFileWriterBase::Reset(BufferOptions buffer_options) {

FILE: riegeli/bytes/chain_backward_writer.cc
  type riegeli (line 35) | namespace riegeli {

FILE: riegeli/bytes/chain_backward_writer.h
  function namespace (line 42) | namespace riegeli {

FILE: riegeli/bytes/chain_reader.cc
  type riegeli (line 38) | namespace riegeli {

FILE: riegeli/bytes/chain_reader.h
  function namespace (line 36) | namespace riegeli {
  function Done (line 191) | void Done(ChainReader& self) {

FILE: riegeli/bytes/chain_writer.cc
  type riegeli (line 39) | namespace riegeli {
    function Reader (line 414) | Reader* ChainWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/chain_writer.h
  function namespace (line 43) | namespace riegeli {

FILE: riegeli/bytes/compact_string_writer.h
  function namespace (line 29) | namespace riegeli {

FILE: riegeli/bytes/copy_all.cc
  type riegeli::copy_all_internal (line 34) | namespace riegeli::copy_all_internal {
    function ABSL_ATTRIBUTE_COLD (line 38) | ABSL_ATTRIBUTE_COLD absl::Status MaxLengthExceeded(Reader& src,
    function CopyAllImpl (line 44) | absl::Status CopyAllImpl(Reader& src, Writer& dest, Position max_length,
    function CopyAllImpl (line 85) | absl::Status CopyAllImpl(Reader& src, Writer& dest, Position max_length,
    function CopyAllImpl (line 101) | absl::Status CopyAllImpl(Reader& src, BackwardWriter& dest, size_t max...

FILE: riegeli/bytes/copy_all.h
  function namespace (line 32) | namespace riegeli {

FILE: riegeli/bytes/cord_backward_writer.cc
  type riegeli (line 39) | namespace riegeli {

FILE: riegeli/bytes/cord_backward_writer.h
  function SupportsTruncate (line 125) | bool SupportsTruncate() override { return true; }
  function Done (line 139) | void Done() override;
  function explicit (line 246) | explicit CordBackwardWriter(Closed) -> CordBackwardWriter<DeleteCtad<Clo...

FILE: riegeli/bytes/cord_reader.cc
  type riegeli (line 37) | namespace riegeli {

FILE: riegeli/bytes/cord_reader.h
  function namespace (line 39) | namespace riegeli {
  function Done (line 254) | void Done(CordReader& self) {

FILE: riegeli/bytes/cord_writer.cc
  type riegeli (line 42) | namespace riegeli {
    function Reader (line 488) | Reader* CordWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/cord_writer.h
  function SupportsRandomAccess (line 134) | bool SupportsRandomAccess() override { return true; }
  function SupportsReadMode (line 135) | bool SupportsReadMode() override { return true; }
  function Done (line 149) | void Done() override;
  function explicit (line 304) | explicit CordWriter(Closed) -> CordWriter<DeleteCtad<Closed>>;

FILE: riegeli/bytes/fd_handle.cc
  type riegeli (line 49) | namespace riegeli {
    type fd_internal (line 51) | namespace fd_internal {
      class FdBase<UnownedFdDeleter> (line 53) | class FdBase<UnownedFdDeleter>
      class FdBase<OwnedFdDeleter> (line 54) | class FdBase<OwnedFdDeleter>

FILE: riegeli/bytes/fd_handle.h
  function namespace (line 49) | namespace riegeli {
  function class (line 147) | class FdHandle : public WithEqual<FdHandle> {
  type Methods (line 197) | struct Methods {
  function GetMethod (line 237) | int GetMethod(TypeErasedRef target) {
  function IsOwningMethod (line 242) | bool IsOwningMethod(TypeErasedRef target) {
  function namespace (line 278) | namespace fd_internal {
  function Release (line 521) | int Release() { return std::exchange(fd_, -1); }
  function Destroy (line 527) | void Destroy() {
  function FdBase (line 550) | UnownedFd(int fd ABSL_ATTRIBUTE_LIFETIME_BOUND) : FdBase(fd) {}
  function explicit (line 553) | explicit UnownedFd(FdHandle fd) : FdBase(fd.get(), fd.filename()) {}
  function ABSL_ATTRIBUTE_REINITIALIZES (line 563) | ABSL_ATTRIBUTE_REINITIALIZES void Reset(FdHandle fd) {
  function get (line 596) | int get() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return FdBase::get(); }

FILE: riegeli/bytes/fd_internal.cc
  type riegeli::fd_internal (line 46) | namespace riegeli::fd_internal {
    function FilenameForFd (line 48) | std::string FilenameForFd(int fd) {

FILE: riegeli/bytes/fd_internal.h
  function namespace (line 24) | namespace riegeli::fd_internal {

FILE: riegeli/bytes/fd_internal_for_cc.h
  function namespace (line 33) | namespace riegeli::fd_internal {

FILE: riegeli/bytes/fd_mmap_reader.cc
  type riegeli (line 91) | namespace riegeli {
    type HandleDeleter (line 97) | struct HandleDeleter {
    function GetPageSize (line 112) | inline absl::StatusOr<Position> GetPageSize() {
    function Position (line 122) | inline Position GetPageSize() {
    type HavePosixFadvise (line 135) | struct HavePosixFadvise : std::false_type {}
    type HavePosixFadvise<
    DependentInt,
    std::void_t<decltype(posix_fadvise(
        std::declval<DependentInt>(), std::declval<fd_internal::Offset>(),
        std::declval<fd_internal::Offset>(), std::declval<int>()))>> (line 138) | struct HavePosixFadvise<
    function FdSetReadAllHint (line 146) | inline void FdSetReadAllHint(ABSL_ATTRIBUTE_UNUSED DependentInt src,
    class MMapBlock (line 158) | class MMapBlock {
      method MMapBlock (line 160) | explicit MMapBlock(const char* addr) : addr_(addr) {}
      method MMapBlock (line 162) | MMapBlock(MMapBlock&& that) = default;
      method MMapBlock (line 163) | MMapBlock& operator=(MMapBlock&& that) = default;
      method RiegeliSupportsExternalRef (line 166) | void RiegeliSupportsExternalRef(MMapBlock*) {}
      method RiegeliDumpStructure (line 172) | void RiegeliDumpStructure(ABSL_ATTRIBUTE_UNUSED const MMapBlock* self,

FILE: riegeli/bytes/fd_mmap_reader.h
  function namespace (line 44) | namespace riegeli {

FILE: riegeli/bytes/fd_reader.cc
  type riegeli (line 87) | namespace riegeli {
    type HaveCopyFileRange (line 111) | struct HaveCopyFileRange : std::false_type {}
    type HaveCopyFileRange<
    DependentInt,
    std::void_t<decltype(copy_file_range(
        std::declval<DependentInt>(), std::declval<fd_internal::Offset*>(),
        std::declval<int>(), std::declval<fd_internal::Offset*>(),
        std::declval<size_t>(), std::declval<unsigned>()))>> (line 114) | struct HaveCopyFileRange<
    function CopyFileRange (line 123) | inline ssize_t CopyFileRange(DependentInt src, fd_internal::Offset* sr...
    type HavePosixFadvise (line 139) | struct HavePosixFadvise : std::false_type {}
    type HavePosixFadvise<
    DependentInt,
    std::void_t<decltype(posix_fadvise(
        std::declval<DependentInt>(), std::declval<fd_internal::Offset>(),
        std::declval<fd_internal::Offset>(), std::declval<int>()))>> (line 142) | struct HavePosixFadvise<
    function FdSetReadAllHint (line 150) | inline void FdSetReadAllHint(ABSL_ATTRIBUTE_UNUSED DependentInt src,

FILE: riegeli/bytes/fd_reader.h
  function namespace (line 47) | namespace riegeli {
  function explicit (line 434) | explicit FdReader(Closed) -> FdReader<DeleteCtad<Closed>>;

FILE: riegeli/bytes/fd_writer.cc
  type riegeli (line 76) | namespace riegeli {
    function TypeId (line 78) | TypeId FdWriterBase::GetTypeId() const { return TypeId::For<FdWriterBa...
    function Reader (line 694) | Reader* FdWriterBase::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/bytes/fd_writer.h
  function namespace (line 48) | namespace riegeli {
  function explicit (line 609) | explicit FdWriter(Closed) -> FdWriter<DeleteCtad<Closed>>;
  function Reset (line 659) | inline void FdWriterBase::Reset(Closed) {
  function Reset (line 673) | inline void FdWriterBase::Reset(BufferOptions buffer_options) {

FILE: riegeli/bytes/file_mode_string.cc
  type riegeli::file_internal (line 35) | namespace riegeli::file_internal {
    function SetExisting (line 37) | void SetExisting(bool existing, std::string& mode) {
    function SetRead (line 61) | void SetRead(bool read, std::string& mode) {
    function GetRead (line 84) | bool GetRead(absl::string_view mode) {
    function SetExclusive (line 94) | void SetExclusive(bool exclusive, std::string& mode) {
    function GetExclusive (line 122) | bool GetExclusive(absl::string_view mode) {
    function SetInheritableImpl (line 133) | void SetInheritableImpl(bool inheritable, std::string& mode) {
    function SetInheritableReading (line 168) | void SetInheritableReading(bool inheritable, std::string& mode) {
    function SetInheritableWriting (line 173) | void SetInheritableWriting(bool inheritable, std::string& mode) {
    function GetInheritable (line 178) | bool GetInheritable(absl::string_view mode) {
    function SetTextImpl (line 194) | inline void SetTextImpl(bool text, std::string& mode) {
    function SetTextReading (line 226) | void SetTextReading(bool text, std::string& mode) {
    function SetTextWriting (line 231) | void SetTextWriting(bool text, std::string& mode) {
    function GetTextAsFlags (line 238) | int GetTextAsFlags(absl::string_view mode) {

FILE: riegeli/bytes/file_mode_string.h
  function namespace (line 23) | namespace riegeli::file_internal {

FILE: riegeli/bytes/iostream_internal.h
  function namespace (line 22) | namespace riegeli::iostream_internal {

FILE: riegeli/bytes/istream_reader.cc
  type riegeli (line 36) | namespace riegeli {

FILE: riegeli/bytes/istream_reader.h
  function namespace (line 37) | namespace riegeli {
  function explicit (line 185) | explicit IStreamReader(Closed) -> IStreamReader<DeleteCtad<Closed>>;
  function Reset (line 224) | inline void IStreamReaderBase::Reset(BufferOptions buffer_options,

FILE: riegeli/bytes/joining_reader.cc
  type riegeli (line 36) | namespace riegeli {

FILE: riegeli/bytes/joining_reader.h
  function namespace (line 35) | namespace riegeli {
  function Reset (line 223) | inline void JoiningReaderBase::Reset(Closed) {
  function Reset (line 228) | inline void JoiningReaderBase::Reset() {
  function shard_is_open (line 233) | inline bool JoiningReaderBase::shard_is_open() const {
  function SyncBuffer (line 241) | inline void JoiningReaderBase::SyncBuffer(Reader& shard) {
  function MakeBuffer (line 250) | inline void JoiningReaderBase::MakeBuffer(Reader& shard) {
  function Done (line 275) | void Done(JoiningReader& self) {

FILE: riegeli/bytes/limiting_backward_writer.cc
  type riegeli (line 37) | namespace riegeli {

FILE: riegeli/bytes/limiting_backward_writer.h
  function namespace (line 40) | namespace riegeli {
  function Reset (line 297) | inline void LimitingBackwardWriterBase::Reset(Closed) {
  function Reset (line 303) | inline void LimitingBackwardWriterBase::Reset(bool exact) {
  function SyncBuffer (line 309) | inline bool LimitingBackwardWriterBase::SyncBuffer(BackwardWriter& dest) {
  function MakeBuffer (line 318) | inline void LimitingBackwardWriterBase::MakeBuffer(BackwardWriter& dest) {
  function Done (line 345) | void Done(LimitingBackwardWriter& self) {

FILE: riegeli/bytes/limiting_reader.cc
  type riegeli (line 37) | namespace riegeli {

FILE: riegeli/bytes/limiting_reader.h
  function namespace (line 40) | namespace riegeli {
  function explicit (line 353) | explicit LimitingReader(Closed) -> LimitingReader<DeleteCtad<Closed>>;
  function class (line 402) | class ScopedLimiter {
  function explicit (line 454) | explicit ScopedLimiterOrLimitingReader(Src* src ABSL_ATTRIBUTE_LIFETIME_...
  function explicit (line 458) | explicit ScopedLimiterOrLimitingReader(const ReaderSpan<Src>& src)
  function Close (line 475) | bool Close() { return reader_.Close(); }
  function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 492) | ABSL_ATTRIBUTE_ALWAYS_INLINE
  function explicit (line 497) | explicit ScopedLimiterOrLimitingReader(const ReaderSpan<Src>& src)
  function Close (line 518) | bool Close() { return reader().ok(); }
  function ReaderSpan (line 546) | const ReaderSpan<ReaderType>& manager() const ABSL_ATTRIBUTE_LIFETIME_BO...
  function LimitingReaderBase (line 571) | inline LimitingReaderBase::LimitingReaderBase(bool exact, bool fail_if_l...
  function Reset (line 590) | inline void LimitingReaderBase::Reset(Closed) {
  function Reset (line 597) | inline void LimitingReaderBase::Reset(bool exact, bool fail_if_longer) {
  function restore_max_pos (line 604) | inline void LimitingReaderBase::restore_max_pos(Position max_pos) {
  function set_max_pos (line 618) | inline void LimitingReaderBase::set_max_pos(Position max_pos) {
  function set_max_length (line 623) | inline void LimitingReaderBase::set_max_length(Position max_length) {
  function SyncBuffer (line 638) | inline void LimitingReaderBase::SyncBuffer(Reader& src) {
  function MakeBuffer (line 642) | inline void LimitingReaderBase::MakeBuffer(Reader& src) {
  function Done (line 661) | void Done(LimitingReader& self) {

FILE: riegeli/bytes/limiting_writer.cc
  type riegeli (line 38) | namespace riegeli {
    function Reader (line 309) | Reader* LimitingWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/limiting_writer.h
  function namespace (line 40) | namespace riegeli {
  function Reset (line 294) | inline void LimitingWriterBase::Reset(Closed) {
  function Reset (line 300) | inline void LimitingWriterBase::Reset(bool exact) {
  function SyncBuffer (line 306) | inline bool LimitingWriterBase::SyncBuffer(Writer& dest) {
  function MakeBuffer (line 315) | inline void LimitingWriterBase::MakeBuffer(Writer& dest) {
  function Done (line 342) | void Done(LimitingWriter& self) {

FILE: riegeli/bytes/null_backward_writer.cc
  type riegeli (line 36) | namespace riegeli {

FILE: riegeli/bytes/null_backward_writer.h
  function namespace (line 36) | namespace riegeli {
  function NullBackwardWriter (line 94) | inline NullBackwardWriter::NullBackwardWriter(Options options) noexcept
  function Reset (line 111) | inline void NullBackwardWriter::Reset(Closed) {
  function Reset (line 117) | inline void NullBackwardWriter::Reset(Options options) {

FILE: riegeli/bytes/null_writer.cc
  type riegeli (line 36) | namespace riegeli {

FILE: riegeli/bytes/null_writer.h
  function namespace (line 36) | namespace riegeli {
  function NullWriter (line 100) | inline NullWriter::NullWriter(Options options) noexcept
  function Reset (line 117) | inline void NullWriter::Reset(Closed) {
  function Reset (line 124) | inline void NullWriter::Reset(Options options) {

FILE: riegeli/bytes/ostream_writer.cc
  type riegeli (line 40) | namespace riegeli {
    function Reader (line 305) | Reader* OStreamWriterBase::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/bytes/ostream_writer.h
  function namespace (line 40) | namespace riegeli {
  function explicit (line 213) | explicit OStreamWriter(Closed) -> OStreamWriter<DeleteCtad<Closed>>;
  function Reset (line 263) | inline void OStreamWriterBase::Reset(BufferOptions buffer_options) {

FILE: riegeli/bytes/path_ref.h
  function namespace (line 38) | namespace riegeli {
  function friend (line 163) | friend riegeli::StrongOrdering RIEGELI_COMPARE(
  function class (line 175) | class PathInitializer : public Initializer<std::string> {

FILE: riegeli/bytes/position_shifting_backward_writer.cc
  type riegeli (line 37) | namespace riegeli {

FILE: riegeli/bytes/position_shifting_backward_writer.h
  function namespace (line 41) | namespace riegeli {

FILE: riegeli/bytes/position_shifting_reader.cc
  type riegeli (line 39) | namespace riegeli {

FILE: riegeli/bytes/position_shifting_reader.h
  function namespace (line 39) | namespace riegeli {
  function Reset (line 221) | inline void PositionShiftingReaderBase::Reset(Closed) {
  function Reset (line 226) | inline void PositionShiftingReaderBase::Reset(Position base_pos) {
  function Initialize (line 231) | inline void PositionShiftingReaderBase::Initialize(Reader* src) {
  function SyncBuffer (line 237) | inline void PositionShiftingReaderBase::SyncBuffer(Reader& src) {
  function MakeBuffer (line 241) | inline bool PositionShiftingReaderBase::MakeBuffer(Reader& src,
  function Done (line 297) | void Done(PositionShiftingReader& self) {

FILE: riegeli/bytes/position_shifting_writer.cc
  type riegeli (line 41) | namespace riegeli {
    function Reader (line 208) | Reader* PositionShiftingWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/position_shifting_writer.h
  function namespace (line 41) | namespace riegeli {
  function Reset (line 226) | inline void PositionShiftingWriterBase::Reset(Closed) {
  function Reset (line 232) | inline void PositionShiftingWriterBase::Reset(Position base_pos) {
  function Initialize (line 238) | inline void PositionShiftingWriterBase::Initialize(Writer* dest) {
  function SyncBuffer (line 244) | inline void PositionShiftingWriterBase::SyncBuffer(Writer& dest) {
  function MakeBuffer (line 248) | inline bool PositionShiftingWriterBase::MakeBuffer(Writer& dest,
  function Done (line 282) | void Done(PositionShiftingWriter& self) {

FILE: riegeli/bytes/prefix_limiting_backward_writer.cc
  type riegeli (line 37) | namespace riegeli {

FILE: riegeli/bytes/prefix_limiting_backward_writer.h
  function namespace (line 40) | namespace riegeli {

FILE: riegeli/bytes/prefix_limiting_reader.cc
  type riegeli (line 38) | namespace riegeli {

FILE: riegeli/bytes/prefix_limiting_reader.h
  function namespace (line 37) | namespace riegeli {

FILE: riegeli/bytes/prefix_limiting_writer.cc
  type riegeli (line 40) | namespace riegeli {
    function Reader (line 204) | Reader* PrefixLimitingWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/prefix_limiting_writer.h
  function namespace (line 40) | namespace riegeli {

FILE: riegeli/bytes/pullable_reader.cc
  type riegeli (line 43) | namespace riegeli {

FILE: riegeli/bytes/pullable_reader.h
  function namespace (line 32) | namespace riegeli {
  function Reset (line 199) | inline void PullableReader::Reset(Closed) {
  function Reset (line 204) | inline void PullableReader::Reset() {
  function PullableReader (line 213) | inline PullableReader::BehindScratch::BehindScratch(
  function PullableReader (line 219) | inline PullableReader::BehindScratch::~BehindScratch() {

FILE: riegeli/bytes/pushable_backward_writer.cc
  type riegeli (line 42) | namespace riegeli {

FILE: riegeli/bytes/pushable_backward_writer.h
  function namespace (line 35) | namespace riegeli {
  function Reset (line 212) | inline void PushableBackwardWriter::Reset(Closed) {
  function Reset (line 217) | inline void PushableBackwardWriter::Reset() {
  function PushableBackwardWriter (line 226) | inline PushableBackwardWriter::BehindScratch::BehindScratch(
  function PushableBackwardWriter (line 232) | inline PushableBackwardWriter::BehindScratch::~BehindScratch() {

FILE: riegeli/bytes/pushable_writer.cc
  type riegeli (line 42) | namespace riegeli {
    function Reader (line 299) | Reader* PushableWriter::ReadModeBehindScratch(Position initial_pos) {
    function Reader (line 444) | Reader* PushableWriter::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/pushable_writer.h
  function namespace (line 36) | namespace riegeli {
  function Reset (line 215) | inline void PushableWriter::Reset(Closed) {
  function Reset (line 220) | inline void PushableWriter::Reset() {
  function PushableWriter (line 229) | inline PushableWriter::BehindScratch::BehindScratch(
  function PushableWriter (line 235) | inline PushableWriter::BehindScratch::~BehindScratch() {

FILE: riegeli/bytes/read_all.cc
  type riegeli::read_all_internal (line 37) | namespace riegeli::read_all_internal {
    function ABSL_ATTRIBUTE_COLD (line 41) | ABSL_ATTRIBUTE_COLD absl::Status MaxLengthExceeded(Reader& src,
    function ReadAllImpl (line 47) | absl::Status ReadAllImpl(Reader& src, absl::string_view& dest,
    function ReadAndAppendAllImpl (line 81) | absl::Status ReadAndAppendAllImpl(Reader& src, std::string& dest,
    function ReadAndAppendAllImpl (line 139) | absl::Status ReadAndAppendAllImpl(Reader& src, Chain& dest, size_t max...
    function ReadAndAppendAllImpl (line 172) | absl::Status ReadAndAppendAllImpl(Reader& src, absl::Cord& dest,
    function ReadAllImpl (line 208) | absl::Status ReadAllImpl(Reader& src, absl::string_view& dest,
    function ReadAllImpl (line 215) | absl::Status ReadAllImpl(Reader& src, char* dest, size_t max_length,
    function ReadAllImpl (line 225) | absl::Status ReadAllImpl(Reader& src, std::string& dest, size_t max_le...
    function ReadAllImpl (line 231) | absl::Status ReadAllImpl(Reader& src, Chain& dest, size_t max_length,
    function ReadAllImpl (line 237) | absl::Status ReadAllImpl(Reader& src, absl::Cord& dest, size_t max_len...
    function ReadAndAppendAllImpl (line 243) | absl::Status ReadAndAppendAllImpl(Reader& src, std::string& dest,
    function ReadAndAppendAllImpl (line 258) | absl::Status ReadAndAppendAllImpl(Reader& src, Chain& dest, size_t max...
    function ReadAndAppendAllImpl (line 273) | absl::Status ReadAndAppendAllImpl(Reader& src, absl::Cord& dest,

FILE: riegeli/bytes/read_all.h
  function namespace (line 34) | namespace riegeli {
  function Status (line 295) | Status ReadAll(Src&& src, char* dest, size_t max_length,

FILE: riegeli/bytes/reader.cc
  type riegeli (line 45) | namespace riegeli {

FILE: riegeli/bytes/reader.h
  function namespace (line 42) | namespace riegeli {
  function Reset (line 664) | inline void Reader::Reset(Closed) {
  function Reset (line 672) | inline void Reader::Reset() {
  function Done (line 680) | inline void Reader::Done() {
  function VerifyEndAndClose (line 685) | inline bool Reader::VerifyEndAndClose() {
  function VerifyEnd (line 690) | inline void Reader::VerifyEnd() { VerifyEndImpl(); }
  function SetReadAllHint (line 692) | inline void Reader::SetReadAllHint(bool read_all_hint) {
  function Pull (line 696) | inline bool Reader::Pull(size_t min_length, size_t recommended_length) {
  function move_cursor (line 707) | inline void Reader::move_cursor(size_t length) {
  function set_cursor (line 713) | inline void Reader::set_cursor(const char* cursor) {
  function set_buffer (line 721) | inline void Reader::set_buffer(const char* start, size_t start_to_limit,
  function ReadByte (line 730) | inline bool Reader::ReadByte(uint8_t& dest) {
  function Read (line 737) | inline bool Reader::Read(char& dest) {
  function Read (line 744) | inline bool Reader::Read(size_t length, absl::string_view& dest,
  function Read (line 754) | inline bool Reader::Read(size_t length, char* dest, size_t* length_read) {
  function ReadSome (line 765) | inline bool Reader::ReadSome(size_t max_length, absl::string_view& dest,
  function ReadSome (line 776) | inline bool Reader::ReadSome(size_t max_length, char* dest,
  function ReadHint (line 792) | inline void Reader::ReadHint(size_t min_length, size_t recommended_lengt...
  function Sync (line 797) | inline bool Reader::Sync(SyncType sync_type) { return SyncImpl(sync_type...
  function move_limit_pos (line 811) | inline void Reader::move_limit_pos(Position length) {
  function set_limit_pos (line 818) | inline void Reader::set_limit_pos(Position limit_pos) {
  function Seek (line 822) | inline bool Reader::Seek(Position new_pos) {
  function Skip (line 830) | inline bool Reader::Skip(Position length, Position* length_skipped) {
  function std (line 867) | inline std::optional<Position> Reader::Size() { return SizeImpl(); }

FILE: riegeli/bytes/reader_cfile.cc
  type riegeli::cfile_internal (line 43) | namespace riegeli::cfile_internal {
    function ReaderCFileRead (line 143) | static ssize_t ReaderCFileRead(void* cookie, char* buf, size_t size) {
    function ReaderCFileSeek (line 147) | static int ReaderCFileSeek(void* cookie, off64_t* offset, int whence) {
    function ReaderCFileClose (line 159) | static int ReaderCFileClose(void* cookie) {
    function OwnedCFile (line 171) | OwnedCFile ReaderCFileImpl(ReaderCFileCookieBase* cookie,

FILE: riegeli/bytes/reader_cfile.h
  function namespace (line 39) | namespace riegeli {
  function namespace (line 92) | namespace cfile_internal {

FILE: riegeli/bytes/reader_factory.cc
  type riegeli (line 44) | namespace riegeli {
    class ReaderFactoryBase::ConcurrentReader (line 46) | class ReaderFactoryBase::ConcurrentReader : public PullableReader {
      method ConcurrentReader (line 50) | ConcurrentReader(const ConcurrentReader&) = delete;
      method ConcurrentReader (line 51) | ConcurrentReader& operator=(const ConcurrentReader&) = delete;
      method SupportsRandomAccess (line 54) | bool SupportsRandomAccess() override { return true; }
      method SupportsNewReader (line 55) | bool SupportsNewReader() override { return true; }

FILE: riegeli/bytes/reader_factory.h
  function namespace (line 34) | namespace riegeli {

FILE: riegeli/bytes/reader_istream.cc
  type riegeli (line 32) | namespace riegeli {
    type stream_internal (line 34) | namespace stream_internal {
      class ReaderStreambuf::BufferSync (line 36) | class ReaderStreambuf::BufferSync {
        method BufferSync (line 38) | explicit BufferSync(ReaderStreambuf* streambuf) : streambuf_(strea...
        method BufferSync (line 42) | BufferSync(const BufferSync&) = delete;
        method BufferSync (line 43) | BufferSync& operator=(const BufferSync&) = delete;

FILE: riegeli/bytes/reader_istream.h
  function namespace (line 35) | namespace riegeli {
  function Reset (line 296) | inline void ReaderIStreamBase::Reset(Closed) {
  function Reset (line 302) | inline void ReaderIStreamBase::Reset() {
  function Initialize (line 308) | inline void ReaderIStreamBase::Initialize(Reader* src) {
  function Done (line 320) | void Done(ReaderIStream& self) { self.streambuf_.MoveEnd(self.src_.get()...

FILE: riegeli/bytes/resizable_writer.cc
  type riegeli (line 40) | namespace riegeli {
    function Reader (line 379) | Reader* ResizableWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/resizable_writer.h
  function namespace (line 45) | namespace riegeli {
  function Size (line 354) | static size_t Size(const Resizable& dest) { return dest.size(); }
  function Resize (line 356) | static bool Resize(Resizable& dest, size_t new_size, size_t used_size) {
  function Grow (line 367) | static bool Grow(Resizable& dest, size_t new_size, size_t used_size) {
  function GrowUnderCapacity (line 381) | static bool GrowUnderCapacity(Resizable& dest, size_t new_size) {
  function ResizableWriterBase (line 413) | inline ResizableWriterBase::ResizableWriterBase(BufferOptions buffer_opt...
  function Reset (line 437) | inline void ResizableWriterBase::Reset(Closed) {
  function Reset (line 445) | inline void ResizableWriterBase::Reset(BufferOptions buffer_options) {
  function MoveSecondaryBuffer (line 455) | inline void ResizableWriterBase::MoveSecondaryBuffer(

FILE: riegeli/bytes/restricted_chain_writer.cc
  type riegeli (line 33) | namespace riegeli {

FILE: riegeli/bytes/restricted_chain_writer.h
  function namespace (line 33) | namespace riegeli {
  function RestrictedChainWriter (line 97) | inline RestrictedChainWriter::RestrictedChainWriter(
  function Reset (line 110) | inline void RestrictedChainWriter::Reset(Closed) {
  function Reset (line 115) | inline void RestrictedChainWriter::Reset() {
  function MoveDest (line 120) | inline void RestrictedChainWriter::MoveDest(RestrictedChainWriter&& that) {

FILE: riegeli/bytes/splitting_writer.cc
  type riegeli (line 41) | namespace riegeli {

FILE: riegeli/bytes/splitting_writer.h
  function namespace (line 37) | namespace riegeli {
  function Reset (line 243) | inline void SplittingWriterBase::Reset(Closed) {
  function Reset (line 249) | inline void SplittingWriterBase::Reset() {
  function shard_is_open (line 255) | inline bool SplittingWriterBase::shard_is_open() const {
  function SyncBuffer (line 263) | inline void SplittingWriterBase::SyncBuffer(Writer& shard) {
  function MakeBuffer (line 272) | inline void SplittingWriterBase::MakeBuffer(Writer& shard) {
  function Done (line 298) | void Done(SplittingWriter& self) {

FILE: riegeli/bytes/std_io.cc
  type riegeli (line 25) | namespace riegeli {
    function SizedSharedBuffer (line 33) | SizedSharedBuffer& StdInPending() {

FILE: riegeli/bytes/std_io.h
  function namespace (line 25) | namespace riegeli {

FILE: riegeli/bytes/string_reader.cc
  type riegeli (line 27) | namespace riegeli {

FILE: riegeli/bytes/string_reader.h
  function namespace (line 35) | namespace riegeli {
  function Initialize (line 171) | inline void StringReaderBase::Initialize(absl::string_view src) {
  function Done (line 192) | void Done(StringReader& self) {

FILE: riegeli/bytes/string_writer.cc
  type riegeli (line 42) | namespace riegeli {
    function Reader (line 541) | Reader* StringWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/string_writer.h
  function namespace (line 41) | namespace riegeli {
  function explicit (line 270) | explicit StringWriter(Closed) -> StringWriter<DeleteCtad<Closed>>;
  function Reset (line 316) | inline void StringWriterBase::Reset(BufferOptions buffer_options) {
  function Initialize (line 326) | inline void StringWriterBase::Initialize(std::string* dest, bool append) {
  function MoveSecondaryBuffer (line 337) | inline void StringWriterBase::MoveSecondaryBuffer(StringWriterBase& that) {
  function Done (line 376) | void Done(StringWriter& self) {

FILE: riegeli/bytes/stringify.h
  function namespace (line 32) | namespace riegeli {
  function Position (line 62) | inline Position StringifiedSize(ABSL_ATTRIBUTE_UNUSED char src) { return...
  function Position (line 64) | inline Position StringifiedSize(ABSL_ATTRIBUTE_UNUSED char8_t src) { ret...
  function Position (line 66) | inline Position StringifiedSize(BytesRef src) { return src.size(); }
  function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 67) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline Position StringifiedSize(const char*...
  function Position (line 70) | inline Position StringifiedSize(const Chain& src) { return src.size(); }
  function Position (line 71) | inline Position StringifiedSize(const absl::Cord& src) { return src.size...
  function Position (line 72) | inline Position StringifiedSize(ByteFill src) { return src.size(); }
  function Position (line 73) | inline Position StringifiedSize(signed char src) {
  function Position (line 76) | inline Position StringifiedSize(unsigned char src) {
  function Position (line 79) | inline Position StringifiedSize(short src) {
  function Position (line 82) | inline Position StringifiedSize(unsigned short src) {
  function Position (line 85) | inline Position StringifiedSize(int src) {
  function Position (line 88) | inline Position StringifiedSize(unsigned src) {
  function Position (line 91) | inline Position StringifiedSize(long src) {
  function Position (line 94) | inline Position StringifiedSize(unsigned long src) {
  function Position (line 97) | inline Position StringifiedSize(long long src) {
  function Position (line 100) | inline Position StringifiedSize(unsigned long long src) {
  function Position (line 103) | inline Position StringifiedSize(absl::int128 src) {
  function Position (line 106) | inline Position StringifiedSize(absl::uint128 src) {
  function namespace (line 132) | namespace stringify_internal {

FILE: riegeli/bytes/stringify_writer.h
  function namespace (line 33) | namespace riegeli {
  function explicit (line 82) | explicit StringifyWriter(
  function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 97) | const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function explicit (line 105) | explicit StringifyWriter(Closed) -> StringifyWriter<DeleteCtad<Closed>>;
  function Reset (line 139) | inline void StringifyWriter<WriterStringifySink*>::Reset(Closed) {
  function Reset (line 144) | inline void StringifyWriter<WriterStringifySink*>::Reset(

FILE: riegeli/bytes/vector_writer.h
  function namespace (line 30) | namespace riegeli {

FILE: riegeli/bytes/wrapping_backward_writer.cc
  type riegeli (line 34) | namespace riegeli {

FILE: riegeli/bytes/wrapping_backward_writer.h
  function namespace (line 39) | namespace riegeli {

FILE: riegeli/bytes/wrapping_reader.cc
  type riegeli (line 36) | namespace riegeli {

FILE: riegeli/bytes/wrapping_reader.h
  function namespace (line 37) | namespace riegeli {
  function Initialize (line 169) | inline void WrappingReaderBase::Initialize(Reader* src) {
  function SyncBuffer (line 175) | inline void WrappingReaderBase::SyncBuffer(Reader& src) {
  function MakeBuffer (line 179) | inline void WrappingReaderBase::MakeBuffer(Reader& src) {
  function Done (line 197) | void Done(WrappingReader& self) {

FILE: riegeli/bytes/wrapping_writer.cc
  type riegeli (line 36) | namespace riegeli {
    function Reader (line 174) | Reader* WrappingWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/bytes/wrapping_writer.h
  function namespace (line 39) | namespace riegeli {
  function Initialize (line 165) | inline void WrappingWriterBase::Initialize(Writer* dest) {
  function SyncBuffer (line 171) | inline void WrappingWriterBase::SyncBuffer(Writer& dest) {
  function MakeBuffer (line 175) | inline void WrappingWriterBase::MakeBuffer(Writer& dest) {
  function Done (line 193) | void Done(WrappingWriter& self) {

FILE: riegeli/bytes/write.h
  function namespace (line 33) | namespace riegeli {

FILE: riegeli/bytes/write_int_internal.cc
  type riegeli::write_int_internal (line 31) | namespace riegeli::write_int_internal {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 72) | ABSL_ATTRIBUTE_ALWAYS_INLINE
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 133) | ABSL_ATTRIBUTE_ALWAYS_INLINE
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 156) | ABSL_ATTRIBUTE_ALWAYS_INLINE
    type StringifiedSizeEntry (line 351) | struct StringifiedSizeEntry {
    function MakeStringifiedSizeEntries (line 362) | constexpr std::array<StringifiedSizeEntry<T>, kNumStringifiedSizeEntri...
    function StringifiedSize (line 388) | size_t StringifiedSize(uint32_t src) {
    function StringifiedSize (line 397) | size_t StringifiedSize(uint64_t src) {
    function StringifiedSize (line 406) | size_t StringifiedSize(absl::uint128 src) {
    function StringifiedSize (line 418) | size_t StringifiedSize(int32_t src) {
    function StringifiedSize (line 426) | size_t StringifiedSize(int64_t src) {
    function StringifiedSize (line 434) | size_t StringifiedSize(absl::int128 src) {

FILE: riegeli/bytes/write_int_internal.h
  function namespace (line 27) | namespace riegeli::write_int_internal {

FILE: riegeli/bytes/writer.cc
  type riegeli (line 44) | namespace riegeli {
    function WriteUnsigned (line 49) | inline bool WriteUnsigned(T src, Writer& dest) {
    function WriteSigned (line 58) | inline bool WriteSigned(T src, Writer& dest) {
    function Reader (line 281) | Reader* Writer::ReadModeImpl(Position initial_pos) {
    type writer_internal (line 286) | namespace writer_internal {
      function DeleteReader (line 288) | void DeleteReader(Reader* reader) { delete reader; }

FILE: riegeli/bytes/writer.h
  function class (line 52) | class WriterStringifySink {
  function WriteByte (line 189) | bool WriteByte(uint8_t src) { return Write(static_cast<char>(src)); }
  function Write (line 199) | bool Write(char8_t src) { return Write(static_cast<char>(src)); }
  function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 202) | ABSL_ATTRIBUTE_ALWAYS_INLINE
  function Position (line 311) | Position pos() const;
  function virtual (line 348) | virtual bool SupportsTruncate() { return SupportsRandomAccess(); }
  function virtual (line 363) | virtual bool SupportsReadMode() { return false; }
  function friend (line 387) | friend void AbslFormatFlush(Writer* dest, absl::string_view src) {
  function Done (line 410) | void Done() override;
  function Append (line 563) | inline void WriterStringifySink::Append(size_t length, char fill) {
  function Append (line 567) | inline void WriterStringifySink::Append(absl::string_view src) {
  function Reset (line 587) | inline void Writer::Reset(Closed) {
  function Reset (line 595) | inline void Writer::Reset() {
  function Close (line 603) | inline bool Writer::Close() {
  function Done (line 608) | inline void Writer::Done() {
  function SetWriteSizeHint (line 613) | inline void Writer::SetWriteSizeHint(std::optional<Position> write_size_...
  function Push (line 618) | inline bool Writer::Push(size_t min_length, size_t recommended_length) {
  function move_cursor (line 630) | inline void Writer::move_cursor(size_t length) {
  function set_cursor (line 636) | inline void Writer::set_cursor(char* cursor) {
  function set_buffer (line 644) | inline void Writer::set_buffer(char* start, size_t start_to_limit,
  function Write (line 653) | inline bool Writer::Write(char src) {
  function Write (line 660) | inline bool Writer::Write(BytesRef src) {
  function Write (line 671) | inline bool Writer::Write(ExternalRef src) {
  function Write (line 684) | bool Writer::Write(Src&& src) {
  function Write (line 688) | inline bool Writer::Write(ByteFill src) {
  function Flush (line 732) | inline bool Writer::Flush(FlushType flush_type) {
  function set_start_pos (line 758) | inline void Writer::set_start_pos(Position start_pos) {
  function Seek (line 762) | inline bool Writer::Seek(Position new_pos) {
  function std (line 768) | inline std::optional<Position> Writer::Size() {
  function Truncate (line 773) | inline bool Writer::Truncate(Position new_size) {
  function Reader (line 778) | inline Reader* Writer::ReadMode(Position initial_pos)
  function namespace (line 784) | namespace writer_internal {

FILE: riegeli/bytes/writer_cfile.cc
  type riegeli::cfile_internal (line 45) | namespace riegeli::cfile_internal {
    function WriterCFileRead (line 233) | static ssize_t WriterCFileRead(void* cookie, char* buf, size_t size) {
    function WriterCFileWrite (line 237) | static ssize_t WriterCFileWrite(void* cookie, const char* buf, size_t ...
    function WriterCFileSeek (line 241) | static int WriterCFileSeek(void* cookie, off64_t* offset, int whence) {
    function WriterCFileClose (line 253) | static int WriterCFileClose(void* cookie) {
    function OwnedCFile (line 265) | OwnedCFile WriterCFileImpl(WriterCFileCookieBase* cookie,

FILE: riegeli/bytes/writer_cfile.h
  function namespace (line 39) | namespace riegeli {
  function namespace (line 124) | namespace cfile_internal {

FILE: riegeli/bytes/writer_ostream.cc
  type riegeli (line 36) | namespace riegeli {
    type stream_internal (line 38) | namespace stream_internal {
      class WriterStreambuf::BufferSync (line 40) | class WriterStreambuf::BufferSync {
        method BufferSync (line 42) | explicit BufferSync(WriterStreambuf* streambuf) : streambuf_(strea...
        method BufferSync (line 50) | BufferSync(const BufferSync&) = delete;
        method BufferSync (line 51) | BufferSync& operator=(const BufferSync&) = delete;

FILE: riegeli/bytes/writer_ostream.h
  function namespace (line 37) | namespace riegeli {
  function Reset (line 299) | inline void WriterOStreamBase::Reset(Closed) {
  function Reset (line 305) | inline void WriterOStreamBase::Reset() {
  function Initialize (line 311) | inline void WriterOStreamBase::Initialize(Writer* dest) {
  function Done (line 322) | void Done(WriterOStream& self) {

FILE: riegeli/bzip2/bzip2_error.cc
  type riegeli::bzip2_internal (line 25) | namespace riegeli::bzip2_internal {
    function Bzip2ErrorToStatus (line 27) | absl::Status Bzip2ErrorToStatus(absl::string_view operation, int bzlib...

FILE: riegeli/bzip2/bzip2_error.h
  function namespace (line 21) | namespace riegeli::bzip2_internal {

FILE: riegeli/bzip2/bzip2_reader.cc
  type riegeli (line 38) | namespace riegeli {
    function GetByte (line 266) | inline bool GetByte(Reader& src, size_t offset, uint8_t& value) {
    function RecognizeBzip2 (line 274) | bool RecognizeBzip2(Reader& src) {

FILE: riegeli/bzip2/bzip2_reader.h
  function namespace (line 37) | namespace riegeli {
  function explicit (line 189) | explicit Bzip2Reader(Closed) -> Bzip2Reader<DeleteCtad<Closed>>;
  function Reset (line 234) | inline void Bzip2ReaderBase::Reset(BufferOptions buffer_options,

FILE: riegeli/bzip2/bzip2_writer.cc
  type riegeli (line 37) | namespace riegeli {

FILE: riegeli/bzip2/bzip2_writer.h
  function namespace (line 35) | namespace riegeli {
  function explicit (line 170) | explicit Bzip2Writer(Closed) -> Bzip2Writer<DeleteCtad<Closed>>;
  function Reset (line 194) | inline void Bzip2WriterBase::Reset(Closed) {
  function Reset (line 200) | inline void Bzip2WriterBase::Reset(BufferOptions buffer_options) {

FILE: riegeli/chunk_encoding/brotli_encoder_selection.cc
  type riegeli::chunk_encoding_internal (line 31) | namespace riegeli::chunk_encoding_internal {
    function ABSL_ATTRIBUTE_WEAK (line 33) | ABSL_ATTRIBUTE_WEAK std::unique_ptr<Writer> NewBrotliWriter(
    function NewCBrotliWriter (line 51) | std::unique_ptr<Writer> NewCBrotliWriter(

FILE: riegeli/chunk_encoding/brotli_encoder_selection.h
  function namespace (line 25) | namespace riegeli::chunk_encoding_internal {

FILE: riegeli/chunk_encoding/chunk.cc
  type riegeli (line 28) | namespace riegeli {

FILE: riegeli/chunk_encoding/chunk.h
  function namespace (line 30) | namespace riegeli {

FILE: riegeli/chunk_encoding/chunk_decoder.cc
  type riegeli (line 43) | namespace riegeli {

FILE: riegeli/chunk_encoding/chunk_decoder.h
  function namespace (line 45) | namespace riegeli {
  function Reset (line 241) | inline void ChunkDecoder::Reset(Options options) {
  function Clear (line 247) | inline void ChunkDecoder::Clear() {
  function ReadRecord (line 255) | inline bool ChunkDecoder::ReadRecord(absl::string_view& record) {
  function ReadRecord (line 270) | inline bool ChunkDecoder::ReadRecord(std::string& record) {
  function ReadRecord (line 285) | inline bool ChunkDecoder::ReadRecord(Chain& record) {
  function ReadRecord (line 300) | inline bool ChunkDecoder::ReadRecord(absl::Cord& record) {
  function SetIndex (line 315) | inline void ChunkDecoder::SetIndex(uint64_t index) {

FILE: riegeli/chunk_encoding/chunk_encoder.cc
  type riegeli (line 26) | namespace riegeli {

FILE: riegeli/chunk_encoding/chunk_encoder.h
  function namespace (line 37) | namespace riegeli {

FILE: riegeli/chunk_encoding/compressor.cc
  type riegeli::chunk_encoding_internal (line 39) | namespace riegeli::chunk_encoding_internal {

FILE: riegeli/chunk_encoding/compressor.h
  function class (line 33) | class Compressor : public Object {

FILE: riegeli/chunk_encoding/compressor_options.cc
  type riegeli (line 29) | namespace riegeli {

FILE: riegeli/chunk_encoding/compressor_options.h
  function BrotliEncoder (line 37) | enum class BrotliEncoder {

FILE: riegeli/chunk_encoding/constants.h
  type class (line 25) | enum class
  function CompressionType (line 34) | enum class CompressionType : uint8_t {

FILE: riegeli/chunk_encoding/decompressor.cc
  type riegeli::chunk_encoding_internal (line 28) | namespace riegeli::chunk_encoding_internal {
    function UncompressedSize (line 30) | std::optional<uint64_t> UncompressedSize(const Chain& compressed_data,

FILE: riegeli/chunk_encoding/decompressor.h
  function namespace (line 42) | namespace riegeli::chunk_encoding_internal {

FILE: riegeli/chunk_encoding/deferred_encoder.cc
  type riegeli (line 41) | namespace riegeli {

FILE: riegeli/chunk_encoding/deferred_encoder.h
  function class (line 41) | class DeferredEncoder : public ChunkEncoder {

FILE: riegeli/chunk_encoding/field_projection.h
  function namespace (line 26) | namespace riegeli {
  function Field (line 118) | inline Field::Field(std::initializer_list<int> path) : path_(path) {

FILE: riegeli/chunk_encoding/hash.cc
  type riegeli::chunk_encoding_internal (line 29) | namespace riegeli::chunk_encoding_internal {
    function Hash (line 42) | uint64_t Hash(absl::string_view data) {
    function Hash (line 49) | uint64_t Hash(const Chain& data) {

FILE: riegeli/chunk_encoding/hash.h
  function namespace (line 23) | namespace riegeli::chunk_encoding_internal {

FILE: riegeli/chunk_encoding/simple_decoder.cc
  type riegeli (line 34) | namespace riegeli {

FILE: riegeli/chunk_encoding/simple_decoder.h
  function class (line 33) | class SimpleDecoder : public Object {

FILE: riegeli/chunk_encoding/simple_encoder.cc
  type riegeli (line 42) | namespace riegeli {

FILE: riegeli/chunk_encoding/simple_encoder.h
  function class (line 52) | class SimpleEncoder : public ChunkEncoder {

FILE: riegeli/chunk_encoding/transpose_decoder.cc
  type riegeli (line 56) | namespace riegeli {
    function Reader (line 59) | Reader* kEmptyReader() {
    type DataBucket (line 68) | struct DataBucket {
    type FieldIncluded (line 83) | enum class FieldIncluded {
    function ValidTag (line 90) | bool ValidTag(uint32_t tag) {
    type CallbackType (line 108) | enum class CallbackType : uint8_t {
    function CallbackType (line 147) | constexpr CallbackType operator+(CallbackType a, uint8_t b) {
    type StateMachineNodeTemplate (line 157) | struct StateMachineNodeTemplate {
    function CallbackType (line 171) | inline CallbackType GetCopyTagCallbackType(size_t tag_length) {
    function CallbackType (line 181) | inline CallbackType GetVarintCallbackType(
    function CallbackType (line 198) | inline CallbackType GetFixed32CallbackType(size_t tag_length) {
    function CallbackType (line 207) | inline CallbackType GetFixed64CallbackType(size_t tag_length) {
    function CallbackType (line 216) | inline CallbackType GetFixed32ExistenceCallbackType(size_t tag_length) {
    function CallbackType (line 225) | inline CallbackType GetFixed64ExistenceCallbackType(size_t tag_length) {
    function CallbackType (line 234) | inline CallbackType GetStringCallbackType(
    function CallbackType (line 254) | inline CallbackType GetStringExcludeCallbackType(
    function CallbackType (line 269) | inline CallbackType GetStringExistenceCallbackType(
    function CallbackType (line 285) | inline CallbackType GetStartProjectionGroupCallbackType(size_t tag_len...
    function CallbackType (line 293) | inline CallbackType GetEndProjectionGroupCallbackType(size_t tag_lengt...
    function CallbackType (line 302) | inline CallbackType GetCallbackType(FieldIncluded field_included, uint...
    type TransposeDecoder::StateMachineNode (line 370) | struct TransposeDecoder::StateMachineNode {
    type TransposeDecoder::Context (line 392) | struct TransposeDecoder::Context {
      type IncludeType (line 409) | enum class IncludeType : uint8_t {
      type IncludedField (line 420) | struct IncludedField {
    function Reader (line 972) | inline Reader* TransposeDecoder::GetBuffer(Context& context,
    function ABSL_ATTRIBUTE_NOINLINE (line 1040) | ABSL_ATTRIBUTE_NOINLINE absl::Status InvalidArgumentError(
    type TransposeDecoder::DecodingState (line 1045) | struct TransposeDecoder::DecodingState {
      class SubmessageStack (line 1052) | class SubmessageStack {
        method ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1054) | ABSL_ATTRIBUTE_ALWAYS_INLINE void Push(size_t position,
        type SubmessageStackElement (line 1062) | struct SubmessageStackElement {
        method Pop (line 1067) | Pop() {
        method ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1073) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool Empty() const { return size_ == ...
    function DecodingState (line 1110) | explicit DecodingState(TransposeDecoder* decoder, Context* context,
    function DecodingState (line 1127) | DecodingState(const DecodingState&) = delete;
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1130) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool SetCallbackType() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1137) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool CopyTagCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1157) | ABSL_ATTRIBUTE_ALWAYS_INLINE void MaskBuffer(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1168) | ABSL_ATTRIBUTE_ALWAYS_INLINE void MaskBuffer(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1179) | ABSL_ATTRIBUTE_ALWAYS_INLINE void MaskBuffer(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1190) | ABSL_ATTRIBUTE_ALWAYS_INLINE void MaskBuffer(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1198) | ABSL_ATTRIBUTE_ALWAYS_INLINE void MaskBuffer(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1206) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool VarintCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1225) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool FixedCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1242) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool FixedExistenceCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1255) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool StringCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1283) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool StartProjectionGroupCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1292) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool EndProjectionGroupCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1297) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool SubmessageStartCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1321) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool MessageStartCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1332) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool NonprotoCallback() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1347) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool HandleNode() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1441) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool TransitionNode() {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 1456) | ABSL_ATTRIBUTE_ALWAYS_INLINE bool Finish() {
  function ABSL_ATTRIBUTE_NOINLINE (line 1527) | ABSL_ATTRIBUTE_NOINLINE inline bool TransposeDecoder::SetCallbackType(

FILE: riegeli/chunk_encoding/transpose_decoder.h
  type StateMachineNode (line 92) | struct StateMachineNode
  type Context (line 93) | struct Context
  type DecodingState (line 94) | struct DecodingState

FILE: riegeli/chunk_encoding/transpose_encoder.cc
  type riegeli (line 63) | namespace riegeli {
    function IsProtoMessage (line 90) | bool IsProtoMessage(Reader& record) {
    type PriorityQueueEntry (line 137) | struct PriorityQueueEntry : WithCompare<PriorityQueueEntry> {
      method PriorityQueueEntry (line 138) | PriorityQueueEntry() = default;
      method PriorityQueueEntry (line 140) | explicit PriorityQueueEntry(uint32_t dest_index, size_t num_transiti...
      method StrongOrdering (line 148) | StrongOrdering RIEGELI_COMPARE(const PriorityQueueEntry& a,
    function BackwardWriter (line 308) | inline BackwardWriter* TransposeEncoder::GetBuffer(Node* node,

FILE: riegeli/chunk_encoding/transpose_encoder.h
  function RecyclingPoolOptions (line 110) | const RecyclingPoolOptions& recycling_pool_options() const

FILE: riegeli/chunk_encoding/transpose_internal.h
  function MessageId (line 26) | enum class MessageId : uint32_t {
  function Subtype (line 50) | enum class Subtype : uint8_t {

FILE: riegeli/containers/chunked_sorted_string_set.cc
  type riegeli (line 42) | namespace riegeli {
    function ChunkedSortedStringSet (line 44) | ChunkedSortedStringSet ChunkedSortedStringSet::FromSorted(
    function ChunkedSortedStringSet (line 49) | ChunkedSortedStringSet ChunkedSortedStringSet::FromUnsorted(
    function StrongOrdering (line 99) | StrongOrdering ChunkedSortedStringSet::Compare(
    function ChunkedSortedStringSet (line 295) | ChunkedSortedStringSet ChunkedSortedStringSet::Builder::Build() {

FILE: riegeli/containers/chunked_sorted_string_set.h
  function namespace (line 45) | namespace riegeli {
  function reference (line 367) | reference operator*() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function pointer (line 375) | pointer operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function explicit (line 402) | explicit IteratorImpl(const ChunkedSortedStringSet* set)
  function class (line 421) | class ChunkedSortedStringSet::SplitElements {
  function class (line 452) | class ChunkedSortedStringSet::Builder {
  function class (line 550) | class ChunkedSortedStringSet::NextInsertIterator {
  function Builder (line 601) | Builder* builder() const { return builder_; }
  function explicit (line 606) | explicit NextInsertIterator(Builder* builder) : builder_(builder) {}
  function ChunkedSortedStringSet (line 633) | ChunkedSortedStringSet ChunkedSortedStringSet::FromUnsorted(

FILE: riegeli/containers/linear_sorted_string_set.cc
  type riegeli (line 50) | namespace riegeli {
    function CommonPrefix (line 54) | inline size_t CommonPrefix(absl::string_view a, absl::string_view b) {
    function LinearSortedStringSet (line 88) | LinearSortedStringSet LinearSortedStringSet::FromSorted(
    function LinearSortedStringSet (line 93) | LinearSortedStringSet LinearSortedStringSet::FromUnsorted(
    function StrongOrdering (line 250) | StrongOrdering LinearSortedStringSet::Compare(const LinearSortedString...
    function StrongOrdering (line 601) | StrongOrdering LinearSortedStringSet::SplitElement::Compare(
    function StrongOrdering (line 642) | StrongOrdering LinearSortedStringSet::SplitElement::Compare(
    function LinearSortedStringSet (line 772) | LinearSortedStringSet LinearSortedStringSet::Builder::Build() {

FILE: riegeli/containers/linear_sorted_string_set.h
  function namespace (line 46) | namespace riegeli {
  function class (line 386) | class LinearSortedStringSet::SplitElement : public WithCompare<SplitElem...
  function RiegeliDebug (line 440) | void RiegeliDebug(const SplitElement& src, DebugStream& dest) {
  function class (line 462) | class LinearSortedStringSet::SplitElementIterator
  function class (line 553) | class LinearSortedStringSet::SplitElements {
  function class (line 586) | class LinearSortedStringSet::Builder {
  function class (line 678) | class LinearSortedStringSet::NextInsertIterator {
  function Builder (line 729) | Builder* builder() const { return builder_; }
  function explicit (line 734) | explicit NextInsertIterator(Builder* builder) : builder_(builder) {}
  function LinearSortedStringSet (line 757) | LinearSortedStringSet LinearSortedStringSet::FromUnsorted(Src&& src) {
  function remove_prefix (line 906) | inline void LinearSortedStringSet::SplitElement::remove_prefix(size_t le...
  function remove_suffix (line 919) | inline void LinearSortedStringSet::SplitElement::remove_suffix(size_t le...

FILE: riegeli/csv/csv_reader.cc
  type riegeli (line 43) | namespace riegeli {
    type csv_internal (line 550) | namespace csv_internal {
      function ReadStandaloneRecord (line 552) | inline bool ReadStandaloneRecord(CsvReaderBase& csv_reader,
    function ReadCsvRecordFromString (line 650) | absl::Status ReadCsvRecordFromString(absl::string_view src,

FILE: riegeli/csv/csv_reader.h
  function namespace (line 42) | namespace riegeli {
  function set_recovery (line 354) | void set_recovery(
  function CsvHeader (line 372) | const CsvHeader& header() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function CharClass (line 471) | enum class CharClass : uint8_t {
  function Reader (line 582) | Reader* SrcReader() const ABSL_ATTRIBUTE_LIFETIME_BOUND override {
  function explicit (line 594) | explicit CsvReader(Closed) -> CsvReader<DeleteCtad<Closed>>;
  function Reset (line 657) | inline void CsvReaderBase::Reset() {

FILE: riegeli/csv/csv_record.cc
  type riegeli (line 47) | namespace riegeli {
    function WriteDebugQuoted (line 51) | inline void WriteDebugQuoted(absl::string_view src, Writer& dest,
    function DebugQuotedIfNeeded (line 68) | inline std::string DebugQuotedIfNeeded(absl::string_view src) {
    type csv_internal (line 78) | namespace csv_internal {
      function WriteDebugQuotedIfNeeded (line 80) | void WriteDebugQuotedIfNeeded(absl::string_view src, Writer& dest) {
    function AsciiCaseInsensitive (line 101) | std::string AsciiCaseInsensitive(absl::string_view name) {
    function CsvHeader (line 118) | CsvHeader& CsvHeader::operator=(

FILE: riegeli/csv/csv_record.h
  function namespace (line 52) | namespace riegeli::csv_internal {
  function namespace (line 69) | namespace riegeli {
  function RiegeliRegisterSubobjects (line 354) | void RiegeliRegisterSubobjects(const CsvHeader* self,
  type Payload (line 360) | struct Payload {
  function CsvHeaderConstant (line 485) | constexpr CsvHeaderConstant(
  function class (line 550) | class CsvRecord : public WithEqual<CsvRecord> {
  function RiegeliRegisterSubobjects (line 859) | void RiegeliRegisterSubobjects(const CsvRecord* self,
  function namespace (line 886) | namespace csv_internal {
  function typename (line 892) | inline typename CsvHeader::iterator::reference CsvHeader::iterator::oper...
  function typename (line 897) | inline typename CsvHeader::iterator::pointer CsvHeader::iterator::operat...
  function Status (line 994) | Status CsvHeader::TryReset(Names&& names) {
  function Status (line 1000) | Status CsvHeader::TryReset(
  function MaybeResetToCachedPayload (line 1037) | inline bool CsvHeader::MaybeResetToCachedPayload(
  function Add (line 1062) | void CsvHeader::Add(StringInitializer name, Names&&... names) {
  function std (line 1082) | inline const std::function<std::string(absl::string_view)>&
  function CsvRecord (line 1213) | inline CsvRecord::CsvRecord(CsvHeader header)
  function Status (line 1234) | Status CsvRecord::TryReset(CsvHeader header, Fields&& fields) {
  function Status (line 1278) | Status CsvRecord::TryMerge(Src&& src) {
  function Status (line 1332) | Status CsvRecord::TrySplit(Dest& dest) const {

FILE: riegeli/csv/csv_writer.cc
  type riegeli (line 37) | namespace riegeli {

FILE: riegeli/csv/csv_writer.h
  function namespace (line 46) | namespace riegeli {
  function CsvHeader (line 263) | const CsvHeader& header() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  function Writer (line 436) | Writer* DestWriter() const ABSL_ATTRIBUTE_LIFETIME_BOUND override {
  function explicit (line 448) | explicit CsvWriter(Closed) -> CsvWriter<DeleteCtad<Closed>>;
  function Reset (line 510) | inline void CsvWriterBase::Reset() {
  function namespace (line 519) | namespace csv_internal {
  function WriteRecord (line 532) | bool CsvWriterBase::WriteRecord(const Record& record) {
  function WriteRecord (line 536) | inline bool CsvWriterBase::WriteRecord(
  function WriteRecordInternal (line 542) | bool CsvWriterBase::WriteRecordInternal(const Record& record) {
  function Options (line 620) | Options options) {
  function std (line 633) | inline std::string WriteCsvRecordToString(

FILE: riegeli/digests/adler32_digester.cc
  type riegeli (line 25) | namespace riegeli {

FILE: riegeli/digests/adler32_digester.h
  function namespace (line 22) | namespace riegeli {

FILE: riegeli/digests/crc32_digester.cc
  type riegeli (line 25) | namespace riegeli {

FILE: riegeli/digests/crc32_digester.h
  function namespace (line 22) | namespace riegeli {

FILE: riegeli/digests/crc32c_digester.h
  function class (line 43) | class Crc32cDigester {
  function MaskCrc32c (line 65) | uint32_t MaskCrc32c(uint32_t unmasked) {
  function UnmaskCrc32c (line 72) | uint32_t UnmaskCrc32c(uint32_t masked) {

FILE: riegeli/digests/digest_converter.h
  function namespace (line 31) | namespace riegeli {
  function To (line 71) | To Convert(const From& digest) {
  function To (line 89) | static To Convert(const std::array<char, size>& digest) {
  function To (line 104) | static To Convert(uint32_t digest) {
  function To (line 118) | static To Convert(uint64_t digest) {
  function To (line 132) | static To Convert(absl::uint128 digest) {
  function To (line 153) | static To Convert(std::array<char, sizeof(uint32_t)> digest) {
  function To (line 164) | static To Convert(std::array<char, sizeof(uint64_t)> digest) {
  function To (line 176) | static To Convert(std::array<char, sizeof(absl::uint128)> digest) {
  function To (line 190) | static To Convert(const std::array<uint64_t, size>& digest) {
  function To (line 213) | static To Convert(const std::array<char, size>& digest) {
  function namespace (line 284) | namespace digest_converter_internal {

FILE: riegeli/digests/digester_handle.cc
  type riegeli (line 32) | namespace riegeli {

FILE: riegeli/digests/digester_handle.h
  function namespace (line 44) | namespace riegeli {
  function class (line 127) | class DigesterBaseHandle : public WithEqual<DigesterBaseHandle> {
  function SetWriteSizeHint (line 155) | void SetWriteSizeHint(std::optional<Position> write_size_hint) {
  function Write (line 162) | bool Write(char src) { return Write(absl::string_view(&src, 1)); }
  function Write (line 164) | bool Write(char8_t src) { return Write(static_cast<char>(src)); }
  function Write (line 166) | bool Write(BytesRef src) { return methods()->write(target(), src); }
  function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 167) | ABSL_ATTRIBUTE_ALWAYS_INLINE
  function Write (line 169) | bool Write(const Chain& src) { return methods()->write_chain(target(), s...
  function Write (line 170) | bool Write(const absl::Cord& src) {
  function Write (line 173) | bool Write(ByteFill src) { return methods()->write_byte_fill(target(), s...
  function Close (line 213) | bool Close() { return methods()->close(target()); }
  function SetWriteSizeHintMethod (line 295) | void SetWriteSizeHintMethod(TypeErasedRef target,
  function WriteMethod (line 308) | bool WriteMethod(TypeErasedRef target, absl::string_view src) {
  function WriteChainMethod (line 320) | bool WriteChainMethod(TypeErasedRef target, const Chain& src) {
  function WriteCordMethod (line 338) | bool WriteCordMethod(TypeErasedRef target, const absl::Cord& src) {
  function WriteByteFillMethod (line 356) | bool WriteByteFillMethod(TypeErasedRef target, ByteFill src) {
  function CloseMethod (line 367) | bool CloseMethod(TypeErasedRef target) {
  type Methods (line 385) | struct Methods {
  function explicit (line 413) | explicit DigesterBaseHandle(const Methods* methods, TypeErasedRef target)
  function Methods (line 416) | const Methods* methods() const { return methods_; }
  function namespace (line 426) | namespace digester_handle_internal {
  function DigestType (line 521) | static DigestType DigestMethodDefault(
  function DigestType (line 527) | DigestType DigestMethod(TypeErasedRef target) {
  function Methods (line 537) | struct Methods : DigesterBaseHandle::Methods {
  function Methods (line 549) | const Methods* methods() const {
  function class (line 605) | class DigesterBaseHandle::DigesterStringifySink {

FILE: riegeli/digests/digesting_reader.cc
  type riegeli (line 37) | namespace riegeli {
    function ABSL_ATTRIBUTE_COLD (line 41) | ABSL_ATTRIBUTE_COLD absl::Status FailedStatus(DigesterBaseHandle diges...

FILE: riegeli/digests/digesting_reader.h
  function namespace (line 43) | namespace riegeli {
  function MakeBuffer (line 285) | inline void DigestingReaderBase::MakeBuffer(Reader& src) {
  function Done (line 307) | void Done(DigestingReader& self) {

FILE: riegeli/digests/digesting_writer.cc
  type riegeli (line 36) | namespace riegeli {
    type digesting_writer_internal (line 38) | namespace digesting_writer_internal {
      function FailedStatus (line 40) | absl::Status FailedStatus(DigesterBaseHandle digester) {
    function Reader (line 157) | Reader* DigestingWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/digests/digesting_writer.h
  function namespace (line 48) | namespace riegeli {
  function MakeBuffer (line 322) | inline void DigestingWriterBase::MakeBuffer(Writer& dest) {
  function Done (line 344) | void Done(DigestingWriter& self) {
  function namespace (line 445) | namespace digesting_writer_internal {
  function DesiredDigestType (line 459) | DesiredDigestType DigestFromImpl(std::tuple<Srcs...> srcs,
  function DesiredDigestType (line 484) | DesiredDigestType DigestFromImpl(std::tuple<Srcs...> srcs,

FILE: riegeli/digests/highwayhash_digester.cc
  type riegeli (line 19) | namespace riegeli {

FILE: riegeli/digests/highwayhash_digester.h
  function namespace (line 30) | namespace riegeli {

FILE: riegeli/digests/md5_digester.h
  function namespace (line 22) | namespace riegeli {

FILE: riegeli/digests/openssl_digester.h
  function namespace (line 26) | namespace riegeli {

FILE: riegeli/digests/sha1_digester.h
  function namespace (line 22) | namespace riegeli {

FILE: riegeli/digests/sha256_digester.h
  function namespace (line 22) | namespace riegeli {

FILE: riegeli/digests/sha512_256_digester.h
  function namespace (line 22) | namespace riegeli {

FILE: riegeli/digests/sha512_digester.h
  function namespace (line 22) | namespace riegeli {

FILE: riegeli/digests/wrapping_digester.h
  function namespace (line 37) | namespace riegeli {
  function SetWriteSizeHint (line 107) | void SetWriteSizeHint(std::optional<Position> write_size_hint) {
  function Write (line 111) | bool Write(absl::string_view src) { return base_.get().Write(src); }
  function Write (line 112) | bool Write(const Chain& src) { return base_.get().Write(src); }
  function Write (line 113) | bool Write(const absl::Cord& src) { return base_.get().Write(src); }
  function Write (line 114) | bool Write(ByteFill src) { return base_.get().Write(src); }
  function Close (line 115) | bool Close() { return !base_.IsOwning() || base_.get().Close(); }

FILE: riegeli/gcs/gcs_internal.h
  function namespace (line 22) | namespace riegeli::gcs_internal {

FILE: riegeli/gcs/gcs_object.cc
  type riegeli (line 38) | namespace riegeli {
    function IsUtf8Tail (line 44) | inline bool IsUtf8Tail(char ch, unsigned char start = 0x80,

FILE: riegeli/gcs/gcs_object.h
  function namespace (line 34) | namespace riegeli {
  function GcsObject (line 181) | inline GcsObject::GcsObject(absl::string_view uri) { ParseUri(uri); }
  function Reset (line 183) | inline void GcsObject::Reset() {
  function Reset (line 190) | inline void GcsObject::Reset(StringInitializer bucket_name,
  function Reset (line 200) | inline void GcsObject::Reset(absl::string_view uri) {

FILE: riegeli/gcs/gcs_reader.cc
  type riegeli (line 43) | namespace riegeli {

FILE: riegeli/gcs/gcs_reader.h
  function namespace (line 49) | namespace riegeli {
  function Initialize (line 241) | void GcsReader::Initialize(const Options& options,
  function SetReadObject (line 289) | void GcsReader::SetReadObject(

FILE: riegeli/gcs/gcs_writer.cc
  type riegeli (line 44) | namespace riegeli {
    function Reader (line 226) | Reader* GcsWriter::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/gcs/gcs_writer.h
  function namespace (line 59) | namespace riegeli {
  function google (line 199) | const google::cloud::storage::ObjectMetadata& metadata() const&;
  function Initialize (line 450) | void GcsWriter::Initialize(
  function SetFunctions (line 480) | void GcsWriter::SetFunctions(
  function google (line 539) | inline google::cloud::storage::ObjectMetadata&& GcsWriter::metadata() && {

FILE: riegeli/lines/line_reading.cc
  type riegeli (line 34) | namespace riegeli {
    function ReadFlatAndSkip (line 45) | inline void ReadFlatAndSkip(Reader& src, size_t length_to_read,
    function ReadFlatAndSkip (line 57) | inline void ReadFlatAndSkip(Reader& src, size_t length_to_read,
    function ReadFlatAndSkip (line 69) | inline void ReadFlatAndSkip(Reader& src, size_t length_to_read,
    function ReadFlat (line 82) | inline void ReadFlat(Reader& src, size_t length, Dest& dest) {
    function ABSL_ATTRIBUTE_COLD (line 87) | ABSL_ATTRIBUTE_COLD bool FailMaxLineLengthExceeded(Reader& src, Dest& ...
    function FoundNewline (line 95) | inline bool FoundNewline(Reader& src, Dest& dest, ReadLineOptions opti...
    function ReadLineInternal (line 107) | inline bool ReadLineInternal(Reader& src, Dest& dest, ReadLineOptions ...
    function ReadLine (line 179) | bool ReadLine(Reader& src, absl::string_view& dest, ReadLineOptions op...
    function ReadLine (line 244) | bool ReadLine(Reader& src, std::string& dest, ReadLineOptions options) {
    function ReadLine (line 249) | bool ReadLine(Reader& src, Chain& dest, ReadLineOptions options) {
    function ReadLine (line 254) | bool ReadLine(Reader& src, absl::Cord& dest, ReadLineOptions options) {
    function SkipUtf8Bom (line 259) | void SkipUtf8Bom(Reader& src) {

FILE: riegeli/lines/line_reading.h
  function namespace (line 31) | namespace riegeli {

FILE: riegeli/lines/line_writing.h
  function namespace (line 32) | namespace riegeli {

FILE: riegeli/lines/newline.h
  type class (line 23) | enum class
  function WriteNewline (line 29) | enum class WriteNewline {

FILE: riegeli/lines/text_reader.cc
  type riegeli (line 33) | namespace riegeli {
    type text_reader_internal (line 95) | namespace text_reader_internal {

FILE: riegeli/lines/text_reader.h
  function namespace (line 39) | namespace riegeli {
  function explicit (line 165) | explicit TextReader(Closed) noexcept

FILE: riegeli/lines/text_writer.cc
  type riegeli (line 33) | namespace riegeli {
    type text_writer_internal (line 53) | namespace text_writer_internal {
      class TextWriterImpl<WriteNewline::kCrLf> (line 82) | class TextWriterImpl<WriteNewline::kCrLf>

FILE: riegeli/lines/text_writer.h
  function namespace (line 38) | namespace riegeli {
  function explicit (line 130) | explicit TextWriter(Closed) noexcept
  function Initialize (line 195) | inline void TextWriterBase::Initialize(Writer* dest) {

FILE: riegeli/lz4/lz4_dictionary.cc
  type riegeli (line 30) | namespace riegeli {
    function LZ4F_CDict (line 36) | inline const LZ4F_CDict* Lz4Dictionary::Repr::PrepareCompressionDictio...
    function LZ4F_CDict (line 44) | const LZ4F_CDict* Lz4Dictionary::PrepareCompressionDictionary() const

FILE: riegeli/lz4/lz4_dictionary.h
  type LZ4F_CDict (line 38) | typedef struct LZ4F_CDict_s LZ4F_CDict;
  function namespace (line 40) | namespace riegeli {

FILE: riegeli/lz4/lz4_reader.cc
  type riegeli (line 41) | namespace riegeli {
    type lz4_internal (line 336) | namespace lz4_internal {
      function GetFrameInfo (line 338) | inline bool GetFrameInfo(Reader& src, LZ4F_frameInfo_t& frame_info,
    function RecognizeLz4 (line 375) | bool RecognizeLz4(Reader& src,
    function Lz4UncompressedSize (line 381) | std::optional<Position> Lz4UncompressedSize(

FILE: riegeli/lz4/lz4_reader.h
  function namespace (line 40) | namespace riegeli {
  function explicit (line 277) | explicit Lz4Reader(Closed) -> Lz4Reader<DeleteCtad<Closed>>;
  function Reset (line 350) | inline void Lz4ReaderBase::Reset(

FILE: riegeli/lz4/lz4_writer.cc
  type riegeli (line 43) | namespace riegeli {
    function Reader (line 268) | Reader* Lz4WriterBase::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/lz4/lz4_writer.h
  function namespace (line 40) | namespace riegeli {
  function RecyclingPoolOptions (line 233) | const RecyclingPoolOptions& recycling_pool_options() const
  function Writer (line 351) | Writer* DestWriter() const ABSL_ATTRIBUTE_LIFETIME_BOUND override {
  function explicit (line 364) | explicit Lz4Writer(Closed) -> Lz4Writer<DeleteCtad<Closed>>;
  function Reset (line 425) | inline void Lz4WriterBase::Reset(

FILE: riegeli/messages/context_projection.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 34) | ABSL_POINTERS_DEFAULT_NONNULL
  function namespace (line 83) | namespace context_projection_internal {
  function Status (line 156) | Status HandleVarint(uint64_t repr, Context&... context) const {
  function Status (line 179) | Status DynamicHandleVarint(Accepted&& accepted, uint64_t repr,
  function Status (line 195) | Status HandleFixed32(uint32_t repr, Context&... context) const {
  function Status (line 218) | Status DynamicHandleFixed32(Accepted&& accepted, uint32_t repr,
  function Status (line 234) | Status HandleFixed64(uint64_t repr, Context&... context) const {
  function Status (line 257) | Status DynamicHandleFixed64(Accepted&& accepted, uint64_t repr,
  function Status (line 274) | Status HandleLengthDelimitedFromReader(ReaderSpan<> repr,
  function Status (line 291) | Status HandleLengthDelimitedFromCord(CordIteratorSpan repr,
  function Status (line 309) | Status HandleLengthDelimitedFromString(absl::string_view repr,
  function Status (line 336) | Status DynamicHandleLengthDelimitedFromReader(
  function Status (line 354) | Status DynamicHandleLengthDelimitedFromCord(Accepted&& accepted,
  function Status (line 374) | Status DynamicHandleLengthDelimitedFromString(
  function Status (line 390) | Status HandleStartGroup(Context&... context) const {
  function Status (line 413) | Status DynamicHandleStartGroup(Accepted&& accepted,
  function Status (line 429) | Status HandleEndGroup(Context&... context) const {
  function Status (line 452) | Status DynamicHandleEndGroup(Accepted&& accepted,

FILE: riegeli/messages/dynamic_field_handler.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 32) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/field_copier.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 36) | ABSL_POINTERS_DEFAULT_NONNULL
  function Status (line 133) | Status HandleVarint(uint64_t repr, Context&... context) const {
  function Status (line 141) | Status HandleFixed32(uint32_t repr, Context&... context) const {
  function Status (line 149) | Status HandleFixed64(uint64_t repr, Context&... context) const {
  function Status (line 158) | Status HandleLengthDelimitedFromReader(ReaderSpan<> repr,
  function Status (line 169) | Status HandleLengthDelimitedFromCord(
  function Status (line 181) | Status HandleLengthDelimitedFromString(absl::string_view repr,
  function Status (line 191) | Status HandleStartGroup(Context&... context) const {
  function Status (line 199) | Status HandleEndGroup(Context&... context) const {
  function Status (line 240) | Status DynamicHandleVarint(int field_number, uint64_t repr,
  function Status (line 257) | Status DynamicHandleFixed32(int field_number, uint32_t repr,
  function Status (line 274) | Status DynamicHandleFixed64(int field_number, uint64_t repr,
  function Status (line 289) | Status DynamicHandleLengthDelimitedFromReader(
  function Status (line 300) | Status DynamicHandleLengthDelimitedFromCord(
  function Status (line 312) | Status DynamicHandleLengthDelimitedFromString(
  function Status (line 331) | Status DynamicHandleStartGroup(int field_number,
  function Status (line 348) | Status DynamicHandleEndGroup(int field_number,
  type AcceptAnyField (line 363) | struct AcceptAnyField {
  function AnyFieldCopierType (line 367) | constexpr AnyFieldCopierType AnyFieldCopier() {
  function field_number_ (line 376) | constexpr UnboundFieldCopierType(int field_number)
  function Status (line 387) | Status HandleVarint(uint64_t repr, Context&... context) const {
  function Status (line 395) | Status HandleFixed32(uint32_t repr, Context&... context) const {
  function Status (line 403) | Status HandleFixed64(uint64_t repr, Context&... context) const {
  function Status (line 412) | Status HandleLengthDelimitedFromReader(ReaderSpan<> repr,
  function Status (line 423) | Status HandleLengthDelimitedFromCord(
  function Status (line 435) | Status HandleLengthDelimitedFromString(absl::string_view repr,
  function Status (line 445) | Status HandleStartGroup(Context&... context) const {
  function Status (line 453) | Status HandleEndGroup(Context&... context) const {

FILE: riegeli/messages/field_handler_map.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 40) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/field_handlers.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 28) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/field_handlers.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 44) | ABSL_POINTERS_DEFAULT_NONNULL
  function namespace (line 465) | namespace field_handlers_internal {
  function Status (line 763) | Status HandleVarint(uint64_t repr, Context&... context) const {
  function Status (line 774) | Status HandleFixed32(uint32_t repr, Context&... context) const {
  function Status (line 785) | Status HandleFixed64(uint64_t repr, Context&... context) const {
  function Status (line 797) | Status HandleLengthDelimitedFromReader(ReaderSpan<> repr,
  function Status (line 811) | Status HandleLengthDelimitedFromCord(CordIteratorSpan repr,
  function Status (line 826) | Status HandleLengthDelimitedFromString(absl::string_view repr,
  function Status (line 858) | Status HandleLengthDelimitedFromReader(ReaderSpan<> repr,

FILE: riegeli/messages/map_entry_field.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 20) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/message_wire_format.h
  function WireType (line 30) | enum class WireType : uint32_t {
  function MakeTag (line 89) | constexpr uint32_t MakeTag(int field_number, WireType wire_type) {
  function WireType (line 94) | constexpr WireType GetTagWireType(uint32_t tag) {
  function GetTagFieldNumber (line 98) | constexpr int GetTagFieldNumber(uint32_t tag) {

FILE: riegeli/messages/parse_message.cc
  type riegeli (line 47) | namespace riegeli {
    function ABSL_ATTRIBUTE_COLD (line 51) | ABSL_ATTRIBUTE_COLD inline absl::Status ParseError(
    function ABSL_ATTRIBUTE_COLD (line 57) | ABSL_ATTRIBUTE_COLD inline absl::Status ParseError(
    function CheckInitialized (line 62) | inline absl::Status CheckInitialized(google::protobuf::MessageLite& dest,
    function CheckInitialized (line 73) | inline absl::Status CheckInitialized(Reader& src,
    function ParseMessageFromReaderSpanImpl (line 86) | absl::Status ParseMessageFromReaderSpanImpl(ReaderSpan<ReaderType> src,
    function ParseLengthPrefixedMessageImpl (line 134) | absl::Status ParseLengthPrefixedMessageImpl(Src& src,
    type parse_message_internal (line 150) | namespace parse_message_internal {
      function ParseMessageImpl (line 152) | absl::Status ParseMessageImpl(Reader& src, google::protobuf::Message...
      function ParseMessageImpl (line 189) | absl::Status ParseMessageImpl(ReaderSpan<Reader> src,
      function ParseMessageImpl (line 195) | absl::Status ParseMessageImpl(ReaderSpan<> src,
    function ParseLengthPrefixedMessage (line 203) | absl::Status ParseLengthPrefixedMessage(Reader& src,
    function ParseLengthPrefixedMessage (line 209) | absl::Status ParseLengthPrefixedMessage(LimitingReaderBase& src,
    function ParseMessage (line 215) | absl::Status ParseMessage(BytesRef src, google::protobuf::MessageLite&...
    function ParseMessage (line 238) | absl::Status ParseMessage(const Chain& src, google::protobuf::MessageL...
    function ParseMessage (line 274) | absl::Status ParseMessage(const absl::Cord& src,
    function ParseMessage (line 311) | absl::Status ParseMessage(CordIteratorSpan src,

FILE: riegeli/messages/parse_message.h
  function namespace (line 39) | namespace riegeli {

FILE: riegeli/messages/serialize_message.cc
  type riegeli (line 48) | namespace riegeli {
    function ABSL_ATTRIBUTE_COLD (line 52) | ABSL_ATTRIBUTE_COLD inline absl::Status FailSizeOverflow(
    function ABSL_ATTRIBUTE_COLD (line 59) | ABSL_ATTRIBUTE_COLD inline absl::Status FailSizeOverflow(
    function ABSL_ATTRIBUTE_COLD (line 64) | ABSL_ATTRIBUTE_COLD inline absl::Status FailSizeOverflow(
    function SerializeMessageUsingStream (line 70) | inline absl::Status SerializeMessageUsingStream(
    function SerializeMessageHavingSize (line 95) | inline absl::Status SerializeMessageHavingSize(
    function SerializeMessageHavingSize (line 123) | inline absl::Status SerializeMessageHavingSize(
    type serialize_message_internal (line 163) | namespace serialize_message_internal {
      function SerializeMessageImpl (line 165) | absl::Status SerializeMessageImpl(const google::protobuf::MessageLit...
      function SerializeMessageImpl (line 181) | absl::Status SerializeMessageImpl(const google::protobuf::MessageLit...
    function SerializeLengthPrefixedMessage (line 200) | absl::Status SerializeLengthPrefixedMessage(
    function SerializeMessage (line 218) | absl::Status SerializeMessage(const google::protobuf::MessageLite& src,
    function SerializeMessage (line 265) | absl::Status SerializeMessage(const google::protobuf::MessageLite& src,
    function SerializeMessage (line 304) | absl::Status SerializeMessage(const google::protobuf::MessageLite& src,
    function SerializeMessage (line 346) | absl::Status SerializeMessage(const google::protobuf::MessageLite& src,

FILE: riegeli/messages/serialize_message.h
  function namespace (line 42) | namespace riegeli {

FILE: riegeli/messages/serialized_message_assembler.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 39) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/serialized_message_assembler.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 51) | ABSL_POINTERS_DEFAULT_NONNULL
  function Status (line 548) | Status SerializedMessageAssembler::RewriteFields(

FILE: riegeli/messages/serialized_message_backward_writer.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 35) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/serialized_message_backward_writer.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 46) | ABSL_POINTERS_DEFAULT_NONNULL
  function set_dest (line 273) | inline void SerializedMessageBackwardWriter::set_dest(

FILE: riegeli/messages/serialized_message_internal.h
  function namespace (line 29) | namespace riegeli {

FILE: riegeli/messages/serialized_message_reader.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 32) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/serialized_message_reader.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 54) | ABSL_POINTERS_DEFAULT_NONNULL
  function absl (line 1189) | inline absl::Status SkipLengthDelimitedFromReader(ReaderSpan<> value) {
  function absl (line 1215) | inline absl::Status SkipLengthDelimitedFromCord(CordIteratorSpan value) {

FILE: riegeli/messages/serialized_message_reader_internal.h
  function absl (line 604) | inline absl::Status AnnotateWithFieldNumber(absl::Status status,
  function absl (line 614) | inline absl::Status AnnotateWithSourceAndFieldNumber(absl::Status status,
  function ReadVarintField (line 654) | inline bool ReadVarintField(
  function ReadFixed32Field (line 677) | inline bool ReadFixed32Field(
  function ReadFixed64Field (line 700) | inline bool ReadFixed64Field(
  function ReadLengthDelimitedFieldFromReader (line 723) | inline bool ReadLengthDelimitedFieldFromReader(
  function ReadLengthDelimitedFieldFromCord (line 772) | inline bool ReadLengthDelimitedFieldFromCord(
  function ReadLengthDelimitedFieldFromString (line 814) | inline bool ReadLengthDelimitedFieldFromString(
  function ReadStartGroupField (line 839) | inline bool ReadStartGroupField(
  function ReadEndGroupField (line 862) | inline bool ReadEndGroupField(

FILE: riegeli/messages/serialized_message_writer.cc
  function ABSL_POINTERS_DEFAULT_NONNULL (line 40) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/serialized_message_writer.h
  function ABSL_POINTERS_DEFAULT_NONNULL (line 49) | ABSL_POINTERS_DEFAULT_NONNULL

FILE: riegeli/messages/text_parse_message.cc
  type riegeli (line 35) | namespace riegeli {
    type text_parse_message_internal (line 37) | namespace text_parse_message_internal {
      function TextParseMessageImpl (line 60) | absl::Status TextParseMessageImpl(Reader& src, google::protobuf::Mes...
    type text_parse_message_internal (line 58) | namespace text_parse_message_internal {
      function TextParseMessageImpl (line 60) | absl::Status TextParseMessageImpl(Reader& src, google::protobuf::Mes...
    function TextParseMessage (line 77) | absl::Status TextParseMessage(BytesRef src, google::protobuf::Message&...
    function TextParseMessage (line 82) | absl::Status TextParseMessage(const Chain& src, google::protobuf::Mess...
    function TextParseMessage (line 87) | absl::Status TextParseMessage(const absl::Cord& src,

FILE: riegeli/messages/text_parse_message.h
  function namespace (line 40) | namespace text_parse_message_internal {
  function class (line 58) | class TextParseMessageOptions {

FILE: riegeli/messages/text_print_message.cc
  type riegeli (line 33) | namespace riegeli {
    type text_print_message_internal (line 35) | namespace text_print_message_internal {
      function TextPrintMessageImpl (line 37) | absl::Status TextPrintMessageImpl(const google::protobuf::Message& src,
    function TextPrintMessage (line 65) | absl::Status TextPrintMessage(const google::protobuf::Message& src,
    function TextPrintMessage (line 71) | absl::Status TextPrintMessage(const google::protobuf::Message& src, Ch...
    function TextPrintMessage (line 76) | absl::Status TextPrintMessage(const google::protobuf::Message& src,

FILE: riegeli/messages/text_print_message.h
  function class (line 34) | class TextPrintMessageOptions {

FILE: riegeli/ordered_varint/ordered_varint_internal.h
  function namespace (line 23) | namespace riegeli {

FILE: riegeli/ordered_varint/ordered_varint_reading.cc
  type riegeli::ordered_varint_internal (line 24) | namespace riegeli::ordered_varint_internal {
    function ReadOrderedVarint32Slow (line 26) | bool ReadOrderedVarint32Slow(Reader& src, uint32_t& dest) {
    function ReadOrderedVarint64Slow (line 63) | bool ReadOrderedVarint64Slow(Reader& src, uint64_t& dest) {

FILE: riegeli/ordered_varint/ordered_varint_reading.h
  function namespace (line 24) | namespace riegeli {

FILE: riegeli/ordered_varint/ordered_varint_writing.cc
  type riegeli::ordered_varint_internal (line 25) | namespace riegeli::ordered_varint_internal {
    function WriteOrderedVarint32Slow (line 27) | bool WriteOrderedVarint32Slow(uint32_t data, Writer& dest) {
    function WriteOrderedVarint64Slow (line 57) | bool WriteOrderedVarint64Slow(uint64_t data, Writer& dest) {

FILE: riegeli/ordered_varint/ordered_varint_writing.h
  function namespace (line 27) | namespace riegeli {

FILE: riegeli/records/block.h
  function namespace (line 30) | namespace riegeli::records_internal {

FILE: riegeli/records/chunk_reader.cc
  type riegeli (line 39) | namespace riegeli {

FILE: riegeli/records/chunk_reader.h
  function namespace (line 34) | namespace riegeli {
  function Reset (line 366) | inline void DefaultChunkReaderBase::Reset(Closed) {
  function Reset (line 375) | inline void DefaultChunkReaderBase::Reset() {

FILE: riegeli/records/chunk_writer.cc
  type riegeli (line 40) | namespace riegeli {
    type records_internal (line 42) | namespace records_internal {
      function Position (line 44) | Position PosAfterPadding(Position pos, Position padding) {

FILE: riegeli/records/chunk_writer.h
  function namespace (line 35) | namespace riegeli {
  function ChunkWriter (line 280) | inline ChunkWriter::ChunkWriter(ChunkWriter&& that) noexcept
  function Reset (line 289) | inline void ChunkWriter::Reset(Closed) {
  function Reset (line 294) | inline void ChunkWriter::Reset() {
  function Flush (line 299) | inline bool ChunkWriter::Flush(FlushType flush_type) {
  function Position (line 303) | inline Position ChunkWriter::PosAfterWriteChunk(
  function DefaultChunkWriterBase (line 308) | inline DefaultChunkWriterBase::DefaultChunkWriterBase(

FILE: riegeli/records/record_position.cc
  type riegeli (line 44) | namespace riegeli {
    type records_internal (line 115) | namespace records_internal {
      type Visitor (line 122) | struct Visitor {

FILE: riegeli/records/record_position.h
  function namespace (line 37) | namespace riegeli {
  function namespace (line 131) | namespace records_internal {
  function class (line 185) | class ABSL_ATTRIBUTE_TRIVIAL_ABI FutureRecordPosition {
  function RecordPosition (line 217) | inline RecordPosition::RecordPosition(uint64_t chunk_begin,
  function namespace (line 225) | namespace records_internal {
  function FutureChunkBegin (line 273) | inline FutureChunkBegin::FutureChunkBegin(FutureChunkBegin&& that) noexcept
  function FutureRecordPosition (line 290) | inline FutureRecordPosition::FutureRecordPosition(RecordPosition pos) no...
  function FutureRecordPosition (line 293) | inline FutureRecordPosition::FutureRecordPosition(
  function FutureRecordPosition (line 297) | inline FutureRecordPosition::FutureRecordPosition(
  function FutureRecordPosition (line 308) | inline FutureRecordPosition::FutureRecordPosition(

FILE: riegeli/records/record_reader.cc
  type riegeli (line 60) | namespace riegeli {
    class RecordsMetadataDescriptors::ErrorCollector (line 62) | class RecordsMetadataDescriptors::ErrorCollector
      method RecordError (line 65) | void RecordError(absl::string_view filename, absl::string_view eleme...
      method ErrorCollector (line 76) | explicit ErrorCollector(RecordsMetadataDescriptors* descriptors)
    function RecordReaderBase (line 117) | RecordReaderBase& RecordReaderBase::operator=(
    class RecordReaderBase::ChunkSearchTraits (line 534) | class RecordReaderBase::ChunkSearchTraits {
      method ChunkSearchTraits (line 536) | explicit ChunkSearchTraits(RecordReaderBase* self)
      method Empty (line 541) | bool Empty(Position low, Position high) const { return low >= high; }
      method Middle (line 543) | std::optional<Position> Middle(Position low, Position high) const {
    type ChunkSuffix (line 582) | struct ChunkSuffix {

FILE: riegeli/records/record_reader.h
  function namespace (line 54) | namespace riegeli {
  function RecordPosition (line 326) | RecordPosition last_pos() const;
  function explicit (line 642) | explicit RecordReader(Closed) -> RecordReader<DeleteCtad<Closed>>;
  function TryRecovery (line 664) | inline bool RecordReaderBase::TryRecovery() {
  function namespace (line 688) | namespace record_reader_internal {

FILE: riegeli/records/record_writer.cc
  type riegeli (line 66) | namespace riegeli {
    class FileDescriptorCollector (line 70) | class FileDescriptorCollector {
      method FileDescriptorCollector (line 72) | explicit FileDescriptorCollector(
      method AddFile (line 77) | void AddFile(const google::protobuf::FileDescriptor* file_descriptor) {
    function SetRecordType (line 93) | void SetRecordType(const google::protobuf::Descriptor& descriptor,
    class RecordWriterBase::Worker (line 174) | class RecordWriterBase::Worker {
      method Done (line 217) | virtual void Done() {}
    class RecordWriterBase::SerialWorker (line 382) | class RecordWriterBase::SerialWorker : public Worker {
      method OpenChunk (line 389) | void OpenChunk() override { chunk_encoder_->Clear(); }
    function FutureRecordPosition (line 486) | FutureRecordPosition RecordWriterBase::SerialWorker::LastPos() const {
    function FutureRecordPosition (line 494) | FutureRecordPosition RecordWriterBase::SerialWorker::Pos() const {
    function Position (line 498) | Position RecordWriterBase::SerialWorker::EstimatedSize() const {
    class RecordWriterBase::ParallelWorker (line 504) | class RecordWriterBase::ParallelWorker : public Worker {
      method OpenChunk (line 513) | void OpenChunk() override { chunk_encoder_ = MakeChunkEncoder(); }
      type ChunkPromises (line 531) | struct ChunkPromises {
      type DoneRequest (line 537) | struct DoneRequest {
      type AnnotateStatusRequest (line 540) | struct AnnotateStatusRequest {
      type WriteChunkRequest (line 544) | struct WriteChunkRequest {
      type WritePaddingRequest (line 548) | struct WritePaddingRequest {
      type FlushRequest (line 551) | struct FlushRequest {
    type Visitor (line 573) | struct Visitor {
    type Visitor (line 783) | struct Visitor {
    function FutureRecordPosition (line 807) | FutureRecordPosition RecordWriterBase::ParallelWorker::LastPos() const {
    function FutureRecordPosition (line 817) | FutureRecordPosition RecordWriterBase::ParallelWorker::Pos() const {
    function Position (line 826) | Position RecordWriterBase::ParallelWorker::EstimatedSize() const {
    function RecordWriterBase (line 858) | RecordWriterBase& RecordWriterBase::operator=(
    function FutureRecordPosition (line 1071) | FutureRecordPosition RecordWriterBase::LastPos() const {
    function FutureRecordPosition (line 1085) | FutureRecordPosition RecordWriterBase::Pos() const {
    function Position (line 1090) | Position RecordWriterBase::EstimatedSize() const {

FILE: riegeli/records/record_writer.h
  function namespace (line 55) | namespace riegeli {

FILE: riegeli/records/skipped_region.cc
  type riegeli (line 22) | namespace riegeli {

FILE: riegeli/records/skipped_region.h
  function namespace (line 27) | namespace riegeli {

FILE: riegeli/records/tools/describe_riegeli_file.cc
  type riegeli::tools (line 71) | namespace riegeli::tools {
    function DescribeFileMetadataChunk (line 74) | absl::Status DescribeFileMetadataChunk(const Chunk& chunk,
    function ReadRecords (line 105) | absl::Status ReadRecords(
    function DescribeSimpleChunk (line 121) | absl::Status DescribeSimpleChunk(const Chunk& chunk,
    function DescribeTransposedChunk (line 210) | absl::Status DescribeTransposedChunk(
    function DescribeFile (line 276) | void DescribeFile(absl::string_view filename, Writer& report) {
  function main (line 369) | int main(int argc, char** argv) {

FILE: riegeli/records/tools/records_benchmark.cc
  function ABSL_FLAG (line 89) | ABSL_FLAG(uint64_t, max_size, uint64_t{100} * 1000 * 1000,

FILE: riegeli/records/tools/tfrecord_recognizer.cc
  type riegeli (line 29) | namespace riegeli {

FILE: riegeli/records/tools/tfrecord_recognizer.h
  function namespace (line 24) | namespace riegeli {

FILE: riegeli/snappy/framed/framed_snappy_reader.cc
  type riegeli (line 39) | namespace riegeli {
    function MaskChecksum (line 44) | inline uint32_t MaskChecksum(uint32_t x) {
    function RecognizeFramedSnappy (line 293) | bool RecognizeFramedSnappy(Reader& src) {

FILE: riegeli/snappy/framed/framed_snappy_reader.h
  function namespace (line 36) | namespace riegeli {
  function Done (line 200) | void Done(FramedSnappyReader& self) {

FILE: riegeli/snappy/framed/framed_snappy_writer.cc
  type riegeli (line 44) | namespace riegeli {
    function Reader (line 176) | Reader* FramedSnappyWriterBase::ReadModeBehindScratch(Position initial...

FILE: riegeli/snappy/framed/framed_snappy_writer.h
  function namespace (line 36) | namespace riegeli {

FILE: riegeli/snappy/hadoop/hadoop_snappy_reader.cc
  type riegeli (line 38) | namespace riegeli {

FILE: riegeli/snappy/hadoop/hadoop_snappy_reader.h
  function namespace (line 36) | namespace riegeli {

FILE: riegeli/snappy/hadoop/hadoop_snappy_writer.cc
  type riegeli (line 40) | namespace riegeli {
    function Reader (line 147) | Reader* HadoopSnappyWriterBase::ReadModeBehindScratch(Position initial...

FILE: riegeli/snappy/hadoop/hadoop_snappy_writer.h
  function namespace (line 36) | namespace riegeli {

FILE: riegeli/snappy/snappy_reader.cc
  type riegeli (line 38) | namespace riegeli {
    type snappy_internal (line 83) | namespace snappy_internal {
      function SnappyDecompressImpl (line 85) | absl::Status SnappyDecompressImpl(Reader& src, Writer& dest) {
    function SnappyUncompressedSize (line 103) | std::optional<size_t> SnappyUncompressedSize(Reader& src) {

FILE: riegeli/snappy/snappy_reader.h
  function namespace (line 35) | namespace riegeli {

FILE: riegeli/snappy/snappy_streams.cc
  type riegeli::snappy_internal (line 29) | namespace riegeli::snappy_internal {

FILE: riegeli/snappy/snappy_streams.h
  function namespace (line 26) | namespace riegeli::snappy_internal {

FILE: riegeli/snappy/snappy_writer.cc
  type riegeli (line 44) | namespace riegeli {
    function Reader (line 249) | Reader* SnappyWriterBase::ReadModeImpl(Position initial_pos) {
    type snappy_internal (line 257) | namespace snappy_internal {
      function SnappyCompressImpl (line 259) | absl::Status SnappyCompressImpl(Reader& src, Writer& dest,
    function SnappyMaxCompressedSize (line 278) | size_t SnappyMaxCompressedSize(size_t uncompressed_size) {

FILE: riegeli/snappy/snappy_writer.h
  function namespace (line 41) | namespace riegeli {
  function Reset (line 270) | inline void SnappyWriterBase::Reset(Closed) {
  function Reset (line 278) | inline void SnappyWriterBase::Reset() {
  function Initialize (line 286) | inline void SnappyWriterBase::Initialize(Writer* dest, int compression_l...
  function MoveUncompressed (line 295) | inline void SnappyWriterBase::MoveUncompressed(SnappyWriterBase& that) {
  function namespace (line 348) | namespace snappy_internal {

FILE: riegeli/tensorflow/io/file_reader.cc
  type riegeli::tensorflow (line 53) | namespace riegeli::tensorflow {

FILE: riegeli/tensorflow/io/file_reader.h
  function namespace (line 46) | namespace riegeli {

FILE: riegeli/tensorflow/io/file_writer.cc
  type riegeli::tensorflow (line 51) | namespace riegeli::tensorflow {
    function Reader (line 304) | Reader* FileWriterBase::ReadModeImpl(Position initial_pos) {

FILE: riegeli/tensorflow/io/file_writer.h
  function namespace (line 47) | namespace riegeli {

FILE: riegeli/tensorflow/io/tstring_writer.h
  function namespace (line 30) | namespace riegeli::tensorflow {

FILE: riegeli/tensorflow/kernels/riegeli_dataset_ops.cc
  type riegeli::tensorflow (line 49) | namespace riegeli::tensorflow {
    class RiegeliDatasetOp (line 52) | class RiegeliDatasetOp : public ::tensorflow::data::DatasetOpKernel {
      method MakeDataset (line 56) | void MakeDataset(::tensorflow::OpKernelContext* ctx,
      class Dataset (line 83) | class Dataset : public ::tensorflow::data::DatasetBase {
        method Dataset (line 85) | explicit Dataset(::tensorflow::OpKernelContext* ctx,
        method MakeIteratorInternal (line 93) | std::unique_ptr<::tensorflow::data::IteratorBase> MakeIteratorInte...
        method DebugString (line 112) | std::string DebugString() const override {
        method CheckExternalState (line 116) | absl::Status CheckExternalState() const override {
        method InputDatasets (line 120) | absl::Status InputDatasets(
        method AsGraphDefInternal (line 128) | absl::Status AsGraphDefInternal(
        class Iterator (line 143) | class Iterator : public ::tensorflow::data::DatasetIterator<Datase...
          method Iterator (line 145) | explicit Iterator(const Params& params) : DatasetIterator(params...
          method ABSL_LOCKS_EXCLUDED (line 150) | ABSL_LOCKS_EXCLUDED(mu_) {
          method ABSL_LOCKS_EXCLUDED (line 206) | ABSL_LOCKS_EXCLUDED(mu_) {
          method ABSL_LOCKS_EXCLUDED (line 221) | ABSL_LOCKS_EXCLUDED(mu_) {
          method ABSL_EXCLUSIVE_LOCKS_REQUIRED (line 258) | ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
          method ABSL_GUARDED_BY (line 275) | ABSL_GUARDED_BY(mu_) = 0;

FILE: riegeli/tensorflow/ops/riegeli_dataset_ops.cc
  type riegeli::tensorflow (line 19) | namespace riegeli::tensorflow {

FILE: riegeli/text/ascii_align.h
  function namespace (line 43) | namespace riegeli {
  function friend (line 237) | friend auto RiegeliStringifiedSize(const AsciiCenterType& src) {
  function Stringify (line 251) | void Stringify(WriterStringifySink& dest) const& { WriteTo(*dest.dest()); }
  function Stringify (line 252) | void Stringify(WriterStringifySink& dest) && {
  function friend (line 362) | friend auto RiegeliStringifiedSize(const AsciiRightType& src) {
  function Stringify (line 376) | void Stringify(WriterStringifySink& dest) const& { WriteTo(*dest.dest()); }
  function Stringify (line 377) | void Stringify(WriterStringifySink& dest) && {
  function namespace (line 456) | namespace align_internal {

FILE: riegeli/text/concat.h
  function namespace (line 30) | namespace riegeli {

FILE: riegeli/text/join.h
  function namespace (line 36) | namespace riegeli {
  function StringifiedSize (line 57) | struct DefaultFormatter {
  function explicit (line 239) | explicit JoinType(Initializer<Src> src,
  function friend (line 264) | friend auto RiegeliStringifiedSize(const JoinType& src) {
  function Stringify (line 277) | void Stringify(WriterStringifySink& dest) const { WriteTo(*dest.dest()); }

FILE: riegeli/text/write_int.cc
  type riegeli::write_int_internal (line 35) | namespace riegeli::write_int_internal {
    function __m128i (line 45) | inline __m128i HexDigits<DigitCase::kLower>() {
    function __m128i (line 51) | inline __m128i HexDigits<DigitCase::kUpper>() {
    function __m128i (line 57) | inline __m128i WriteHex2Impl(uint8_t src) {
    function __m128i (line 71) | inline __m128i WriteHex4Impl(uint16_t src) {
    function __m128i (line 88) | inline __m128i WriteHex8Impl(uint32_t src) {
    function __m128i (line 105) | inline __m128i WriteHex16Impl(uint64_t src) {
    function T (line 124) | inline T DigitCaseDependent(T for_lower, T for_upper) {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 224) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline char* WriteHexImpl(uint8_t src, ch...
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 239) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline char* WriteHexImpl(uint16_t src, c...
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 271) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline char* WriteHexImpl(uint32_t src, c...
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 302) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline char* WriteHexImpl(uint64_t src, c...
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 333) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline char* WriteHexImpl(absl::uint128 src,

FILE: riegeli/text/write_int.h
  function namespace (line 37) | namespace riegeli {
  function friend (line 120) | friend Position RiegeliStringifiedSize(const DecType& src) {
  function DigitCase (line 147) | enum class DigitCase {
  function friend (line 233) | friend Position RiegeliStringifiedSize(const HexType& src) {
  function namespace (line 267) | namespace write_int_internal {

FILE: riegeli/varint/varint_internal.h
  function namespace (line 23) | namespace riegeli {

FILE: riegeli/varint/varint_reading.cc
  type riegeli (line 32) | namespace riegeli {
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 45) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline T ReadVarintValue(const char* src,...
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 56) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool ReadVarintFromReaderBufferLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 80) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool ReadVarintFromReaderLoop(Read...
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 107) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool ReadVarintFromCordBufferLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 131) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool ReadVarintFromCordLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 159) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline size_t ReadVarintFromArrayLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 182) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline void CopyVarintValue(const char* src,
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 189) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline size_t CopyVarintFromReaderBufferL...
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 212) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline size_t CopyVarintFromReaderLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 236) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline size_t CopyVarintFromCordBufferLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 259) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline size_t CopyVarintFromCordLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 286) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline size_t CopyVarintFromArrayLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 309) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool SkipVarintFromReaderBufferLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 330) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool SkipVarintFromReaderLoop(Read...
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 353) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool SkipVarintFromCordBufferLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 375) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool SkipVarintFromCordLoop(
    function ABSL_ATTRIBUTE_ALWAYS_INLINE (line 400) | ABSL_ATTRIBUTE_ALWAYS_INLINE inline size_t SkipVarintFromArrayLoop(
    function ReadNativeEndian (line 420) | inline uint64_t ReadNativeEndian(const char* src) {
    type varint_internal (line 428) | namespace varint_internal {
      function ReadVarintFromReaderBuffer (line 431) | bool ReadVarintFromReaderBuffer(Reader& src, const char* cursor, T acc,
      function ReadVarintFromReader (line 464) | bool ReadVarintFromReader(Reader& src, T acc, T& dest) {
      function ReadVarintFromCordBuffer (line 483) | bool ReadVarintFromCordBuffer(absl::Cord::CharIterator& src, size_t ...
      function ReadVarintFromCord (line 516) | bool ReadVarintFromCord(absl::Cord::CharIterator& src, size_t availa...
      function ReadVarintFromArray (line 539) | size_t ReadVarintFromArray(const char* src, size_t available, T acc,...
      function CopyVarintFromReaderBuffer (line 564) | size_t CopyVarintFromReaderBuffer(Reader& src, const char* cursor, c...
      function CopyVarintFromReader (line 587) | size_t CopyVarintFromReader(Reader& src, char* dest) {
      function CopyVarintFromCordBuffer (line 605) | size_t CopyVarintFromCordBuffer(absl::Cord::CharIterator& src, size_...
      function CopyVarintFromCord (line 632) | size_t CopyVarintFromCord(absl::Cord::CharIterator& src, size_t avai...
      function CopyVarintFromArray (line 651) | size_t CopyVarintFromArray(const char* src, size_t available, char* ...
      function SkipVarintFromReaderBuffer (line 672) | bool SkipVarintFromReaderBuffer(Reader& src, const char* cursor) {
      function SkipVarintFromReader (line 695) | bool SkipVarintFromReader(Reader& src) {
      function SkipVarintFromCordBuffer (line 708) | bool SkipVarintFromCordBuffer(absl::Cord::CharIterator& src, size_t ...
      function SkipVarintFromCord (line 734) | bool SkipVarintFromCord(absl::Cord::CharIterator& src, size_t availa...
      function SkipVarintFromArray (line 751) | size_t SkipVarintFromArray(const char* src, size_t available) {
    function CountVarints (line 768) | size_t CountVarints(absl::string_view value) {
    function VerifyBools (line 806) | bool VerifyBools(absl::string_view value) {

FILE: riegeli/varint/varint_reading.h
  function namespace (line 31) | namespace riegeli {

FILE: riegeli/varint/varint_writing.h
  function namespace (line 29) | namespace riegeli {

FILE: riegeli/xz/xz_error.cc
  type riegeli::xz_internal (line 25) | namespace riegeli::xz_internal {
    function XzErrorToStatus (line 27) | absl::Status XzErrorToStatus(absl::string_view operation,

FILE: riegeli/xz/xz_error.h
  function namespace (line 22) | namespace riegeli::xz_internal {

FILE: riegeli/xz/xz_reader.cc
  type riegeli (line 40) | namespace riegeli {
    function RecognizeXz (line 301) | bool RecognizeXz(Reader& src) {

FILE: riegeli/xz/xz_reader.h
  function class (line 43) | class XzReaderBase : public BufferedReader {

FILE: riegeli/xz/xz_writer.cc
  type riegeli (line 41) | namespace riegeli {
    function Reader (line 233) | Reader* XzWriterBase::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/xz/xz_writer.h
  function class (line 46) | class XzWriterBase : public BufferedWriter {

FILE: riegeli/zlib/zlib_dictionary.h
  function namespace (line 30) | namespace riegeli {

FILE: riegeli/zlib/zlib_error.cc
  type riegeli::zlib_internal (line 25) | namespace riegeli::zlib_internal {
    function ZlibErrorToStatus (line 27) | absl::Status ZlibErrorToStatus(absl::string_view operation, int zlib_c...

FILE: riegeli/zlib/zlib_error.h
  function namespace (line 22) | namespace riegeli::zlib_internal {

FILE: riegeli/zlib/zlib_reader.cc
  type riegeli (line 43) | namespace riegeli {
    function RecognizeZlib (line 312) | bool RecognizeZlib(Reader& src, ZlibReaderBase::Header header,
    function GzipUncompressedSizeModulo4G (line 373) | std::optional<uint32_t> GzipUncompressedSizeModulo4G(Reader& src) {

FILE: riegeli/zlib/zlib_reader.h
  function namespace (line 40) | namespace riegeli {

FILE: riegeli/zlib/zlib_writer.cc
  type riegeli (line 41) | namespace riegeli {
    function Reader (line 233) | Reader* ZlibWriterBase::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/zlib/zlib_writer.h
  function namespace (line 36) | namespace riegeli {

FILE: riegeli/zstd/zstd_dictionary.cc
  type riegeli (line 37) | namespace riegeli {
    function ZSTD_DDict (line 74) | inline const ZSTD_DDict* ZstdDictionary::Repr::PrepareDecompressionDic...
    function ZSTD_DDict (line 90) | const ZSTD_DDict* ZstdDictionary::PrepareDecompressionDictionary() const

FILE: riegeli/zstd/zstd_dictionary.h
  function namespace (line 38) | namespace riegeli {
  function class (line 158) | class ZstdDictionary::Repr {
  function ZSTD_CDictCache (line 215) | struct ZstdDictionary::ZSTD_CDictCache {
  function ZstdDictionary (line 229) | inline ZstdDictionary& ZstdDictionary::set_data(BytesInitializer data,
  function ZstdDictionary (line 238) | inline ZstdDictionary& ZstdDictionary::set_data_unowned(

FILE: riegeli/zstd/zstd_reader.cc
  type riegeli (line 47) | namespace riegeli {
    function GetFrameHeader (line 332) | inline bool GetFrameHeader(Reader& src, ZSTD_frameHeader& header) {
    function RecognizeZstd (line 348) | bool RecognizeZstd(Reader& src) {
    function ZstdUncompressedSize (line 353) | std::optional<Position> ZstdUncompressedSize(Reader& src) {
    function ZstdDictId (line 361) | std::optional<uint32_t> ZstdDictId(Reader& src) {

FILE: riegeli/zstd/zstd_reader.h
  function namespace (line 40) | namespace riegeli {
  function explicit (line 254) | explicit ZstdReader(Closed) -> ZstdReader<DeleteCtad<Closed>>;
  function Reset (line 331) | inline void ZstdReaderBase::Reset(

FILE: riegeli/zstd/zstd_writer.cc
  type riegeli (line 47) | namespace riegeli {
    function Reader (line 289) | Reader* ZstdWriterBase::ReadModeBehindBuffer(Position initial_pos) {

FILE: riegeli/zstd/zstd_writer.h
  function namespace (line 40) | namespace riegeli {
  function explicit (line 385) | explicit ZstdWriter(Closed) -> ZstdWriter<DeleteCtad<Closed>>;
  function Reset (line 441) | inline void ZstdWriterBase::Reset(