Struct cookie_store::CookieStore

pub struct CookieStore { /* private fields */ }

An implementation for storing and retrieving Cookies per the path and domain matching rules specified in RFC6265.

Implementations

impl CookieStore

pub fn get_request_cookies(
    &self,
    url: &Url
) -> impl Iterator<Item = &RawCookie<'static>>

👎Deprecated since 0.14.1:

Please use the get_request_values function instead

Return an Iterator of the cookies for url in the store, suitable for submitting in an HTTP request. As the items are intended for use in creating a Cookie header in a GET request, they may contain only the name and value of a received cookie, eliding other parameters such as path or expires. For iteration over Cookie instances containing all data, please refer to CookieStore::matches.

pub fn get_request_values(&self, url: &Url) -> impl Iterator<Item = (&str, &str)>

Return an Iterator of the cookie (name, value) pairs for url in the store, suitable for use in the Cookie header of an HTTP request. For iteration over Cookie instances, please refer to CookieStore::matches.

pub fn store_response_cookies<I: Iterator<Item = RawCookie<'static>>>(
    &mut self,
    cookies: I,
    url: &Url
)

Store the cookies received from url

pub fn with_suffix_list(self, psl: List) -> CookieStore

Specify a publicsuffix::List for the CookieStore to allow public suffix matching

pub fn contains(&self, domain: &str, path: &str, name: &str) -> bool

Returns true if the CookieStore contains an unexpired Cookie corresponding to the specified domain, path, and name.

pub fn contains_any(&self, domain: &str, path: &str, name: &str) -> bool

Returns true if the CookieStore contains any (even an expired) Cookie corresponding to the specified domain, path, and name.

pub fn get(&self, domain: &str, path: &str, name: &str) -> Option<&Cookie<'_>>

Returns a reference to the unexpired Cookie corresponding to the specified domain, path, and name.

pub fn get_any(
    &self,
    domain: &str,
    path: &str,
    name: &str
) -> Option<&Cookie<'static>>

Returns a reference to the (possibly expired) Cookie corresponding to the specified domain, path, and name.

pub fn remove(
    &mut self,
    domain: &str,
    path: &str,
    name: &str
) -> Option<Cookie<'static>>

Removes a Cookie from the store, returning the Cookie if it was in the store

pub fn matches(&self, request_url: &Url) -> Vec<&Cookie<'static>>

Returns a collection of references to unexpired cookies that path- and domain-match request_url, as well as having HttpOnly and Secure attributes compatible with the request_url.

pub fn parse(
    &mut self,
    cookie_str: &str,
    request_url: &Url
) -> Result<StoreAction, CookieError>

Parses a new Cookie from cookie_str and inserts it into the store.

pub fn insert_raw(
    &mut self,
    cookie: &RawCookie<'_>,
    request_url: &Url
) -> Result<StoreAction, CookieError>

Converts a cookie::Cookie (from the cookie crate) into a cookie_store::Cookie and inserts it into the store.

pub fn insert(
    &mut self,
    cookie: Cookie<'static>,
    request_url: &Url
) -> Result<StoreAction, CookieError>

Inserts cookie, received from request_url, into the store, following the rules of the IETF RFC6265 Storage Model. If the Cookie is unexpired and is successfully inserted, returns Ok(StoreAction::Inserted). If the Cookie is expired and matches an existing Cookie in the store, the existing Cookie wil be expired() and Ok(StoreAction::ExpiredExisting) will be returned.

pub fn clear(&mut self)

Clear the contents of the store

pub fn iter_unexpired<'a>(
    &'a self
) -> impl Iterator<Item = &'a Cookie<'static>> + 'a

An iterator visiting all the unexpired cookies in the store

pub fn iter_any<'a>(&'a self) -> impl Iterator<Item = &'a Cookie<'static>> + 'a

An iterator visiting all (including expired) cookies in the store

pub fn save<W, E, F>(
    &self,
    writer: &mut W,
    cookie_to_string: F
) -> Result<(), Error> where
    W: Write,
    F: Fn(&Cookie<'static>) -> Result<String, E>,
    Error: From<E>, 

Serialize any unexpired and persistent cookies in the store with cookie_to_string and write them to writer

pub fn save_json<W: Write>(&self, writer: &mut W) -> Result<(), Error>

Serialize any unexpired and persistent cookies in the store to JSON format and write them to writer

pub fn load<R, E, F>(reader: R, cookie_from_str: F) -> Result<CookieStore, Error> where
    R: BufRead,
    F: Fn(&str) -> Result<Cookie<'static>, E>,
    Error: From<E>, 

Load cookies from reader, deserializing with cookie_from_str, skipping any expired cookies

pub fn load_all<R, E, F>(
    reader: R,
    cookie_from_str: F
) -> Result<CookieStore, Error> where
    R: BufRead,
    F: Fn(&str) -> Result<Cookie<'static>, E>,
    Error: From<E>, 

Load cookies from reader, deserializing with cookie_from_str, loading both unexpired and expired cookies

pub fn load_json<R: BufRead>(reader: R) -> Result<CookieStore, Error>

Load JSON-formatted cookies from reader, skipping any expired cookies

pub fn load_json_all<R: BufRead>(reader: R) -> Result<CookieStore, Error>

Load JSON-formatted cookies from reader, loading both expired and unexpired cookies

pub fn from_cookies<I, E>(iter: I, include_expired: bool) -> Result<Self, E> where
    I: IntoIterator<Item = Result<Cookie<'static>, E>>, 

Create a CookieStore from an iterator of Cookie values. When include_expired is true, both expired and unexpired cookies in the incoming iterator will be included in the produced CookieStore; otherwise, only unexpired cookies will be included, and expired cookies filtered out.

Trait Implementations

impl Debug for CookieStore

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

Formats the value using the given formatter.

impl Default for CookieStore

fn default() -> CookieStore

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CookieStore

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for CookieStore

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.