Enum CarHeader 

pub enum CarHeader {
    V1(CarHeaderV1),
    V2(),
}

Variants

V1(CarHeaderV1)

V2()

Implementations

impl CarHeader

pub fn new_v1(roots: Vec<Cid>) -> Self

pub fn roots(&self) -> Vec<Cid>

Examples found in repository

examples/extract.rs (line 17)

fn main() {
    let file_name = std::env::args().nth(1);
    let path = file_name.as_ref().map(|f| f.into()).unwrap_or_else(|| {
        let file = std::path::Path::new("test");
        file.join("carv1-basic.car")
    });
    let file = std::fs::File::open(path).unwrap();
    let mut reader = reader::new_v1(file).unwrap();
    let roots = reader.header().roots();
    for r in roots.iter() {
        extract_ipld_to_current_path(&mut reader, *r).unwrap();
    }
}

examples/cat_cid.rs (line 19)

fn main() {
    // let cid = std::env::args().nth(1).expect("use cid as argument");
    let cid = "bafkreiaqv66m5nd6mwgkk7h5lwqnjzj54s4f7knmnrjhb7ylzqfg2vdo54";
    let file = std::path::Path::new("test");
    let file = file.join("carv1-basic.car");
    let file = std::fs::File::open(file).unwrap();
    let mut reader = reader::new_v1(file).unwrap();
    let roots = reader.header().roots();
    let file_cid = Cid::try_from(cid).expect("cid format error");
    for r in roots.iter() {
        let root_ipld = reader.ipld(r).unwrap();
        let root: Result<UnixFs, CarError> = root_ipld.try_into();
        let root_dir = root.unwrap();
        let count = root_dir
            .links()
            .iter()
            .filter(|u| u.hash() == file_cid)
            .count();
        if count > 0 {
            cat_ipld(&mut reader, file_cid).unwrap();
        }
    }
}

pub fn read_header<R>(r: R) -> Result<CarHeader, CarError>

where R: Read + Seek,

pub fn decode(buf: &[u8]) -> Result<CarHeader, CarError>

pub fn encode(&self) -> Result<Vec<u8>, CarError>

Trait Implementations

impl Clone for CarHeader

fn clone(&self) -> CarHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CarHeader

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

Formats the value using the given formatter.