src/fonts/font_info/src/lib.rs - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 mod sources;
 mod vmo_stream;

 use {
     anyhow::{format_err, Error},
     byteorder::{BigEndian, ReadBytesExt},
     char_set::CharSet,
     freetype_ffi::{
         FT_Add_Default_Modules, FT_Done_Face, FT_Done_Library, FT_Err_Ok, FT_Face,
         FT_Get_First_Char, FT_Get_Next_Char, FT_Get_Postscript_Name, FT_Get_Sfnt_Name,
         FT_Get_Sfnt_Name_Count, FT_Library, FT_New_Library, FT_Open_Face, FT_SfntName, FT_MEMORY,
         TT_MS_ID_SYMBOL_CS, TT_MS_ID_UNICODE_CS, TT_MS_LANGID_ENGLISH_UNITED_STATES,
         TT_NAME_ID_FULL_NAME, TT_PLATFORM_MICROSOFT,
     },
     std::{ffi::CStr, io::Cursor, ops::Range, ptr},
 };

 pub use crate::sources::FTOpenArgs;
 pub use crate::sources::FontAssetSource;

 /// Contains information parsed from a font file.
 #[derive(Default, Clone, Debug, Eq, PartialEq)]
 pub struct FontInfo {
     pub char_set: CharSet,
     /// The "Postscript name" of the font face.
     pub postscript_name: Option<String>,
     /// The user-friendly "full name" of the font face.
     pub full_name: Option<String>,
 }

 /// An object that can load a `FontInfo` from a `FontAssetSource`.
 ///
 /// Separate from the [implementation][`FontInfoLoaderImpl`] to allow easier mocking for tests.
 pub trait FontInfoLoader {
     /// Load information about a font from the given file source, located at the given index within
     /// the file.
     ///
     /// `S` is any type for which a conversion is defined into `FT_Open_Args`. In practice,
     /// this must be either a something that contains an `FT_Stream`, or a file path.
     ///
     /// For simplicity, use [crates::sources::FontAssetSource].
     fn load_font_info<S, E>(&self, source: S, index: u32) -> Result<FontInfo, Error>
     where
         S: TryInto<FontAssetSource, Error = E>,
         E: Sync + Send + Into<Error>;
 }

 /// Reads information from font files using the FreeType library.
 ///
 /// This class is tested in `../tests/tests.rs`.
 #[derive(Debug)]
 pub struct FontInfoLoaderImpl {
     library: FTLibrary,
 }

 impl FontInfoLoaderImpl {
     pub fn new() -> Result<FontInfoLoaderImpl, Error> {
         let library = FTLibrary::new()?;
         Ok(Self { library })
     }

     pub fn load_font_info<S, E>(&self, source: S, index: u32) -> Result<FontInfo, Error>
     where
         S: TryInto<FontAssetSource, Error = E>,
         E: Sync + Send + Into<Error>,
     {
         let source: FontAssetSource = source.try_into().map_err(|e| e.into())?;
         let open_args: FTOpenArgs = source.try_into()?;

         let face = self.library.open_face(open_args, index)?;
         let code_points = face.code_points().collect();
         let postscript_name = face.postscript_name().ok().filter(|x| !x.is_empty());
         let full_name = face.full_name()?.filter(|x| !x.is_empty());

         Ok(FontInfo { char_set: CharSet::new(code_points), postscript_name, full_name })
     }
 }

 impl FontInfoLoader for FontInfoLoaderImpl {
     fn load_font_info<S, E>(&self, source: S, index: u32) -> Result<FontInfo, Error>
     where
         S: TryInto<FontAssetSource, Error = E>,
         E: Sync + Send + Into<Error>,
     {
         FontInfoLoaderImpl::load_font_info(&self, source, index)
     }
 }

 #[derive(Debug)]
 struct FTLibrary {
     ft_library: FT_Library,
 }

 /// Rusty wrapper around `FT_Library`.
 impl FTLibrary {
     pub fn new() -> Result<FTLibrary, Error> {
         // Unsafe to call FreeType FFI. On success, stores the `FT_Library` pointer in `FTLibrary`,
         // which calls `FT_Done_Library` in `drop()`.
         unsafe {
             let mut ft_library = ptr::null_mut();
             if FT_New_Library(&FT_MEMORY, &mut ft_library) != FT_Err_Ok {
                 return Err(format_err!("Failed to initialize FreeType library."));
             }
             FT_Add_Default_Modules(ft_library);
             Ok(FTLibrary { ft_library })
         }
     }

     /// Opens the font file with the given `open_args` and reads the face at the given index.
     pub fn open_face(&self, open_args: FTOpenArgs, index: u32) -> Result<FTFace, Error> {
         // Unsafe to call FreeType FFI. On success stores the `FT_Face` pointer in `FTFace`, which
         // calls `FT_Done_Face` in `drop()`.
         unsafe {
             let mut ft_face: FT_Face = ptr::null_mut();
             let err = FT_Open_Face(self.ft_library, open_args.as_ref(), index as i64, &mut ft_face);

             if err != FT_Err_Ok {
                 return Err(format_err!(
                     "Failed to parse font {} from {:?}: FreeType error {}",
                     index,
                     open_args.source,
                     err
                 ));
             }

             Ok(FTFace { ft_face, open_args })
         }
     }
 }

 impl std::ops::Drop for FTLibrary {
     fn drop(&mut self) {
         // Unsafe to call FreeType FFI.
         // This is required in order to clean up the FreeType library instance.
         unsafe {
             FT_Done_Library(self.ft_library);
         }
     }
 }

 /// Wrapper around the native `FT_Face`, providing a more Rusty API and retaining some structs that
 /// need to stay alive in memory.
 struct FTFace {
     ft_face: FT_Face,

     /// Retains the stream or file path that backs the `FT_Face`.
     #[allow(dead_code)]
     open_args: FTOpenArgs,
 }

 impl FTFace {
     /// Returns an iterator over the code points (as `u32`s) covered by this font face.
     pub fn code_points<'f>(&'f self) -> CodePointsIterator<'f> {
         CodePointsIterator { face: self, state: CodePointsIteratorState::Uninitialized }
     }

     /// Returns the face's Postscript name.
     pub fn postscript_name(&self) -> Result<String, Error> {
         // Unsafe to call FreeType FFI.
         let postscript_name = unsafe {
             // According to the FT docs, this is supposed to be an ASCII string, so it should
             // trivially convert to UTF-8.
             //
             // Note: Must use c_char, not i8 or u8, because c_char's definition depends on the
             // architecture.
             let postscript_name =
                 FT_Get_Postscript_Name(self.ft_face) as *const std::os::raw::c_char;
             let postscript_name = CStr::from_ptr(postscript_name);
             postscript_name
                 .to_str()
                 .map_err(|e| format_err!("Failed to decode Postscript name. Error: {:?}", e))?
                 .to_string()
         };
         Ok(postscript_name)
     }

     /// Returns the face's "full name", if present.
     pub fn full_name(&self) -> Result<Option<String>, Error> {
         self.get_name(TT_NAME_ID_FULL_NAME)
     }

     /// Finds and decodes the first supported name entry that has the given name ID.
     ///
     /// A "name ID" is a record identifier in the `name` TrueType table, which can also contain
     /// items like copyright info, URLs, etc. See
     /// https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids.
     fn get_name(&self, name_id: u16) -> Result<Option<String>, Error> {
         for name_entry in self.sfnt_names() {
             let name_entry = name_entry?;
             if let Some(name) = FTFace::decode_name_if_matches(&name_entry, name_id)? {
                 return Ok(Some(name));
             }
         }
         Ok(None)
     }

     fn sfnt_name_count(&self) -> u32 {
         unsafe { FT_Get_Sfnt_Name_Count(self.ft_face) }
     }

     fn sfnt_names<'a>(&'a self) -> SfntNamesIterator<'a> {
         SfntNamesIterator { face: self, iter: 0..self.sfnt_name_count() }
     }

     /// If the given `FT_SfntName` contains the requested `name_id` and the encoding is in a
     /// supported format, returns the decoded name string. Otherwise, returns `None`.
     ///
     /// Presently, this only looks at en-US name entries.
     fn decode_name_if_matches(
         name_entry: &FT_SfntName,
         name_id: u16,
     ) -> Result<Option<String>, Error> {
         if name_entry.name_id != name_id {
             return Ok(None);
         }
         match (name_entry.platform_id, name_entry.encoding_id, name_entry.language_id) {
             (TT_PLATFORM_MICROSOFT, TT_MS_ID_SYMBOL_CS, TT_MS_LANGID_ENGLISH_UNITED_STATES)
             | (TT_PLATFORM_MICROSOFT, TT_MS_ID_UNICODE_CS, TT_MS_LANGID_ENGLISH_UNITED_STATES) => {
                 let name = FTFace::decode_name_utf16_be(name_entry)?;
                 Ok(Some(name))
             }
             _ => Ok(None),
         }
     }

     /// Decodes the the given `FT_SfntName` as a UTF-16 Big Endian string.
     fn decode_name_utf16_be(name_entry: &FT_SfntName) -> Result<String, Error> {
         let as_u8 = unsafe {
             std::slice::from_raw_parts(name_entry.string, name_entry.string_len as usize)
         };
         // FT_SfntName.string_len is in bytes. One UTF-16 code unit is two bytes.
         let num_code_units = (name_entry.string_len / 2) as usize;
         let mut reader = Cursor::new(as_u8);
         let mut as_u16 = Vec::with_capacity(num_code_units);
         for _i in 0..num_code_units {
             let ch = reader.read_u16::<BigEndian>()?;
             as_u16.push(ch);
         }
         Ok(String::from_utf16(as_u16.as_slice())?)
     }
 }

 impl std::ops::Drop for FTFace {
     fn drop(&mut self) {
         // Unsafe to call FreeType FFI.
         // This is required in order to clean up the FreeType face instance.
         unsafe {
             FT_Done_Face(self.ft_face);
         }
     }
 }

 /// State of a [`CodePointsIterator`].
 #[derive(Debug, Copy, Clone)]
 enum CodePointsIteratorState {
     Uninitialized,
     /// Stores the previous code point returned.
     Active(u64),
     /// No more code points forthcoming.
     Fused,
 }

 /// Iterates over the code points (as `u32`s) in an `FTFace`.
 pub struct CodePointsIterator<'f> {
     face: &'f FTFace,
     state: CodePointsIteratorState,
 }

 impl<'f> CodePointsIterator<'f> {
     fn next_internal(&mut self, prev_code_point: Option<u64>) -> Option<u32> {
         let mut glyph_index: u32 = 0;
         // Unsafe to call FreeType FFI. Enumerate character map with FT_Get_First_Char() and
         // FT_Get_Next_Char().
         let code_point = unsafe {
             match prev_code_point {
                 Some(prev_code_point) => {
                     FT_Get_Next_Char(self.face.ft_face, prev_code_point, &mut glyph_index)
                 }
                 None => FT_Get_First_Char(self.face.ft_face, &mut glyph_index),
             }
         };
         // Per the FreeType docs, the glyph index will always be zero after the last code point in
         // the face is returned.
         if glyph_index > 0 {
             self.state = CodePointsIteratorState::Active(code_point);
             Some(code_point as u32)
         } else {
             self.state = CodePointsIteratorState::Fused;
             None
         }
     }
 }

 impl<'f> std::iter::Iterator for CodePointsIterator<'f> {
     type Item = u32;

     fn next(&mut self) -> Option<Self::Item> {
         match self.state.clone() {
             CodePointsIteratorState::Uninitialized => self.next_internal(None),
             CodePointsIteratorState::Active(prev_code_point) => {
                 self.next_internal(Some(prev_code_point))
             }
             CodePointsIteratorState::Fused => None,
         }
     }
 }

 impl<'f> std::iter::FusedIterator for CodePointsIterator<'f> {}

 /// Iterator over the `name` table in a font face.
 pub struct SfntNamesIterator<'f> {
     face: &'f FTFace,
     iter: Range<u32>,
 }

 impl<'f> SfntNamesIterator<'f> {
     fn get(&self, idx: u32) -> Result<FT_SfntName, Error> {
         let mut entry = FT_SfntName::default();
         let err_code = unsafe { FT_Get_Sfnt_Name(self.face.ft_face, idx, &mut entry) };
         if err_code == FT_Err_Ok {
             Ok(entry)
         } else {
             Err(format_err!("FreeType error while getting name {}: {}", idx, err_code))
         }
     }
 }

 impl<'f> Iterator for SfntNamesIterator<'f> {
     type Item = Result<FT_SfntName, Error>;

     fn next(&mut self) -> Option<Self::Item> {
         self.iter.next().map(|idx| self.get(idx))
     }
 }

 impl<'f> ExactSizeIterator for SfntNamesIterator<'f> {
     fn len(&self) -> usize {
         self.iter.len()
     }
 }
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	mod sources;
	mod vmo_stream;

	use {
	anyhow::{format_err, Error},
	byteorder::{BigEndian, ReadBytesExt},
	char_set::CharSet,
	freetype_ffi::{
	FT_Add_Default_Modules, FT_Done_Face, FT_Done_Library, FT_Err_Ok, FT_Face,
	FT_Get_First_Char, FT_Get_Next_Char, FT_Get_Postscript_Name, FT_Get_Sfnt_Name,
	FT_Get_Sfnt_Name_Count, FT_Library, FT_New_Library, FT_Open_Face, FT_SfntName, FT_MEMORY,
	TT_MS_ID_SYMBOL_CS, TT_MS_ID_UNICODE_CS, TT_MS_LANGID_ENGLISH_UNITED_STATES,
	TT_NAME_ID_FULL_NAME, TT_PLATFORM_MICROSOFT,
	},
	std::{ffi::CStr, io::Cursor, ops::Range, ptr},
	};

	pub use crate::sources::FTOpenArgs;
	pub use crate::sources::FontAssetSource;

	/// Contains information parsed from a font file.
	#[derive(Default, Clone, Debug, Eq, PartialEq)]
	pub struct FontInfo {
	pub char_set: CharSet,
	/// The "Postscript name" of the font face.
	pub postscript_name: Option<String>,
	/// The user-friendly "full name" of the font face.
	pub full_name: Option<String>,
	}

	/// An object that can load a `FontInfo` from a `FontAssetSource`.
	///
	/// Separate from the [implementation][`FontInfoLoaderImpl`] to allow easier mocking for tests.
	pub trait FontInfoLoader {
	/// Load information about a font from the given file source, located at the given index within
	/// the file.
	///
	/// `S` is any type for which a conversion is defined into `FT_Open_Args`. In practice,
	/// this must be either a something that contains an `FT_Stream`, or a file path.
	///
	/// For simplicity, use [crates::sources::FontAssetSource].
	fn load_font_info<S, E>(&self, source: S, index: u32) -> Result<FontInfo, Error>
	where
	S: TryInto<FontAssetSource, Error = E>,
	E: Sync + Send + Into<Error>;
	}

	/// Reads information from font files using the FreeType library.
	///
	/// This class is tested in `../tests/tests.rs`.
	#[derive(Debug)]
	pub struct FontInfoLoaderImpl {
	library: FTLibrary,
	}

	impl FontInfoLoaderImpl {
	pub fn new() -> Result<FontInfoLoaderImpl, Error> {
	let library = FTLibrary::new()?;
	Ok(Self { library })
	}

	pub fn load_font_info<S, E>(&self, source: S, index: u32) -> Result<FontInfo, Error>
	where
	S: TryInto<FontAssetSource, Error = E>,
	E: Sync + Send + Into<Error>,
	{
	let source: FontAssetSource = source.try_into().map_err(\|e\| e.into())?;
	let open_args: FTOpenArgs = source.try_into()?;

	let face = self.library.open_face(open_args, index)?;
	let code_points = face.code_points().collect();
	let postscript_name = face.postscript_name().ok().filter(\|x\| !x.is_empty());
	let full_name = face.full_name()?.filter(\|x\| !x.is_empty());

	Ok(FontInfo { char_set: CharSet::new(code_points), postscript_name, full_name })
	}
	}

	impl FontInfoLoader for FontInfoLoaderImpl {
	fn load_font_info<S, E>(&self, source: S, index: u32) -> Result<FontInfo, Error>
	where
	S: TryInto<FontAssetSource, Error = E>,
	E: Sync + Send + Into<Error>,
	{
	FontInfoLoaderImpl::load_font_info(&self, source, index)
	}
	}

	#[derive(Debug)]
	struct FTLibrary {
	ft_library: FT_Library,
	}

	/// Rusty wrapper around `FT_Library`.
	impl FTLibrary {
	pub fn new() -> Result<FTLibrary, Error> {
	// Unsafe to call FreeType FFI. On success, stores the `FT_Library` pointer in `FTLibrary`,
	// which calls `FT_Done_Library` in `drop()`.
	unsafe {
	let mut ft_library = ptr::null_mut();
	if FT_New_Library(&FT_MEMORY, &mut ft_library) != FT_Err_Ok {
	return Err(format_err!("Failed to initialize FreeType library."));
	}
	FT_Add_Default_Modules(ft_library);
	Ok(FTLibrary { ft_library })
	}
	}

	/// Opens the font file with the given `open_args` and reads the face at the given index.
	pub fn open_face(&self, open_args: FTOpenArgs, index: u32) -> Result<FTFace, Error> {
	// Unsafe to call FreeType FFI. On success stores the `FT_Face` pointer in `FTFace`, which
	// calls `FT_Done_Face` in `drop()`.
	unsafe {
	let mut ft_face: FT_Face = ptr::null_mut();
	let err = FT_Open_Face(self.ft_library, open_args.as_ref(), index as i64, &mut ft_face);

	if err != FT_Err_Ok {
	return Err(format_err!(
	"Failed to parse font {} from {:?}: FreeType error {}",
	index,
	open_args.source,
	err
	));
	}

	Ok(FTFace { ft_face, open_args })
	}
	}
	}

	impl std::ops::Drop for FTLibrary {
	fn drop(&mut self) {
	// Unsafe to call FreeType FFI.
	// This is required in order to clean up the FreeType library instance.
	unsafe {
	FT_Done_Library(self.ft_library);
	}
	}
	}

	/// Wrapper around the native `FT_Face`, providing a more Rusty API and retaining some structs that
	/// need to stay alive in memory.
	struct FTFace {
	ft_face: FT_Face,

	/// Retains the stream or file path that backs the `FT_Face`.
	#[allow(dead_code)]
	open_args: FTOpenArgs,
	}

	impl FTFace {
	/// Returns an iterator over the code points (as `u32`s) covered by this font face.
	pub fn code_points<'f>(&'f self) -> CodePointsIterator<'f> {
	CodePointsIterator { face: self, state: CodePointsIteratorState::Uninitialized }
	}

	/// Returns the face's Postscript name.
	pub fn postscript_name(&self) -> Result<String, Error> {
	// Unsafe to call FreeType FFI.
	let postscript_name = unsafe {
	// According to the FT docs, this is supposed to be an ASCII string, so it should
	// trivially convert to UTF-8.
	//
	// Note: Must use c_char, not i8 or u8, because c_char's definition depends on the
	// architecture.
	let postscript_name =
	FT_Get_Postscript_Name(self.ft_face) as *const std::os::raw::c_char;
	let postscript_name = CStr::from_ptr(postscript_name);
	postscript_name
	.to_str()
	.map_err(\|e\| format_err!("Failed to decode Postscript name. Error: {:?}", e))?
	.to_string()
	};
	Ok(postscript_name)
	}

	/// Returns the face's "full name", if present.
	pub fn full_name(&self) -> Result<Option<String>, Error> {
	self.get_name(TT_NAME_ID_FULL_NAME)
	}

	/// Finds and decodes the first supported name entry that has the given name ID.
	///
	/// A "name ID" is a record identifier in the `name` TrueType table, which can also contain
	/// items like copyright info, URLs, etc. See
	/// https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids.
	fn get_name(&self, name_id: u16) -> Result<Option<String>, Error> {
	for name_entry in self.sfnt_names() {
	let name_entry = name_entry?;
	if let Some(name) = FTFace::decode_name_if_matches(&name_entry, name_id)? {
	return Ok(Some(name));
	}
	}
	Ok(None)
	}

	fn sfnt_name_count(&self) -> u32 {
	unsafe { FT_Get_Sfnt_Name_Count(self.ft_face) }
	}

	fn sfnt_names<'a>(&'a self) -> SfntNamesIterator<'a> {
	SfntNamesIterator { face: self, iter: 0..self.sfnt_name_count() }
	}

	/// If the given `FT_SfntName` contains the requested `name_id` and the encoding is in a
	/// supported format, returns the decoded name string. Otherwise, returns `None`.
	///
	/// Presently, this only looks at en-US name entries.
	fn decode_name_if_matches(
	name_entry: &FT_SfntName,
	name_id: u16,
	) -> Result<Option<String>, Error> {
	if name_entry.name_id != name_id {
	return Ok(None);
	}
	match (name_entry.platform_id, name_entry.encoding_id, name_entry.language_id) {
	(TT_PLATFORM_MICROSOFT, TT_MS_ID_SYMBOL_CS, TT_MS_LANGID_ENGLISH_UNITED_STATES)
	\| (TT_PLATFORM_MICROSOFT, TT_MS_ID_UNICODE_CS, TT_MS_LANGID_ENGLISH_UNITED_STATES) => {
	let name = FTFace::decode_name_utf16_be(name_entry)?;
	Ok(Some(name))
	}
	_ => Ok(None),
	}
	}

	/// Decodes the the given `FT_SfntName` as a UTF-16 Big Endian string.
	fn decode_name_utf16_be(name_entry: &FT_SfntName) -> Result<String, Error> {
	let as_u8 = unsafe {
	std::slice::from_raw_parts(name_entry.string, name_entry.string_len as usize)
	};
	// FT_SfntName.string_len is in bytes. One UTF-16 code unit is two bytes.
	let num_code_units = (name_entry.string_len / 2) as usize;
	let mut reader = Cursor::new(as_u8);
	let mut as_u16 = Vec::with_capacity(num_code_units);
	for _i in 0..num_code_units {
	let ch = reader.read_u16::<BigEndian>()?;
	as_u16.push(ch);
	}
	Ok(String::from_utf16(as_u16.as_slice())?)
	}
	}

	impl std::ops::Drop for FTFace {
	fn drop(&mut self) {
	// Unsafe to call FreeType FFI.
	// This is required in order to clean up the FreeType face instance.
	unsafe {
	FT_Done_Face(self.ft_face);
	}
	}
	}

	/// State of a [`CodePointsIterator`].
	#[derive(Debug, Copy, Clone)]
	enum CodePointsIteratorState {
	Uninitialized,
	/// Stores the previous code point returned.
	Active(u64),
	/// No more code points forthcoming.
	Fused,
	}

	/// Iterates over the code points (as `u32`s) in an `FTFace`.
	pub struct CodePointsIterator<'f> {
	face: &'f FTFace,
	state: CodePointsIteratorState,
	}

	impl<'f> CodePointsIterator<'f> {
	fn next_internal(&mut self, prev_code_point: Option<u64>) -> Option<u32> {
	let mut glyph_index: u32 = 0;
	// Unsafe to call FreeType FFI. Enumerate character map with FT_Get_First_Char() and
	// FT_Get_Next_Char().
	let code_point = unsafe {
	match prev_code_point {
	Some(prev_code_point) => {
	FT_Get_Next_Char(self.face.ft_face, prev_code_point, &mut glyph_index)
	}
	None => FT_Get_First_Char(self.face.ft_face, &mut glyph_index),
	}
	};
	// Per the FreeType docs, the glyph index will always be zero after the last code point in
	// the face is returned.
	if glyph_index > 0 {
	self.state = CodePointsIteratorState::Active(code_point);
	Some(code_point as u32)
	} else {
	self.state = CodePointsIteratorState::Fused;
	None
	}
	}
	}

	impl<'f> std::iter::Iterator for CodePointsIterator<'f> {
	type Item = u32;

	fn next(&mut self) -> Option<Self::Item> {
	match self.state.clone() {
	CodePointsIteratorState::Uninitialized => self.next_internal(None),
	CodePointsIteratorState::Active(prev_code_point) => {
	self.next_internal(Some(prev_code_point))
	}
	CodePointsIteratorState::Fused => None,
	}
	}
	}

	impl<'f> std::iter::FusedIterator for CodePointsIterator<'f> {}

	/// Iterator over the `name` table in a font face.
	pub struct SfntNamesIterator<'f> {
	face: &'f FTFace,
	iter: Range<u32>,
	}

	impl<'f> SfntNamesIterator<'f> {
	fn get(&self, idx: u32) -> Result<FT_SfntName, Error> {
	let mut entry = FT_SfntName::default();
	let err_code = unsafe { FT_Get_Sfnt_Name(self.face.ft_face, idx, &mut entry) };
	if err_code == FT_Err_Ok {
	Ok(entry)
	} else {
	Err(format_err!("FreeType error while getting name {}: {}", idx, err_code))
	}
	}
	}

	impl<'f> Iterator for SfntNamesIterator<'f> {
	type Item = Result<FT_SfntName, Error>;

	fn next(&mut self) -> Option<Self::Item> {
	self.iter.next().map(\|idx\| self.get(idx))
	}
	}

	impl<'f> ExactSizeIterator for SfntNamesIterator<'f> {
	fn len(&self) -> usize {
	self.iter.len()
	}
	}