ara-com 0.1.0

Core traits and async abstractions for Adaptive AUTOSAR communication in Rust
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

use async_trait::async_trait;
use std::sync::Arc;

use crate::error::AraComError;
use crate::service::ServiceDefinition;
use crate::transport::Transport;
use crate::types::*;

/// Base skeleton that generated skeletons wrap.
///
/// Holds the transport and service identity. Generated skeleton structs embed
/// a `SkeletonBase<T>` and call `offer` / `stop_offer` on it to register the
/// service instance with the transport layer.
pub struct SkeletonBase<T: Transport> {
    transport: Arc<T>,
    service_id: ServiceId,
    instance_id: InstanceId,
}

impl<T: Transport> SkeletonBase<T> {
    /// Create a new `SkeletonBase`.
    pub fn new(transport: Arc<T>, service_id: ServiceId, instance_id: InstanceId) -> Self {
        Self {
            transport,
            service_id,
            instance_id,
        }
    }

    /// Access the underlying transport (used by generated code to send
    /// notifications and register request handlers).
    pub fn transport(&self) -> &Arc<T> {
        &self.transport
    }

    /// The SOME/IP service ID this skeleton is bound to.
    pub fn service_id(&self) -> ServiceId {
        self.service_id
    }

    /// The instance ID this skeleton is bound to.
    pub fn instance_id(&self) -> InstanceId {
        self.instance_id
    }

    /// Advertise this service instance so that remote proxies can find it.
    pub async fn offer(
        &self,
        major_version: MajorVersion,
        minor_version: MinorVersion,
    ) -> Result<(), AraComError> {
        self.transport
            .offer_service(
                self.service_id,
                self.instance_id,
                major_version,
                minor_version,
            )
            .await
    }

    /// Withdraw the service advertisement.
    pub async fn stop_offer(&self) -> Result<(), AraComError> {
        self.transport
            .stop_offer_service(self.service_id, self.instance_id)
            .await
    }
}

/// Trait that generated skeleton structs implement.
///
/// Generated skeletons must also expose `offer` / `stop_offer` and carry a
/// reference to their service definition for type-checked version constants.
#[async_trait]
pub trait Skeleton: Send + Sync {
    type ServiceDef: ServiceDefinition;
    type TransportImpl: Transport;

    fn new(transport: Arc<Self::TransportImpl>, instance_id: InstanceId) -> Self;

    fn service_id() -> ServiceId {
        Self::ServiceDef::SERVICE_ID
    }

    async fn offer(&self) -> Result<(), AraComError>;
    async fn stop_offer(&self) -> Result<(), AraComError>;
}