[−][src]Trait amqp::Basic

pub trait Basic<'a> {
    fn basic_get(&'a mut self, queue: &'a str, no_ack: bool) -> GetIterator<'a>;

    fn basic_consume<T, S>(
        &mut self, 
        callback: T, 
        queue: S, 
        consumer_tag: S, 
        no_local: bool, 
        no_ack: bool, 
        exclusive: bool, 
        nowait: bool, 
        arguments: Table
    ) -> Result<String, AMQPError>
    where
        T: Consumer + 'static,
        S: Into<String>;

    fn basic_publish<S>(
        &mut self, 
        exchange: S, 
        routing_key: S, 
        mandatory: bool, 
        immediate: bool, 
        properties: BasicProperties, 
        content: Vec<u8>
    ) -> Result<(), AMQPError>
    where
        S: Into<String>;

    fn basic_ack(
        &mut self, 
        delivery_tag: u64, 
        multiple: bool
    ) -> Result<(), AMQPError>;

    fn basic_nack(
        &mut self, 
        delivery_tag: u64, 
        multiple: bool, 
        requeue: bool
    ) -> Result<(), AMQPError>;

    fn basic_reject(
        &mut self, 
        delivery_tag: u64, 
        requeue: bool
    ) -> Result<(), AMQPError>;

    fn basic_prefetch(
        &mut self, 
        prefetch_count: u16
    ) -> Result<QosOk, AMQPError>;

    fn basic_qos(
        &mut self, 
        prefetch_size: u32, 
        prefetch_count: u16, 
        global: bool
    ) -> Result<QosOk, AMQPError>;

    fn basic_cancel(
        &mut self, 
        consumer_tag: String, 
        no_wait: bool
    ) -> Result<CancelOk, AMQPError>;
}

Required methods

fn basic_get(&'a mut self, queue: &'a str, no_ack: bool) -> GetIterator<'a>

fn basic_consume<T, S>(
    &mut self,
    callback: T,
    queue: S,
    consumer_tag: S,
    no_local: bool,
    no_ack: bool,
    exclusive: bool,
    nowait: bool,
    arguments: Table
) -> Result<String, AMQPError> where
    T: Consumer + 'static,
    S: Into<String>, 

fn basic_publish<S>(
    &mut self,
    exchange: S,
    routing_key: S,
    mandatory: bool,
    immediate: bool,
    properties: BasicProperties,
    content: Vec<u8>
) -> Result<(), AMQPError> where
    S: Into<String>, 

fn basic_ack(
    &mut self,
    delivery_tag: u64,
    multiple: bool
) -> Result<(), AMQPError>

fn basic_nack(
    &mut self,
    delivery_tag: u64,
    multiple: bool,
    requeue: bool
) -> Result<(), AMQPError>

fn basic_reject(
    &mut self,
    delivery_tag: u64,
    requeue: bool
) -> Result<(), AMQPError>

fn basic_prefetch(&mut self, prefetch_count: u16) -> Result<QosOk, AMQPError>

fn basic_qos(
    &mut self,
    prefetch_size: u32,
    prefetch_count: u16,
    global: bool
) -> Result<QosOk, AMQPError>

fn basic_cancel(
    &mut self,
    consumer_tag: String,
    no_wait: bool
) -> Result<CancelOk, AMQPError>

Loading content...

Implementors

impl<'a> Basic<'a> for Channel
[src]

fn basic_get(&'a mut self, queue: &'a str, no_ack: bool) -> GetIterator<'a>
[src]

Returns a basic iterator.

Example

use std::default::Default;
use amqp::{Options, Session, Basic};
let mut session = match Session::new(Options { .. Default::default() }){
    Ok(session) => session,
    Err(error) => panic!("Failed openning an amqp session: {:?}", error)
};
let mut channel = session.open_channel(1).ok().expect("Can not open a channel");
for get_result in channel.basic_get("my queue", false) {
    println!("Headers: {:?}", get_result.headers);
    println!("Reply: {:?}", get_result.reply);
    println!("Body: {:?}", String::from_utf8_lossy(&get_result.body));
    get_result.ack();
}
Loading content...