///|
pub fn SysMessage::client_id(self : SysMessage) -> String {
  match self {
    Register(..)
    | Registered(..)
    | RegisterRejected(..)
    | TaskExited(..)
    | Connect(..)
    | Connected
    | TaskOnline
    | Error(_)
    | AuthError(..) => ""
    NewClient(client_id~, ..) => client_id
    ClientDisconnected(client_id~) => client_id
  }
}

///|
pub fn SysMessage::with_client_id(self : SysMessage, id : String) -> SysMessage {
  match self {
    NewClient(last_seen_id~, ..) => NewClient(client_id=id, last_seen_id~)
    ClientDisconnected(..) => ClientDisconnected(client_id=id)
    other => other
  }
}

///|
pub fn SysMessage::without_client_id(self : SysMessage) -> SysMessage {
  self.with_client_id("")
}

///|
pub fn TermMessage::client_id(self : TermMessage) -> String {
  match self {
    Data(client_id~, ..) => client_id
    Exited(client_id~, ..) => client_id
  }
}

///|
pub fn TermMessage::with_client_id(
  self : TermMessage,
  cid : String,
) -> TermMessage {
  match self {
    Data(data~, id~, ..) => Data(client_id=cid, data~, id~)
    Exited(id~, ..) => Exited(client_id=cid, id~)
  }
}

///|
pub fn TermMessage::without_client_id(self : TermMessage) -> TermMessage {
  self.with_client_id("")
}

///|
pub fn Message::client_id(self : Message) -> String {
  match self {
    Sys(msg) => msg.client_id()
    Term(msg) => msg.client_id()
    Fs(msg) => msg.client_id()
    Codex(client_id~, ..) => client_id
  }
}

///|
pub fn Message::with_client_id(self : Message, id : String) -> Message {
  match self {
    Sys(msg) => Sys(msg.with_client_id(id))
    Term(msg) => Term(msg.with_client_id(id))
    Fs(msg) => Fs(msg.with_client_id(id))
    Codex(data~, ..) => Codex(client_id=id, data~)
  }
}

///|
pub fn Message::without_client_id(self : Message) -> Message {
  self.with_client_id("")
}

///|
pub fn FsMessage::client_id(self : FsMessage) -> String {
  match self {
    Stat(client_id~, ..) => client_id
    StatResult(client_id~, ..) => client_id
    Readdir(client_id~, ..) => client_id
    ReaddirResult(client_id~, ..) => client_id
    ReadFile(client_id~, ..) => client_id
    ReadFileResult(client_id~, ..) => client_id
    WriteFile(client_id~, ..) => client_id
    Mkdir(client_id~, ..) => client_id
    FsDelete(client_id~, ..) => client_id
    FsRename(client_id~, ..) => client_id
    FsOk(client_id~, ..) => client_id
    FsError(client_id~, ..) => client_id
  }
}

///|
pub fn FsMessage::with_client_id(self : FsMessage, id : String) -> FsMessage {
  match self {
    Stat(req_id~, path~, ..) => Stat(client_id=id, req_id~, path~)
    StatResult(req_id~, stat~, ..) => StatResult(client_id=id, req_id~, stat~)
    Readdir(req_id~, path~, ..) => Readdir(client_id=id, req_id~, path~)
    ReaddirResult(req_id~, entries~, ..) =>
      ReaddirResult(client_id=id, req_id~, entries~)
    ReadFile(req_id~, path~, ..) => ReadFile(client_id=id, req_id~, path~)
    ReadFileResult(req_id~, data~, ..) =>
      ReadFileResult(client_id=id, req_id~, data~)
    WriteFile(req_id~, path~, data~, create~, overwrite~, ..) =>
      WriteFile(client_id=id, req_id~, path~, data~, create~, overwrite~)
    Mkdir(req_id~, path~, ..) => Mkdir(client_id=id, req_id~, path~)
    FsDelete(req_id~, path~, recursive~, ..) =>
      FsDelete(client_id=id, req_id~, path~, recursive~)
    FsRename(req_id~, from~, to~, overwrite~, ..) =>
      FsRename(client_id=id, req_id~, from~, to~, overwrite~)
    FsOk(req_id~, ..) => FsOk(client_id=id, req_id~)
    FsError(req_id~, code~, message~, ..) =>
      FsError(client_id=id, req_id~, code~, message~)
  }
}

///|
pub fn FsMessage::without_client_id(self : FsMessage) -> FsMessage {
  self.with_client_id("")
}