ambers 0.4.2

Pure Rust reader for SPSS .sav and .zsav files
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

pub mod encoding_record;
pub mod float_info;
pub mod integer_info;
pub mod long_string_labels;
pub mod long_string_missing;
pub mod long_var_names;
pub mod mr_sets;
pub mod var_attributes;
pub mod var_display;
pub mod very_long_strings;

use std::io::Read;

use crate::constants::*;
use crate::error::Result;
use crate::io_utils::SavReader;

/// Header for a type 7 (info) record.
#[derive(Debug, Clone)]
pub struct InfoRecordHeader {
    pub subtype: i32,
    pub size: i32,
    pub count: i32,
}

impl InfoRecordHeader {
    /// Parse the info record header. The record type (7) has already been read.
    pub fn parse<R: Read>(reader: &mut SavReader<R>) -> Result<InfoRecordHeader> {
        let subtype = reader.read_i32()?;
        let size = reader.read_i32()?;
        let count = reader.read_i32()?;
        Ok(InfoRecordHeader {
            subtype,
            size,
            count,
        })
    }

    /// Total data bytes for this info record.
    pub fn data_len(&self) -> usize {
        (self.size as usize) * (self.count as usize)
    }
}

/// Parsed info record data.
#[derive(Debug)]
#[allow(dead_code)]
pub enum InfoRecord {
    IntegerInfo(integer_info::IntegerInfo),
    FloatInfo(float_info::FloatInfo),
    VarDisplay(Vec<var_display::VarDisplayEntry>),
    LongNames(Vec<(String, String)>),
    VeryLongStrings(Vec<(String, usize)>),
    Encoding(String),
    LongStringLabels(Vec<long_string_labels::LongStringLabelSet>),
    LongStringMissing(Vec<long_string_missing::LongStringMissingEntry>),
    MrSets(Vec<mr_sets::RawMrSet>),
    VarAttributes(Vec<var_attributes::VarAttributeSet>),
    Unknown { subtype: i32 },
}

/// Parse a type 7 info record based on its subtype.
pub fn parse_info_record<R: Read>(
    reader: &mut SavReader<R>,
    header: &InfoRecordHeader,
) -> Result<InfoRecord> {
    let data_len = header.data_len();

    match header.subtype {
        INFO_MR_SETS => {
            let data = reader.read_bytes(data_len)?;
            let sets = mr_sets::parse_mr_sets(&data);
            Ok(InfoRecord::MrSets(sets))
        }
        INFO_MR_SETS_V2 => {
            let data = reader.read_bytes(data_len)?;
            let sets = mr_sets::parse_mr_sets_v2(&data);
            Ok(InfoRecord::MrSets(sets))
        }
        INFO_INTEGER => {
            let info = integer_info::IntegerInfo::parse(reader)?;
            Ok(InfoRecord::IntegerInfo(info))
        }
        INFO_FLOAT => {
            let info = float_info::FloatInfo::parse(reader)?;
            Ok(InfoRecord::FloatInfo(info))
        }
        INFO_VAR_DISPLAY => {
            let entries = var_display::parse_var_display(reader, header.count)?;
            Ok(InfoRecord::VarDisplay(entries))
        }
        INFO_LONG_NAMES => {
            let data = reader.read_bytes(data_len)?;
            let names = long_var_names::parse_long_var_names(&data);
            Ok(InfoRecord::LongNames(names))
        }
        INFO_VERY_LONG_STRINGS => {
            let data = reader.read_bytes(data_len)?;
            let entries = very_long_strings::parse_very_long_strings(&data);
            Ok(InfoRecord::VeryLongStrings(entries))
        }
        INFO_ENCODING => {
            let data = reader.read_bytes(data_len)?;
            let name = encoding_record::parse_encoding_record(&data);
            Ok(InfoRecord::Encoding(name))
        }
        INFO_LONG_STRING_LABELS => {
            let data = reader.read_bytes(data_len)?;
            let labels = long_string_labels::parse_long_string_labels(&data)?;
            Ok(InfoRecord::LongStringLabels(labels))
        }
        INFO_LONG_STRING_MISSING => {
            let data = reader.read_bytes(data_len)?;
            let entries = long_string_missing::parse_long_string_missing(&data)?;
            Ok(InfoRecord::LongStringMissing(entries))
        }
        INFO_VAR_ATTRIBUTES => {
            let data = reader.read_bytes(data_len)?;
            let attrs = var_attributes::parse_var_attributes(&data);
            Ok(InfoRecord::VarAttributes(attrs))
        }
        _ => {
            // Unknown subtype -- skip the data
            reader.skip(data_len)?;
            Ok(InfoRecord::Unknown {
                subtype: header.subtype,
            })
        }
    }
}