Struct amqp::Channel

pub struct Channel {
    pub id: u16,
    // some fields omitted
}

Fields

id: u16

Methods

impl Channel

pub fn new(     id: u16,     receiver: Receiver<Result<Frame, AMQPError>>,     connection: Connection ) -> Channel

pub fn open(&mut self) -> Result<OpenOk, AMQPError>

pub fn close<T>(     &mut self,     reply_code: u16,     reply_text: T ) -> Result<CloseOk, AMQPError> where     T: Into<String>,

pub fn read(&mut self) -> Result<Frame, AMQPError>

Will block until it reads a frame, other than basic.deliver.

pub fn write(&mut self, frame: Frame) -> Result<(), AMQPError>

pub fn send_method_frame<T>(&mut self, method: &T) -> Result<(), AMQPError> where     T: Method,

pub fn rpc<I, O>(     &mut self,     method: &I,     expected_reply: &str ) -> Result<O, AMQPError> where     I: Method,     O: Method,

pub fn raw_rpc<T>(&mut self, method: &T) -> Result<MethodFrame, AMQPError> where     T: Method,

pub fn read_headers(&mut self) -> Result<ContentHeaderFrame, AMQPError>

pub fn read_body(&mut self, size: u64) -> Result<Vec<u8>, AMQPError>

pub fn exchange_declare<S>(     &mut self,     exchange: S,     _type: S,     passive: bool,     durable: bool,     auto_delete: bool,     internal: bool,     nowait: bool,     arguments: Table ) -> Result<DeclareOk, AMQPError> where     S: Into<String>,

pub fn exchange_bind<S>(     &mut self,     destination: S,     source: S,     routing_key: S,     arguments: Table ) -> Result<BindOk, AMQPError> where     S: Into<String>,

pub fn queue_declare<S>(     &mut self,     queue: S,     passive: bool,     durable: bool,     exclusive: bool,     auto_delete: bool,     nowait: bool,     arguments: Table ) -> Result<DeclareOk, AMQPError> where     S: Into<String>,

pub fn queue_bind<S>(     &mut self,     queue: S,     exchange: S,     routing_key: S,     nowait: bool,     arguments: Table ) -> Result<BindOk, AMQPError> where     S: Into<String>,

pub fn set_frame_max_limit(&mut self, size: u32)

pub fn start_consuming(&mut self)

Trait Implementations

impl<'a> Basic<'a> for Channel

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

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();
}

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>

impl Send for Channel