iceoryx2 0.9.0

iceoryx2: Lock-Free Zero-Copy Interprocess Communication
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

// Copyright (c) 2023 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT

//! Stores the [`Service`](crate::service::Service) messaging pattern specific static configuration.
use core::fmt::Display;

use crate::service::static_config::blackboard;
use crate::service::static_config::event;
use crate::service::static_config::publish_subscribe;
use iceoryx2_bb_derive_macros::ZeroCopySend;
use iceoryx2_bb_elementary_traits::zero_copy_send::ZeroCopySend;
use iceoryx2_log::fatal_panic;
use serde::{Deserialize, Serialize};

use super::request_response;

/// Contains the static config of the corresponding
/// [`service::MessagingPattern`](crate::service::messaging_pattern::MessagingPattern).
///
/// # Safety
///
/// This is a large struct (>1KB). Be cautious with where it is placed and how it is passed around.
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq, ZeroCopySend, Serialize, Deserialize)]
#[repr(C)]
#[allow(clippy::large_enum_variant)]
pub enum MessagingPattern {
    /// Stores the static config of the
    /// [`service::MessagingPattern::RequestResponse`](crate::service::messaging_pattern::MessagingPattern::RequestResponse)
    RequestResponse(request_response::StaticConfig),

    /// Stores the static config of the
    /// [`service::MessagingPattern::PublishSubscribe`](crate::service::messaging_pattern::MessagingPattern::PublishSubscribe)
    PublishSubscribe(publish_subscribe::StaticConfig),

    /// Stores the static config of the
    /// [`service::MessagingPattern::Event`](crate::service::messaging_pattern::MessagingPattern::Event)
    Event(event::StaticConfig),

    /// Stores the static config of the
    /// [`service::MessagingPattern::Blackboard`](crate::service::messaging_pattern::MessagingPattern::Blackboard)
    Blackboard(blackboard::StaticConfig),
}

impl Display for MessagingPattern {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            MessagingPattern::RequestResponse(_) => write!(f, "RequestResponse"),
            MessagingPattern::Event(_) => write!(f, "Event"),
            MessagingPattern::PublishSubscribe(_) => write!(f, "PublishSubscribe"),
            MessagingPattern::Blackboard(_) => write!(f, "Blackboard"),
        }
    }
}

impl MessagingPattern {
    /// checks whether the 2 MessagingPatterns are the same regardless the values inside them.
    pub(crate) fn is_same_pattern(&self, rhs: &MessagingPattern) -> bool {
        core::mem::discriminant(self) == core::mem::discriminant(rhs)
    }

    /// # Safety
    ///
    ///  * User must ensure that publish subscribe is stored inside
    pub unsafe fn publish_subscribe(&self) -> &publish_subscribe::StaticConfig {
        if let MessagingPattern::PublishSubscribe(v) = self {
            v
        } else {
            fatal_panic!(from self,
                "This should never happen! Trying to access publish subscribe messaging pattern that is not stored.");
        }
    }

    /// # Safety
    ///
    ///  * User must ensure that event is stored inside
    pub unsafe fn request_response(&self) -> &request_response::StaticConfig {
        if let MessagingPattern::RequestResponse(v) = self {
            v
        } else {
            fatal_panic!(from self,
                "This should never happen! Trying to access request response messaging pattern that is not stored.");
        }
    }
}

#[cfg(test)]
mod tests {
    use iceoryx2_bb_testing::assert_that;

    use super::*;
    use crate::service::config;
    use crate::service::static_config::event;
    use crate::service::static_config::publish_subscribe;

    #[test]
    fn test_is_same_pattern() {
        let cfg = config::Config::default();
        let p1 = MessagingPattern::PublishSubscribe(publish_subscribe::StaticConfig::new(&cfg));
        let p2 = MessagingPattern::PublishSubscribe(publish_subscribe::StaticConfig::new(&cfg));
        assert_that!(p1.is_same_pattern(&p2), eq true);
        assert_that!(p2.is_same_pattern(&p1), eq true);

        let e1 = MessagingPattern::Event(event::StaticConfig::new(&cfg));
        let e2 = MessagingPattern::Event(event::StaticConfig::new(&cfg));
        assert_that!(e1.is_same_pattern(&e2), eq true);
        assert_that!(e2.is_same_pattern(&e1), eq true);

        let r1 = MessagingPattern::RequestResponse(request_response::StaticConfig::new(&cfg));
        let r2 = MessagingPattern::RequestResponse(request_response::StaticConfig::new(&cfg));
        assert_that!(r1.is_same_pattern(&r2), eq true);
        assert_that!(r2.is_same_pattern(&r1), eq true);

        let b1 = MessagingPattern::Blackboard(blackboard::StaticConfig::new(&cfg));
        let b2 = MessagingPattern::Blackboard(blackboard::StaticConfig::new(&cfg));
        assert_that!(b1.is_same_pattern(&b2), eq true);
        assert_that!(b2.is_same_pattern(&b1), eq true);

        let mut new_defaults = config::Defaults {
            request_response: cfg.defaults.request_response.clone(),
            publish_subscribe: cfg.defaults.publish_subscribe.clone(),
            event: cfg.defaults.event.clone(),
            blackboard: cfg.defaults.blackboard.clone(),
        };
        new_defaults.event.event_id_max_value -= 1;
        new_defaults.publish_subscribe.max_nodes -= 1;
        new_defaults.request_response.max_nodes -= 1;
        new_defaults.blackboard.max_nodes -= 1;

        let cfg2 = config::Config {
            defaults: new_defaults,
            global: cfg.global.clone(),
        };

        // ensure the cfg and cfg2 are not equal
        assert_that!(cfg, ne cfg2);

        let p3 = MessagingPattern::PublishSubscribe(publish_subscribe::StaticConfig::new(&cfg2));
        assert_that!(p1.is_same_pattern(&p3), eq true);
        assert_that!(p3.is_same_pattern(&p1), eq true);

        let e3 = MessagingPattern::Event(event::StaticConfig::new(&cfg2));
        assert_that!(e1.is_same_pattern(&e3), eq true);
        assert_that!(e2.is_same_pattern(&e3), eq true);

        let r3 = MessagingPattern::RequestResponse(request_response::StaticConfig::new(&cfg));
        assert_that!(r1.is_same_pattern(&r3), eq true);
        assert_that!(r2.is_same_pattern(&r3), eq true);

        let b3 = MessagingPattern::Blackboard(blackboard::StaticConfig::new(&cfg));
        assert_that!(b1.is_same_pattern(&b3), eq true);
        assert_that!(b2.is_same_pattern(&b3), eq true);

        assert_that!(p1.is_same_pattern(&e1), eq false);
        assert_that!(p3.is_same_pattern(&e3), eq false);
        assert_that!(p1.is_same_pattern(&r1), eq false);
        assert_that!(p3.is_same_pattern(&r3), eq false);
        assert_that!(p1.is_same_pattern(&b1), eq false);
        assert_that!(p3.is_same_pattern(&b3), eq false);
        assert_that!(e1.is_same_pattern(&r1), eq false);
        assert_that!(e3.is_same_pattern(&r3), eq false);
        assert_that!(e1.is_same_pattern(&b1), eq false);
        assert_that!(e3.is_same_pattern(&b3), eq false);
        assert_that!(r1.is_same_pattern(&b1), eq false);
        assert_that!(r3.is_same_pattern(&b3), eq false);
    }
}