Struct Match

pub struct Match { /* private fields */ }

Struct which stores matches data for search keyword

Implementations

impl Match

pub fn symbol(&self) -> &str

Return symbol

#[tokio::main]
async fn main() {
    let api = alpha_vantage::set_api("demo", reqwest::Client::new());
    let search = api.search("BA").json().await.unwrap();
    let symbol = search.matches()[0].symbol();
    assert_eq!(symbol, "BA");
}

pub fn name(&self) -> &str

Return name for symbol

#[tokio::main]
async fn main() {
    let api = alpha_vantage::set_api("demo", reqwest::Client::new());
    let search = api.search("BA").json().await.unwrap();
    let name = search.matches()[0].name();
    assert_eq!(name, "Boeing Company");
}

pub fn stock_type(&self) -> &str

Return stock type

#[tokio::main]
async fn main() {
    let api = alpha_vantage::set_api("demo", reqwest::Client::new());
    let search = api.search("BA").json().await.unwrap();
    let stock_type = search.matches()[0].stock_type();
    assert_eq!(stock_type, "Equity");
}

pub fn region(&self) -> &str

Return region of search data

#[tokio::main]
async fn main() {
    let api = alpha_vantage::set_api("demo", reqwest::Client::new());
    let search = api.search("BA").json().await.unwrap();
    let region = search.matches()[0].region();
    assert_eq!(region, "United States");
}

pub fn market_open(&self) -> &str

Return market open time

#[tokio::main]
async fn main() {
    let api = alpha_vantage::set_api("demo", reqwest::Client::new());
    let search = api.search("BA").json().await.unwrap();
    let market_open = search.matches()[0].market_open();
    assert_eq!(market_open, "09:30");
}

pub fn market_close(&self) -> &str

Return market close time

#[tokio::main]
async fn main() {
    let api = alpha_vantage::set_api("demo", reqwest::Client::new());
    let search = api.search("BA").json().await.unwrap();
    let market_close = search.matches()[0].market_close();
    assert_eq!(market_close, "16:00");
}

pub fn time_zone(&self) -> &str

Return time zone of symbol

pub fn currency(&self) -> &str

Return currency

#[tokio::main]
async fn main() {
    let api = alpha_vantage::set_api("demo", reqwest::Client::new());
    let search = api.search("BA").json().await.unwrap();
    let currency = search.matches()[0].currency();
    assert_eq!(currency, "USD");
}

pub fn match_score(&self) -> f64

Return match score

#[tokio::main]
async fn main() {
    let api = alpha_vantage::set_api("demo", reqwest::Client::new());
    let search = api.search("BA").json().await.unwrap();
    let match_score = search.matches()[0].match_score();
    assert_eq!(match_score, 1.0);
}

Trait Implementations

impl Clone for Match

fn clone(&self) -> Match

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Match

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

Formats the value using the given formatter.

impl Default for Match

fn default() -> Match

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Match

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.