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 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: PartialEq, A: PartialEq + Any + Copy> PartialEq<Cell<T, A>> for Cell<T, A> where
    T: BinRead<Args = A>, 

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: &Cell<T, A>) -> bool

This method tests for !=.

impl<T: Eq, A: Eq + Any + Copy> Eq for Cell<T, A> where
    T: BinRead<Args = A>, 

impl<T, A: Any + Copy> StructuralEq for Cell<T, A> where
    T: BinRead<Args = A>, 

impl<T, A: Any + Copy> StructuralPartialEq for Cell<T, A> where
    T: BinRead<Args = A>,