ruci 2.1.0

A UCI (Universal Chess Interface) crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

extern crate alloc;

use crate::errors::MessageParseError;
use crate::{MessageParseErrorKind, MessagePointer};
use alloc::string::String;
use core::str::FromStr;

/// Finds the target message and returns the rest of the string, as separated by spaces.
///
/// # Errors
/// No message was found.
pub fn collect_message<'s>(
    target: &'static str,
    s: &'s str,
) -> Result<core::str::Split<'s, char>, MessageParseError>
where
    MessagePointer: FromStr,
{
    let s = s.trim();
    let s = if let Some((s1, _)) = s.split_once('\n') {
        s1
    } else {
        s
    };

    let mut parts = s.split(' ');
    parts
        .find(|&part| part == target)
        .ok_or(MessageParseError {
            expected: target,
            kind: MessageParseErrorKind::NoMessage,
        })?;

    Ok(parts)
}

/// Finds any message and returns the rest of the string, as separated by spaces.
///
/// # Errors
/// No message was found.
pub fn collect_any_message<'s, M>(
    expected: &'static str,
    s: &'s str,
) -> Result<(M, core::str::Split<'s, char>), MessageParseError>
where
    M: FromStr,
{
    let s = s.trim();
    let s = if let Some((s1, _)) = s.split_once('\n') {
        s1
    } else {
        s
    };

    let mut parts = s.split(' ');
    let message = parts
        .find_map(|part| M::from_str(part).ok())
        .ok_or(MessageParseError {
            expected,
            kind: MessageParseErrorKind::NoMessage,
        })?;

    Ok((message, parts))
}

/// Applies a closure to all parameters and their values.
///
/// `parameter_fn` accepts these parameters:
/// - `ParameterPointer`: the pointer associated with the passed in value.
/// - `Option<ParameterPointer>`: the next parameter, if there is one.
/// - `Split<char>`: the parts that this function parses. You should return these, as is given
///   by the `parameter_fn` signature, unless you want to stop parsing. In that case, return `None`
///   and keep the parts to yourself.
pub fn apply_parameters<'p, 'v, ParameterPointer>(
    mut parts: core::str::Split<'p, char>,
    value: &'v mut String,
    mut parameter_fn: impl FnMut(
        ParameterPointer,
        Option<ParameterPointer>,
        &str,
        core::str::Split<'p, char>,
    ) -> Option<core::str::Split<'p, char>>,
) -> Option<&'v str>
where
    ParameterPointer: FromStr + Copy,
{
    let mut first_parameter_encountered = false;
    let mut last_parameter = None;

    while let Some(part) = parts.next() {
        let Ok(parameter) = ParameterPointer::from_str(part) else {
            value.push_str(part);
            value.push(' ');
            continue;
        };

        if !first_parameter_encountered {
            first_parameter_encountered = true;
            value.clear();
        }

        if let Some(last_parameter) = last_parameter {
            if let Some(p) = parameter_fn(last_parameter, Some(parameter), value.trim(), parts) {
                parts = p;
            } else {
                return None;
            }

            value.clear();
        }

        last_parameter = Some(parameter);
    }

    let value = value.trim();

    if let Some(last_parameter) = last_parameter {
        parameter_fn(last_parameter, None, value, parts);
    }

    Some(value)
}