membacking/mapping_manager/
mappable.rs

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
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

use mesh::payload::DefaultEncoding;
use mesh::payload::encoding::ResourceField;
use std::sync::Arc;

/// A section handle.
#[cfg(windows)]
type OwnedType = std::os::windows::io::OwnedHandle;

/// A file descriptor.
#[cfg(unix)]
type OwnedType = std::os::fd::OwnedFd;

/// A handle/fd to an OS object that can be mapped into memory.
///
/// This uses `Arc` to make `clone` cheap and reliable.
#[derive(Debug, Clone)]
pub struct Mappable(Arc<OwnedType>);

impl From<OwnedType> for Mappable {
    fn from(value: OwnedType) -> Self {
        Self(Arc::new(value))
    }
}

impl From<Arc<OwnedType>> for Mappable {
    fn from(value: Arc<OwnedType>) -> Self {
        Self(value)
    }
}

impl From<Mappable> for OwnedType {
    fn from(value: Mappable) -> Self {
        // Currently there is no way to avoid the unwrap here. Mesh improvements
        // to how resources are handled could make this unnecessary.
        Arc::try_unwrap(value.0).unwrap_or_else(|v| v.try_clone().expect("out of fds/handles"))
    }
}

#[cfg(unix)]
impl std::os::fd::AsFd for Mappable {
    fn as_fd(&self) -> std::os::fd::BorrowedFd<'_> {
        self.0.as_fd()
    }
}

#[cfg(windows)]
impl std::os::windows::io::AsHandle for Mappable {
    fn as_handle(&self) -> std::os::windows::io::BorrowedHandle<'_> {
        self.0.as_handle()
    }
}

impl DefaultEncoding for Mappable {
    type Encoding = ResourceField<OwnedType>;
}