Struct Builder

pub struct Builder { /* private fields */ }

A Message Builder for a simpler generation of a message instead of building a string first.

Examples

To build a simple message from scratch:

use irc_rust::Message;
use std::error::Error;

let message = Message::builder("CMD")
    .tag("key1", "value1")
    .tag("key2", "value2")
    .prefix("name", Some("user"), Some("host"))
    .param("param1").param("param2")
    .trailing("trailing")
    .build();

let mut tags = message.tags()?;
let (key, value) = tags.next().unwrap()?;
println!("{}={}", key, value); // Prints 'key1=value1'

To alter an existing message:

use irc_rust::Message;
use std::error::Error;
use irc_rust::builder::Builder;

let message = Message::from("@key=value :name!user@host CMD param1 :trailing!").to_builder()?
    .tag("key", "value2")
    .param("param2")
    .param("param4")
    .set_param(1, "param3")
    .build();

// Or
let message: Message = "@key=value :name!user@host CMD param1 :trailing!".parse::<Builder>()?
    .tag("key", "value2")
    .param("param2")
    .param("param4")
    .set_param(1, "param3")
    .build();

assert_eq!(message.to_string(), "@key=value2 :name!user@host CMD param1 param3 param4 :trailing!");
Ok(())

Implementations

impl Builder

pub fn new<S: ToString>(command: S) -> Self

Creates a new empty builder.

Usage

use irc_rust::builder::Builder;
let message = Builder::new("CMD").build();
assert_eq!("CMD", message.command()?);

pub fn command<S: ToString>(self, cmd: S) -> Builder

Set the command.

Panics

Panics if cmd is empty.

pub fn tag<SK: ToString, SV: ToString>(self, key: SK, value: SV) -> Builder

Set a tag.

Panics

Panics if key is empty. value is allowed to be empty.

pub fn prefix<SN, SU, SH>( self, name: SN, user: Option<SU>, host: Option<SH>, ) -> Builder

where SN: ToString, SU: ToString, SH: ToString,

Set a prefix name.

Panics

Panics if name is empty, user or host == Some(“”) or user is some and host is none.

pub fn param<S: ToString>(self, param: S) -> Builder

Add a param.

Panics

Panics if param is empty.

pub fn set_param<S: ToString>(self, index: usize, param: S) -> Builder

Set a param at the given index. If the index is below 0, it won’t be set. If index >= length of the existing parameters it will be added to the end but not set as trailing. This doesn’t allow to set the trailing parameter.

Panics

Panics if param is empty.

pub fn remove_param(self, index: usize) -> Builder

pub fn trailing<S: ToString>(self, trailing: S) -> Builder

pub fn build(self) -> Message

Create a Message instance and return if valid.

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.

impl FromStr for Builder

type Err = ParserError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for Builder

fn eq(&self, other: &Builder) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<Message> for Builder

type Error = ParserError

The type returned in the event of a conversion error.

fn try_from(value: Message) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Builder

impl StructuralPartialEq for Builder