Struct Event

pub struct Event { /* private fields */ }

Implementations

impl Event

pub fn get(&self, k: &str) -> Option<&String>

Examples found in repository

examples/dump-events.rs (line 35)

fn main() -> std::io::Result<()> {
    let args: Vec<String> = env::args().collect();
    let host = &args[1];
    let event = &args[2];
    let mut stream = TcpStream::connect(host)?;

    let conn = Connection::new(stream);
    let mut client = Client::new(conn);
    let mut stats = Stats{
        event_per_tick: 0,
        events_counts_per_sec: HashMap::new()
    };

    client.auth("cloudpbx").expect("fails to authenticate");
    client.event(event).expect("fails enabling events");

    let mut now = std::time::Instant::now();
    let notify_on_secs = std::time::Duration::from_secs(1);

    loop {
        let event: Event = client.pull_event().unwrap();
        let event_name = event.get("Event-Name").unwrap().to_string();

        stats.event_per_tick += 1;
        if event_name == "CUSTOM" {
            let event_subclass = event.get("Event-Subclass").unwrap().to_string();
            let mut event_name = format!("{}:{}", event_name, event_subclass);
            if let Some(action) = event.get("CC-Action") {
                event_name = format!("{}:{}", event_name, action.to_string())
            }
            if let Some(counter) = stats.events_counts_per_sec.get_mut(&event_name) {
                *counter += 1;
            } else {
                stats.events_counts_per_sec.insert(event_name, 1);
            }
        } else {
            if let Some(counter) = stats.events_counts_per_sec.get_mut(&event_name) {
                *counter += 1;
            } else {
                stats.events_counts_per_sec.insert(event_name, 1);
            }
        }

        if now.elapsed() >= notify_on_secs {
            let stamp = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
            println!("{} {:?} {:?}", stamp.as_secs(), now.elapsed(), stats);

            now = std::time::Instant::now();
            stats.event_per_tick = 0;
            stats.events_counts_per_sec.clear();
        }
    }
    
    Ok(())
}

examples/stats-events.rs (line 35)

fn main() -> std::io::Result<()> {
    let args: Vec<String> = env::args().collect();
    let host = &args[1];
    let event = &args[2];
    let mut stream = TcpStream::connect(host)?;

    let conn = Connection::new(stream);
    let mut client = Client::new(conn);
    let mut stats = Stats{
        event_per_tick: 0,
        events_counts_per_tick: HashMap::new()
    };

    client.auth("cloudpbx").expect("fails to authenticate");
    client.event(event).expect("fails enabling events");

    let mut now = std::time::Instant::now();
    let notify_on_secs = std::time::Duration::from_secs(1);

    loop {
        let event: Event = client.pull_event().unwrap();
        let event_name = event.get("Event-Name").unwrap().to_string();

        stats.event_per_tick += 1;
        if event_name == "CUSTOM" {
            let event_subclass = event.get("Event-Subclass").unwrap().to_string();
            let mut event_name = format!("{}:{}", event_name, event_subclass);
            if let Some(action) = event.get("CC-Action") {
                event_name = format!("{}:{}", event_name, action.to_string())
            }
            if let Some(counter) = stats.events_counts_per_tick.get_mut(&event_name) {
                *counter += 1;
            } else {
                stats.events_counts_per_tick.insert(event_name, 1);
            }
        } else {
            if let Some(counter) = stats.events_counts_per_tick.get_mut(&event_name) {
                *counter += 1;
            } else {
                stats.events_counts_per_tick.insert(event_name, 1);
            }
        }

        if now.elapsed() >= notify_on_secs {
            let stamp = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
            println!("{} {:?} {:?}", stamp.as_secs(), now.elapsed(), stats);

            now = std::time::Instant::now();
            stats.event_per_tick = 0;
            stats.events_counts_per_tick.clear();
        }
    }
    
    Ok(())
}

pub fn len(&self) -> usize

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl Into<HashMap<String, String>> for Event

fn into(self) -> HashMap<String, String>

Converts this type into the (usually inferred) input type.

impl PartialEq for Event

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

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

const 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 Eq for Event

impl StructuralPartialEq for Event