Struct EngineName 

pub struct EngineName(/* private fields */);

Имя торгового движка MOEX (engine).

Implementations

impl EngineName

pub fn as_str(&self) -> &str

Вернуть строковое представление имени движка.

Examples found in repository

examples/actual_indexes_dump.rs (line 118)

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 AsRef<str> for EngineName

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for EngineName

fn clone(&self) -> EngineName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineName

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

Formats the value using the given formatter.

impl Display for EngineName

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

Formats the value using the given formatter.

impl From<&EngineName> for EngineName

fn from(value: &EngineName) -> Self

Converts to this type from the input type.

impl FromStr for EngineName

type Err = ParseEngineNameError

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for EngineName

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EngineName

fn eq(&self, other: &EngineName) -> 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 TryFrom<&str> for EngineName

type Error = ParseEngineNameError

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for EngineName

type Error = ParseEngineNameError

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for EngineName

impl StructuralPartialEq for EngineName