ipld-car 0.1.0

use bytes::Bytes;
use libipld::{
	pb::{PbLink, PbNode},
	Cid,
};
use prost::Message;

// This file is @generated by prost-build.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Data {
	#[prost(enumeration = "data::DataType", required, tag = "1")]
	pub r#type: i32,
	#[prost(bytes = "vec", optional, tag = "2")]
	pub data: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
	#[prost(uint64, optional, tag = "3")]
	pub filesize: ::core::option::Option<u64>,
	#[prost(uint64, repeated, packed = "false", tag = "4")]
	pub blocksizes: ::prost::alloc::vec::Vec<u64>,
	#[prost(uint64, optional, tag = "5")]
	pub hash_type: ::core::option::Option<u64>,
	#[prost(uint64, optional, tag = "6")]
	pub fanout: ::core::option::Option<u64>,
	#[prost(uint32, optional, tag = "7")]
	pub mode: ::core::option::Option<u32>,
	#[prost(message, optional, tag = "8")]
	pub mtime: ::core::option::Option<UnixTime>,
}

impl Data {
	pub fn new_directory() -> Self {
		Self::new(data::DataType::Directory, None, vec![], None)
	}

	pub fn new_symlink<P: Into<Vec<u8>>>(path: P) -> Self {
		let data = Some(path.into());
		Self::new(data::DataType::Symlink, None, vec![], data)
	}

	pub fn new_file(blocksizes: Vec<u64>) -> Self {
		let filesize = blocksizes.iter().sum();
		Self::new(data::DataType::File, Some(filesize), blocksizes, None)
	}

	pub fn new_file_with_data(data: Vec<u8>) -> Self {
		let filesize = data.len() as u64;
		let data = if data.is_empty() { None } else { Some(data) };
		Self::new(data::DataType::File, Some(filesize), vec![], data)
	}

	fn new(r#type: data::DataType, filesize: Option<u64>, blocksizes: Vec<u64>, data: Option<Vec<u8>>) -> Self {
		Self {
			r#type: r#type as i32,
			data,
			filesize,
			blocksizes,
			hash_type: None,
			fanout: None,
			mode: None,
			mtime: None,
		}
	}
}

impl From<Data> for Bytes {
	fn from(d: Data) -> Self {
		Bytes::from(d.encode_to_vec())
	}
}

/// Nested message and enum types in `Data`.
pub mod data {
	#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
	#[repr(i32)]
	pub enum DataType {
		Raw = 0,
		Directory = 1,
		File = 2,
		Metadata = 3,
		Symlink = 4,
		HamtShard = 5,
	}
	impl DataType {
		/// String value of the enum field names used in the ProtoBuf definition.
		///
		/// The values are not transformed in any way and thus are considered stable
		/// (if the ProtoBuf definition does not change) and safe for programmatic use.
		pub fn as_str_name(&self) -> &'static str {
			match self {
				Self::Raw => "Raw",
				Self::Directory => "Directory",
				Self::File => "File",
				Self::Metadata => "Metadata",
				Self::Symlink => "Symlink",
				Self::HamtShard => "HAMTShard",
			}
		}
		/// Creates an enum from field names used in the ProtoBuf definition.
		pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
			match value {
				"Raw" => Some(Self::Raw),
				"Directory" => Some(Self::Directory),
				"File" => Some(Self::File),
				"Metadata" => Some(Self::Metadata),
				"Symlink" => Some(Self::Symlink),
				"HAMTShard" => Some(Self::HamtShard),
				_ => None,
			}
		}
	}
}

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Metadata {
	#[prost(string, optional, tag = "1")]
	pub mime_type: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct UnixTime {
	#[prost(uint64, required, tag = "1")]
	pub seconds: u64,
	#[prost(fixed32, optional, tag = "2")]
	pub fractional_nanoseconds: ::core::option::Option<u32>,
}

pub fn new_pb_node<D>(links: Vec<PbLink>, data: D) -> PbNode
where
	D: Into<Option<Bytes>>,
{
	PbNode { links, data: data.into() }
}

pub fn new_pb_link<N, S>(cid: Cid, name: N, size: S) -> PbLink
where
	N: Into<Option<String>>,
	S: Into<Option<u64>>,
{
	PbLink { cid, name: name.into(), size: size.into() }
}