Struct nt_hive2::Cell

pub struct Cell<T, A: Any + Copy>
where
    T: BinRead<Args = A>,
{ /* private fields */ }

A Cell represents the most basic data structure of hive files. Nearly every other data is stored as content of a Cell.

As Cell is a generic, it receives two generic arguments:

• T denotes the type contained in the Cell
• A specifies the arguments required by binread to correctly parse an object of type T

Usage

If you know what kind of data should be stored in a certain Cell, you can simply read it. Assume you have Cell which should contain a KeyNode, you can read it as follows:

use nt_hive2::*;
use std::io::{Seek, SeekFrom};
use binread::BinReaderExt;

hive.seek(SeekFrom::Start(offset.0.into()))?;
let cell: Cell<KeyNodeWithMagic, ()> = hive.read_le().unwrap();
let my_node: KeyNode = {
    let knwm: KeyNodeWithMagic = cell.into();
    knwm.into()
};

For conveniance reasons, Hive already presents the method read_structure, which does basically the same.

Implementations

impl<T, A> Cell<T, A>

where T: BinRead<Args = A>, A: Any + Copy,

pub fn is_deleted(&self) -> bool

returns true iff the Cell is considered as being deleted

pub fn is_allocated(&self) -> bool

returns true iff the Cell is considered as being allocated. This is a conveniance function which simply calls is_deleted and negates the result.

pub fn data(&self) -> &T

returns a reference to the contained data structure

Trait Implementations

impl<T, A: Any + Copy> BinRead for Cell<T, A>

where T: BinRead<Args = A>,

type Args = A

The type of arguments needed to be supplied in order to read this type, usually a tuple.

fn read_options<R: Read + Seek>( __binread_generated_var_reader: &mut R, __binread_generated_var_options: &ReadOptions, __binread_generated_var_arguments: Self::Args ) -> BinResult<Self>

Read the type from the reader

fn read<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek,

Read the type from the reader while assuming no arguments have been passed

fn read_args<R>(reader: &mut R, args: Self::Args) -> Result<Self, Error>

where R: Read + Seek,

Read the type from the reader using the specified arguments

fn after_parse<R>( &mut self, _: &mut R, _: &ReadOptions, _: Self::Args ) -> Result<(), Error>

where R: Read + Seek,

fn args_default() -> Option<Self::Args>

The default arguments to be used when using the read shortcut method. Override this for any type that optionally requries arguments

impl<T, A: Debug + Any + Copy> Debug for Cell<T, A>

where T: BinRead<Args = A> + Debug,

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

Formats the value using the given formatter.

impl From<Cell<KeyNodeWithMagic, ()>> for KeyNodeWithMagic

fn from(cell: Cell<KeyNodeWithMagic, ()>) -> Self

Converts to this type from the input type.

impl From<Cell<KeyValueWithMagic, ()>> for KeyValue

fn from(cell: Cell<KeyValueWithMagic, ()>) -> Self

Converts to this type from the input type.

impl<T, A: PartialEq + Any + Copy> PartialEq for Cell<T, A>

where T: BinRead<Args = A> + PartialEq,

fn eq(&self, other: &Cell<T, A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, A: Eq + Any + Copy> Eq for Cell<T, A>

where T: BinRead<Args = A> + Eq,

impl<T, A: Any + Copy> StructuralPartialEq for Cell<T, A>

where T: BinRead<Args = A>,