fbx_direct 0.6.0

Low-level FBX library
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

//! Contains macros used by parsers.

#![macro_use]

extern crate byteorder;

/// Unwrap result if `Ok`, returns `reader::Error` if `Err`.
///
/// `try!` converts argument into error type of caller's `Result` return type,
/// but `try_with_pos` converts argument into `reader::error::ErrorKind`.
/// `reader:error::Error` requires position information, so almost all error types cannot be
/// directly converted to `reader::Error` and `try!` cannot be used.
macro_rules! try_with_pos {
    ($pos:expr, $expr:expr) => (match $expr {
        ::std::result::Result::Ok(val) => val,
        ::std::result::Result::Err(err) => {
            return ::std::result::Result::Err($crate::reader::error::Error::new($pos, err));
        },
    })
}

// TODO: Is it possible to simplify `try_read_le_*` using another macros such as `concat_idents!`?

macro_rules! try_read_le_u8 {
    ($pos:expr, $reader:expr) => ({
        use $crate::reader::parser::macros::byteorder::ReadBytesExt;
        let val = try_with_pos!($pos, $reader.read_u8());
        $pos += 1;
        val
    })
}

macro_rules! try_read_le_u32 {
    ($pos:expr, $reader:expr) => ({
        use $crate::reader::parser::macros::byteorder;
        use $crate::reader::parser::macros::byteorder::ReadBytesExt;
        let val = try_with_pos!($pos, $reader.read_u32::<byteorder::LittleEndian>());
        $pos += 4;
        val
    })
}

macro_rules! try_read_le_u64 {
    ($pos:expr, $reader:expr) => ({
        use $crate::reader::parser::macros::byteorder;
        use $crate::reader::parser::macros::byteorder::ReadBytesExt;
        let val = try_with_pos!($pos, $reader.read_u64::<byteorder::LittleEndian>());
        $pos += 8;
        val
    })
}

macro_rules! try_read_le_i16 {
    ($pos:expr, $reader:expr) => ({
        use $crate::reader::parser::macros::byteorder;
        use $crate::reader::parser::macros::byteorder::ReadBytesExt;
        let val = try_with_pos!($pos, $reader.read_i16::<byteorder::LittleEndian>());
        $pos += 2;
        val
    })
}

macro_rules! try_read_le_i32 {
    ($pos:expr, $reader:expr) => ({
        use $crate::reader::parser::macros::byteorder;
        use $crate::reader::parser::macros::byteorder::ReadBytesExt;
        let val = try_with_pos!($pos, $reader.read_i32::<byteorder::LittleEndian>());
        $pos += 4;
        val
    })
}

macro_rules! try_read_le_i64 {
    ($pos:expr, $reader:expr) => ({
        use $crate::reader::parser::macros::byteorder;
        use $crate::reader::parser::macros::byteorder::ReadBytesExt;
        let val = try_with_pos!($pos, $reader.read_i64::<byteorder::LittleEndian>());
        $pos += 8;
        val
    })
}

macro_rules! try_read_le_f32 {
    ($pos:expr, $reader:expr) => ({
        use $crate::reader::parser::macros::byteorder;
        use $crate::reader::parser::macros::byteorder::ReadBytesExt;
        let val = try_with_pos!($pos, $reader.read_f32::<byteorder::LittleEndian>());
        $pos += 4;
        val
    })
}

macro_rules! try_read_le_f64 {
    ($pos:expr, $reader:expr) => ({
        use $crate::reader::parser::macros::byteorder;
        use $crate::reader::parser::macros::byteorder::ReadBytesExt;
        let val = try_with_pos!($pos, $reader.read_f64::<byteorder::LittleEndian>());
        $pos += 8;
        val
    })
}

macro_rules! try_read_fixstr {
    ($pos:expr, $reader:expr, $len:expr) => ({
        let mut buffer = String::with_capacity($len as usize);
        let len = try_with_pos!($pos, $reader.by_ref().take($len as u64).read_to_string(&mut buffer)) as u64;
        if len != ($len as u64) {
            return Err(Error::new($pos, ErrorKind::UnexpectedEof));
        }
        $pos += len;
        buffer
    })
}

macro_rules! try_read_exact {
    ($pos:expr, $reader:expr, $len:expr) => ({
        let mut buffer = Vec::<u8>::with_capacity($len as usize);
        let len = try_with_pos!($pos, $reader.by_ref().take($len as u64).read_to_end(&mut buffer)) as u64;
        if len != ($len as u64) {
            return Err(Error::new($pos, ErrorKind::UnexpectedEof));
        }
        $pos += len;
        buffer
    })
}