Struct Opts 

pub struct Opts { /* private fields */ }

A set of options to constrain the returned proxies.

Opts represents all the filtering options that are passed on to the API by the corresponding Fetcher. By default no values are filtered and any kind of proxy can be returned so this list of options only serves to restrict the proxies returned. The typical way to construct Opts is with OptsBuilder with the entrypoint of Opts::builder().

use iso_country::Country;
use lead_oxide::{
    opts::Opts,
    types::{Countries, LastChecked, Level, Protocol, TimeToConnect}
};
use std::{convert::TryFrom, num::NonZeroU16, time::Duration};

let basic_opts = Opts::builder()
    .post(true)
    .cookies(true)
    .build();
let kitchen_sink = Opts::builder()
    .api_key("<key>".to_string())
    .level(Level::Elite)
    .protocol(Protocol::Socks4)
    .countries(Countries::block().countries(&[Country::CH, Country::ES]))
    .last_checked(LastChecked::try_from(Duration::from_secs(60 * 10)).unwrap())
    .time_to_connect(TimeToConnect::try_from(Duration::from_secs(10)).unwrap())
    .port(NonZeroU16::new(8080).unwrap())
    .cookies(true)
    .connects_to_google(false)
    .https(true)
    .post(false)
    .referer(true)
    .forwards_user_agent(false)
    .build();

Implementations

impl Opts

pub fn builder() -> OptsBuilder

Constructs an OptsBuilder

Trait Implementations

impl Clone for Opts

fn clone(&self) -> Opts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Opts

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

Formats the value using the given formatter.

impl Default for Opts

fn default() -> Opts

Returns the “default value” for a type.

impl From<OptsBuilder> for Opts

fn from(builder: OptsBuilder) -> Self

Converts to this type from the input type.

impl PartialEq for Opts

fn eq(&self, other: &Opts) -> 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 Serialize for Opts

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Opts