Struct Session 

pub struct Session {

    pub origin: Origin,
    pub session_name: String,
    pub session_description: Option<String>,
    pub uri: Option<String>,
    pub emails: Vec<String>,
    pub phones: Vec<String>,
    pub connection: Option<Connection>,
    pub bandwidths: Vec<Bandwidth>,
    pub times: Vec<Time>,
    pub time_zones: Vec<TimeZone>,
    pub key: Option<Key>,
    pub attributes: Vec<Attribute>,
    pub medias: Vec<Media>,
}

SDP session description.

See RFC 8866 Section 5 for more details.

Fields

origin: Origin

Originator of the session.

session_name: String

Name of the session.

session_description: Option<String>

Session description.

uri: Option<String>

URI to additional information about the session.

emails: Vec<String>

E-Mail contacts for the session.

phones: Vec<String>

Phone contacts for the session.

connection: Option<Connection>

Connection data for the session.

bandwidths: Vec<Bandwidth>

Bandwidth information for the session.

times: Vec<Time>

Timing information for the session.

time_zones: Vec<TimeZone>

Time zone information for the session.

key: Option<Key>

Encryption key for the session.

attributes: Vec<Attribute>

Attributes of the session.

medias: Vec<Media>

Media descriptions for this session.

Implementations

impl Session

pub fn parse(data: &[u8]) -> Result<Session, ParserError>

Parse an SDP session description from a byte slice.

Examples found in repository

examples/parse.rs (line 29)

fn main() -> process::ExitCode {
    let mut args = env::args();
    let _ = args.next().unwrap();
    let Some(file) = args.next() else {
        eprintln!("Usage: parse [file.sdp]");
        return process::ExitCode::FAILURE;
    };

    let mut file = match fs::File::open(file) {
        Ok(file) => file,
        Err(err) => {
            eprintln!("Failed to open file: {err}");
            return process::ExitCode::FAILURE;
        }
    };

    let mut content = Vec::new();
    match file.read_to_end(&mut content) {
        Ok(_) => {}
        Err(err) => {
            eprintln!("Failed to read file: {err}");
            return process::ExitCode::FAILURE;
        }
    };

    let sdp = match sdp_types::Session::parse(&content) {
        Ok(sdp) => sdp,
        Err(err) => {
            eprintln!("Failed to parse SDP: {err}");
            return process::ExitCode::FAILURE;
        }
    };

    println!("{sdp:#?}");

    process::ExitCode::SUCCESS
}

impl Session

pub fn write<W: Write>(&self, w: &mut W) -> Result<(), Error>

Write the SDP session description to a std::io::Write.

impl Session

pub fn new(origin: Origin, session_name: impl ToString) -> Self

pub fn builder(origin: Origin, session_name: impl ToString) -> Session

pub fn set_session_description(&mut self, session_description: impl ToString)

pub fn set_uri(&mut self, uri: impl ToString)

pub fn add_email(&mut self, email: impl ToString)

pub fn add_emails(&mut self, emails: impl IntoIterator<Item = impl ToString>)

pub fn add_phone(&mut self, phone: impl ToString)

pub fn add_phones(&mut self, phones: impl IntoIterator<Item = impl ToString>)

pub fn set_connection(&mut self, connection: impl Into<Connection>)

pub fn add_bandwidth(&mut self, bandwidth: Bandwidth)

pub fn add_bandwidths( &mut self, bandwidths: impl IntoIterator<Item = Bandwidth>, )

pub fn add_time(&mut self, time: Time)

pub fn add_times(&mut self, times: impl IntoIterator<Item = Time>)

pub fn add_time_zone(&mut self, time_zone: TimeZone)

pub fn add_time_zones(&mut self, time_zones: impl IntoIterator<Item = TimeZone>)

pub fn set_encryption_key(&mut self, key: impl Into<Key>)

pub fn add_attribute(&mut self, attribute: impl Into<Attribute>)

pub fn add_attribute_from_str(&mut self, attribute: impl ToString)

pub fn add_attribute_with_value( &mut self, attribute: impl ToString, value: impl ToString, )

pub fn add_attributes( &mut self, attributes: impl IntoIterator<Item = impl Into<Attribute>>, )

pub fn add_attributes_from_strs( &mut self, attributes: impl IntoIterator<Item = impl ToString>, )

pub fn add_media(&mut self, media: Media)

pub fn add_medias(&mut self, medias: impl IntoIterator<Item = Media>)

pub fn has_attribute(&self, name: &str) -> bool

Checks if the given attribute exists.

pub fn get_first_attribute_value<'a>( &'a self, name: &'a str, ) -> Option<Option<&'a str>>

Gets the first value of the given attribute.

The outter Option reflects the availability of the attribute. The inner Option reflects the optional value of the attribute.

pub fn get_attribute_values<'a>( &'a self, name: &'a str, ) -> impl Iterator<Item = Option<&'a str>>

Gets an iterator over all attribute values of the given name.

pub fn get_first_attribute_typed<T: TypedAttribute>( &self, ) -> Option<Result<T, AttributeError>>

Gets the first value of the given typed attribute.

pub fn attributes_typed<'a, T: TypedAttribute>( &'a self, ) -> impl Iterator<Item = Result<T, AttributeError>> + 'a

Gets an iterator over all attribute values of the given name.

Each item represents the attribute parsing Result.

The iterator does not terminate upon an error item; continues with the next attribute

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Session

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

Formats the value using the given formatter.

impl Eq for Session

impl PartialEq for Session

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Session