handler

Types

ClientIp

pub type ClientIp =
  Result(#(options.IpAddress, Int), Nil)

Connection

</>

pub type Connection(user_message) {
  Connection(
    client_ip: Result(#(options.IpAddress, Int), Nil),
    socket: socket.Socket,
    transport: transport.Transport,
    sender: process.Subject(Message(user_message)),
  )
}

Constructors

Connection(
  client_ip: Result(#(options.IpAddress, Int), Nil),
  socket: socket.Socket,
  transport: transport.Transport,
  sender: process.Subject(Message(user_message)),
)

Handler

</>

pub type Handler(state, user_message) {
  Handler(
    socket: socket.Socket,
    loop: fn(
      state,
      LoopMessage(user_message),
      Connection(user_message),
    ) -> Next(state, LoopMessage(user_message)),
    on_init: fn(Connection(user_message)) -> #(
      state,
      option.Option(process.Selector(user_message)),
    ),
    on_close: option.Option(fn(state) -> Nil),
    transport: transport.Transport,
    active_state: options.ActiveState,
  )
}

Constructors

Handler(
  socket: socket.Socket,
  loop: fn(
    state,
    LoopMessage(user_message),
    Connection(user_message),
  ) -> Next(state, LoopMessage(user_message)),
  on_init: fn(Connection(user_message)) -> #(
    state,
    option.Option(process.Selector(user_message)),
  ),
  on_close: option.Option(fn(state) -> Nil),
  transport: transport.Transport,
  active_state: options.ActiveState,
)

InternalMessage

</>

All message types that the handler will receive, or that you can send to the handler process

pub type InternalMessage {
  Close
  Ready
  ReceiveMessage(BitArray)
  Closed
  Passive
  SocketError(socket.SocketReason)
}

Constructors

```
Close
```
```
Ready
```
```
ReceiveMessage(BitArray)
```
```
Closed
```
```
Passive
```
```
SocketError(socket.SocketReason)
```

Loop

</>

pub type Loop(state, user_message) =
  fn(state, LoopMessage(user_message), Connection(user_message)) -> Next(
    state,
    LoopMessage(user_message),
  )

LoopMessage

</>

pub type LoopMessage(user_message) {
  Packet(BitArray)
  Custom(user_message)
}

Constructors

```
Packet(BitArray)
```
```
Custom(user_message)
```

LoopState

</>

pub type LoopState(state, user_message) {
  LoopState(
    client_ip: Result(#(options.IpAddress, Int), Nil),
    socket: socket.Socket,
    sender: process.Subject(Message(user_message)),
    transport: transport.Transport,
    state: state,
  )
}

Constructors

LoopState(
  client_ip: Result(#(options.IpAddress, Int), Nil),
  socket: socket.Socket,
  sender: process.Subject(Message(user_message)),
  transport: transport.Transport,
  state: state,
)

Message

</>

pub type Message(user_message) {
  Internal(InternalMessage)
  User(user_message)
}

Constructors

```
Internal(InternalMessage)
```
```
User(user_message)
```

</>

pub type Next(user_state, user_message) {
  Continue(
    state: user_state,
    selector: option.Option(process.Selector(user_message)),
  )
  NormalStop
  AbnormalStop(reason: String)
}

Constructors

Continue(
  state: user_state,
  selector: option.Option(process.Selector(user_message)),
)

```
NormalStop
```
```
AbnormalStop(reason: String)
```

Values

continue

</>

pub fn continue(
  state: user_state,
) -> Next(user_state, user_message)

start

</>

pub fn start(
  handler: Handler(state, user_message),
) -> Result(
  actor.Started(process.Subject(Message(user_message))),
  actor.StartError,
)

Starts an actor for the TCP connection

stop

</>

pub fn stop() -> Next(user_state, user_message)

stop_abnormal

</>

pub fn stop_abnormal(
  reason: String,
) -> Next(user_state, user_message)

with_selector

</>

pub fn with_selector(
  next: Next(user_state, user_message),
  selector: process.Selector(user_message),
) -> Next(user_state, user_message)