Struct SecuritySnapshot 

pub struct SecuritySnapshot { /* private fields */ }

Снимок инструмента с полями LOTSIZE и LAST.

Implementations

impl SecuritySnapshot

pub fn try_new( secid: String, lot_size: Option<i64>, last: Option<f64>, ) -> Result<Self, ParseSecuritySnapshotError>

Построить снимок инструмента из wire-значений ISS.

Examples found in repository

examples/actual_indexes_dump.rs (line 249)

fn parse_board_snapshots_page(
    payload: &str,
    endpoint: &str,
) -> Result<(Vec<SecuritySnapshot>, Option<SecId>), MoexError> {
    let mut tables = decode::raw_tables_json(payload, endpoint)?;
    let security_rows: Vec<RawSecuritySnapshotRow> = tables.take_rows("securities")?;
    let marketdata_rows: Vec<RawMarketdataSnapshotRow> = tables.take_rows("marketdata")?;

    let mut marketdata_by_secid = HashMap::with_capacity(marketdata_rows.len());
    for (row, marketdata) in marketdata_rows.into_iter().enumerate() {
        marketdata_by_secid.insert(marketdata.secid, (row, marketdata.last));
    }

    let mut first_secid_on_page = None;
    let mut snapshots = Vec::with_capacity(security_rows.len().max(marketdata_by_secid.len()));

    for (row, security) in security_rows.into_iter().enumerate() {
        let last = marketdata_by_secid
            .remove(security.secid.as_str())
            .and_then(|(_, last)| last);
        let snapshot = SecuritySnapshot::try_new(security.secid, security.lot_size, last).map_err(
            |source| MoexError::InvalidSecuritySnapshot {
                endpoint: endpoint.to_owned().into_boxed_str(),
                table: "securities",
                row,
                source,
            },
        )?;
        if first_secid_on_page.is_none() {
            first_secid_on_page = Some(snapshot.secid().clone());
        }
        snapshots.push(snapshot);
    }

    for (secid, (row, last)) in marketdata_by_secid {
        let snapshot = SecuritySnapshot::try_new(secid, None, last).map_err(|source| {
            MoexError::InvalidSecuritySnapshot {
                endpoint: endpoint.to_owned().into_boxed_str(),
                table: "marketdata",
                row,
                source,
            }
        })?;
        if first_secid_on_page.is_none() {
            first_secid_on_page = Some(snapshot.secid().clone());
        }
        snapshots.push(snapshot);
    }

    Ok((snapshots, first_secid_on_page))
}

pub fn secid(&self) -> &SecId

Идентификатор инструмента (secid).

Examples found in repository

examples/actual_indexes_dump.rs (line 140)

fn load_security_snapshots(
    moex_client: &Client,
    wanted_secids: &HashSet<SecId>,
) -> Result<(HashMap<SecId, ResolvedSnapshot>, Vec<SecId>), ExampleError> {
    let stock_scope = moex_client
        .stock()
        .expect("stock engine literal must be valid");
    let markets = with_retry(retry_policy(), || stock_scope.markets())?;
    let mut snapshots = HashMap::with_capacity(wanted_secids.len());

    'markets: for market in markets {
        let boards = with_retry(retry_policy(), || {
            moex_client.boards(stock_scope.engine(), market.name())
        })?;

        for board in boards.into_iter().filter(|board| board.is_traded()) {
            let board_snapshots = load_board_snapshots_all_pages(
                moex_client,
                stock_scope.engine().as_str(),
                market.name().as_str(),
                board.boardid().as_str(),
            )?;

            for snapshot in board_snapshots {
                if !wanted_secids.contains(snapshot.secid()) {
                    continue;
                }

                snapshots
                    .entry(snapshot.secid().clone())
                    .or_insert_with(|| ResolvedSnapshot {
                        market: market.name().as_str().to_owned().into_boxed_str(),
                        board: board.boardid().as_str().to_owned().into_boxed_str(),
                        lot_size: snapshot.lot_size(),
                        last: snapshot.last(),
                    });
            }

            if snapshots.len() == wanted_secids.len() {
                break 'markets;
            }
        }
    }

    let missing_mapping = wanted_secids
        .iter()
        .filter(|secid| !snapshots.contains_key(*secid))
        .cloned()
        .collect();

    Ok((snapshots, missing_mapping))
}

fn load_board_snapshots_all_pages(
    moex_client: &Client,
    engine: &str,
    market: &str,
    board: &str,
) -> Result<Vec<SecuritySnapshot>, MoexError> {
    let endpoint = format!("engines/{engine}/markets/{market}/boards/{board}/securities.json");
    let mut start = 0_u32;
    let mut snapshots = Vec::new();
    let mut first_secid_on_previous_page = None;
    let limit = BOARD_SNAPSHOTS_PAGE_LIMIT.to_string();

    loop {
        let payload = with_retry(retry_policy(), || {
            moex_client
                .raw()
                .path(endpoint.as_str())
                .only("securities,marketdata")
                .columns("securities", "SECID,LOTSIZE")
                .columns("marketdata", "SECID,LAST")
                .param("start", start.to_string())
                .param("limit", limit.as_str())
                .send_payload()
        })?;

        let (page, first_secid_on_page) = parse_board_snapshots_page(&payload, endpoint.as_str())?;
        if page.is_empty() {
            break;
        }

        if let (Some(previous), Some(current)) =
            (&first_secid_on_previous_page, &first_secid_on_page)
            && previous == current
        {
            break;
        }
        first_secid_on_previous_page = first_secid_on_page;

        let page_len = u32::try_from(page.len()).map_err(|_| MoexError::PaginationOverflow {
            endpoint: endpoint.clone().into_boxed_str(),
            start,
            limit: BOARD_SNAPSHOTS_PAGE_LIMIT,
        })?;

        snapshots.extend(page);
        if page_len < BOARD_SNAPSHOTS_PAGE_LIMIT {
            break;
        }
        start = start
            .checked_add(page_len)
            .ok_or_else(|| MoexError::PaginationOverflow {
                endpoint: endpoint.clone().into_boxed_str(),
                start,
                limit: BOARD_SNAPSHOTS_PAGE_LIMIT,
            })?;
    }

    Ok(snapshots)
}

fn parse_board_snapshots_page(
    payload: &str,
    endpoint: &str,
) -> Result<(Vec<SecuritySnapshot>, Option<SecId>), MoexError> {
    let mut tables = decode::raw_tables_json(payload, endpoint)?;
    let security_rows: Vec<RawSecuritySnapshotRow> = tables.take_rows("securities")?;
    let marketdata_rows: Vec<RawMarketdataSnapshotRow> = tables.take_rows("marketdata")?;

    let mut marketdata_by_secid = HashMap::with_capacity(marketdata_rows.len());
    for (row, marketdata) in marketdata_rows.into_iter().enumerate() {
        marketdata_by_secid.insert(marketdata.secid, (row, marketdata.last));
    }

    let mut first_secid_on_page = None;
    let mut snapshots = Vec::with_capacity(security_rows.len().max(marketdata_by_secid.len()));

    for (row, security) in security_rows.into_iter().enumerate() {
        let last = marketdata_by_secid
            .remove(security.secid.as_str())
            .and_then(|(_, last)| last);
        let snapshot = SecuritySnapshot::try_new(security.secid, security.lot_size, last).map_err(
            |source| MoexError::InvalidSecuritySnapshot {
                endpoint: endpoint.to_owned().into_boxed_str(),
                table: "securities",
                row,
                source,
            },
        )?;
        if first_secid_on_page.is_none() {
            first_secid_on_page = Some(snapshot.secid().clone());
        }
        snapshots.push(snapshot);
    }

    for (secid, (row, last)) in marketdata_by_secid {
        let snapshot = SecuritySnapshot::try_new(secid, None, last).map_err(|source| {
            MoexError::InvalidSecuritySnapshot {
                endpoint: endpoint.to_owned().into_boxed_str(),
                table: "marketdata",
                row,
                source,
            }
        })?;
        if first_secid_on_page.is_none() {
            first_secid_on_page = Some(snapshot.secid().clone());
        }
        snapshots.push(snapshot);
    }

    Ok((snapshots, first_secid_on_page))
}

pub fn lot_size(&self) -> Option<u32>

Размер лота (LOTSIZE), если поле присутствует в ISS.

Examples found in repository

examples/actual_indexes_dump.rs (line 149)

fn load_security_snapshots(
    moex_client: &Client,
    wanted_secids: &HashSet<SecId>,
) -> Result<(HashMap<SecId, ResolvedSnapshot>, Vec<SecId>), ExampleError> {
    let stock_scope = moex_client
        .stock()
        .expect("stock engine literal must be valid");
    let markets = with_retry(retry_policy(), || stock_scope.markets())?;
    let mut snapshots = HashMap::with_capacity(wanted_secids.len());

    'markets: for market in markets {
        let boards = with_retry(retry_policy(), || {
            moex_client.boards(stock_scope.engine(), market.name())
        })?;

        for board in boards.into_iter().filter(|board| board.is_traded()) {
            let board_snapshots = load_board_snapshots_all_pages(
                moex_client,
                stock_scope.engine().as_str(),
                market.name().as_str(),
                board.boardid().as_str(),
            )?;

            for snapshot in board_snapshots {
                if !wanted_secids.contains(snapshot.secid()) {
                    continue;
                }

                snapshots
                    .entry(snapshot.secid().clone())
                    .or_insert_with(|| ResolvedSnapshot {
                        market: market.name().as_str().to_owned().into_boxed_str(),
                        board: board.boardid().as_str().to_owned().into_boxed_str(),
                        lot_size: snapshot.lot_size(),
                        last: snapshot.last(),
                    });
            }

            if snapshots.len() == wanted_secids.len() {
                break 'markets;
            }
        }
    }

    let missing_mapping = wanted_secids
        .iter()
        .filter(|secid| !snapshots.contains_key(*secid))
        .cloned()
        .collect();

    Ok((snapshots, missing_mapping))
}

pub fn last(&self) -> Option<f64>

Последняя цена (LAST), если поле присутствует в ISS.

Examples found in repository

examples/actual_indexes_dump.rs (line 150)

fn load_security_snapshots(
    moex_client: &Client,
    wanted_secids: &HashSet<SecId>,
) -> Result<(HashMap<SecId, ResolvedSnapshot>, Vec<SecId>), ExampleError> {
    let stock_scope = moex_client
        .stock()
        .expect("stock engine literal must be valid");
    let markets = with_retry(retry_policy(), || stock_scope.markets())?;
    let mut snapshots = HashMap::with_capacity(wanted_secids.len());

    'markets: for market in markets {
        let boards = with_retry(retry_policy(), || {
            moex_client.boards(stock_scope.engine(), market.name())
        })?;

        for board in boards.into_iter().filter(|board| board.is_traded()) {
            let board_snapshots = load_board_snapshots_all_pages(
                moex_client,
                stock_scope.engine().as_str(),
                market.name().as_str(),
                board.boardid().as_str(),
            )?;

            for snapshot in board_snapshots {
                if !wanted_secids.contains(snapshot.secid()) {
                    continue;
                }

                snapshots
                    .entry(snapshot.secid().clone())
                    .or_insert_with(|| ResolvedSnapshot {
                        market: market.name().as_str().to_owned().into_boxed_str(),
                        board: board.boardid().as_str().to_owned().into_boxed_str(),
                        lot_size: snapshot.lot_size(),
                        last: snapshot.last(),
                    });
            }

            if snapshots.len() == wanted_secids.len() {
                break 'markets;
            }
        }
    }

    let missing_mapping = wanted_secids
        .iter()
        .filter(|secid| !snapshots.contains_key(*secid))
        .cloned()
        .collect();

    Ok((snapshots, missing_mapping))
}

Trait Implementations

impl Clone for SecuritySnapshot

fn clone(&self) -> SecuritySnapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SecuritySnapshot

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

Formats the value using the given formatter.

impl PartialEq for SecuritySnapshot

fn eq(&self, other: &SecuritySnapshot) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SecuritySnapshot