wxtla 0.3.1

Wired eXploring Target Layer Accessor
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

//! Internal filesystem helpers shared by concrete filesystem drivers.

use crate::{
  ByteSourceHandle, FormatDescriptor, NamespaceDirectoryEntry, NamespaceNodeId, NamespaceNodeKind,
  NamespaceNodeRecord, NamespaceStreamId, NamespaceStreamRecord, Result,
};

/// Internal read-only filesystem surface exposed by a concrete filesystem type.
pub(crate) trait FileSystem: Send + Sync {
  /// Return the format descriptor for this opened filesystem.
  fn descriptor(&self) -> FormatDescriptor;

  /// Return the identifier of the root node.
  fn root_node_id(&self) -> NamespaceNodeId;

  /// Resolve metadata for a filesystem node.
  fn node(&self, node_id: &NamespaceNodeId) -> Result<NamespaceNodeRecord>;

  /// List the direct children of a directory node.
  fn read_dir(&self, directory_id: &NamespaceNodeId) -> Result<Vec<NamespaceDirectoryEntry>>;

  /// Open file content for a readable file node.
  fn open_file(&self, file_id: &NamespaceNodeId) -> Result<ByteSourceHandle>;

  /// Enumerate streams exposed by a node.
  fn data_streams(&self, node_id: &NamespaceNodeId) -> Result<Vec<NamespaceStreamRecord>> {
    let node = self.node(node_id)?;
    Ok(match node.kind {
      NamespaceNodeKind::File | NamespaceNodeKind::Symlink => {
        vec![NamespaceStreamRecord::new(
          NamespaceStreamId::data(),
          node.size,
        )]
      }
      NamespaceNodeKind::Directory | NamespaceNodeKind::Special => Vec::new(),
    })
  }

  /// Open a specific stream exposed by a node.
  fn open_stream(
    &self, node_id: &NamespaceNodeId, stream_id: &NamespaceStreamId,
  ) -> Result<ByteSourceHandle> {
    if *stream_id == NamespaceStreamId::data() {
      self.open_file(node_id)
    } else {
      Err(crate::Error::not_found(format!(
        "{} does not expose stream {:?}",
        self.descriptor().id,
        stream_id
      )))
    }
  }
}

macro_rules! impl_file_system_data_source {
  ($ty:ty) => {
    impl crate::NamespaceSource for $ty {
      fn root_node_id(&self) -> crate::NamespaceNodeId {
        crate::filesystems::driver::FileSystem::root_node_id(self)
      }

      fn node(
        &self, node_id: &crate::NamespaceNodeId,
      ) -> crate::Result<crate::NamespaceNodeRecord> {
        crate::filesystems::driver::FileSystem::node(self, node_id)
      }

      fn read_dir(
        &self, directory_id: &crate::NamespaceNodeId,
      ) -> crate::Result<Vec<crate::NamespaceDirectoryEntry>> {
        crate::filesystems::driver::FileSystem::read_dir(self, directory_id)
      }

      fn data_streams(
        &self, node_id: &crate::NamespaceNodeId,
      ) -> crate::Result<Vec<crate::NamespaceStreamRecord>> {
        crate::filesystems::driver::FileSystem::data_streams(self, node_id)
      }

      fn open_stream(
        &self, node_id: &crate::NamespaceNodeId, stream_id: &crate::NamespaceStreamId,
      ) -> crate::Result<crate::ByteSourceHandle> {
        crate::filesystems::driver::FileSystem::open_stream(self, node_id, stream_id)
      }
    }

    impl crate::DataSource for $ty {
      fn descriptor(&self) -> crate::FormatDescriptor {
        crate::filesystems::driver::FileSystem::descriptor(self)
      }

      fn facets(&self) -> crate::DataSourceFacets {
        crate::DataSourceFacets::namespace()
      }

      fn namespace(&self) -> Option<&dyn crate::NamespaceSource> {
        Some(self)
      }
    }
  };
}

pub(crate) use impl_file_system_data_source;