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
117
118
119
120

use rustc_serialize::{Encodable, Encoder};

/// Represents different Options that can be sent wth a WAMP event 
#[derive(RustcDecodable, Debug, Clone, PartialEq)]
pub enum Options {
    // TODO: // different options
    Empty,
}

impl Encodable for Options {
    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
        match self {
           &Options::Empty => s.emit_map(0, |_| Ok(())) 
        }
    }
}

/// Represents advanced features this WAMP Client implements
#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
pub struct Details { 
    roles: Roles 
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct Caller {
    features: CallerFeatures 
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct CallerFeatures {
    caller_identification: bool,
    progressive_call_results: bool,
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct Callee {
    features: CalleeFeatures
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct CalleeFeatures {
    caller_identification: bool,
    pattern_based_registration: bool,
    shared_registration: bool,
    progressive_call_results: bool,
    registration_revocation: bool,
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct Publisher {
    features: PublisherFeatures,
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct PublisherFeatures {
    publisher_identification: bool,
    subscriber_blackwhite_listing: bool,
    publisher_exclusion: bool
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct Subscriber {
    features: SubscriberFeatures,
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct SubscriberFeatures {
    publisher_identification: bool,
    pattern_based_subscription: bool,
    subscription_revocation: bool
}

#[derive(RustcDecodable, RustcEncodable, Debug, Clone)]
struct Roles {
    caller: Caller,
    callee: Callee,
    publisher: Publisher,
    subscriber: Subscriber,
}

impl Details {
    pub fn new() -> Self {
        Details { 
            roles: Roles {
                caller: Caller {
                    features: CallerFeatures {
                        caller_identification: false,
                        progressive_call_results: false
                    }
                },
                callee: Callee {
                    features: CalleeFeatures {
                        caller_identification: false,
                        pattern_based_registration: false,
                        shared_registration: false,
                        progressive_call_results: false,
                        registration_revocation: false
                    }
                },
                publisher: Publisher {
                    features: PublisherFeatures {
                        publisher_identification: false,
                        subscriber_blackwhite_listing: false,
                        publisher_exclusion: false,
                    }
                },
                subscriber: Subscriber {
                    features: SubscriberFeatures {
                       publisher_identification: false,
                       pattern_based_subscription: false,
                       subscription_revocation: false,
                    }
                }
            },
        }

    }
}