iceoryx2-cal 0.0.4

Iceoryx2: [internal] high-level traits and implementations that represents OS primitives in an exchangeable fashion
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

// 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

use iceoryx2_bb_log::fail;
use iceoryx2_bb_system_types::file_name::FileName;
use std::{alloc::Layout, fmt::Debug};

use crate::shared_memory::ShmPointer;
use crate::shared_memory_directory::SharedMemoryDirectoryCreateFileError;

use super::file_reference_set::{FileReferenceSet, FileReferenceSetId};

pub struct File<'a> {
    pub(crate) set: &'a FileReferenceSet,
    pub(crate) id: FileReferenceSetId,
    pub(crate) base_address: usize,
}

impl Debug for File<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "File {{ name: {}, id: {:?}, base_address: {} }}",
            self.name(),
            self.id,
            self.base_address
        )
    }
}

impl<'a> File<'a> {
    pub fn name(&self) -> FileName {
        self.set.get_name(self.id)
    }

    pub fn content(&self) -> &[u8] {
        self.set.get_payload(self.id, self.base_address)
    }

    pub fn content_mut(&mut self) -> &mut [u8] {
        self.set.get_payload_mut(self.id, self.base_address)
    }

    pub fn is_persistent(&self) -> bool {
        self.set.is_persistent(self.id)
    }
}

impl<'a> Drop for File<'a> {
    fn drop(&mut self) {
        self.set.release(self.id)
    }
}

#[derive(Debug)]
pub struct FileCreator<'a> {
    set: &'a FileReferenceSet,
    layout: Layout,
    is_persistent: bool,
    memory: ShmPointer,
    base_address: usize,
}

impl<'a> FileCreator<'a> {
    pub(crate) fn new(
        set: &'a FileReferenceSet,
        memory: ShmPointer,
        layout: Layout,
        base_address: usize,
    ) -> Self {
        Self {
            set,
            layout,
            is_persistent: false,
            memory,
            base_address,
        }
    }

    pub fn is_persistent(mut self, value: bool) -> Self {
        self.is_persistent = value;
        self
    }

    pub fn create<F: FnMut(&mut [u8])>(
        self,
        name: &FileName,
        mut initializer: F,
    ) -> Result<File<'a>, SharedMemoryDirectoryCreateFileError> {
        let id = fail!(from self, when self.set.insert(
                                        name,
                                        self.memory.offset.value(),
                                        self.layout.size(),
                                        self.is_persistent,
                                    ),
                            "Failed to create new file {}.", *name);

        initializer(unsafe {
            core::slice::from_raw_parts_mut(self.memory.data_ptr, self.layout.size())
        });

        self.set.finalize_initialization(id);

        Ok(File {
            set: self.set,
            id,
            base_address: self.base_address,
        })
    }
}