Struct QString

pub struct QString { /* private fields */ }

A query string. Holds a list of (key,value).

Examples

Parameters can be get by their names.

let qs = qstring::QString::from("?foo=bar%20baz");
let foo = qs.get("foo").unwrap();
assert_eq!(foo, "bar baz");

Parameters not found are None.

let qs = qstring::QString::from("?foo=bar");
let foo = &qs.get("panda");
assert!(foo.is_none());

The query string can be assembled from pairs.

let qs = qstring::QString::new(vec![
   ("foo", "bar baz"),
   ("panda", "true"),
]);
assert_eq!(format!("{}", qs), "foo=bar%20baz&panda=true");

Implementations

impl QString

pub fn new<S, T>(params: Vec<(S, T)>) -> QString

where S: Into<String>, T: Into<String>,

Constructs a QString from a list of pairs.

let qs = qstring::QString::new(vec![
   ("foo", "bar baz"),
   ("panda", "true"),
]);
assert_eq!(format!("{}", qs), "foo=bar%20baz&panda=true");

pub fn has(&self, name: &str) -> bool

Tells if a query parameter is present.

let qs = qstring::QString::from("?foo");
assert!(qs.has("foo"));
assert!(qs.get("foo").is_some());

pub fn get<'a>(&'a self, name: &str) -> Option<&'a str>

Get a query parameter by name.

Empty query parameters (?foo) return ""

let qs = qstring::QString::from("?foo=bar");
let foo = qs.get("foo");
assert_eq!(foo, Some("bar"));

pub fn into_pairs(self) -> Vec<(String, String)>

Converts the QString to list of pairs.

let qs = qstring::QString::from("?foo=bar&baz=boo");
let ps = qs.into_pairs();
assert_eq!(ps, vec![
    ("foo".to_string(), "bar".to_string()),
    ("baz".to_string(), "boo".to_string()),
]);

pub fn to_pairs(&self) -> Vec<(&str, &str)>

Represent the QString as a list of pairs.

let qs = qstring::QString::from("?foo=bar&baz=boo");
let ps = qs.to_pairs();
assert_eq!(ps, vec![
    ("foo", "bar"),
    ("baz", "boo"),
]);

pub fn add_pair<S, T>(&mut self, pair: (S, T))

where S: Into<String>, T: Into<String>,

Adds another query parameter pair.

let mut qs = qstring::QString::from("?foo=bar&baz=boo");

qs.add_pair(("panda", "bear"));

assert_eq!(qs.to_string(), "foo=bar&baz=boo&panda=bear");

pub fn add_str(&mut self, origin: &str)

Parse the string and add all found parameters to this instance.

let mut qs = qstring::QString::from("?foo");

qs.add_str("&bar=baz&pooch&panda=bear");

assert_eq!(qs.to_string(), "foo&bar=baz&pooch&panda=bear");

pub fn len(&self) -> usize

The number of query string pairs.

pub fn is_empty(&self) -> bool

if this query string is empty.

Trait Implementations

impl Clone for QString

fn clone(&self) -> QString

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QString

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

Formats the value using the given formatter.

impl Default for QString

fn default() -> QString

Returns the “default value” for a type.

impl Display for QString

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for QString

fn from(origin: &str) -> Self

Constructs a new QString by parsing a query string part of the URL. Can start with ? or not, either works.

Examples

let qs = qstring::QString::from("?foo=bar");
let v: Vec<(String, String)> = qs.into_pairs();
assert_eq!(v, vec![("foo".to_string(), "bar".to_string())]);

impl Into<String> for QString

fn into(self) -> String

Converts this type into the (usually inferred) input type.

impl Into<Vec<(String, String)>> for QString

fn into(self) -> Vec<(String, String)>

Converts this type into the (usually inferred) input type.

impl IntoIterator for QString

type Item = (String, String)

The type of the elements being iterated over.

type IntoIter = IntoIter<(String, String)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for QString

fn eq(&self, other: &QString) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for QString