openscenario-rs 0.3.1

Rust library for parsing and manipulating OpenSCENARIO files
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
123

//! Init action builders for scenario initialization
//!
//! This module provides builders for creating OpenSCENARIO initialization actions
//! that set up entities and environment before scenario execution begins.
//!
//! # Architecture
//!
//! - **InitActionBuilder**: Main builder for complete Init structure
//! - **PrivateActionBuilder**: Builder for entity-specific initialization
//! - **GlobalActionBuilder**: Builder for environment and infrastructure setup
//!
//! # Usage
//!
//! ```rust
//! use openscenario_rs::builder::init::InitActionBuilder;
//! use openscenario_rs::builder::positions::WorldPositionBuilder;
//!
//! let init = InitActionBuilder::new()
//!     .add_teleport_action("ego",
//!         WorldPositionBuilder::new()
//!             .at_coordinates(0.0, 0.0, 0.0)
//!             .build()
//!             .unwrap()
//!     )
//!     .add_speed_action("ego", 30.0)
//!     .build()
//!     .unwrap();
//! ```

pub mod actions;
pub mod private;

pub use actions::InitActionBuilder;
pub use private::{GlobalActionBuilder, PrivateActionBuilder};

/// Convenience functions for common initialization patterns
impl InitActionBuilder {
    /// Create a basic initialization with environment setup
    pub fn with_default_environment() -> Self {
        Self::new().add_global_environment_action()
    }

    /// Create initialization for a single vehicle scenario
    pub fn for_single_vehicle(entity_ref: &str) -> Self {
        Self::new()
            .add_global_environment_action()
            .add_private_action(entity_ref)
    }

    /// Create initialization for multi-vehicle scenario
    pub fn for_multiple_vehicles(entity_refs: &[&str]) -> Self {
        let mut builder = Self::new().add_global_environment_action();

        for entity_ref in entity_refs {
            builder = builder.add_private_action(entity_ref);
        }

        builder
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::builder::positions::WorldPositionBuilder;
    use crate::types::positions::Position;

    #[test]
    fn test_init_builder_basic() {
        let init = InitActionBuilder::new().build().unwrap();

        assert!(init.actions.global_actions.is_empty());
        assert!(init.actions.private_actions.is_empty());
    }

    #[test]
    fn test_init_builder_with_environment() {
        let init = InitActionBuilder::with_default_environment()
            .build()
            .unwrap();

        assert_eq!(init.actions.global_actions.len(), 1);
        assert!(init.actions.global_actions[0].environment_action.is_some());
    }

    #[test]
    fn test_init_builder_single_vehicle() {
        let init = InitActionBuilder::for_single_vehicle("ego")
            .build()
            .unwrap();

        assert_eq!(init.actions.global_actions.len(), 1);
        assert_eq!(init.actions.private_actions.len(), 1);
        assert_eq!(
            init.actions.private_actions[0]
                .entity_ref
                .as_literal()
                .unwrap(),
            "ego"
        );
    }

    #[test]
    fn test_init_builder_multiple_vehicles() {
        let vehicles = ["ego", "target", "obstacle"];
        let init = InitActionBuilder::for_multiple_vehicles(&vehicles)
            .build()
            .unwrap();

        assert_eq!(init.actions.global_actions.len(), 1);
        assert_eq!(init.actions.private_actions.len(), 3);

        for (i, vehicle) in vehicles.iter().enumerate() {
            assert_eq!(
                init.actions.private_actions[i]
                    .entity_ref
                    .as_literal()
                    .unwrap(),
                *vehicle
            );
        }
    }
}