xbbg_core 1.1.2

Safe Rust wrappers for BLPAPI session, request, and response primitives
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

//! Schema introspection test for IntradayTickRequest
//!
//! Run with: cargo run -p xbbg_core --example schema_tick --features live

use xbbg_core::{session::Session, EventType, SessionOptions};

#[allow(clippy::result_large_err)]
fn main() -> xbbg_core::Result<()> {
    println!("=== Schema Introspection for IntradayTickRequest ===\n");

    let opts = SessionOptions::new()?;
    let sess = Session::new(&opts)?;
    sess.start()?;

    // Wait for session
    loop {
        let ev = sess.next_event(Some(5000))?;
        if ev.event_type() == EventType::SessionStatus {
            break;
        }
    }

    // Open refdata service
    sess.open_service("//blp/refdata")?;
    loop {
        let ev = sess.next_event(Some(5000))?;
        if ev.event_type() == EventType::ServiceStatus {
            break;
        }
    }

    let svc = sess.get_service("//blp/refdata")?;

    println!("Service has {} operations\n", svc.num_operations());

    // Find IntradayTickRequest operation
    for op in svc.operations() {
        let name = op.name();
        if name == "IntradayTickRequest" {
            println!("Found: {}", name);
            println!("Description: {}", op.description());

            // Get request schema
            if let Ok(req_def) = op.request_definition() {
                println!("\nRequest Schema Elements:");
                let type_def = req_def.type_definition();
                print_type_def(&type_def, 1);
            }

            // Get response schemas
            println!(
                "\nResponse Schemas ({} types):",
                op.num_response_definitions()
            );
            for i in 0..op.num_response_definitions() {
                if let Ok(resp_def) = op.response_definition(i) {
                    println!("  Response {}:", i);
                    let type_def = resp_def.type_definition();
                    print_type_def(&type_def, 2);
                }
            }
            break;
        }
    }

    sess.stop();
    Ok(())
}

fn print_type_def(type_def: &xbbg_core::schema::SchemaTypeDefinition, indent: usize) {
    let prefix = "  ".repeat(indent);

    println!(
        "{}Type: {} ({} elements)",
        prefix,
        type_def.name_str(),
        type_def.num_element_definitions()
    );

    for elem_def in type_def.element_definitions() {
        let elem_name = elem_def.name_str();
        let status = elem_def.status();
        let inner_type = elem_def.type_definition();
        let type_name = inner_type.name_str();
        let required = if elem_def.is_required() {
            "required"
        } else {
            "optional"
        };
        let array = if elem_def.is_array() { "[]" } else { "" };

        println!(
            "{}  - {}{} : {} ({}, {:?})",
            prefix, elem_name, array, type_name, required, status
        );
    }
}