# Struct actix_web::http::header::OccupiedEntry[−][src]

    pub struct OccupiedEntry<'a, T> where
        T: 'a,  { /* fields omitted */ }

A view into a single occupied location in a `HeaderMap`.

This struct is returned as part of the `Entry` enum.

## Methods

###

`impl<'a, T> OccupiedEntry<'a, T>`

[src]

####

`pub fn key(&self) -> &HeaderName`

[src]

Returns a reference to the entry's key.

# Examples

    let mut map = HeaderMap::new();
    map.insert(HOST, "world".parse().unwrap());

    if let Entry::Occupied(e) = map.entry("host").unwrap() {
        assert_eq!("host", e.key());
    }

####
ⓘImportant traits for &'a mut R

### Important traits for &'a mut R

`impl<'a, R> Read for &'a mut R where
R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;`

`pub fn get(&self) -> &T`

[src]

Get a reference to the first value in the entry.

Values are stored in insertion order.

# Panics

`get` panics if there are no values associated with the entry.

# Examples

    let mut map = HeaderMap::new();
    map.insert(HOST, "hello.world".parse().unwrap());

    if let Entry::Occupied(mut e) = map.entry("host").unwrap() {
        assert_eq!(e.get(), &"hello.world");

        e.append("hello.earth".parse().unwrap());

        assert_eq!(e.get(), &"hello.world");
    }

####
ⓘImportant traits for &'a mut R

### Important traits for &'a mut R

`impl<'a, R> Read for &'a mut R where
R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;`

`pub fn get_mut(&mut self) -> &mut T`

[src]

Get a mutable reference to the first value in the entry.

Values are stored in insertion order.

# Panics

`get_mut` panics if there are no values associated with the entry.

# Examples

    let mut map = HeaderMap::default();
    map.insert(HOST, "hello.world".to_string());

    if let Entry::Occupied(mut e) = map.entry("host").unwrap() {
        e.get_mut().push_str("-2");
        assert_eq!(e.get(), &"hello.world-2");
    }

####
ⓘImportant traits for &'a mut R

### Important traits for &'a mut R

`impl<'a, R> Read for &'a mut R where
R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;`

`pub fn into_mut(self) -> &'a mut T`

[src]

Converts the `OccupiedEntry` into a mutable reference to the first value.

The lifetime of the returned reference is bound to the original map.

# Panics

`into_mut` panics if there are no values associated with the entry.

# Examples

    let mut map = HeaderMap::default();
    map.insert(HOST, "hello.world".to_string());
    map.append(HOST, "hello.earth".to_string());

    if let Entry::Occupied(e) = map.entry("host").unwrap() {
        e.into_mut().push_str("-2");
    }

    assert_eq!("hello.world-2", map["host"]);

####

`pub fn insert(&mut self, value: T) -> T`

[src]

Sets the value of the entry.

All previous values associated with the entry are removed and the first one is returned. See `insert_mult` for an API that returns all values.

# Examples

    let mut map = HeaderMap::new();
    map.insert(HOST, "hello.world".parse().unwrap());

    if let Entry::Occupied(mut e) = map.entry("host").unwrap() {
        let mut prev = e.insert("earth".parse().unwrap());
        assert_eq!("hello.world", prev);
    }

    assert_eq!("earth", map["host"]);

####
ⓘImportant traits for ValueDrain<'a, T>

### Important traits for ValueDrain<'a, T>

`impl<'a, T> Iterator for ValueDrain<'a, T> type Item = T;`

`pub fn insert_mult(&mut self, value: T) -> ValueDrain<T>`

[src]

Sets the value of the entry.

This function does the same as `insert` except it returns an iterator that yields all values previously associated with the key.

# Examples

    let mut map = HeaderMap::new();
    map.insert(HOST, "world".parse().unwrap());
    map.append(HOST, "world2".parse().unwrap());

    if let Entry::Occupied(mut e) = map.entry("host").unwrap() {
        let mut prev = e.insert_mult("earth".parse().unwrap());
        assert_eq!("world", prev.next().unwrap());
        assert_eq!("world2", prev.next().unwrap());
        assert!(prev.next().is_none());
    }

    assert_eq!("earth", map["host"]);

####

`pub fn append(&mut self, value: T)`

[src]

Insert the value into the entry.

The new value is appended to the end of the entry's value list. All previous values associated with the entry are retained.

# Examples

    let mut map = HeaderMap::new();
    map.insert(HOST, "world".parse().unwrap());

    if let Entry::Occupied(mut e) = map.entry("host").unwrap() {
        e.append("earth".parse().unwrap());
    }

    let values = map.get_all("host");
    let mut i = values.iter();
    assert_eq!("world", *i.next().unwrap());
    assert_eq!("earth", *i.next().unwrap());

####

`pub fn remove(self) -> T`

[src]

Remove the entry from the map.

All values associated with the entry are removed and the first one is returned. See `remove_entry_mult` for an API that returns all values.

# Examples

    let mut map = HeaderMap::new();
    map.insert(HOST, "world".parse().unwrap());

    if let Entry::Occupied(e) = map.entry("host").unwrap() {
        let mut prev = e.remove();
        assert_eq!("world", prev);
    }

    assert!(!map.contains_key("host"));

####

`pub fn remove_entry(self) -> (HeaderName, T)`

[src]

Remove the entry from the map.

The key and all values associated with the entry are removed and the first one is returned. See `remove_entry_mult` for an API that returns all values.

# Examples

    let mut map = HeaderMap::new();
    map.insert(HOST, "world".parse().unwrap());

    if let Entry::Occupied(e) = map.entry("host").unwrap() {
        let (key, mut prev) = e.remove_entry();
        assert_eq!("host", key.as_str());
        assert_eq!("world", prev);
    }

    assert!(!map.contains_key("host"));

####

`pub fn remove_entry_mult(self) -> (HeaderName, ValueDrain<'a, T>)`

[src]

Remove the entry from the map.

The key and all values associated with the entry are removed and returned.

####
ⓘImportant traits for ValueIter<'a, T>

### Important traits for ValueIter<'a, T>

`impl<'a, T> Iterator for ValueIter<'a, T> where
T: 'a, type Item = &'a T;`

`pub fn iter(&self) -> ValueIter<T>`

[src]

Returns an iterator visiting all values associated with the entry.

Values are iterated in insertion order.

# Examples

    let mut map = HeaderMap::new();
    map.insert(HOST, "world".parse().unwrap());
    map.append(HOST, "earth".parse().unwrap());

    if let Entry::Occupied(e) = map.entry("host").unwrap() {
        let mut iter = e.iter();
        assert_eq!(&"world", iter.next().unwrap());
        assert_eq!(&"earth", iter.next().unwrap());
        assert!(iter.next().is_none());
    }

####
ⓘImportant traits for ValueIterMut<'a, T>

### Important traits for ValueIterMut<'a, T>

`impl<'a, T> Iterator for ValueIterMut<'a, T> where
T: 'a, type Item = &'a mut T;`

`pub fn iter_mut(&mut self) -> ValueIterMut<T>`

[src]

Returns an iterator mutably visiting all values associated with the entry.

Values are iterated in insertion order.

# Examples

    let mut map = HeaderMap::default();
    map.insert(HOST, "world".to_string());
    map.append(HOST, "earth".to_string());

    if let Entry::Occupied(mut e) = map.entry("host").unwrap() {
        for e in e.iter_mut() {
            e.push_str("-boop");
        }
    }

    let mut values = map.get_all("host");
    let mut i = values.iter();
    assert_eq!(&"world-boop", i.next().unwrap());
    assert_eq!(&"earth-boop", i.next().unwrap());

## Trait Implementations

###

`impl<'a, 'b, T> IntoIterator for &'b OccupiedEntry<'a, T> where 'b: 'a,`

[src]

#### `type Item = &'a T`

The type of the elements being iterated over.

#### `type IntoIter = ValueIter<'a, T>`

Which kind of iterator are we turning this into?

####
ⓘImportant traits for ValueIter<'a, T>

### Important traits for ValueIter<'a, T>

`impl<'a, T> Iterator for ValueIter<'a, T> where
T: 'a, type Item = &'a T;`

`fn into_iter(self) -> ValueIter<'a, T>`

[src]

Creates an iterator from a value. Read more

###

`impl<'a, 'b, T> IntoIterator for &'b mut OccupiedEntry<'a, T> where 'b: 'a,`

[src]

#### `type Item = &'a mut T`

The type of the elements being iterated over.

#### `type IntoIter = ValueIterMut<'a, T>`

Which kind of iterator are we turning this into?

####
ⓘImportant traits for ValueIterMut<'a, T>

### Important traits for ValueIterMut<'a, T>

`impl<'a, T> Iterator for ValueIterMut<'a, T> where
T: 'a, type Item = &'a mut T;`

`fn into_iter(self) -> ValueIterMut<'a, T>`

[src]

Creates an iterator from a value. Read more

###

`impl<'a, T> IntoIterator for OccupiedEntry<'a, T>`

[src]

#### `type Item = &'a mut T`

The type of the elements being iterated over.

#### `type IntoIter = ValueIterMut<'a, T>`

Which kind of iterator are we turning this into?

####
ⓘImportant traits for ValueIterMut<'a, T>

### Important traits for ValueIterMut<'a, T>

`impl<'a, T> Iterator for ValueIterMut<'a, T> where
T: 'a, type Item = &'a mut T;`

`fn into_iter(self) -> ValueIterMut<'a, T>`

[src]

Creates an iterator from a value. Read more

###

`impl<'a, T> Debug for OccupiedEntry<'a, T> where T: 'a + Debug,`

[src]

####

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

[src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

###

`impl<'a, T> Send for OccupiedEntry<'a, T> where T: Send,`

###

`impl<'a, T> Sync for OccupiedEntry<'a, T> where T: Sync,`

# 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`)