1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use super::message_builder::MessageBuilder;
use super::session_builder::SessionBuilder;
use super::subscription_builder::SubscriptionBuilder;
use super::header::*;
use super::connection::{HeartBeat, Credentials, OwnedCredentials};
use super::subscription::AckMode;
use super::session::{ReceiptRequest, GenerateReceipt};

pub trait OptionSetter<T> {
    fn set_option(self, T) -> T;
}

impl<'a, T> OptionSetter<MessageBuilder<'a, T>> for Header {
    fn set_option(self, mut builder: MessageBuilder<'a, T>) -> MessageBuilder<'a, T> {
        builder.frame.headers.push(self);
        builder
    }
}

impl<'a, 'b, T> OptionSetter<MessageBuilder<'b, T>> for SuppressedHeader<'a> {
    fn set_option(self, mut builder: MessageBuilder<'b, T>) -> MessageBuilder<'b, T> {
        let SuppressedHeader(key) = self;
        builder
            .frame
            .headers
            .retain(|header| header.get_key().as_str() != key);
        builder
    }
}

impl OptionSetter<SessionBuilder> for Header {
    fn set_option(self, mut builder: SessionBuilder) -> SessionBuilder {
        builder.config.headers.push(self);
        builder
    }
}

impl OptionSetter<SessionBuilder> for HeartBeat {
    fn set_option(self, mut builder: SessionBuilder) -> SessionBuilder {
        builder.config.heartbeat = self;
        builder
    }
}

impl<'b> OptionSetter<SessionBuilder> for Credentials<'b> {
    fn set_option(self, mut builder: SessionBuilder) -> SessionBuilder {
        builder.config.credentials = Some(OwnedCredentials::from(self));
        builder
    }
}

impl<'b> OptionSetter<SessionBuilder> for SuppressedHeader<'b> {
    fn set_option(self, mut builder: SessionBuilder) -> SessionBuilder {
        let SuppressedHeader(key) = self;
        builder
            .config
            .headers
            .retain(|header| header.get_key().as_str() != key);
        builder
    }
}

impl<'a, T> OptionSetter<SubscriptionBuilder<'a, T>> for Header {
    fn set_option(self, mut builder: SubscriptionBuilder<'a, T>) -> SubscriptionBuilder<'a, T> {
        builder.headers.push(self);
        builder
    }
}

impl<'a, 'b, T> OptionSetter<SubscriptionBuilder<'b, T>> for SuppressedHeader<'a> {
    fn set_option(self, mut builder: SubscriptionBuilder<'b, T>) -> SubscriptionBuilder<'b, T> {
        let SuppressedHeader(key) = self;
        builder
            .headers
            .retain(|header| header.get_key().as_str() != key);
        builder
    }
}

impl<'a, T> OptionSetter<SubscriptionBuilder<'a, T>> for AckMode {
    fn set_option(self, mut builder: SubscriptionBuilder<'a, T>) -> SubscriptionBuilder<'a, T> {
        builder.ack_mode = self;
        builder
    }
}

impl<'a, T> OptionSetter<MessageBuilder<'a, T>> for GenerateReceipt
    where
        T: tokio_io::AsyncWrite + tokio_io::AsyncRead + Send + 'static,
{
    fn set_option(self, mut builder: MessageBuilder<'a, T>) -> MessageBuilder<'a, T> {
        let next_id = builder.session.generate_receipt_id();
        let receipt_id = format!("message/{}", next_id);
        builder.receipt_request = Some(ReceiptRequest::new(receipt_id.clone()));
        builder
            .frame
            .headers
            .push(Header::new(RECEIPT, receipt_id.as_ref()));
        builder
    }
}

impl<'a, T> OptionSetter<SubscriptionBuilder<'a, T>> for GenerateReceipt
    where
        T: tokio_io::AsyncWrite + tokio_io::AsyncRead + Send + 'static,
{
    fn set_option(self, mut builder: SubscriptionBuilder<'a, T>) -> SubscriptionBuilder<'a, T> {
        let next_id = builder.session.generate_receipt_id();
        let receipt_id = format!("message/{}", next_id);
        builder.receipt_request = Some(ReceiptRequest::new(receipt_id.clone()));
        builder
            .headers
            .push(Header::new(RECEIPT, receipt_id.as_ref()));
        builder
    }
}