nx 0.3.0

A high performance Rust library used to read NX files with minimal memory usage.
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

// Copyright © 2015-2018, Peter Atashian
//! Stuff for working with NX files

use memmap::Mmap;
use std::error::Error as StdError;
use std::fmt::{Display, Formatter};
use std::fmt::Error as FmtError;
use std::fs::File as FsFile;
use std::io::Error as IoError;
use std::mem::size_of;
use std::path::Path;
use std::result::Result;
use std::slice::from_raw_parts;
use std::str::from_utf8_unchecked;

use repr::{self, Header};

pub use node::{Node};
pub use node::{GenericNode};
pub use node::{Type};

/// An error occuring anywhere in the library.
#[derive(Debug)]
pub enum Error {
    /// An internal IoError.
    Io(IoError),
    /// Magic value in header was incorrect.
    InvalidMagic,
    /// File was too short.
    TooShort,
}
impl StdError for Error {
    fn description(&self) -> &str {
        match self {
            &Error::Io(ref e) => e.description(),
            &Error::InvalidMagic => "Header magic value was invalid",
            &Error::TooShort => "File was too short for header",
        }
    }
    fn cause(&self) -> Option<&StdError> {
        match self {
            &Error::Io(ref e) => Some(e),
            _ => None,
        }
    }
}
impl Display for Error {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), FmtError> {
        match self.cause() {
            Some(cause) => write!(fmt, "{} ({})", self.description(), cause),
            None => write!(fmt, "{}", self.description()),
        }
    }
}
impl From<IoError> for Error {
    fn from(err: IoError) -> Error {
        Error::Io(err)
    }
}

/// A memory-mapped NX file.
pub struct File {
    #[allow(dead_code)]
    map: Mmap,
    data: *const u8,
    header: *const Header,
    nodetable: *const repr::Node,
    stringtable: *const u64,
    audiotable: *const u64,
    bitmaptable: *const u64,
}

impl File {
    /// Opens an NX file via memory-mapping. This also checks the magic bytes in the header.
    ///
    /// This is unsafe because it assumes the NX file is correct and UB may occur if
    /// there are mistakes.
    pub unsafe fn open(path: &Path) -> Result<File, Error> {
        let file = try!(FsFile::open(path));
        let map = try!(Mmap::map(&file));
        if map.len() < size_of::<Header>() {
            return Err(Error::TooShort)
        }
        let data = map.as_ptr();
        let header = data as *const Header;
        if (*header).magic != 0x34474B50 {
            return Err(Error::InvalidMagic)
        }
        let nodetable = data.offset((*header).nodeoffset as isize) as *const repr::Node;
        let stringtable = data.offset((*header).stringoffset as isize) as *const u64;
        let audiotable = data.offset((*header).audiooffset as isize) as *const u64;
        let bitmaptable = data.offset((*header).bitmapoffset as isize) as *const u64;
        Ok(File {
            map: map,
            data: data,
            header: header,
            nodetable: nodetable,
            stringtable: stringtable,
            audiotable: audiotable,
            bitmaptable: bitmaptable,
        })
    }
    /// Gets the file header.
    #[inline]
    fn header(&self) -> &Header {
        unsafe { &*self.header }
    }
    /// Number of nodes in the file
    #[inline]
    pub fn node_count(&self) -> u32 {
        self.header().nodecount
    }
    /// Gets the root node of the file.
    #[inline]
    pub fn root<'a>(&'a self) -> Node<'a> {
        unsafe { Node::construct(&*self.nodetable, self) }
    }
    /// Gets the string at the specified index in the string table.
    #[inline]
    pub unsafe fn get_str(&self, index: u32) -> &str {
        let off = *self.stringtable.offset(index as isize);
        let ptr = self.data.offset(off as isize);
        let size = ptr as *const u16;
        from_utf8_unchecked(from_raw_parts(ptr.offset(2), (*size) as usize))
    }
    /// Gets the node data at the specified index in the node table.
    #[inline]
    pub unsafe fn get_node(&self, index: u32) -> &repr::Node {
        &*self.nodetable.offset(index as isize)
    }
    /// Gets the audio data at the specified index in the node table.
    #[inline]
    pub unsafe fn get_audio(&self, index: u32, length: u32) -> &[u8] {
        let off = *self.audiotable.offset(index as isize);
        let ptr = self.data.offset(off as isize);
        from_raw_parts(ptr, length as usize)
    }
    /// Gets the bitmap data at the specified index in the node table.
    #[inline]
    pub unsafe fn get_bitmap(&self, index: u32) -> &[u8] {
        let off = *self.bitmaptable.offset(index as isize);
        let ptr = self.data.offset(off as isize);
        let len = *(ptr as *const u32);
        from_raw_parts(ptr.offset(4), len as usize)
    }
}
unsafe impl Send for File {}
unsafe impl Sync for File {}