pub mod version {


    //! jsonrpc version field
    use serde::{Serialize, Serializer, Deserialize, Deserializer, Error};
    use serde::de::Visitor;
    #[derive(PartialEq, Debug)]
    pub enum Version { V2, }
    impl Serialize for Version {
        fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer {
            match self { &Version::V2 => serializer.visit_str("2.0"), }
        }
    }
    impl Deserialize for Version {
        fn deserialize<D>(deserializer: &mut D) -> Result<Version, D::Error>
         where D: Deserializer {
            deserializer.visit(VersionVisitor)
        }
    }
    struct VersionVisitor;
    impl Visitor for VersionVisitor {
        type
        Value
        =
        Version;
        fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E>
         where E: Error {
            match value {
                "2.0" => Ok(Version::V2),
                _ => Err(Error::syntax("invalid version")),
            }
        }
        fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E>
         where E: Error {
            self.visit_str(value.as_ref())
        }
    }
}
pub mod id {
    //! jsonrpc id field
    use serde::{Serialize, Serializer, Deserialize, Deserializer, Error};
    use serde::de::Visitor;
    #[derive(PartialEq, Debug)]
    pub enum Id { Null, Num(u64), }
    impl Serialize for Id {
        fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer {
            match *self {
                Id::Null => serializer.visit_unit(),
                Id::Num(v) => serializer.visit_u64(v),
            }
        }
    }
    impl Deserialize for Id {
        fn deserialize<D>(deserializer: &mut D) -> Result<Id, D::Error> where
         D: Deserializer {
            deserializer.visit(IdVisitor)
        }
    }
    struct IdVisitor;
    impl Visitor for IdVisitor {
        type
        Value
        =
        Id;
        fn visit_unit<E>(&mut self) -> Result<Self::Value, E> where E: Error {
            Ok(Id::Null)
        }
        fn visit_u64<E>(&mut self, value: u64) -> Result<Self::Value, E> where
         E: Error {
            Ok(Id::Num(value))
        }
        fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E>
         where E: Error {
            self.visit_string(value.to_owned())
        }
        fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E>
         where E: Error {
            value.parse::<u64>().map(Id::Num).map_err(|_|
                                                          Error::syntax("invalid id"))
        }
    }
    #[cfg(test)]
    mod tests {
        use super::*;
        use serde_json;
        #[test]
        fn id_deserialization() {
            let s = r#""2""#;
            let deserialized: Id = serde_json::from_str(s).unwrap();
            assert_eq!(deserialized , Id:: Num ( 2 ));
            let s = r#"[null, 0, 2, "3"]"#;
            let deserialized: Vec<Id> = serde_json::from_str(s).unwrap();
            assert_eq!(deserialized , vec ! [
                       Id:: Null , Id:: Num ( 0 ) , Id:: Num ( 2 ) , Id:: Num
                       ( 3 ) ]);
        }
        #[test]
        fn id_serialization() {
            let d =
                vec!(Id:: Null , Id:: Num ( 0 ) , Id:: Num ( 2 ) , Id:: Num (
                     3 ));
            let serialized = serde_json::to_string(&d).unwrap();
            assert_eq!(serialized , r#"[null,0,2,3]"#);
        }
    }
}
pub mod params {
    //! jsonrpc params field
    use std::collections::BTreeMap;
    use serde::{Serialize, Serializer, Deserialize, Deserializer};
    use serde::de::{Visitor, SeqVisitor, MapVisitor};
    use serde::de::impls::{VecVisitor, BTreeMapVisitor};
    use super::Value;
    #[derive(PartialEq, Debug)]
    pub enum Params { Array(Vec<Value>), Map(BTreeMap<String, Value>), None, }
    impl Serialize for Params {
        fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer {
            match *self {
                Params::Array(ref vec) => vec.serialize(serializer),
                Params::Map(ref map) => map.serialize(serializer),
                Params::None => ([] as [u8; 0]).serialize(serializer),
            }
        }
    }
    struct ParamsVisitor;
    impl Deserialize for Params {
        fn deserialize<D>(deserializer: &mut D) -> Result<Params, D::Error>
         where D: Deserializer {
            deserializer.visit(ParamsVisitor)
        }
    }
    impl Visitor for ParamsVisitor {
        type
        Value
        =
        Params;
        fn visit_seq<V>(&mut self, visitor: V)
         -> Result<Self::Value, V::Error> where V: SeqVisitor {
            VecVisitor::new().visit_seq(visitor).and_then(|vec|
                                                              match vec.is_empty()
                                                                  {
                                                                  true =>
                                                                  Ok(Params::None),
                                                                  false =>
                                                                  Ok(Params::Array(vec)),
                                                              })
        }
        fn visit_map<V>(&mut self, visitor: V)
         -> Result<Self::Value, V::Error> where V: MapVisitor {
            BTreeMapVisitor::new().visit_map(visitor).and_then(|map|
                                                                   match map.is_empty()
                                                                       {
                                                                       true =>
                                                                       Ok(Params::None),
                                                                       false
                                                                       =>
                                                                       Ok(Params::Map(map)),
                                                                   })
        }
    }
    #[test]
    fn params_deserialization() {
        use serde_json;
        use std::collections::BTreeMap;
        let s = r#"[null, true, -1, 4, 2.3, "hello", [0], {"key": "value"}]"#;
        let deserialized: Params = serde_json::from_str(s).unwrap();
        let mut map = BTreeMap::new();
        map.insert("key".to_string(), Value::String("value".to_string()));
        assert_eq!(Params:: Array (
                   vec ! [
                   Value:: Null , Value:: Bool ( true ) , Value:: I64 ( - 1 )
                   , Value:: U64 ( 4 ) , Value:: F64 ( 2.3 ) , Value:: String
                   ( "hello" . to_string (  ) ) , Value:: Array (
                   vec ! [ Value:: U64 ( 0 ) ] ) , Value:: Object ( map ) ] )
                   , deserialized);
    }
}
pub mod request {
    //! jsonrpc request
    use serde::de::{Deserialize, Deserializer, Visitor, SeqVisitor,
                    MapVisitor, Error};
    use serde_json::value;
    use super::{Id, Params, Version, Value};
    /// Represents jsonrpc request which is a method call.
    #[derive(PartialEq, Debug)]
    pub struct MethodCall {
        /// A String specifying the version of the JSON-RPC protocol. 
        /// MUST be exactly "2.0".
        pub jsonrpc: Version,
        /// A String containing the name of the method to be invoked.
        pub method: String,
        /// A Structured value that holds the parameter values to be used 
        /// during the invocation of the method. This member MAY be omitted.
        pub params: Option<Params>,
        /// An identifier established by the Client that MUST contain a String,
        /// Number, or NULL value if included. If it is not included it is assumed 
        /// to be a notification. 
        pub id: Id,
    }
    impl ::serde::de::Deserialize for MethodCall {
        fn deserialize<__D>(deserializer: &mut __D)
         -> ::std::result::Result<MethodCall, __D::Error> where
         __D: ::serde::de::Deserializer {
            {
                #[allow(non_camel_case_types)]
                enum __Field { __field0, __field1, __field2, __field3, }
                impl ::serde::de::Deserialize for __Field {
                    #[inline]
                    fn deserialize<D>(deserializer: &mut D)
                     -> ::std::result::Result<__Field, D::Error> where
                     D: ::serde::de::Deserializer {
                        use std::marker::PhantomData;
                        struct __FieldVisitor<D> {
                            phantom: PhantomData<D>,
                        }
                        impl <__D> ::serde::de::Visitor for
                         __FieldVisitor<__D> where
                         __D: ::serde::de::Deserializer {
                            type
                            Value
                            =
                            __Field;
                            fn visit_usize<E>(&mut self, value: usize)
                             -> ::std::result::Result<__Field, E> where
                             E: ::serde::de::Error {
                                match value {
                                    0usize => { Ok(__Field::__field0) }
                                    1usize => { Ok(__Field::__field1) }
                                    2usize => { Ok(__Field::__field2) }
                                    3usize => { Ok(__Field::__field3) }
                                    _ => {
                                        Err(::serde::de::Error::syntax("expected a field"))
                                    }
                                }
                            }
                            fn visit_str<E>(&mut self, value: &str)
                             -> ::std::result::Result<__Field, E> where
                             E: ::serde::de::Error {
                                match value {
                                    "jsonrpc" => { Ok(__Field::__field0) }
                                    "method" => { Ok(__Field::__field1) }
                                    "params" => { Ok(__Field::__field2) }
                                    "id" => { Ok(__Field::__field3) }
                                    _ => {
                                        Err(::serde::de::Error::unknown_field(value))
                                    }
                                }
                            }
                            fn visit_bytes<E>(&mut self, value: &[u8])
                             -> ::std::result::Result<__Field, E> where
                             E: ::serde::de::Error {
                                match ::std::str::from_utf8(value) {
                                    Ok(s) => self.visit_str(s),
                                    _ => {
                                        Err(::serde::de::Error::syntax("could not convert a byte string to a String"))
                                    }
                                }
                            }
                        }
                        deserializer.visit_struct_field(__FieldVisitor::<D>{phantom:
                                                                                PhantomData,})
                    }
                }
                struct __Visitor<__D: ::serde::de::Deserializer>(::std::marker::PhantomData<__D>);
                impl <__D: ::serde::de::Deserializer> ::serde::de::Visitor for
                 __Visitor<__D> {
                    type
                    Value
                    =
                    MethodCall;
                    #[inline]
                    fn visit_seq<__V>(&mut self, mut visitor: __V)
                     -> ::std::result::Result<MethodCall, __V::Error> where
                     __V: ::serde::de::SeqVisitor {
                        {
                            let __field0 =
                                match try!(visitor . visit (  )) {
                                    Some(value) => { value }
                                    None => {
                                        return Err(::serde::de::Error::end_of_stream());
                                    }
                                };
                            let __field1 =
                                match try!(visitor . visit (  )) {
                                    Some(value) => { value }
                                    None => {
                                        return Err(::serde::de::Error::end_of_stream());
                                    }
                                };
                            let __field2 =
                                match try!(visitor . visit (  )) {
                                    Some(value) => { value }
                                    None => {
                                        return Err(::serde::de::Error::end_of_stream());
                                    }
                                };
                            let __field3 =
                                match try!(visitor . visit (  )) {
                                    Some(value) => { value }
                                    None => {
                                        return Err(::serde::de::Error::end_of_stream());
                                    }
                                };
                            try!(visitor . end (  ));
                            Ok(MethodCall{jsonrpc: __field0,
                                          method: __field1,
                                          params: __field2,
                                          id: __field3,})
                        }
                    }
                    #[inline]
                    fn visit_map<__V>(&mut self, mut visitor: __V)
                     -> ::std::result::Result<MethodCall, __V::Error> where
                     __V: ::serde::de::MapVisitor {
                        {
                            let mut __field0 = None;
                            let mut __field1 = None;
                            let mut __field2 = None;
                            let mut __field3 = None;
                            while let Some(key) =
                                      try!(visitor . visit_key (  )) {
                                match key {
                                    __Field::__field0 => {
                                        __field0 =
                                            Some(try!(visitor . visit_value (
                                                      )));
                                    }
                                    __Field::__field1 => {
                                        __field1 =
                                            Some(try!(visitor . visit_value (
                                                      )));
                                    }
                                    __Field::__field2 => {
                                        __field2 =
                                            Some(try!(visitor . visit_value (
                                                      )));
                                    }
                                    __Field::__field3 => {
                                        __field3 =
                                            Some(try!(visitor . visit_value (
                                                      )));
                                    }
                                }
                            }
                            let __field0 =
                                match __field0 {
                                    Some(__field0) => __field0,
                                    None =>
                                    try!(visitor . missing_field ( "jsonrpc"
                                         )),
                                };
                            let __field1 =
                                match __field1 {
                                    Some(__field1) => __field1,
                                    None =>
                                    try!(visitor . missing_field ( "method"
                                         )),
                                };
                            let __field2 =
                                match __field2 {
                                    Some(__field2) => __field2,
                                    None =>
                                    try!(visitor . missing_field ( "params"
                                         )),
                                };
                            let __field3 =
                                match __field3 {
                                    Some(__field3) => __field3,
                                    None =>
                                    try!(visitor . missing_field ( "id" )),
                                };
                            try!(visitor . end (  ));
                            Ok(MethodCall{jsonrpc: __field0,
                                          method: __field1,
                                          params: __field2,
                                          id: __field3,})
                        }
                    }
                }
                const FIELDS: &'static [&'static str] =
                    &["jsonrpc", "method", "params", "id"];
                deserializer.visit_struct("MethodCall", FIELDS,
                                          __Visitor::<__D>(::std::marker::PhantomData))
            }
        }
    }
    /// Represents jsonrpc request which is a notification.
    #[derive(PartialEq, Debug)]
    pub struct Notification {
        /// A String specifying the version of the JSON-RPC protocol. 
        /// MUST be exactly "2.0".
        pub jsonrpc: Version,
        /// A String containing the name of the method to be invoked.
        pub method: String,
        /// A Structured value that holds the parameter values to be used 
        /// during the invocation of the method. This member MAY be omitted.
        pub params: Option<Params>,
    }
    impl ::serde::de::Deserialize for Notification {
        fn deserialize<__D>(deserializer: &mut __D)
         -> ::std::result::Result<Notification, __D::Error> where
         __D: ::serde::de::Deserializer {
            {
                #[allow(non_camel_case_types)]
                enum __Field { __field0, __field1, __field2, }
                impl ::serde::de::Deserialize for __Field {
                    #[inline]
                    fn deserialize<D>(deserializer: &mut D)
                     -> ::std::result::Result<__Field, D::Error> where
                     D: ::serde::de::Deserializer {
                        use std::marker::PhantomData;
                        struct __FieldVisitor<D> {
                            phantom: PhantomData<D>,
                        }
                        impl <__D> ::serde::de::Visitor for
                         __FieldVisitor<__D> where
                         __D: ::serde::de::Deserializer {
                            type
                            Value
                            =
                            __Field;
                            fn visit_usize<E>(&mut self, value: usize)
                             -> ::std::result::Result<__Field, E> where
                             E: ::serde::de::Error {
                                match value {
                                    0usize => { Ok(__Field::__field0) }
                                    1usize => { Ok(__Field::__field1) }
                                    2usize => { Ok(__Field::__field2) }
                                    _ => {
                                        Err(::serde::de::Error::syntax("expected a field"))
                                    }
                                }
                            }
                            fn visit_str<E>(&mut self, value: &str)
                             -> ::std::result::Result<__Field, E> where
                             E: ::serde::de::Error {
                                match value {
                                    "jsonrpc" => { Ok(__Field::__field0) }
                                    "method" => { Ok(__Field::__field1) }
                                    "params" => { Ok(__Field::__field2) }
                                    _ => {
                                        Err(::serde::de::Error::unknown_field(value))
                                    }
                                }
                            }
                            fn visit_bytes<E>(&mut self, value: &[u8])
                             -> ::std::result::Result<__Field, E> where
                             E: ::serde::de::Error {
                                match ::std::str::from_utf8(value) {
                                    Ok(s) => self.visit_str(s),
                                    _ => {
                                        Err(::serde::de::Error::syntax("could not convert a byte string to a String"))
                                    }
                                }
                            }
                        }
                        deserializer.visit_struct_field(__FieldVisitor::<D>{phantom:
                                                                                PhantomData,})
                    }
                }
                struct __Visitor<__D: ::serde::de::Deserializer>(::std::marker::PhantomData<__D>);
                impl <__D: ::serde::de::Deserializer> ::serde::de::Visitor for
                 __Visitor<__D> {
                    type
                    Value
                    =
                    Notification;
                    #[inline]
                    fn visit_seq<__V>(&mut self, mut visitor: __V)
                     -> ::std::result::Result<Notification, __V::Error> where
                     __V: ::serde::de::SeqVisitor {
                        {
                            let __field0 =
                                match try!(visitor . visit (  )) {
                                    Some(value) => { value }
                                    None => {
                                        return Err(::serde::de::Error::end_of_stream());
                                    }
                                };
                            let __field1 =
                                match try!(visitor . visit (  )) {
                                    Some(value) => { value }
                                    None => {
                                        return Err(::serde::de::Error::end_of_stream());
                                    }
                                };
                            let __field2 =
                                match try!(visitor . visit (  )) {
                                    Some(value) => { value }
                                    None => {
                                        return Err(::serde::de::Error::end_of_stream());
                                    }
                                };
                            try!(visitor . end (  ));
                            Ok(Notification{jsonrpc: __field0,
                                            method: __field1,
                                            params: __field2,})
                        }
                    }
                    #[inline]
                    fn visit_map<__V>(&mut self, mut visitor: __V)
                     -> ::std::result::Result<Notification, __V::Error> where
                     __V: ::serde::de::MapVisitor {
                        {
                            let mut __field0 = None;
                            let mut __field1 = None;
                            let mut __field2 = None;
                            while let Some(key) =
                                      try!(visitor . visit_key (  )) {
                                match key {
                                    __Field::__field0 => {
                                        __field0 =
                                            Some(try!(visitor . visit_value (
                                                      )));
                                    }
                                    __Field::__field1 => {
                                        __field1 =
                                            Some(try!(visitor . visit_value (
                                                      )));
                                    }
                                    __Field::__field2 => {
                                        __field2 =
                                            Some(try!(visitor . visit_value (
                                                      )));
                                    }
                                }
                            }
                            let __field0 =
                                match __field0 {
                                    Some(__field0) => __field0,
                                    None =>
                                    try!(visitor . missing_field ( "jsonrpc"
                                         )),
                                };
                            let __field1 =
                                match __field1 {
                                    Some(__field1) => __field1,
                                    None =>
                                    try!(visitor . missing_field ( "method"
                                         )),
                                };
                            let __field2 =
                                match __field2 {
                                    Some(__field2) => __field2,
                                    None =>
                                    try!(visitor . missing_field ( "params"
                                         )),
                                };
                            try!(visitor . end (  ));
                            Ok(Notification{jsonrpc: __field0,
                                            method: __field1,
                                            params: __field2,})
                        }
                    }
                }
                const FIELDS: &'static [&'static str] =
                    &["jsonrpc", "method", "params"];
                deserializer.visit_struct("Notification", FIELDS,
                                          __Visitor::<__D>(::std::marker::PhantomData))
            }
        }
    }
    /// Represents single jsonrpc call.
    #[derive(PartialEq, Debug)]
    pub enum Call {
        MethodCall(MethodCall),
        Notification(Notification),
        Invalid,
    }
    impl Deserialize for Call {
        fn deserialize<D>(deserializer: &mut D) -> Result<Call, D::Error>
         where D: Deserializer {
            let v = try!(Value:: deserialize ( deserializer ));
            Deserialize::deserialize(&mut value::Deserializer::new(v.clone())).map(Call::Notification).or_else(|_|
                                                                                                                   Deserialize::deserialize(&mut value::Deserializer::new(v.clone())).map(Call::MethodCall)).map_err(|_|
                                                                                                                                                                                                                         Error::syntax("")).or_else(|_:
                                                                                                                                                                                                                                                         D::Error|
                                                                                                                                                                                                                                                        Ok(Call::Invalid))
        }
    }
    /// Represents jsonrpc request.
    #[derive(PartialEq, Debug)]
    pub enum Request { Single(Call), Batch(Vec<Call>), }
    impl Deserialize for Request {
        fn deserialize<D>(deserializer: &mut D) -> Result<Request, D::Error>
         where D: Deserializer {
            let v = try!(Value:: deserialize ( deserializer ));
            Deserialize::deserialize(&mut value::Deserializer::new(v.clone())).map(Request::Batch).or_else(|_|
                                                                                                               Deserialize::deserialize(&mut value::Deserializer::new(v.clone())).map(Request::Single)).map_err(|_|
                                                                                                                                                                                                                    Error::syntax(""))
        }
    }
    #[test]
    fn notification_deserialize() {
        use serde_json;
        use serde_json::Value;
        let s = r#"{"jsonrpc": "2.0", "method": "update", "params": [1,2]}"#;
        let deserialized: Notification = serde_json::from_str(s).unwrap();
        assert_eq!(deserialized , Notification {
                   jsonrpc : Version:: V2 , method : "update" . to_string (  )
                   , params : Some (
                   Params:: Array (
                   vec ! [ Value:: U64 ( 1 ) , Value:: U64 ( 2 ) ] ) ) });
        let s = r#"{"jsonrpc": "2.0", "method": "foobar"}"#;
        let deserialized: Notification = serde_json::from_str(s).unwrap();
        assert_eq!(deserialized , Notification {
                   jsonrpc : Version:: V2 , method : "foobar" . to_string (  )
                   , params : None });
        let s =
            r#"{"jsonrpc": "2.0", "method": "update", "params": [1,2], "id": 1}"#;
        let deserialized: Result<Notification, _> = serde_json::from_str(s);
        assert!(deserialized . is_err (  ))
    }
    #[test]
    fn call_deserialize() {
        use serde_json;
        let s = r#"{"jsonrpc": "2.0", "method": "update", "params": [1]}"#;
        let deserialized: Call = serde_json::from_str(s).unwrap();
        assert_eq!(deserialized , Call:: Notification (
                   Notification {
                   jsonrpc : Version:: V2 , method : "update" . to_owned (  )
                   , params : Some (
                   Params:: Array ( vec ! [ Value:: U64 ( 1 ) ] ) ) } ));
        let s =
            r#"{"jsonrpc": "2.0", "method": "update", "params": [1], "id": 1}"#;
        let deserialized: Call = serde_json::from_str(s).unwrap();
        assert_eq!(deserialized , Call:: MethodCall (
                   MethodCall {
                   jsonrpc : Version:: V2 , method : "update" . to_owned (  )
                   , params : Some (
                   Params:: Array ( vec ! [ Value:: U64 ( 1 ) ] ) ) , id :
                   Id:: Num ( 1 ) } ));
    }
    #[test]
    fn request_deserialize_batch() {
        use serde_json;
        let s =
            r#"[1, {"jsonrpc": "2.0", "method": "update", "params": [1,2], "id": 1},{"jsonrpc": "2.0", "method": "update", "params": [1]}]"#;
        let deserialized: Request = serde_json::from_str(s).unwrap();
        assert_eq!(deserialized , Request:: Batch (
                   vec ! [
                   Call:: Invalid , Call:: MethodCall (
                   MethodCall {
                   jsonrpc : Version:: V2 , method : "update" . to_owned (  )
                   , params : Some (
                   Params:: Array (
                   vec ! [ Value:: U64 ( 1 ) , Value:: U64 ( 2 ) ] ) ) , id :
                   Id:: Num ( 1 ) } ) , Call:: Notification (
                   Notification {
                   jsonrpc : Version:: V2 , method : "update" . to_owned (  )
                   , params : Some (
                   Params:: Array ( vec ! [ Value:: U64 ( 1 ) ] ) ) } ) ] ))
    }
}
pub mod response {
    //! jsonrpc response
    use serde::{Serialize, Serializer};
    use super::{Id, Value, Error, Version};
    #[derive(PartialEq, Debug)]
    pub struct Success {
        pub jsonrpc: Version,
        pub result: Value,
        pub id: Id,
    }
    impl ::serde::ser::Serialize for Success {
        fn serialize<__S>(&self, serializer: &mut __S)
         -> ::std::result::Result<(), __S::Error> where
         __S: ::serde::ser::Serializer {
            {
                struct Visitor<'__a> {
                    state: usize,
                    value: &'__a Success,
                    _structure_ty: ::std::marker::PhantomData<&'__a Success>,
                }
                impl <'__a> ::serde::ser::MapVisitor for Visitor<'__a> {
                    #[inline]
                    fn visit<S>(&mut self, serializer: &mut S)
                     -> ::std::result::Result<Option<()>, S::Error> where
                     S: ::serde::ser::Serializer {
                        loop  {
                            match self.state {
                                0usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "jsonrpc" ,
                                                        &self.value.jsonrpc ,
                                                        ))));
                                }
                                1usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "result" ,
                                                        &self.value.result ,
                                                        ))));
                                }
                                2usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "id" , &self.value.id
                                                        , ))));
                                }
                                _ => { return Ok(None); }
                            }
                        }
                    }
                    #[inline]
                    fn len(&self) -> Option<usize> { Some(0 + 1 + 1 + 1) }
                }
                serializer.visit_struct("Success",
                                        Visitor{value: self,
                                                state: 0,
                                                _structure_ty:
                                                    ::std::marker::PhantomData::<&Success>,})
            }
        }
    }
    #[derive(PartialEq, Debug)]
    pub struct Failure {
        pub jsonrpc: Version,
        pub error: Error,
        pub id: Id,
    }
    impl ::serde::ser::Serialize for Failure {
        fn serialize<__S>(&self, serializer: &mut __S)
         -> ::std::result::Result<(), __S::Error> where
         __S: ::serde::ser::Serializer {
            {
                struct Visitor<'__a> {
                    state: usize,
                    value: &'__a Failure,
                    _structure_ty: ::std::marker::PhantomData<&'__a Failure>,
                }
                impl <'__a> ::serde::ser::MapVisitor for Visitor<'__a> {
                    #[inline]
                    fn visit<S>(&mut self, serializer: &mut S)
                     -> ::std::result::Result<Option<()>, S::Error> where
                     S: ::serde::ser::Serializer {
                        loop  {
                            match self.state {
                                0usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "jsonrpc" ,
                                                        &self.value.jsonrpc ,
                                                        ))));
                                }
                                1usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "error" ,
                                                        &self.value.error ,
                                                        ))));
                                }
                                2usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "id" , &self.value.id
                                                        , ))));
                                }
                                _ => { return Ok(None); }
                            }
                        }
                    }
                    #[inline]
                    fn len(&self) -> Option<usize> { Some(0 + 1 + 1 + 1) }
                }
                serializer.visit_struct("Failure",
                                        Visitor{value: self,
                                                state: 0,
                                                _structure_ty:
                                                    ::std::marker::PhantomData::<&Failure>,})
            }
        }
    }
    #[derive(PartialEq, Debug)]
    pub enum Output { Success(Success), Failure(Failure), }
    impl Serialize for Output {
        fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer {
            match *self {
                Output::Success(ref s) => s.serialize(serializer),
                Output::Failure(ref f) => f.serialize(serializer),
            }
        }
    }
    #[derive(PartialEq, Debug)]
    pub enum Response { Single(Output), Batch(Vec<Output>), }
    impl Serialize for Response {
        fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer {
            match *self {
                Response::Single(ref o) => o.serialize(serializer),
                Response::Batch(ref b) => b.serialize(serializer),
            }
        }
    }
}
pub mod error {
    //! jsonrpc errors
    use serde::{Serialize, Serializer};
    use super::Value;
    #[derive(PartialEq, Debug)]
    pub enum ErrorCode {

        /// Invalid JSON was received by the server.
        /// An error occurred on the server while parsing the JSON text.
        ParseError,

        /// The JSON sent is not a valid Request object.
        InvalidRequest,

        /// The method does not exist / is not available.
        MethodNotFound,

        /// Invalid method parameter(s).
        InvalidParams,

        /// Internal JSON-RPC error.
        InternalError,

        /// Reserved for implementation-defined server-errors.
        ServerError(i64),
    }
    impl ErrorCode {
        pub fn code(&self) -> i64 {
            match *self {
                ErrorCode::ParseError => -32700,
                ErrorCode::InvalidRequest => -32600,
                ErrorCode::MethodNotFound => -32601,
                ErrorCode::InvalidParams => -32602,
                ErrorCode::InternalError => -32603,
                ErrorCode::ServerError(code) => code,
            }
        }
        pub fn description(&self) -> String {
            let desc =
                match *self {
                    ErrorCode::ParseError => "Parse error.",
                    ErrorCode::InvalidRequest => "Invalid request.",
                    ErrorCode::MethodNotFound => "Method not found.",
                    ErrorCode::InvalidParams => "Invalid params.",
                    ErrorCode::InternalError => "Internal error.",
                    ErrorCode::ServerError(_) => "Server error.",
                };
            desc.to_string()
        }
    }
    impl Serialize for ErrorCode {
        fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer {
            serializer.visit_i64(self.code())
        }
    }
    #[derive(PartialEq, Debug)]
    pub struct Error {
        pub code: ErrorCode,
        pub message: String,
        pub data: Option<Value>,
    }
    impl ::serde::ser::Serialize for Error {
        fn serialize<__S>(&self, serializer: &mut __S)
         -> ::std::result::Result<(), __S::Error> where
         __S: ::serde::ser::Serializer {
            {
                struct Visitor<'__a> {
                    state: usize,
                    value: &'__a Error,
                    _structure_ty: ::std::marker::PhantomData<&'__a Error>,
                }
                impl <'__a> ::serde::ser::MapVisitor for Visitor<'__a> {
                    #[inline]
                    fn visit<S>(&mut self, serializer: &mut S)
                     -> ::std::result::Result<Option<()>, S::Error> where
                     S: ::serde::ser::Serializer {
                        loop  {
                            match self.state {
                                0usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "code" ,
                                                        &self.value.code ,
                                                        ))));
                                }
                                1usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "message" ,
                                                        &self.value.message ,
                                                        ))));
                                }
                                2usize => {
                                    self.state += 1;
                                    { }
                                    return Ok(Some(try!(serializer .
                                                        visit_struct_elt (
                                                        "data" ,
                                                        &self.value.data ,
                                                        ))));
                                }
                                _ => { return Ok(None); }
                            }
                        }
                    }
                    #[inline]
                    fn len(&self) -> Option<usize> { Some(0 + 1 + 1 + 1) }
                }
                serializer.visit_struct("Error",
                                        Visitor{value: self,
                                                state: 0,
                                                _structure_ty:
                                                    ::std::marker::PhantomData::<&Error>,})
            }
        }
    }
    impl Error {
        pub fn new(code: ErrorCode) -> Self {
            Error{message: code.description(), code: code, data: None,}
        }
        pub fn parse_error() -> Self { Self::new(ErrorCode::ParseError) }
        pub fn invalid_request() -> Self {
            Self::new(ErrorCode::InvalidRequest)
        }
        pub fn method_not_found() -> Self {
            Self::new(ErrorCode::MethodNotFound)
        }
        pub fn invalid_params() -> Self {
            Self::new(ErrorCode::InvalidParams)
        }
        pub fn internal_error() -> Self {
            Self::new(ErrorCode::InternalError)
        }
    }
}
pub mod commander {
    //! method and notification commands executor
    use std::collections::HashMap;
    use super::{Params, Value, Error, ErrorCode};
    /// Should be used to handle single method call.
    pub trait MethodCommand: Send + Sync {
        fn execute(&mut self, params: Params)
        -> Result<Value, Error>;
    }
    /// Default method command implementation for closure.
    impl <F> MethodCommand for F where F: Fn(Params) -> Result<Value, Error>,
     F: Sync + Send {
        fn execute(&mut self, params: Params) -> Result<Value, Error> {
            self(params)
        }
    }
    /// Should be used to handle single notification.
    pub trait NotificationCommand: Send + Sync {
        fn execute(&mut self, params: Params);
    }
    /// Default notification command implementation for closure.
    impl <F> NotificationCommand for F where F: Fn(Params), F: Sync + Send {
        fn execute(&mut self, params: Params) { self(params) }
    }
    /// Commands executor.
    pub struct Commander {
        methods: HashMap<String, Box<MethodCommand>>,
        notifications: HashMap<String, Box<NotificationCommand>>,
    }
    impl Commander {
        pub fn new() -> Self {
            Commander{methods: HashMap::new(), notifications: HashMap::new(),}
        }
        pub fn add_method<C>(&mut self, name: String, command: Box<C>) where
         C: MethodCommand + 'static {
            self.methods.insert(name, command);
        }
        pub fn add_methods(&mut self,
                           methods: HashMap<String, Box<MethodCommand>>) {
            self.methods.extend(methods);
        }
        pub fn add_notification<C>(&mut self, name: String, command: Box<C>)
         where C: NotificationCommand + 'static {
            self.notifications.insert(name, command);
        }
        pub fn add_notifications(&mut self,
                                 notifications:
                                     HashMap<String,
                                             Box<NotificationCommand>>) {
            self.notifications.extend(notifications);
        }
        pub fn execute_method(&mut self, name: String, params: Params)
         -> Result<Value, Error> {
            match self.methods.get_mut(&name) {
                Some(command) => command.execute(params),
                None => Err(Error::new(ErrorCode::MethodNotFound)),
            }
        }
        pub fn execute_notification(&mut self, name: String, params: Params) {
            if let Some(command) = self.notifications.get_mut(&name) {
                command.execute(params)
            }
        }
    }
}
pub mod request_handler {
    //! jsonrpc server request handler
    use std::collections::HashMap;
    use super::*;
    pub struct RequestHandler {
        commander: Commander,
    }
    impl RequestHandler {
        pub fn new() -> Self { RequestHandler{commander: Commander::new(),} }
        #[inline]
        pub fn add_method<C>(&mut self, name: String, command: Box<C>) where
         C: MethodCommand + 'static {
            self.commander.add_method(name, command)
        }
        #[inline]
        pub fn add_methods(&mut self,
                           methods: HashMap<String, Box<MethodCommand>>) {
            self.commander.add_methods(methods);
        }
        #[inline]
        pub fn add_notification<C>(&mut self, name: String, command: Box<C>)
         where C: NotificationCommand + 'static {
            self.commander.add_notification(name, command)
        }
        #[inline]
        pub fn add_notifications(&mut self,
                                 notifications:
                                     HashMap<String,
                                             Box<NotificationCommand>>) {
            self.commander.add_notifications(notifications);
        }
        pub fn handle_request(&mut self, request: Request)
         -> Option<Response> {
            match request {
                Request::Single(call) =>
                self.handle_call(call).map(Response::Single),
                Request::Batch(calls) => {
                    let outs: Vec<Output> =
                        calls.into_iter().filter_map(|call|
                                                         self.handle_call(call)).collect();
                    match outs.len() {
                        0 => None,
                        _ => Some(Response::Batch(outs)),
                    }
                }
            }
        }
        fn handle_call(&mut self, call: Call) -> Option<Output> {
            match call {
                Call::MethodCall(method) =>
                Some(self.handle_method_call(method)),
                Call::Notification(notification) => {
                    self.handle_notification(notification);
                    None
                }
                Call::Invalid =>
                Some(Output::Failure(Failure{id: Id::Null,
                                             jsonrpc: Version::V2,
                                             error:
                                                 Error::new(ErrorCode::InvalidRequest),})),
            }
        }
        fn handle_method_call(&mut self, method: MethodCall) -> Output {
            let params =
                match method.params { Some(p) => p, None => Params::None, };
            match self.commander.execute_method(method.method, params) {
                Ok(result) =>
                Output::Success(Success{id: method.id,
                                        jsonrpc: method.jsonrpc,
                                        result: result,}),
                Err(error) =>
                Output::Failure(Failure{id: method.id,
                                        jsonrpc: method.jsonrpc,
                                        error: error,}),
            }
        }
        fn handle_notification(&mut self, notification: Notification) {
            let params =
                match notification.params {
                    Some(p) => p,
                    None => Params::None,
                };
            self.commander.execute_notification(notification.method, params)
        }
    }
}
pub mod io {
    //! jsonrpc io
    use std::sync::Arc;
    use std::collections::HashMap;
    use super::{MethodCommand, NotificationCommand, Params, Value, Error,
                Response, Output, Version, Id, ErrorCode, RequestHandler,
                Request, Failure};
    use serde_json;
    struct DelegateMethod<T, F> where F: Fn(&T, Params) ->
           Result<Value, Error>, F: Send + Sync, T: Send + Sync {
        delegate: Arc<T>,
        closure: F,
    }
    impl <T, F> MethodCommand for DelegateMethod<T, F> where F: Fn(&T, Params)
     -> Result<Value, Error>, F: Send + Sync, T: Send + Sync {
        fn execute(&mut self, params: Params) -> Result<Value, Error> {
            let closure = &self.closure;
            closure(&self.delegate, params)
        }
    }
    struct DelegateNotification<T, F> where F: Fn(&T, Params), F: Send + Sync,
           T: Send + Sync {
        delegate: Arc<T>,
        closure: F,
    }
    impl <T, F> NotificationCommand for DelegateNotification<T, F> where
     F: Fn(&T, Params), F: Send + Sync, T: Send + Sync {
        fn execute(&mut self, params: Params) {
            let closure = &self.closure;
            closure(&self.delegate, params)
        }
    }
    pub struct IoDelegate<T> where T: Send + Sync + 'static {
        delegate: Arc<T>,
        methods: HashMap<String, Box<MethodCommand>>,
        notifications: HashMap<String, Box<NotificationCommand>>,
    }
    impl <T> IoDelegate<T> where T: Send + Sync + 'static {
        pub fn new(delegate: Arc<T>) -> Self {
            IoDelegate{delegate: delegate,
                       methods: HashMap::new(),
                       notifications: HashMap::new(),}
        }
        pub fn add_method<F>(&mut self, name: &str, closure: F) where
         F: Fn(&T, Params) -> Result<Value, Error> + Send + Sync + 'static {
            let delegate = self.delegate.clone();
            self.methods.insert(name.to_owned(),
                                Box::new(DelegateMethod{delegate: delegate,
                                                        closure: closure,}));
        }
        pub fn add_notification<F>(&mut self, name: &str, closure: F) where
         F: Fn(&T, Params) + Send + Sync + 'static {
            let delegate = self.delegate.clone();
            self.notifications.insert(name.to_owned(),
                                      Box::new(DelegateNotification{delegate:
                                                                        delegate,
                                                                    closure:
                                                                        closure,}));
        }
    }
    /// Should be used to handle jsonrpc io.
    /// 
    /// ```rust
    /// extern crate jsonrpc_core;
    /// use jsonrpc_core::*;
    ///
    /// fn main() {
    /// 	let mut io = IoHandler::new();
    /// 	struct SayHello;
    /// 	impl MethodCommand for SayHello {
    /// 		fn execute(&mut self, _params: Params) -> Result<Value, Error> {
    /// 			Ok(Value::String("hello".to_string()))
    /// 		}
    /// 	}
    ///
    /// 	io.add_method("say_hello", SayHello);
    ///
    /// 	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
    /// 	let response = r#"{"jsonrpc":"2.0","result":"hello","id":1}"#;
    ///
    /// 	assert_eq!(io.handle_request(request), Some(response.to_string()));
    /// }
    /// ```
    pub struct IoHandler {
        request_handler: RequestHandler,
    }
    fn read_request(request_str: &str) -> Result<Request, Error> {
        serde_json::from_str(request_str).map_err(|_|
                                                      Error::new(ErrorCode::ParseError))
    }
    fn write_response(response: Response) -> String {
        serde_json::to_string(&response).unwrap()
    }
    impl IoHandler {
        pub fn new() -> Self {
            IoHandler{request_handler: RequestHandler::new(),}
        }
        #[inline]
        pub fn add_method<C>(&mut self, name: &str, command: C) where
         C: MethodCommand + 'static {
            self.request_handler.add_method(name.to_owned(),
                                            Box::new(command))
        }
        #[inline]
        pub fn add_notification<C>(&mut self, name: &str, command: C) where
         C: NotificationCommand + 'static {
            self.request_handler.add_notification(name.to_owned(),
                                                  Box::new(command))
        }
        pub fn add_delegate<D>(&mut self, delegate: IoDelegate<D>) where
         D: Send + Sync {
            self.request_handler.add_methods(delegate.methods);
            self.request_handler.add_notifications(delegate.notifications);
        }
        pub fn handle_request<'a>(&mut self, request_str: &'a str)
         -> Option<String> {
            match read_request(request_str) {
                Ok(request) =>
                self.request_handler.handle_request(request).map(write_response),
                Err(error) =>
                Some(write_response(Response::Single(Output::Failure(Failure{id:
                                                                                 Id::Null,
                                                                             jsonrpc:
                                                                                 Version::V2,
                                                                             error:
                                                                                 error,})))),
            }
        }
    }
    #[cfg(test)]
    mod tests {
        use super::super::*;
        #[test]
        fn test_io_handler() {
            let mut io = IoHandler::new();
            struct SayHello;
            impl MethodCommand for SayHello {
                fn execute(&mut self, _params: Params)
                 -> Result<Value, Error> {
                    Ok(Value::String("hello".to_string()))
                }
            }
            io.add_method("say_hello", SayHello);
            let request =
                r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
            let response = r#"{"jsonrpc":"2.0","result":"hello","id":1}"#;
            assert_eq!(io . handle_request ( request ) , Some (
                       response . to_string (  ) ));
        }
    }
}
pub mod util {
    use serde::{Deserialize, Serialize};
    use serde_json::value::{Value, Deserializer, Serializer};
    use super::{Params, Error};
    pub fn from_params<D>(params: Params) -> Result<D, Error> where
     D: Deserialize {
        let value =
            match params {
                Params::Array(vec) => Value::Array(vec),
                Params::Map(map) => Value::Object(map),
                Params::None => Value::Null,
            };
        let mut deserializer = Deserializer::new(value);
        Deserialize::deserialize(&mut deserializer).map_err(|_|
                                                                Error::invalid_params())
    }
    pub fn to_value<S>(s: &S) -> Result<Value, Error> where S: Serialize {
        let mut serializer = Serializer::new();
        match s.serialize(&mut serializer) {
            Err(_) => Err(Error::internal_error()),
            _ => Ok(serializer.unwrap()),
        }
    }
}
pub use serde_json::Value;
pub use self::version::Version;
pub use self::id::Id;
pub use self::params::Params;
pub use self::request::{Request, Call, MethodCall, Notification};
pub use self::response::{Response, Output, Success, Failure};
pub use self::error::{ErrorCode, Error};
pub use self::commander::{Commander, MethodCommand, NotificationCommand};
pub use self::request_handler::RequestHandler;
pub use self::io::{IoHandler, IoDelegate};
pub use self::util::{from_params, to_value};