class View

This is almost the same as the default move behavior. But it also

explicitly resets the moved-from error state to kUnused so that the

moved-from View can be destroyed without checking it.

Check the container for errors after using iterators. When begin() or

iterator::operator++() encounters an error, it simply returns end() so

that loops terminate normally. Thereafter, take_error() must be called

to check whether the loop terminated because it iterated past the last

item or because it encountered an error. Once begin() has been called,

take_error() must be called before the View is destroyed, so no error

goes undetected. After take_error() is called the error state is

consumed and take_error() cannot be called again until another begin() or

iterator::operator++() call has been made.

If you explicitly don't care about any error that might have terminated

the last loop early, then call ignore_error() instead of take_error().

Trivial accessors for the underlying Storage (view) object.

This returns its own error state and does not affect the `take_error()`

state of the View.

After calling begin(), it's mandatory to call take_error() before

destroying the View object. An iteration that encounters an error will

simply end early, i.e. begin() or operator++() will yield an iterator

that equals end(). At the end of a loop, call take_error() to check for

errors. It's also acceptable to call take_error() during an iteration

that hasn't reached end() yet, but it cannot be called again before the

next begin() or operator++() call.

Looks up an item by type, returning the iterator pointing to the first

match or else end().

Like begin(), find() resets the internal error state and it is the

responsibility of the caller to take or ignore that error before calling

this method.

Replace an item's header with a new one, using an iterator into this

view.. This never changes the existing item's length (nor its payload).

So the header can be `{.type = XYZ}` alone or whatever fields and flags

matter. Note this returns only the storage error type, not an Error since

no ZBI format errors are possible here, only a storage failure to update.

This method is not available if zbitl::StorageTraits

<storage

_type>

doesn't support mutation.

When the iterator is mutable and not a temporary, make the next

operator*() consistent with the new header if it worked. For kReference

storage types, the change is reflected intrinsically.

Verifies that a given View iterator points to an item with a valid CRC32.

Copy a range of the underlying storage into an existing piece of storage,

which can be any mutable type with sufficient capacity. The Error return

value is for a read error. The "success" return value indicates there was

no read error. It's another fit::result

<error

_type> for the writing side

(which may be different than the type used in Error::storage_error). The

optional `to_offset` argument says where in `to` the data is written, as a

byte offset that is zero by default.

Copy a range of the underlying storage into a freshly-created new piece of

storage (whatever that means for this storage type). The Error return

value is for a read error. The "success" return value indicates there was

no read error. It's another fit::result

<read

_error_type, T> for some

T akin to storage_type, possibly storage_type itself. For example, all

the unowned VMO storage types yield zx::vmo as the owning equivalent

storage type. If the optional `to_offset` argument is nonzero, the new

storage starts with that many zero bytes before the copied data.

Copy a single item's payload into supplied storage.

Copy a single item's payload into newly-created storage.

Copy a single item's header and payload into supplied storage.

Copy a single item's header and payload into newly-created storage.

Copy a single item's payload into supplied storage, including

decompressing a ZBI_TYPE_STORAGE_* item if necessary. This statically

determines based on the input and output storage types whether it has to

use streaming decompression or can use the one-shot mode (which is more

efficient and requires less scratch memory). So the unused part of the

decompression library can be elided at link time.

If decompression is necessary, then this calls `scratch(size_t{bytes})` to

allocate scratch memory for the decompression engine. This returns

`fit::result

<std

::string_view, T>` where T is any movable object that has

a `get()` method returning a pointer (of any type implicitly converted to

`void*`) to the scratch memory. The returned object is destroyed after

decompression is finished and the scratch memory is no longer needed.

zbitl::decompress:DefaultAllocator is a default-constructible class that

can serve as `scratch`. The overloads below with fewer arguments use it.

These overloads have the effect of default arguments for the allocator

arguments to the general versions above, but template argument deduction

doesn't work with default arguments.

Copy the subrange `[first,last)` of the ZBI into supplied storage.

The storage will contain a new ZBI container with only those items.

Copy the subrange `[first,last)` of the ZBI into newly-created storage.

The storage will contain a new ZBI container with only those items.