# actix_web::http::Cookie - Rust
API documentation for the Rust `Cookie` struct in crate `actix_web`.
Keywords: rust, rustlang, rust-lang, Cookie

# [−] [src] Struct actix_web::http::Cookie

    pub struct Cookie<'c> { /* fields omitted */ }

Representation of an HTTP cookie.

# Constructing a `Cookie`

To construct a cookie with only a name/value, use the new method:

    use cookie::Cookie;

    let cookie = Cookie::new("name", "value");
    assert_eq!(&cookie.to_string(), "name=value");

To construct more elaborate cookies, use the build method and `CookieBuilder` methods:

    use cookie::Cookie;

    let cookie = Cookie::build("name", "value")
        .domain("www.rust-lang.org")
        .path("/")
        .secure(true)
        .http_only(true)
        .finish();

## Methods

###

`impl Cookie<'static>`

[src]

####

`pub fn new<N, V>(name: N, value: V) -> Cookie<'static> where N: Into<Cow<'static, str>>, V: Into<Cow<'static, str>>,`

[src]

Creates a new `Cookie` with the given name and value.

# Example

    use cookie::Cookie;

    let cookie = Cookie::new("name", "value");
    assert_eq!(cookie.name_value(), ("name", "value"));

####

`pub fn named<N>(name: N) -> Cookie<'static> where N: Into<Cow<'static, str>>,`

[src]

Creates a new `Cookie` with the given name and an empty value.

# Example

    use cookie::Cookie;

    let cookie = Cookie::named("name");
    assert_eq!(cookie.name(), "name");
    assert!(cookie.value().is_empty());

####

`pub fn build<N, V>(name: N, value: V) -> CookieBuilder where N: Into<Cow<'static, str>>, V: Into<Cow<'static, str>>,`

[src]

Creates a new `CookieBuilder` instance from the given key and value strings.

# Example

    use cookie::Cookie;

    let c = Cookie::build("foo", "bar").finish();
    assert_eq!(c.name_value(), ("foo", "bar"));

###

`impl<'c> Cookie<'c>`

[src]

####

`pub fn parse<S>(s: S) -> Result<Cookie<'c>, ParseError> where S: Into<Cow<'c, str>>,`

[src]

Parses a `Cookie` from the given HTTP cookie header value string. Does not perform any percent-decoding.

# Example

    use cookie::Cookie;

    let c = Cookie::parse("foo=bar%20baz; HttpOnly").unwrap();
    assert_eq!(c.name_value(), ("foo", "bar%20baz"));
    assert_eq!(c.http_only(), Some(true));

####

`pub fn parse_encoded<S>(s: S) -> Result<Cookie<'c>, ParseError> where S: Into<Cow<'c, str>>,`

[src]

Parses a `Cookie` from the given HTTP cookie header value string where the name and value fields are percent-encoded. Percent-decodes the name/value fields.

This API requires the `percent-encode` feature to be enabled on this crate.

# Example

    use cookie::Cookie;

    let c = Cookie::parse_encoded("foo=bar%20baz; HttpOnly").unwrap();
    assert_eq!(c.name_value(), ("foo", "bar baz"));
    assert_eq!(c.http_only(), Some(true));

####

`pub fn encoded(&'a self) -> EncodedCookie<'a, 'c>`

[src]

Wraps `self` in an `EncodedCookie`: a cost-free wrapper around `Cookie` whose `Display` implementation percent-encodes the name and value of the wrapped `Cookie`.

This method is only available when the `percent-encode` feature is enabled.

# Example

    use cookie::Cookie;

    let mut c = Cookie::new("my name", "this; value?");
    assert_eq!(&c.encoded().to_string(), "my%20name=this%3B%20value%3F");

####

`pub fn into_owned(self) -> Cookie<'static>`

[src]

Converts `self` into a `Cookie` with a static lifetime. This method results in at most one allocation.

# Example

    use cookie::Cookie;

    let c = Cookie::new("a", "b");
    let owned_cookie = c.into_owned();
    assert_eq!(owned_cookie.name_value(), ("a", "b"));

####

`pub fn name(&self) -> &str`

[src]

Returns the name of `self`.

# Example

    use cookie::Cookie;

    let c = Cookie::new("name", "value");
    assert_eq!(c.name(), "name");

####

`pub fn value(&self) -> &str`

[src]

Returns the value of `self`.

# Example

    use cookie::Cookie;

    let c = Cookie::new("name", "value");
    assert_eq!(c.value(), "value");

####

`pub fn name_value(&self) -> (&str, &str)`

[src]

Returns the name and value of `self` as a tuple of `(name, value)`.

# Example

    use cookie::Cookie;

    let c = Cookie::new("name", "value");
    assert_eq!(c.name_value(), ("name", "value"));

####

`pub fn http_only(&self) -> Option<bool>`

[src]

Returns whether this cookie was marked `HttpOnly` or not. Returns `Some(true)` when the cookie was explicitly set (manually or parsed) as `HttpOnly`, `Some(false)` when `http_only` was manually set to `false`, and `None` otherwise.

# Example

    use cookie::Cookie;

    let c = Cookie::parse("name=value; httponly").unwrap();
    assert_eq!(c.http_only(), Some(true));

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.http_only(), None);

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.http_only(), None);

    // An explicitly set "false" value.
    c.set_http_only(false);
    assert_eq!(c.http_only(), Some(false));

    // An explicitly set "true" value.
    c.set_http_only(true);
    assert_eq!(c.http_only(), Some(true));

####

`pub fn secure(&self) -> Option<bool>`

[src]

Returns whether this cookie was marked `Secure` or not. Returns `Some(true)` when the cookie was explicitly set (manually or parsed) as `Secure`, `Some(false)` when `secure` was manually set to `false`, and `None` otherwise.

# Example

    use cookie::Cookie;

    let c = Cookie::parse("name=value; Secure").unwrap();
    assert_eq!(c.secure(), Some(true));

    let mut c = Cookie::parse("name=value").unwrap();
    assert_eq!(c.secure(), None);

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.secure(), None);

    // An explicitly set "false" value.
    c.set_secure(false);
    assert_eq!(c.secure(), Some(false));

    // An explicitly set "true" value.
    c.set_secure(true);
    assert_eq!(c.secure(), Some(true));

####

`pub fn same_site(&self) -> Option<SameSite>`

[src]

Returns the `SameSite` attribute of this cookie if one was specified.

# Example

    use cookie::{Cookie, SameSite};

    let c = Cookie::parse("name=value; SameSite=Lax").unwrap();
    assert_eq!(c.same_site(), Some(SameSite::Lax));

####

`pub fn max_age(&self) -> Option<Duration>`

[src]

Returns the specified max-age of the cookie if one was specified.

# Example

    use cookie::Cookie;

    let c = Cookie::parse("name=value").unwrap();
    assert_eq!(c.max_age(), None);

    let c = Cookie::parse("name=value; Max-Age=3600").unwrap();
    assert_eq!(c.max_age().map(|age| age.num_hours()), Some(1));

####

`pub fn path(&self) -> Option<&str>`

[src]

Returns the `Path` of the cookie if one was specified.

# Example

    use cookie::Cookie;

    let c = Cookie::parse("name=value").unwrap();
    assert_eq!(c.path(), None);

    let c = Cookie::parse("name=value; Path=/").unwrap();
    assert_eq!(c.path(), Some("/"));

    let c = Cookie::parse("name=value; path=/sub").unwrap();
    assert_eq!(c.path(), Some("/sub"));

####

`pub fn domain(&self) -> Option<&str>`

[src]

Returns the `Domain` of the cookie if one was specified.

# Example

    use cookie::Cookie;

    let c = Cookie::parse("name=value").unwrap();
    assert_eq!(c.domain(), None);

    let c = Cookie::parse("name=value; Domain=crates.io").unwrap();
    assert_eq!(c.domain(), Some("crates.io"));

####

`pub fn expires(&self) -> Option<Tm>`

[src]

Returns the `Expires` time of the cookie if one was specified.

# Example

    use cookie::Cookie;

    let c = Cookie::parse("name=value").unwrap();
    assert_eq!(c.expires(), None);

    let expire_time = "Wed, 21 Oct 2017 07:28:00 GMT";
    let cookie_str = format!("name=value; Expires={}", expire_time);
    let c = Cookie::parse(cookie_str).unwrap();
    assert_eq!(c.expires().map(|t| t.tm_year), Some(117));

####

`pub fn set_name<N>(&mut self, name: N) where N: Into<Cow<'static, str>>,`

[src]

Sets the name of `self` to `name`.

# Example

    use cookie::Cookie;

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.name(), "name");

    c.set_name("foo");
    assert_eq!(c.name(), "foo");

####

`pub fn set_value<V>(&mut self, value: V) where V: Into<Cow<'static, str>>,`

[src]

Sets the value of `self` to `value`.

# Example

    use cookie::Cookie;

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.value(), "value");

    c.set_value("bar");
    assert_eq!(c.value(), "bar");

####

`pub fn set_http_only(&mut self, value: bool)`

[src]

Sets the value of `http_only` in `self` to `value`.

# Example

    use cookie::Cookie;

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.http_only(), None);

    c.set_http_only(true);
    assert_eq!(c.http_only(), Some(true));

####

`pub fn set_secure(&mut self, value: bool)`

[src]

Sets the value of `secure` in `self` to `value`.

# Example

    use cookie::Cookie;

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.secure(), None);

    c.set_secure(true);
    assert_eq!(c.secure(), Some(true));

####

`pub fn set_same_site(&mut self, value: SameSite)`

[src]

Sets the value of `same_site` in `self` to `value`.

# Example

    use cookie::{Cookie, SameSite};

    let mut c = Cookie::new("name", "value");
    assert!(c.same_site().is_none());

    c.set_same_site(SameSite::Strict);
    assert_eq!(c.same_site(), Some(SameSite::Strict));

####

`pub fn set_max_age(&mut self, value: Duration)`

[src]

Sets the value of `max_age` in `self` to `value`.

# Example

    extern crate time;

    use cookie::Cookie;
    use time::Duration;

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.max_age(), None);

    c.set_max_age(Duration::hours(10));
    assert_eq!(c.max_age(), Some(Duration::hours(10)));

####

`pub fn set_path<P>(&mut self, path: P) where P: Into<Cow<'static, str>>,`

[src]

Sets the `path` of `self` to `path`.

# Example

    use cookie::Cookie;

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.path(), None);

    c.set_path("/");
    assert_eq!(c.path(), Some("/"));

####

`pub fn set_domain<D>(&mut self, domain: D) where D: Into<Cow<'static, str>>,`

[src]

Sets the `domain` of `self` to `domain`.

# Example

    use cookie::Cookie;

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.domain(), None);

    c.set_domain("rust-lang.org");
    assert_eq!(c.domain(), Some("rust-lang.org"));

####

`pub fn set_expires(&mut self, time: Tm)`

[src]

Sets the expires field of `self` to `time`.

# Example

    extern crate time;

    use cookie::Cookie;

    let mut c = Cookie::new("name", "value");
    assert_eq!(c.expires(), None);

    let mut now = time::now();
    now.tm_year += 1;

    c.set_expires(now);
    assert!(c.expires().is_some())

####

`pub fn make_permanent(&mut self)`

[src]

Makes `self` a "permanent" cookie by extending its expiration and max age 20 years into the future.

# Example

    extern crate time;

    use cookie::Cookie;
    use time::Duration;

    let mut c = Cookie::new("foo", "bar");
    assert!(c.expires().is_none());
    assert!(c.max_age().is_none());

    c.make_permanent();
    assert!(c.expires().is_some());
    assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));

####

`pub fn name_raw(&self) -> Option<&'c str>`

[src]

Returns the name of `self` as a string slice of the raw string `self` was originally parsed from. If `self` was not originally parsed from a raw string, returns `None`.

This method differs from name in that it returns a string with the same lifetime as the originally parsed string. This lifetime may outlive `self`. If a longer lifetime is not required, or you're unsure if you need a longer lifetime, use name.

# Example

    use cookie::Cookie;

    let cookie_string = format!("{}={}", "foo", "bar");

    // `c` will be dropped at the end of the scope, but `name` will live on
    let name = {
        let c = Cookie::parse(cookie_string.as_str()).unwrap();
        c.name_raw()
    };

    assert_eq!(name, Some("foo"));

####

`pub fn value_raw(&self) -> Option<&'c str>`

[src]

Returns the value of `self` as a string slice of the raw string `self` was originally parsed from. If `self` was not originally parsed from a raw string, returns `None`.

This method differs from value in that it returns a string with the same lifetime as the originally parsed string. This lifetime may outlive `self`. If a longer lifetime is not required, or you're unsure if you need a longer lifetime, use value.

# Example

    use cookie::Cookie;

    let cookie_string = format!("{}={}", "foo", "bar");

    // `c` will be dropped at the end of the scope, but `value` will live on
    let value = {
        let c = Cookie::parse(cookie_string.as_str()).unwrap();
        c.value_raw()
    };

    assert_eq!(value, Some("bar"));

####

`pub fn path_raw(&self) -> Option<&'c str>`

[src]

Returns the `Path` of `self` as a string slice of the raw string `self` was originally parsed from. If `self` was not originally parsed from a raw string, or if `self` doesn't contain a `Path`, or if the `Path` has changed since parsing, returns `None`.

This method differs from path in that it returns a string with the same lifetime as the originally parsed string. This lifetime may outlive `self`. If a longer lifetime is not required, or you're unsure if you need a longer lifetime, use path.

# Example

    use cookie::Cookie;

    let cookie_string = format!("{}={}; Path=/", "foo", "bar");

    // `c` will be dropped at the end of the scope, but `path` will live on
    let path = {
        let c = Cookie::parse(cookie_string.as_str()).unwrap();
        c.path_raw()
    };

    assert_eq!(path, Some("/"));

####

`pub fn domain_raw(&self) -> Option<&'c str>`

[src]

Returns the `Domain` of `self` as a string slice of the raw string `self` was originally parsed from. If `self` was not originally parsed from a raw string, or if `self` doesn't contain a `Domain`, or if the `Domain` has changed since parsing, returns `None`.

This method differs from domain in that it returns a string with the same lifetime as the originally parsed string. This lifetime may outlive `self` struct. If a longer lifetime is not required, or you're unsure if you need a longer lifetime, use domain.

# Example

    use cookie::Cookie;

    let cookie_string = format!("{}={}; Domain=crates.io", "foo", "bar");

    //`c` will be dropped at the end of the scope, but `domain` will live on
    let domain = {
        let c = Cookie::parse(cookie_string.as_str()).unwrap();
        c.domain_raw()
    };

    assert_eq!(domain, Some("crates.io"));

## Trait Implementations

###

`impl<'c> Debug for Cookie<'c>`

[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl FromStr for Cookie<'static>`

[src]

#### `type Err = ParseError`

The associated error which can be returned from parsing.

####

`fn from_str(s: &str) -> Result<Cookie<'static>, ParseError>`

[src]

Parses a string `s` to return a value of this type. Read more

###

`impl<'c> Clone for Cookie<'c>`

[src]

####

`fn clone(&self) -> Cookie<'c>`

[src]

Returns a copy of the value. Read more

####

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

1.0.0
[src]

Performs copy-assignment from `source`. Read more

###

`impl<'a, 'b> PartialEq<Cookie<'b>> for Cookie<'a>`

[src]

####

`fn eq(&self, other: &Cookie<'b>) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

1.0.0
[src]

This method tests for `!=`.

###

`impl<'c> Display for Cookie<'c>`

[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the cookie `self` as a `Set-Cookie` header value.

# Example

    use cookie::Cookie;

    let mut cookie = Cookie::build("foo", "bar")
        .path("/")
        .finish();

    assert_eq!(&cookie.to_string(), "foo=bar; Path=/");

## Auto Trait Implementations

###

`impl<'c> Send for Cookie<'c>`

###

`impl<'c> Sync for Cookie<'c>`

## Blanket Implementations

###

`impl<T> ToOwned for T where T: Clone,`

[src]

#### `type Owned = T`

####

`fn to_owned(&self) -> T`

[src]

Creates owned data from borrowed data, usually by cloning. Read more

####

`fn clone_into(&self, target: &mut T)`

[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

###

`impl<T> ToString for T where T: Display + ?Sized,`

[src]

####

`fn to_string(&self) -> String`

[src]

Converts the given value to a `String`. Read more

###

`impl<T> From for T`

[src]

####

`fn from(t: T) -> T`

[src]

Performs the conversion.

###

`impl<T, U> Into for T where U: From<T>,`

[src]

####

`fn into(self) -> U`

[src]

Performs the conversion.

###

`impl<T, U> TryFrom for T where T: From<U>,`

[src]

#### `type Error = !`

🔬 This is a nightly-only experimental API. (`try_from`)

The type returned in the event of a conversion error.

####

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

[src]

🔬 This is a nightly-only experimental API. (`try_from`)

Performs the conversion.

###

`impl<T> Borrow for T where T: ?Sized,`

[src]

####

`fn borrow(&self) -> &T`

[src]

Immutably borrows from an owned value. Read more

###

`impl<T> BorrowMut for T where T: ?Sized,`

[src]

####

`fn borrow_mut(&mut self) -> &mut T`

[src]

Mutably borrows from an owned value. Read more

###

`impl<T, U> TryInto for T where U: TryFrom<T>,`

[src]

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

🔬 This is a nightly-only experimental API. (`try_from`)

The type returned in the event of a conversion error.

####

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

[src]

🔬 This is a nightly-only experimental API. (`try_from`)

Performs the conversion.

###

`impl<T> Any for T where T: 'static + ?Sized,`

[src]

####

`fn get_type_id(&self) -> TypeId`

[src]

🔬 This is a nightly-only experimental API. (`get_type_id`)

this method will likely be replaced by an associated static

Gets the `TypeId` of `self`. Read more

###

`impl<T> Erased for T`

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)