Struct Record 

pub struct Record { /* private fields */ }

One AU3 resource record.

Implementations

impl Record

pub const fn index(&self) -> usize

Returns the zero-based record index.

Returns

The position of this record within the parsed stream.

Examples found in repository

examples/dump.rs (line 145)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn offset(&self) -> usize

Returns the file offset where this record starts.

Returns

The absolute byte offset of the record’s FILE marker in the input.

Examples found in repository

examples/dump.rs (line 145)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub fn subtype(&self) -> &str

Returns the decoded subtype text.

Returns

The record subtype as decoded text (e.g. the >>>AUTOIT SCRIPT<<< tag).

Examples found in repository

examples/dump.rs (line 146)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub fn subtype_bytes(&self) -> &[u8]

Returns the raw decrypted subtype bytes.

Returns

The decrypted subtype bytes prior to text decoding.

pub fn name(&self) -> &str

Returns the decoded stored name/path text.

Returns

The record’s stored name or path as decoded text.

Examples found in repository

examples/dump.rs (line 147)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub fn name_bytes(&self) -> &[u8]

Returns the raw decrypted name/path bytes.

Returns

The decrypted name/path bytes prior to text decoding.

pub const fn compressed(&self) -> bool

Returns whether the record payload is marked compressed.

Returns

true when the record’s compression flag is set, false otherwise.

Examples found in repository

examples/dump.rs (line 160)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn compressed_size(&self) -> u32

Returns the stored encrypted/compressed data size.

Returns

The byte length of the on-disk encrypted (and possibly compressed) blob.

Examples found in repository

examples/dump.rs (line 161)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn uncompressed_size(&self) -> u32

Returns the advertised uncompressed data size.

Returns

The uncompressed byte length declared in the record header.

Examples found in repository

examples/dump.rs (line 162)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn checksum(&self) -> u32

Returns the stored checksum value.

For EA04/JB01 records, which carry no checksum field, this is 0.

Returns

The stored adler32 checksum (EA05/EA06), or 0 when absent (EA04/JB01).

Examples found in repository

examples/dump.rs (line 169)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn checksum_valid(&self) -> bool

Returns whether the stored checksum matches the decrypted record data.

EA04/JB01 records carry no checksum, so they are treated as validated and this returns true.

Returns

true when the adler32 of the decrypted data matches the stored checksum, or when no checksum is present (EA04/JB01); false on mismatch.

Examples found in repository

examples/dump.rs (line 170)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn creation_time(&self) -> u64

Returns the creation timestamp as a raw Windows FILETIME.

Returns

The record’s creation time as a 64-bit Windows FILETIME value.

Examples found in repository

examples/dump.rs (line 181)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn last_write_time(&self) -> u64

Returns the last-write timestamp as a raw Windows FILETIME.

Returns

The record’s last-write time as a 64-bit Windows FILETIME value.

Examples found in repository

examples/dump.rs (line 182)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub fn encrypted_data(&self) -> &[u8]

Returns the encrypted record data bytes as stored on disk.

Returns

The raw encrypted (and possibly compressed) payload bytes.

Examples found in repository

examples/dump.rs (line 189)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub fn decrypted_data(&self) -> &[u8]

Returns the decrypted record data bytes.

These are still in their compressed (wrapped) form when the record is marked compressed.

Returns

The decrypted payload bytes, prior to any decompression.

Examples found in repository

examples/dump.rs (line 190)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub fn decompressed_data(&self) -> Option<&[u8]>

Returns the decompressed record data bytes when decompression succeeded.

Returns

Some with the decompressed bytes when the record was compressed and decompression succeeded, or None when the record was not compressed or decompression failed.

Examples found in repository

examples/dump.rs (line 192)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub fn payload_data(&self) -> &[u8]

Returns the best available payload bytes.

This is decompressed data when present, otherwise decrypted record data.

Returns

The decompressed bytes when available, otherwise the decrypted bytes.

Examples found in repository

examples/dump.rs (line 194)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn decompression_status(&self) -> DecompressionStatus

Returns the decompression status for this record.

Returns

A DecompressionStatus describing whether the record was compressed and, if so, whether decompression succeeded.

Examples found in repository

examples/dump.rs (line 199)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

pub const fn profile(&self) -> RecordProfile

Returns the extraction profile facts for this record.

Returns

A RecordProfile describing the encoding, encryption stream, and compression wrapper observed for the record.

Examples found in repository

examples/dump.rs (line 148)

fn print_records(records: &[Record]) {
    section(&format!("records ({})", records.len()));
    for record in records {
        println!("  #{} @ offset {}", record.index(), record.offset());
        subfield("subtype", escape_inline(record.subtype()));
        subfield("name", escape_inline(record.name()));
        let profile = record.profile();
        subfield(
            "profile",
            format!(
                "encoding={:?} encryption={:?} compression={:?}",
                profile.encoding, profile.encryption, profile.compression
            ),
        );
        subfield(
            "compressed",
            format!(
                "{} (compressed_size={}, uncompressed_size={})",
                record.compressed(),
                record.compressed_size(),
                record.uncompressed_size()
            ),
        );
        subfield(
            "checksum",
            format!(
                "{:#010x} ({})",
                record.checksum(),
                if record.checksum_valid() {
                    "valid"
                } else {
                    "invalid"
                }
            ),
        );
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                record.creation_time(),
                record.last_write_time()
            ),
        );
        subfield(
            "data sizes",
            format!(
                "encrypted={} decrypted={} decompressed={} payload={}",
                record.encrypted_data().len(),
                record.decrypted_data().len(),
                record
                    .decompressed_data()
                    .map_or_else(|| "none".to_string(), |data| data.len().to_string()),
                record.payload_data().len()
            ),
        );
        subfield(
            "decompression",
            format!("{:?}", record.decompression_status()),
        );
    }
}

Trait Implementations

impl Clone for Record

fn clone(&self) -> Record

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Record

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Record

impl PartialEq for Record

fn eq(&self, other: &Record) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Record