Struct url_encoded_data::UrlEncodedData[−][src]

pub struct UrlEncodedData<'a> {
    pub original_data_str: &'a str,
    // some fields omitted
}

Represents the form-urlencoded data: eg: url query string, or application/x-www-form-urlencoded of the body.

Fields

original_data_str: &'a str

Implementations

impl<'a> UrlEncodedData<'a>[src]

UrlEncodedData: parse url_encoded_data to pairs eagerly

pub fn parse_str(s: &'a str) -> Self[src]

UrlEncodedData from &str


use url_encoded_data::UrlEncodedData;
let q = UrlEncodedData::parse_str("abcd=efg");
let first_pair = q.iter().next().unwrap();
let (k, v) = first_pair;
assert_eq!(k.as_ref(), "abcd");
assert_eq!(v.as_ref(), "efg");

pub fn builder(s: &'a str) -> UrlEncodedDataBuilder<'_>[src]

pub fn as_pairs(&'a self) -> Vec<(&'a Cow<'a, str>, &'a Cow<'a, str>)>[src]

As pairs slice in random order, better performance than as_pairs_of_original_order and as_pairs_of_sorted_order

example:

use url_encoded_data::*;
use url_encoded_data::UrlEncodedData;
let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key".to_string();
for s in [
    qs.as_str(),
    ("https://abc.com/?".to_string() + qs.as_str()).as_str(),
    ("https://abc.com/?????".to_string() + qs.as_str()).as_str(),
]
.iter()
{
    let q = UrlEncodedData::parse_str(s);
    // let mut q = UrlEncodedData::prepare(url_1);
    // let q = q.parse();
    println!("got qs: {}", q);

    let pairs_expected_as_str = [
        ("a", "1"),
        ("b", "2"),
        ("c", "3"),
        ("c", "4"),
        ("key_without_value", ""),
        ("", "value_without_key"),
    ];

   for (k, v) in q.as_pairs().iter().map(|(k,v)|(k.as_ref(), v.as_ref())) {
       assert!(pairs_expected_as_str.contains(&(k, v)));
   }
}

An example of decoding:

use url_encoded_data::*;
let s = "hello=%e4%bd%a0%e5%a5%bd&world=%e4%b8%96%e7%95%8c";
let qs = UrlEncodedData::from(s);
let str_vec: Vec<_> = qs.as_pairs().into_iter().map(|(k, v)| (k.as_ref(), v.as_ref())).collect();
// random order
assert!(str_vec[0] == ("hello", "你好") || str_vec[0] == ("world", "世界"));
assert!(str_vec[1] == ("hello", "你好") || str_vec[1] == ("world", "世界"));

pub fn as_pairs_of_original_order(
    &'a self
) -> Vec<(&'a Cow<'a, str>, &'a Cow<'a, str>)>[src]

As pairs slice

example:

use url_encoded_data::UrlEncodedData;
let s = "c=3&a=1&b=2&c=4&key_without_value&=value_without_key";
let q = UrlEncodedData::parse_str(s);
// let mut q = UrlEncodedData::prepare(url_1);
// let q = q.parse();
println!("got qs: {}", q);

let pairs_expected_as_str = [
    ("c", "3"),
    ("c", "4"),
    ("a", "1"),
    ("b", "2"),
    ("key_without_value", ""),
    ("", "value_without_key"),
];


for (i, (k, v)) in q.as_pairs_of_original_order().iter().enumerate() {
    let (k_, v_) = pairs_expected_as_str[i];
    println!("{}, ({}, {}), ({}, {})", i, k, v, k_, v_);
    assert_eq!(k.as_ref(), k_);
    assert_eq!(v.as_ref(), v_);
}

An example of decoding:

use url_encoded_data::*;
let s = "hello=%e4%bd%a0%e5%a5%bd&world=%e4%b8%96%e7%95%8c";
let qs = UrlEncodedData::from(s);
let str_vec: Vec<_> = qs.as_pairs_of_original_order().into_iter().map(|(k, v)| (k.as_ref(), v.as_ref())).collect();
assert_eq!(str_vec[0], ("hello", "你好"));
assert_eq!(str_vec[1], ("world", "世界"));

pub fn as_pairs_of_sorted_order(
    &'a self
) -> Vec<(&'a Cow<'a, str>, &'a Cow<'a, str>)>[src]

As pairs slice

example:



use url_encoded_data::UrlEncodedData;
let s = "c=3&a=1&b=2&c=4&key_without_value&=value_without_key";
let q = UrlEncodedData::parse_str(s);
// let mut q = UrlEncodedData::prepare(url_1);
// let q = q.parse();
println!("got qs: {}", q);

let pairs_expected_as_str = [
    ("", "value_without_key"),
    ("a", "1"),
    ("b", "2"),
    ("c", "3"),
    ("c", "4"),
    ("key_without_value", ""),
];

dbg!(q.as_pairs_of_sorted_order());
for (i, (k, v)) in q.as_pairs_of_sorted_order().iter().enumerate() {
    let (k_, v_) = pairs_expected_as_str[i];
    println!("{}, ({}, {}), ({}, {})", i, k, v, k_, v_);
    assert_eq!(k.as_ref(), k_);
    assert_eq!(v.as_ref(), v_);
}

An example of decoding:

use url_encoded_data::*;
let s = "hello=%e4%bd%a0%e5%a5%bd&world=%e4%b8%96%e7%95%8c";
let qs = UrlEncodedData::from(s);
let str_vec: Vec<_> = qs.as_pairs_of_sorted_order().into_iter().map(|(k, v)| (k.as_ref(), v.as_ref())).collect();
assert_eq!(str_vec[0], ("hello", "你好"));
assert_eq!(str_vec[1], ("world", "世界"));

pub fn iter(
    &'a self
) -> impl Iterator<Item = (&'a Cow<'a, str>, &'a Cow<'a, str>)>[src]

Yields an iterator with Item = (key, value) pair Item = (Cow<’a, str>, Cow<’a, str>)

pub fn as_string_pairs(&'a self) -> Vec<(String, String)>[src]

As_String_pairs

example:

use url_encoded_data::UrlEncodedData;
let qs = "a=1&b=2";
let q = UrlEncodedData::parse_str(qs);
// let mut q = UrlEncodedData::prepare(url_1);
// let q = q.parse();
println!("got qs: {}", q);

let pairs_expected_as_str = [
    ("a", "1"),
    ("b", "2"),
];


for (k, v) in q.as_string_pairs().iter() {
    if k.as_str() == "a" {
        assert_eq!(v.as_str(), "1")
    } else {
        assert_eq!(v.as_str(), "2")
    }
}

pub fn stringify(pairs: &[(&'_ Cow<'_, str>, &'_ Cow<'_, str>)]) -> String[src]

encode pairs to url-encoded-string

example

use url_encoded_data::stringify;
let encoded = stringify(&[("a", "b"), ("c", "d")]);
assert_eq!(encoded, "a=b&c=d");
use url_encoded_data::stringify;
let encoded = stringify(&[("hello", "你好"), ("world", "世界")]);
assert_eq!(encoded, "hello=%E4%BD%A0%E5%A5%BD&world=%E4%B8%96%E7%95%8C");

pub fn to_final_string(&self) -> String[src]

You can just use .to_string() instead. (alloc::string::ToString trait is auto-implemented on T: fmt::Display + ?Sized). To final string, same as print!("{}", self)

use url_encoded_data::UrlEncodedData;
let url = "https://google.com/?q=rust";
let q = UrlEncodedData::parse_str(url).set_one("q", "rust-lang").done();
assert_eq!(q.to_final_string(), "https://google.com/?q=rust-lang")

pub fn to_string_of_original_order(&self) -> String[src]

to_string_of_original_order

use url_encoded_data::UrlEncodedData;
let url = "https://google.com/?q=rust&ei=code";
let q = UrlEncodedData::parse_str(url).set_one("q", "rust-lang").done();
assert_eq!(q.to_string_of_original_order(), "https://google.com/?q=rust-lang&ei=code")

pub fn to_string_of_sorted_order(&self) -> String[src]

to_string_of_sorted_order

use url_encoded_data::UrlEncodedData;
let url = "https://google.com/?q=rust&ei=code";
let q = UrlEncodedData::parse_str(url).set_one("q", "rust-lang").done();
assert_eq!(q.to_string_of_sorted_order(), "https://google.com/?ei=code&q=rust-lang")

pub fn as_map_of_single_key_to_multiple_values(
    &'a self
) -> &'a HashMap<Cow<'a, str>, Vec<Cow<'a, str>>>[src]

As Map of Single-key to Multiple-values

example:

#[macro_use]
extern crate maplit;

fn main() {
    use url_encoded_data::UrlEncodedData;
    let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key".to_string();
    for s in [
        qs.as_str(),
        ("https://abc.com/?".to_string() + qs.as_str()).as_str(),
        ("https://abc.com/?????".to_string() + qs.as_str()).as_str(),
    ]
    .iter()
    {
        let q = UrlEncodedData::parse_str(s);
        println!("got qs: {}", q);

        //
        let map_of_multiple_values_expected = hashmap! {
            "a"=>vec!("1"),
            "b"=>vec!("2"),
            "c"=>vec!("3", "4"),
            "key_without_value" => vec!(""),
            "" => vec!("value_without_key"),
        };
        dbg!("as_map_of_single_key_to_multiple_values");
        println!("as_map_of_single_key_to_multiple_values");
        let map = q.as_map_of_single_key_to_multiple_values();

        assert_eq!(map.len(), 5);
        for (k1, v1) in map {
            let v2 = map_of_multiple_values_expected.get(k1.as_ref()).unwrap();
            for (i, v2i) in v2.into_iter().enumerate() {
                assert_eq!(v1[i].to_string(), v2i.to_string());
            }
        }

    }
}

eg: “a=b&a=c&d=&e” => {“a” : [“b”, “c”], “d: [”“], “”: [“e”]}

pub fn as_map_of_single_key_to_first_occurrence_value(
    &'a self
) -> HashMap<&'a Cow<'_, str>, &'a Cow<'_, str>>[src]

As Map of Single-key to First Occurrence Value

example:



#[macro_use]
extern crate maplit;

fn main() {
    use std::borrow::Cow;
    use url_encoded_data::UrlEncodedData;
    let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key".to_string();
    for s in [
        qs.as_str(),
        ("https://abc.com/?".to_string() + qs.as_str()).as_str(),
        ("https://abc.com/?????".to_string() + qs.as_str()).as_str(),
    ]
    .iter()
    {
        let q = UrlEncodedData::parse_str(s);
        println!("got qs: {}", q);

        //
        let map_of_multiple_values_expected = hashmap! {
            "a"=>vec!("1"),
            "b"=>vec!("2"),
            "c"=>vec!("3", "4"),
            "key_without_value" => vec!(""),
            "" => vec!("value_without_key"),
        };
        let map_of_first_occurrence_value_expected = hashmap! {
            "a"=>"1",
            "b"=>"2",
            "c"=>"3",
            "key_without_value" => "",
            "" => "value_without_key",
        };
        dbg!("as_map_of_single_key_to_first_occurrence_value");
        let mut q_clone = q.clone();
        let map = q_clone.as_map_of_single_key_to_first_occurrence_value();
        assert_eq!(map.len(), 5);
        for (k1, v1) in map {
            let v2 = map_of_first_occurrence_value_expected
                .get(k1.as_ref())
                .unwrap();
            // let v3 = &v1;
            assert_eq!(&v1, v2); // ok, signifies comparing with each reference, it will  auto-dereference to compare the value, which is more convenient
            let ptr1 = v1 as *const Cow<'_, str> as *const usize;
            let ptr2 = v2 as *const &str as *const usize;
            let msg = format!("{:p}, {:p}", ptr1, ptr2);
            dbg!(msg);
            println!("{:p}, {:p}", ptr1, ptr2);
            assert!(!std::ptr::eq(ptr1, ptr2));
            assert_eq!(*v1, **v2); // ok, value compare
        }
    }
}

eg: “a=b&a=c” => {“a” : “b”}

pub fn as_map_of_single_key_to_last_occurrence_value(
    &'a self
) -> HashMap<&'a Cow<'_, str>, &'a Cow<'_, str>>[src]

As Map of Single-key to Last Occurrence Value

example:



#[macro_use]
extern crate maplit;

fn main() {
    use url_encoded_data::UrlEncodedData;
let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key".to_string();
    for s in [
        qs.as_str(),
        ("https://abc.com/?".to_string() + qs.as_str()).as_str(),
        ("https://abc.com/?????".to_string() + qs.as_str()).as_str(),
    ]
    .iter()
    {
        let q = UrlEncodedData::parse_str(s);
        println!("got qs: {}", q);

        let map_of_last_occurrence_value_expected = hashmap! {
            "a"=>"1",
            "b"=>"2",
            "c"=>"4",
            "key_without_value" => "",
            "" => "value_without_key",
        };
        dbg!("as_map_of_single_key_to_last_occurrence_value");
        let map = q.as_map_of_single_key_to_last_occurrence_value();
        assert_eq!(map.len(), 5);

        for (k1, v1) in map {
            let v2 = map_of_last_occurrence_value_expected
                .get(k1.as_ref())
                .unwrap();
            assert_eq!(&v1, v2);
        }
    }
}

eg: “a=b&a=c” => {“a” : “b”}

pub fn get_multiple_values<'b>(
    &'a self,
    key: &'b str
) -> Option<&Vec<Cow<'_, str>>>[src]

Get multiple values by key

example:

#[macro_use]
extern crate maplit;

fn main() {
     
     
    use url_encoded_data::UrlEncodedData;
    let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key";
    let q = UrlEncodedData::parse_str(qs);
    println!("got qs: {}", q);

    assert_eq!(q.get_multiple_values("a").unwrap()[0].as_ref(), "1");
    assert_eq!(q.get_multiple_values("c").unwrap().iter().map(|x| x.as_ref()).collect::<Vec<_>>(), vec!["3", "4"]);
    assert_eq!(q.get_multiple_values("non-exist"), None);
}

pub fn get_first_occurrence_value<'b>(
    &'a self,
    key: &'b str
) -> Option<&'a Cow<'_, str>>[src]

Get first occurrence value by key

example:

use url_encoded_data::UrlEncodedData;
let s = "a=1&b=2&c=3&c=4";
let q = UrlEncodedData::parse_str(s);
println!("got qs: {}", q);

assert_eq!(q.get_first_occurrence_value("a").unwrap().as_ref(), "1");
assert_eq!(q.get_first_occurrence_value("c").unwrap().as_ref(), "3");
assert_eq!(q.get_first_occurrence_value("non-exist"), None);

pub fn get_last_occurrence_value<'b>(
    &'a self,
    key: &'b str
) -> Option<&'a Cow<'_, str>>[src]

Get last occurrence value by key

example:

#[macro_use]
extern crate maplit;

fn main() {
     
     
    use url_encoded_data::UrlEncodedData;
    let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key";
    let q = UrlEncodedData::parse_str(qs);
    println!("got qs: {}", q);

    assert_eq!(q.get_last_occurrence_value("a").unwrap(), "1");
    assert_eq!(q.get_last_occurrence_value("c").unwrap(), "4");
    assert_eq!(q.get_last_occurrence_value("non-exist"), None);
}

pub fn set(&mut self, key: &'a str, value: &[&'a str]) -> &mut Self[src]

set a key with value slice

example:

use url_encoded_data::UrlEncodedData;
let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key";
let q = UrlEncodedData::parse_str(qs).set("a", &["100", "200"]).done();

assert_eq!(q.get("a").unwrap(), vec!["100", "200"]);

pub fn set_one<'b>(&'b mut self, key: &'a str, value: &'a str) -> &'b mut Self[src]

set a key with exactly one value

example:

use url_encoded_data::UrlEncodedData;
let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key";
let q = UrlEncodedData::parse_str(qs).set_one("a", "100").done();

assert_eq!(q.get_first("a").unwrap(), "100");

pub fn push(&mut self, key: &'a str, value: &'a str) -> &mut Self[src]

Push(aka, append) a value to the key

example:

use url_encoded_data::UrlEncodedData;
let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key";
let q = UrlEncodedData::parse_str(qs).push("a", "100").push("hello", "world").done();

assert_eq!(q.get("a").unwrap(), vec!["1", "100"]);
assert_eq!(q.get("hello").unwrap(), vec!["world"]);
assert_eq!(q.get_first("hello").unwrap(), "world");

pub fn done(&self) -> Self[src]

Done setting

example:

use url_encoded_data::UrlEncodedData;
let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key";
let mut q = UrlEncodedData::parse_str(qs).set_one("a", "100").set_one("b", "200").done();

assert_eq!(q.get_first("a").unwrap(), "100");
assert_eq!(q.get_first("b").unwrap(), "200");

pub fn get<'b>(&'a self, key: &'b str) -> Option<Vec<&'a str>>[src]

Get multiple values, same as method: get_multiple_values(key) but return Option<Vec<&'a str>> instead

example:

use url_encoded_data::UrlEncodedData;
let qs = "a=1&b=2&c=3&c=4&key_without_value&=value_without_key";
let q = UrlEncodedData::parse_str(qs);
assert_eq!(q.get("c").unwrap(), vec!["3", "4"]);

pub fn get_first<'b>(&'a self, key: &'b str) -> Option<&'a str>[src]

Get first occurrence value by key, similar to self.get_first_occurrence_value(key), but returns Option<&'a str> instead.

example:

use url_encoded_data::UrlEncodedData;
let s = "a=1&b=2&c=3&c=4";
let q = UrlEncodedData::parse_str(s);
println!("got qs: {}", q);

assert_eq!(q.get_first("c").unwrap(), "3");
assert_eq!(q.get_first("a").unwrap(), "1");
assert_eq!(q.get_first("b").unwrap(), "2");
assert_eq!(q.get_first("non-exist"), None);

similar to self.get_first_occurrence_value(key), but returns Option<&'a str> instead.

pub fn get_last<'b>(&'a self, key: &'b str) -> Option<&'a str>[src]

Get last occurrence value by key, similar to self.get_last_occurrence_value(key), but returns Option<&'a str> instead.

example:

use url_encoded_data::UrlEncodedData;
let s = "a=1&b=2&c=3&c=4";
let q = UrlEncodedData::parse_str(s);
println!("got qs: {}", q);

assert_eq!(q.get_last("c").unwrap(), "4");
assert_eq!(q.get_last("a").unwrap(), "1");
assert_eq!(q.get_last("b").unwrap(), "2");
assert_eq!(q.get_last("non-exist"), None);

similar to self.get_last_occurrence_value(key), but returns Option<&'a str> instead.

pub fn delete(&mut self, key: &'a str) -> &mut Self[src]

Delete (k, v) pairs of key

example:

use url_encoded_data::UrlEncodedData;
let s = "a=1&b=2&c=3&c=4&d=5";
let mut  q = UrlEncodedData::parse_str(s);
println!("got qs: {}", q);

assert_eq!(q.get_first("c").unwrap(), "3");
assert_eq!(q.get_last("c").unwrap(), "4");
q.delete("c").delete("b").delete("a");
assert_eq!(q.get("c"), None);
assert_eq!(q.get_first("c"), None);
assert_eq!(q.get_last("c"), None);

assert_eq!(q.get_first("a"), None);
assert_eq!(q.get_first("b"), None);
assert_eq!(q.get_first("d").unwrap(), "5");

pub fn clear(self) -> Self[src]

Clear all (k, v) pairs

example:

use url_encoded_data::UrlEncodedData;
let s = "a=1&b=2&c=3&c=4&d=5";
let q = UrlEncodedData::parse_str(s);
assert_eq!(q.len(), 5);
assert_eq!(q.keys_length(), 4);
let q = q.clear();
assert_eq!(q.len(), 0);
assert_eq!(q.get("c"), None);
assert_eq!(q.get_first("c"), None);
assert_eq!(q.get_last("c"), None);

assert_eq!(q.get_first("a"), None);
assert_eq!(q.get_first("b"), None);
assert_eq!(q.get_first("d"), None);

pub fn len(&self) -> usize[src]

len of pairs

example:

use url_encoded_data::UrlEncodedData;
let s = "a=1&b=2&c=3&c=4&d=5";
let q = UrlEncodedData::parse_str(s);
assert_eq!(q.len(), 5);
assert_eq!(q.keys_length(), 4);
let q = q.clear();
assert_eq!(q.len(), 0);
assert_eq!(q.keys_length(), 0);

pub fn keys_length(&self) -> usize[src]

length of keys

example:

use url_encoded_data::UrlEncodedData;
let s = "a=1&b=2&c=3&c=4&d=5";
let q = UrlEncodedData::parse_str(s);
assert_eq!(q.len(), 5);
assert_eq!(q.keys_length(), 4);
let q = q.clear();
assert_eq!(q.len(), 0);
assert_eq!(q.keys_length(), 0);

pub fn is_empty(&self) -> bool[src]

len of pairs

example:

use url_encoded_data::UrlEncodedData;
let s = "a=1&b=2&c=3&c=4&d=5";
let q = UrlEncodedData::parse_str(s);
assert!(!q.is_empty());
let mut q = q; // const -> mut
let q = q.clear();
assert!(q.is_empty());

pub fn keys(&self) -> Vec<&str>[src]

length of keys

example:

use url_encoded_data::UrlEncodedData;
use std::borrow::Cow;
let s = "c=3&b=2&a=1&c=4&d=5";
let q = UrlEncodedData::parse_str(s);
let keys = q.keys();
assert!(keys.contains(&"a"));
assert!(keys.contains(&"b"));
assert!(keys.contains(&"c"));
assert!(keys.contains(&"d"));
assert!(!keys.contains(&"e"));
assert_eq!(q.keys_length(), 4);

pub fn exists(&self, key: &str) -> bool[src]

Is key exists?

example:

use url_encoded_data::UrlEncodedData;
use std::borrow::Cow;
let s = "c=3&b=2&a=1&c=4&d=5";
let q = UrlEncodedData::parse_str(s);
assert!(q.exists("c"));
assert!(q.exists("b"));
assert!(q.exists("a"));
assert!(q.exists("d"));
assert!(!q.exists("e"));

pub fn keys_of_original_order(&self) -> Vec<Cow<'_, str>>[src]

keys_of_original_order

example:

use url_encoded_data::UrlEncodedData;
use std::borrow::Cow;
let s = "c=3&b=2&a=1&c=4&d=5";
let q = UrlEncodedData::parse_str(s);
let keys = q.keys();
assert_eq!(q.keys_of_original_order(), vec!["c", "b", "a", "d"]);

pub fn keys_of_sorted_order(&self) -> Vec<Cow<'_, str>>[src]

keys_of_original_order

example:

use url_encoded_data::UrlEncodedData;
use std::borrow::Cow;
let s = "c=3&b=2&a=1&c=4&d=5";
let q = UrlEncodedData::parse_str(s);
let keys = q.keys();
assert_eq!(q.keys_of_sorted_order(), vec!["a", "b", "c", "d"]);

Trait Implementations

impl<'a> Clone for UrlEncodedData<'a>[src]

impl<'a> Debug for UrlEncodedData<'a>[src]

impl<'a> Display for UrlEncodedData<'a>[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result[src]

use url_encoded_data::*;
let q = UrlEncodedData::from("abcd=efg");
let display = format!("got qs: {}", q);
assert!(display.len() > 3)

impl<'a> From<&'a str> for UrlEncodedData<'a>[src]

fn from(s: &'a str) -> Self[src]

UrlEncodedData from &str

use url_encoded_data::*;
let q = UrlEncodedData::from("abcd=efg");
let first_pair = q.iter().next().unwrap();
let (k, v) = first_pair;
assert_eq!(k.as_ref(), "abcd");
assert_eq!(v.as_ref(), "efg");

Auto Trait Implementations

impl<'a> RefUnwindSafe for UrlEncodedData<'a>

impl<'a> Send for UrlEncodedData<'a>

impl<'a> Sync for UrlEncodedData<'a>

impl<'a> Unpin for UrlEncodedData<'a>

impl<'a> UnwindSafe for UrlEncodedData<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.