ipld-car 0.1.0

DAG-PB serialization/deserialization library for IPFS CAR v1 archives
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

use crate::{
	bounded_reader::{
		sync::BoundedReader,
		traits::{Bounded, CloneAndRewind},
	},
	dag_pb::{DagPb, DagPbType},
	traits::ContextLen,
};

use derivative::Derivative;
use libipld::Cid;

#[derive(Derivative, derive_more::Debug)]
#[derivative(Clone(bound = ""))]
pub enum BlockType<T> {
	Raw,
	DagPb(DagPb<T>),
}

#[derive(Derivative, derive_more::Debug)]
#[derivative(Clone(bound = ""))]
pub struct Block<T> {
	pub cid: Cid,
	pub r#type: BlockType<T>,
	pub data: BoundedReader<T>,
}

impl<T> Block<T> {
	pub fn new_raw<D>(cid: Cid, data: D) -> Self
	where
		D: Into<BoundedReader<T>>,
	{
		Self { cid, data: data.into(), r#type: BlockType::Raw }
	}

	pub fn new_dag_pb<PB, D>(cid: Cid, dag_pb: PB, data: D) -> Self
	where
		D: Into<BoundedReader<T>>,
		PB: Into<DagPb<T>>,
	{
		Self { cid, data: data.into(), r#type: BlockType::DagPb(dag_pb.into()) }
	}

	pub fn dag_pb_type(&self) -> Option<&DagPbType> {
		match &self.r#type {
			BlockType::Raw => None,
			BlockType::DagPb(dag) => Some(&dag.r#type),
		}
	}

	pub fn as_sfb_data(&self) -> Option<BoundedReader<T>> {
		match &self.r#type {
			BlockType::Raw => Some(self.data.clone_and_rewind()),
			BlockType::DagPb(dag) => dag.as_sfb_data(),
		}
	}
}

impl<T> ContextLen for Block<T> {
	fn data_len(&self) -> u64 {
		match &self.r#type {
			BlockType::Raw => self.data.bound_len(),
			BlockType::DagPb(dag_pb) => dag_pb.data_len(),
		}
	}

	fn pb_data_len(&self) -> u64 {
		match &self.r#type {
			BlockType::Raw => self.data.bound_len(),
			BlockType::DagPb(dag_pb) => dag_pb.data.bound_len() + self.data.bound_len(),
		}
	}
}