use super::base::*;

impl Serializer for PrettySerializer {
	type Error;

	type SerializeDict: SerializeDictBase;
	type SerializeList: SerializeListBase;
	type SerializeMultilineText: SerializeMultilineTextBase;

	#[inline]
	fn serialize_real_u8(self, real: u8) -> Result<(), Self::Error> {
		self.base.serialize_real_u8(real)
	}
	fn serialize_real_u16(self, real: u16) -> Result<(), Self::Error> {
		self.base.serialize_real_u8(real)
	}
	fn serialize_real_u32(self, real: u32) -> Result<(), Self::Error> {
		self.base.serialize_real_u8(real)
	}
	fn serialize_real_u64(self, real: u64) -> Result<(), Self::Error> {
		self.base.serialize_real_u8(real)
	}

	fn serialize_real_i8(self, real: i8) -> Result<(), Self::Error> {
		self.base.serialize_real_u8(real)
	}
	fn serialize_real_i16(self, real: i16) -> Result<(), Self::Error> {
		self.base.serialize_real_u8(real)
	}
	fn serialize_real_i32(self, real: i32) -> Result<(), Self::Error> {
		self.base.serialize_real_u8(real)
	}
	fn serialize_real_i64(self, real: i64) -> Result<(), Self::Error> {
		self.base.serialize_real_i64(real)
	}
	fn serialize_real_f32(self, real: f32) -> Result<(), Self::Error> {
		self.base.serialize_real_f32(real)
	}
	fn serialize_real_f64(self, real: f64) -> Result<(), Self::Error> {
		self.base.serialize_real_f64(real)
	}

	fn serialize_atom<'a>(self, atom: &'a str) -> Result<(), Self::Error>;
	fn serialize_text<'a>(self, text: &'a str) -> Result<(), Self::Error>;

	fn serialize_multiline_text<'a, M>(self, lines: M) -> Result<(), Self::Error>
		where M: IntoIterator<Item = &'a str>;

	fn serialize_unit<'a, V>(self, name: &'a str, value: V) -> Result<(), Self::Error>
		where V: Serialize;

	fn serialize_list_parts(self) -> Result<Self::SerializeList, Self::Error>;
	fn serialize_dict_parts(self) -> Result<Self::SerializeDict, Self::Error>;
	fn serialize_multiline_text_parts(self) -> Result<Self::SerializeMultilineText, Self::Error>;

	fn serialize_list<V, L>(self, list: L) -> Result<(), Self::Error>
	where
		V: Serialize,
		L: IntoIterator<Item = V>;

	fn serialize_dict<K, V, D>(self, dict: D) -> Result<(), Self::Error>
	where
		K: Serialize,
		V: Serialize,
		D: IntoIterator<Item = (K, V)>;
}