class VmoStore

A data structure that keeps track of registered VMOs using a `Backing` storage type.

`VmoStore` keeps track of registered VMOs and performs common mapping and pinning operations,

providing common operations used in VMO pre-registration on Banjo and FIDL APIs.

This structure is not thread-safe. Users must provide their own thread-safety accounting for the

chosen `Backing` format.

`Backing` is the data structure used to store the registered VMOs. It must implement

`AbstractStorage`.

Example usage:

```

using namespace vmo_store;

// Declaring our types first.

// `MyKey` is the key type that is used to register and retrieve VMOs from a VmoStore.

using MyKey = size_t;

// `MyMeta` is extra user metadata associated with every stored VMO (can be `void`).

using MyMeta = std::string;

// Declare our store alias, we're using `HashTableStorage` in this example.

// See `storage_types.h` for other Backing storage types.

using MyVmoStore = VmoStore

<HashTableStorage

<MyKey

, MyMeta>>;

MyVmoStore store(Options{...});

// Now let's register, retrieve, and unregister a `zx::vmo` obtained through `GetVmo()`.

// The second argument to `Register` is our user metadata.

zx::result

<size

_t> result = store.Register(GetVmo(), "my first VMO");

size_t key = result.take_value();

auto * my_registered_vmo = store.GetVmo(key);

// Print metadata associated with VMO.

std::cout

<

<

"Got Vmo called "

<

<

my_registered_vmo->meta()

<

<

std::endl;

// see `stored_vmo.h` for other `StoredVmo` methods, like retrieving mapped or pinned memory.

// Finally, unregister the VMO, which will discard the VMO handle along with any mapping or

// pinning.

store.Unregister(key);

```

See `OwnedVmoStore` for an alternative API where registration happens through an ownership agent.