# Struct reqwest::redirect::Policy [−] [src]

    pub struct Policy { /* fields omitted */ }

A type that controls the policy on how to handle the following of redirects.

The default value will catch redirect loops, and has a maximum of 10 redirects it will follow in a chain before returning an error.

- `limited` can be used have the same as the default behavior, but adjust the allowed maximum redirect hops in a chain.
- `none` can be used to disable all redirect behavior.
- `custom` can be used to create a customized policy.

## Implementations

### `impl Policy` [src]

#### `pub fn limited(max: usize) -> Self` [src]

Create a `Policy` with a maximum number of redirects.

An `Error` will be returned if the max is reached.

#### `pub fn none() -> Self` [src]

Create a `Policy` that does not follow any redirect.

#### `pub fn custom<T>(policy: T) -> Self where
T: Fn(Attempt<'_>) -> Action + Send + Sync + 'static,` [src]

Create a custom `Policy` using the passed function.

# Note

The default `Policy` handles a maximum loop chain, but the custom variant does not do that for you automatically. The custom policy should have some way of handling those.

Information on the next request and previous requests can be found on the `Attempt` argument passed to the closure.

Actions can be conveniently created from methods on the `Attempt`.

# Example

    let custom = redirect::Policy::custom(|attempt| {
        if attempt.previous().len() > 5 {
            attempt.error("too many redirects")
        } else if attempt.url().host_str() == Some("example.domain") {
            // prevent redirects to 'example.domain'
            attempt.stop()
        } else {
            attempt.follow()
        }
    });
    let client = reqwest::Client::builder()
        .redirect(custom)
        .build()?;

#### `pub fn redirect(&self, attempt: Attempt<'_>) -> Action` [src]

Apply this policy to a given `Attempt` to produce a `Action`.

# Note

This method can be used together with `Policy::custom()` to construct one `Policy` that wraps another.

# Example

    let custom = redirect::Policy::custom(|attempt| {
        eprintln!("{}, Location: {:?}", attempt.status(), attempt.url());
        redirect::Policy::default().redirect(attempt)
    });

## Trait Implementations

### `impl Debug for Policy` [src]

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

Formats the value using the given formatter. Read more

### `impl Default for Policy` [src]

#### `fn default() -> Policy` [src]

Returns the “default value” for a type. Read more

## Auto Trait Implementations

### `impl !RefUnwindSafe for Policy`

### `impl Send for Policy`

### `impl Sync for Policy`

### `impl Unpin for Policy`

### `impl !UnwindSafe for Policy`

## Blanket Implementations

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

#### `pub fn type_id(&self) -> TypeId` [src]

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

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

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

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

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

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

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T> Instrument for T` [src]

#### `pub fn instrument(self, span: Span) -> Instrumented<Self>` [src]

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more

#### `pub fn in_current_span(self) -> Instrumented<Self>` [src]

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more

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

#### `pub fn into(self) -> U` [src]

Performs the conversion.

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

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

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

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.