# `Kombu.Pidbox.Mailbox`
[🔗](https://github.com/hacktobeer/kombu/blob/v0.1.0/lib/kombu/pidbox.ex#L21)

Process Mailbox (`kombu.pidbox.Mailbox`).

# `t`

```elixir
@type t() :: %Kombu.Pidbox.Mailbox{
  accept: term(),
  clock: term(),
  connection: term(),
  exchange: term(),
  namespace: term(),
  oid: term(),
  producer_pool: term(),
  queue_durable: term(),
  queue_exclusive: term(),
  queue_expires: term(),
  queue_ttl: term(),
  reply_exchange: term(),
  reply_queue_expires: term(),
  reply_queue_ttl: term(),
  serializer: term(),
  type: term(),
  unclaimed_pid: term()
}
```

# `abcast`

```elixir
@spec abcast(t(), String.t(), map() | keyword(), keyword()) :: :ok
```

Broadcasts command to all nodes without expecting a reply.

# `bind`

```elixir
@spec bind(t(), Kombu.Connection.t()) :: t()
```

Binds the mailbox to a connection.

# `broadcast`

```elixir
@spec broadcast(t(), String.t(), map() | keyword(), keyword()) :: [term()] | :ok
```

Core broadcast publisher and collector matching `Mailbox._broadcast`.

# `call`

```elixir
@spec call(t(), [String.t()] | nil, String.t(), map() | keyword(), keyword()) :: [
  term()
]
```

Sends command to `destination` expecting a reply.

# `cast`

```elixir
@spec cast(t(), [String.t()] | nil, String.t(), map() | keyword(), keyword()) :: :ok
```

Sends command to `destination` without expecting a reply.

# `collect`

```elixir
@spec collect(t(), String.t(), keyword()) :: [term()]
```

Collects replies for `ticket` up to `limit` or `timeout` (`Mailbox._collect`).

# `get_queue`

```elixir
@spec get_queue(t(), String.t()) :: Kombu.Queue.t()
```

Returns the node queue for `hostname`.

# `get_reply_queue`

```elixir
@spec get_reply_queue(t()) :: Kombu.Queue.t()
```

Returns the reply queue for this mailbox instance.

# `multi_call`

```elixir
@spec multi_call(t(), String.t(), map() | keyword(), keyword()) :: [term()]
```

Broadcasts command to all nodes expecting multiple replies up to `limit` or `timeout`.

# `new`

```elixir
@spec new(String.t(), keyword()) :: t()
```

# `node`

```elixir
@spec node(t(), String.t() | nil, keyword()) :: Kombu.Pidbox.Node.t()
```

Creates a new `Node` for `mailbox`.

# `publish_reply`

```elixir
@spec publish_reply(t(), term(), String.t(), String.t(), String.t(), keyword()) :: :ok
```

Publishes a reply message (`Mailbox._publish_reply`).

---

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