# `Minga.Parser.RequestState`
[🔗](https://github.com/jsmestad/minga/blob/main/lib/minga/parser/request_state.ex#L1)

Owned state for sequence-fenced synchronous parser requests.

Request handlers perform replies and Port writes; this module alone constructs
and updates the request aggregate installed by `Minga.Parser.Manager`.

# `command_builder`

```elixir
@type command_builder() :: (pos_integer(), non_neg_integer() -> binary())
```

# `deferred_request`

```elixir
@type deferred_request() :: %{
  from: GenServer.from(),
  buffer: pid(),
  command_builder: command_builder(),
  required_sequence: non_neg_integer() | nil
}
```

# `in_flight_request`

```elixir
@type in_flight_request() :: %{
  from: GenServer.from(),
  buffer: pid(),
  token: reference()
}
```

# `t`

```elixir
@type t() :: %Minga.Parser.RequestState{
  deferred: %{required(reference()) => deferred_request()},
  fences: %{required(reference()) => pid()},
  in_flight: %{required(non_neg_integer()) => in_flight_request()},
  next_id: pos_integer()
}
```

# `defer`

```elixir
@spec defer(t(), reference(), deferred_request()) :: t()
```

Adds a deferred request and its buffer fence.

# `drop_fence`

```elixir
@spec drop_fence(t(), reference()) :: t()
```

Removes a fence by token.

# `emit`

```elixir
@spec emit(t(), in_flight_request()) :: {pos_integer(), t()}
```

Allocates an ID and records an emitted request.

# `new`

```elixir
@spec new() :: t()
```

Constructs empty parser request state.

# `next_id`

```elixir
@spec next_id(t()) :: pos_integer()
```

Returns the ID that will be allocated to the next emitted request.

# `pop_deferred`

```elixir
@spec pop_deferred(t(), reference()) :: {deferred_request() | nil, t()}
```

Removes a deferred request by token.

# `pop_in_flight`

```elixir
@spec pop_in_flight(t(), non_neg_integer()) :: {in_flight_request() | nil, t()}
```

Removes an in-flight request by parser request ID.

# `pop_in_flight_by_token`

```elixir
@spec pop_in_flight_by_token(t(), reference()) :: {in_flight_request() | nil, t()}
```

Removes the in-flight request associated with a fence token.

# `satisfy_fence`

```elixir
@spec satisfy_fence(t(), reference(), pid(), non_neg_integer()) :: {:ok, t()} | :stale
```

Consumes a matching fence and records the snapshot sequence.

# `take_all`

```elixir
@spec take_all(t()) :: {[GenServer.from()], t()}
```

Removes every deferred, fenced, and in-flight request.

# `take_buffer`

```elixir
@spec take_buffer(t(), pid()) :: {[GenServer.from()], t()}
```

Removes every deferred, fenced, and in-flight request for one buffer.

# `take_ready`

```elixir
@spec take_ready(t(), pid(), (deferred_request() -> boolean())) ::
  {[{reference(), deferred_request()}], t()}
```

Splits ready deferred requests for one synchronized buffer.

---

*Consult [api-reference.md](api-reference.md) for complete listing*