EBML: Write support for \Segment children

Author: Serial-ATA

lofty/src/ebml/tag/mod.rs

@@ -21,10 +21,11 @@ use crate::io::{FileLike, Length, Truncate};
 use crate::picture::Picture;
 use crate::tag::companion_tag::CompanionTag;
 use crate::tag::{Accessor, MergeTag, SplitTag, TagExt, TagType};
+use crate::ebml::tag::write::{ElementWriterCtx, WriteableElement};
 
 use std::borrow::Cow;
 use std::collections::HashMap;
-use std::io::Write;
+use std::io::{Cursor, Write};
 use std::ops::Deref;
 
 use lofty_attr::tag;
@@ -356,23 +357,23 @@ impl TagExt for MatroskaTag {
 
 	fn save_to<F>(
 		&self,
-		_file: &mut F,
-		_write_options: WriteOptions,
+		file: &mut F,
+		write_options: WriteOptions,
 	) -> std::result::Result<(), Self::Err>
 	where
 		F: FileLike,
 		LoftyError: From<<F as Truncate>::Error>,
 		LoftyError: From<<F as Length>::Error>,
 	{
-		todo!()
+		MatroskaTagRef::from(self).write_to(file, write_options)
 	}
 
 	fn dump_to<W: Write>(
 		&self,
-		_writer: &mut W,
-		_write_options: WriteOptions,
+		writer: &mut W,
+		write_options: WriteOptions,
 	) -> std::result::Result<(), Self::Err> {
-		todo!()
+		MatroskaTagRef::from(self).dump_to(writer, write_options)
 	}
 
 	fn clear(&mut self) {
@@ -440,51 +441,64 @@ impl From<crate::tag::Tag> for MatroskaTag {
 	}
 }
 
-pub(crate) struct MatroskaTagRef<'a, I>
-where
-	I: Iterator<Item = TagRef<'a>>,
+pub(crate) struct MatroskaTagRef<'a>
 {
-	pub(crate) tags: I,
+	pub(crate) tags: Vec<TagRef<'a>>,
 }
 
-pub(crate) fn simple_tags_for_tag(tag: &crate::tag::Tag) -> impl Iterator<Item = TagRef<'static>> {
-	let mut mapped_tags: HashMap<TargetType, Vec<Cow<'static, SimpleTag<'static>>>> =
-		HashMap::new();
-	for item in &tag.items {
-		if let Some((simple_tag, target_type)) = generic::simple_tag_for_item(Cow::Borrowed(item)) {
-			mapped_tags
-				.entry(target_type)
-				.or_default()
-				.push(Cow::Owned(simple_tag))
+impl<'a> From<&'a MatroskaTag> for MatroskaTagRef<'a> {
+	fn from(value: &'a MatroskaTag) -> Self {
+		Self {
+			tags: value.tags.iter().map(Into::into).collect::<Vec<_>>()
 		}
 	}
+}
 
-	mapped_tags
-		.into_iter()
-		.map(|(target_type, simple_tags)| TagRef {
-			targets: TargetDescriptor::Basic(target_type),
-			simple_tags: Box::new(simple_tags.into_iter()),
-		})
+impl<'a> From<&'a crate::tag::Tag> for MatroskaTagRef<'static> {
+	fn from(value: &'a crate::tag::Tag) -> Self {
+		let mut mapped_tags: HashMap<TargetType, Vec<Cow<'static, SimpleTag<'static>>>> =
+			HashMap::new();
+		for item in &value.items {
+			if let Some((simple_tag, target_type)) = generic::simple_tag_for_item(Cow::Borrowed(item)) {
+				mapped_tags
+					.entry(target_type)
+					.or_default()
+					.push(Cow::Owned(simple_tag))
+			}
+		}
+
+		let tags = mapped_tags
+			.into_iter()
+			.map(|(target_type, simple_tags)| TagRef {
+				targets: TargetDescriptor::Basic(target_type),
+				simple_tags,
+			}).collect::<Vec<_>>();
+
+		Self {
+			tags
+		}
+	}
 }
 
-impl<'a, I> MatroskaTagRef<'a, I>
-where
-	I: Iterator<Item = TagRef<'a>>,
+impl<'a> MatroskaTagRef<'a>
 {
-	pub(crate) fn write_to<F>(&mut self, _file: &mut F, _write_options: WriteOptions) -> Result<()>
+	pub(crate) fn write_to<F>(&mut self, file: &mut F, write_options: WriteOptions) -> Result<()>
 	where
 		F: FileLike,
 		LoftyError: From<<F as Truncate>::Error>,
 		LoftyError: From<<F as Length>::Error>,
 	{
-		todo!("Writing matroska tags")
+		write::write_to(file, self, write_options)
 	}
 
 	pub(crate) fn dump_to<W: Write>(
 		&self,
-		_writer: &mut W,
+		writer: &mut W,
 		_write_options: WriteOptions,
 	) -> Result<()> {
-		todo!("Dumping matroska tags")
+		let mut buf = Cursor::new(Vec::new());
+		self.write_element(ElementWriterCtx::default(), &mut buf)?;
+		writer.write_all(&buf.into_inner())?;
+		Ok(())
 	}
 }

lofty/src/ebml/tag/tag.rs

@@ -122,7 +122,16 @@ impl Tag<'static> {
 	}
 }
 
+impl<'a> From<&'a Tag<'a>> for TagRef<'a> {
+	fn from(tag: &'a Tag<'a>) -> Self {
+		Self {
+			targets: tag.target.as_ref().map(Into::into).unwrap_or_default(),
+			simple_tags: tag.simple_tags.iter().map(Cow::Borrowed).collect(),
+		}
+	}
+}
+
 pub(crate) struct TagRef<'a> {
 	pub(crate) targets: TargetDescriptor<'a>,
-	pub(crate) simple_tags: Box<dyn Iterator<Item = Cow<'a, SimpleTag<'a>>>>,
+	pub(crate) simple_tags: Vec<Cow<'a, SimpleTag<'a>>>,
 }

lofty/src/ebml/tag/target.rs

@@ -158,6 +158,12 @@ impl TargetDescriptor<'_> {
 	}
 }
 
+impl Default for TargetDescriptor<'_> {
+	fn default() -> Self {
+		TargetDescriptor::Basic(TargetType::default())
+	}
+}
+
 impl<'a> From<&'a Target> for TargetDescriptor<'a> {
 	fn from(target: &'a Target) -> Self {
 		if !target.has_uids() {

lofty/src/ebml/tag/write/elements/attached_file.rs

@@ -11,6 +11,7 @@ const FileReferral_ID: ElementId = ElementId(0x4675);
 const FileUsedStartTime_ID: ElementId = ElementId(0x4661);
 const FileUsedEndTime_ID: ElementId = ElementId(0x4662);
 
+// Segment\Attachments\AttachedFile
 impl WriteableElement for AttachedFile<'_> {
 	const ID: ElementId = ElementId(0x61A7);
 

lofty/src/ebml/tag/write/elements/mod.rs

@@ -4,3 +4,4 @@ pub(super) mod attached_file;
 pub(super) mod simple_tag;
 pub(super) mod tags;
 pub(super) mod target;
+mod tag;

lofty/src/ebml/tag/write/elements/simple_tag.rs

@@ -9,6 +9,7 @@ const TagDefault_ID: ElementId = ElementId(0x4484);
 const TagString_ID: ElementId = ElementId(0x4487);
 const TagBinary_ID: ElementId = ElementId(0x4485);
 
+// Segment\Tags\Tag\SimpleTag
 impl WriteableElement for SimpleTag<'_> {
 	const ID: ElementId = ElementId(0x67C8);
 

lofty/src/ebml/tag/write/elements/tag.rs

@@ -0,0 +1,32 @@
+use crate::ebml::tag::write::{ElementWriterCtx, WriteableElement, write_element};
+use crate::ebml::{ElementId, TagRef};
+use crate::io::FileLike;
+
+use std::io::Cursor;
+
+// Segment\Tags\Tag
+impl WriteableElement for TagRef<'_> {
+	const ID: ElementId = ElementId(0x7373);
+
+	fn write_element<F: FileLike>(
+		&self,
+		ctx: ElementWriterCtx,
+		writer: &mut F,
+	) -> crate::error::Result<()> {
+		let mut element_children = Cursor::new(Vec::new());
+		self.targets.write_element(ctx, &mut element_children)?;
+
+		for simple_tag in &self.simple_tags {
+			simple_tag.write_element(ctx, &mut element_children)?;
+		}
+
+		write_element(
+			ctx,
+			Self::ID,
+			&element_children.get_ref().as_slice(),
+			writer,
+		)?;
+
+		Ok(())
+	}
+}

lofty/src/ebml/tag/write/elements/tags.rs

@@ -1,24 +1,23 @@
-use crate::ebml::tag::write::{ElementWriterCtx, WriteableElement, write_element};
-use crate::ebml::{ElementId, TagRef};
+use crate::ebml::tag::write::{write_element, ElementWriterCtx, WriteableElement};
+use crate::ebml::{ElementId, MatroskaTagRef};
 use crate::io::FileLike;
 
 use std::io::Cursor;
 
-impl WriteableElement for TagRef<'_> {
-	const ID: ElementId = ElementId(0x7373);
+// Segment\Tags
+impl<'a> WriteableElement for MatroskaTagRef<'a>
+{
+	const ID: ElementId = ElementId(0x1254_C367);
 
 	fn write_element<F: FileLike>(
 		&self,
 		ctx: ElementWriterCtx,
 		writer: &mut F,
 	) -> crate::error::Result<()> {
 		let mut element_children = Cursor::new(Vec::new());
-		self.targets.write_element(ctx, &mut element_children)?;
-
-		// TODO
-		// for simple_tag in self.simple_tags {
-		// 	simple_tag.write_element(ctx, &mut element_children)?;
-		// }
+		for tag in &self.tags {
+			tag.write_element(ctx, &mut element_children)?;
+		}
 
 		write_element(
 			ctx,

lofty/src/ebml/tag/write/elements/target.rs

@@ -9,6 +9,7 @@ const TagEditionUID_ID: ElementId = ElementId(0x63C9);
 const TagChapterUID_ID: ElementId = ElementId(0x63C4);
 const TagAttachmentUID_ID: ElementId = ElementId(0x63C6);
 
+// Segment\Tags\Tag\Targets
 impl WriteableElement for TargetDescriptor<'_> {
 	const ID: ElementId = ElementId(0x63C0);
 
@@ -93,10 +94,7 @@ mod tests {
 		let target_descriptor = TargetDescriptor::from(&target);
 		target_descriptor
 			.write_element(
-				ElementWriterCtx {
-					max_id_len: 4,
-					max_size_len: 8,
-				},
+				ElementWriterCtx::default(),
 				&mut buf,
 			)
 			.unwrap();

lofty/src/ebml/tag/write/mod.rs

@@ -3,7 +3,10 @@ mod type_encodings;
 
 use crate::ebml::{ElementId, VInt};
 use crate::error::Result;
-use crate::io::FileLike;
+use super::MatroskaTagRef;
+use crate::config::WriteOptions;
+use crate::error::LoftyError;
+use crate::io::{FileLike, Truncate};
 
 use std::io::Write;
 
@@ -15,6 +18,15 @@ pub(crate) struct ElementWriterCtx {
 	pub(crate) max_size_len: u8,
 }
 
+impl Default for ElementWriterCtx {
+	fn default() -> Self {
+		Self {
+			max_id_len: 4,
+			max_size_len: 8,
+		}
+	}
+}
+
 pub(crate) trait EbmlWriteExt: Write + Sized {
 	fn write_id(&mut self, ctx: ElementWriterCtx, id: ElementId) -> Result<()> {
 		id.write_to(Some(ctx.max_id_len), self)?;
@@ -46,3 +58,15 @@ pub(crate) fn write_element<W: Write, E: ElementEncodable>(
 
 	Ok(())
 }
+
+pub(crate) fn write_to<'a, F>(
+	_file: &mut F,
+	_tag_ref: &mut MatroskaTagRef<'a>,
+	_write_options: WriteOptions,
+) -> Result<()>
+where
+	F: FileLike,
+	LoftyError: From<<F as Truncate>::Error>,
+{
+	todo!("Writing Segment\\Tags")
+}