From 3fd8c8b3306ae33bdc85811aa410ba01967922bc Mon Sep 17 00:00:00 2001 From: Palmer Cox Date: Tue, 14 Jan 2014 22:32:24 -0500 Subject: Rename iterators for consistency Rename existing iterators to get rid of the Iterator suffix and to give them names that better describe the things being iterated over. --- src/libstd/path/mod.rs | 16 ++++++++-------- src/libstd/path/posix.rs | 22 +++++++++++----------- src/libstd/path/windows.rs | 26 +++++++++++++------------- 3 files changed, 32 insertions(+), 32 deletions(-) (limited to 'src/libstd/path') diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 354cc10f022..56e86afaaef 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -93,29 +93,29 @@ pub use Path = self::windows::Path; /// Typedef for the platform-native component iterator #[cfg(unix)] -pub use ComponentIter = self::posix::ComponentIter; +pub use Components = self::posix::Components; /// Typedef for the platform-native reverse component iterator #[cfg(unix)] -pub use RevComponentIter = self::posix::RevComponentIter; +pub use RevComponents = self::posix::RevComponents; /// Typedef for the platform-native component iterator #[cfg(windows)] -pub use ComponentIter = self::windows::ComponentIter; +pub use Components = self::windows::Components; /// Typedef for the platform-native reverse component iterator #[cfg(windows)] -pub use RevComponentIter = self::windows::RevComponentIter; +pub use RevComponents = self::windows::RevComponents; /// Typedef for the platform-native str component iterator #[cfg(unix)] -pub use StrComponentIter = self::posix::StrComponentIter; +pub use StrComponents = self::posix::StrComponents; /// Typedef for the platform-native reverse str component iterator #[cfg(unix)] -pub use RevStrComponentIter = self::posix::RevStrComponentIter; +pub use RevStrComponents = self::posix::RevStrComponents; /// Typedef for the platform-native str component iterator #[cfg(windows)] -pub use StrComponentIter = self::windows::StrComponentIter; +pub use StrComponents = self::windows::StrComponents; /// Typedef for the platform-native reverse str component iterator #[cfg(windows)] -pub use RevStrComponentIter = self::windows::RevStrComponentIter; +pub use RevStrComponents = self::windows::RevStrComponents; /// Typedef for the platform-native separator char func #[cfg(unix)] diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index e2ddabc1714..0a93f385a06 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -21,21 +21,21 @@ use str; use str::Str; use to_bytes::IterBytes; use vec; -use vec::{CopyableVector, RSplitIterator, SplitIterator, Vector, VectorVector, +use vec::{CopyableVector, RevSplits, Splits, Vector, VectorVector, ImmutableEqVector, OwnedVector, ImmutableVector, OwnedCopyableVector}; use super::{BytesContainer, GenericPath, GenericPathUnsafe}; /// Iterator that yields successive components of a Path as &[u8] -pub type ComponentIter<'a> = SplitIterator<'a, u8>; +pub type Components<'a> = Splits<'a, u8>; /// Iterator that yields components of a Path in reverse as &[u8] -pub type RevComponentIter<'a> = RSplitIterator<'a, u8>; +pub type RevComponents<'a> = RevSplits<'a, u8>; /// Iterator that yields successive components of a Path as Option<&str> -pub type StrComponentIter<'a> = Map<'a, &'a [u8], Option<&'a str>, - ComponentIter<'a>>; +pub type StrComponents<'a> = Map<'a, &'a [u8], Option<&'a str>, + Components<'a>>; /// Iterator that yields components of a Path in reverse as Option<&str> -pub type RevStrComponentIter<'a> = Map<'a, &'a [u8], Option<&'a str>, - RevComponentIter<'a>>; +pub type RevStrComponents<'a> = Map<'a, &'a [u8], Option<&'a str>, + RevComponents<'a>>; /// Represents a POSIX file path #[deriving(Clone, DeepClone)] @@ -371,7 +371,7 @@ impl Path { /// Does not distinguish between absolute and relative paths, e.g. /// /a/b/c and a/b/c yield the same set of components. /// A path of "/" yields no components. A path of "." yields one component. - pub fn components<'a>(&'a self) -> ComponentIter<'a> { + pub fn components<'a>(&'a self) -> Components<'a> { let v = if self.repr[0] == sep_byte { self.repr.slice_from(1) } else { self.repr.as_slice() }; @@ -385,7 +385,7 @@ impl Path { /// Returns an iterator that yields each component of the path in reverse. /// See components() for details. - pub fn rev_components<'a>(&'a self) -> RevComponentIter<'a> { + pub fn rev_components<'a>(&'a self) -> RevComponents<'a> { let v = if self.repr[0] == sep_byte { self.repr.slice_from(1) } else { self.repr.as_slice() }; @@ -399,13 +399,13 @@ impl Path { /// Returns an iterator that yields each component of the path as Option<&str>. /// See components() for details. - pub fn str_components<'a>(&'a self) -> StrComponentIter<'a> { + pub fn str_components<'a>(&'a self) -> StrComponents<'a> { self.components().map(str::from_utf8_opt) } /// Returns an iterator that yields each component of the path in reverse as Option<&str>. /// See components() for details. - pub fn rev_str_components<'a>(&'a self) -> RevStrComponentIter<'a> { + pub fn rev_str_components<'a>(&'a self) -> RevStrComponents<'a> { self.rev_components().map(str::from_utf8_opt) } } diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index a42fdabef88..9b0169bf22d 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -20,7 +20,7 @@ use from_str::FromStr; use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Invert, Iterator, Map}; use option::{Option, Some, None}; use str; -use str::{CharSplitIterator, OwnedStr, Str, StrVector, StrSlice}; +use str::{CharSplits, OwnedStr, Str, StrVector, StrSlice}; use to_bytes::IterBytes; use vec::{Vector, OwnedVector, ImmutableVector}; use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe}; @@ -29,21 +29,21 @@ use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe}; /// /// Each component is yielded as Option<&str> for compatibility with PosixPath, but /// every component in WindowsPath is guaranteed to be Some. -pub type StrComponentIter<'a> = Map<'a, &'a str, Option<&'a str>, - CharSplitIterator<'a, char>>; +pub type StrComponents<'a> = Map<'a, &'a str, Option<&'a str>, + CharSplits<'a, char>>; /// Iterator that yields components of a Path in reverse as &str /// /// Each component is yielded as Option<&str> for compatibility with PosixPath, but /// every component in WindowsPath is guaranteed to be Some. -pub type RevStrComponentIter<'a> = Invert, - CharSplitIterator<'a, char>>>; +pub type RevStrComponents<'a> = Invert, + CharSplits<'a, char>>>; /// Iterator that yields successive components of a Path as &[u8] -pub type ComponentIter<'a> = Map<'a, Option<&'a str>, &'a [u8], - StrComponentIter<'a>>; +pub type Components<'a> = Map<'a, Option<&'a str>, &'a [u8], + StrComponents<'a>>; /// Iterator that yields components of a Path in reverse as &[u8] -pub type RevComponentIter<'a> = Map<'a, Option<&'a str>, &'a [u8], - RevStrComponentIter<'a>>; +pub type RevComponents<'a> = Map<'a, Option<&'a str>, &'a [u8], + RevStrComponents<'a>>; /// Represents a Windows path // Notes for Windows path impl: @@ -615,7 +615,7 @@ impl Path { /// \a\b\c and a\b\c. /// Does not distinguish between absolute and cwd-relative paths, e.g. /// C:\foo and C:foo. - pub fn str_components<'a>(&'a self) -> StrComponentIter<'a> { + pub fn str_components<'a>(&'a self) -> StrComponents<'a> { let s = match self.prefix { Some(_) => { let plen = self.prefix_len(); @@ -632,13 +632,13 @@ impl Path { /// Returns an iterator that yields each component of the path in reverse as an Option<&str> /// See str_components() for details. - pub fn rev_str_components<'a>(&'a self) -> RevStrComponentIter<'a> { + pub fn rev_str_components<'a>(&'a self) -> RevStrComponents<'a> { self.str_components().invert() } /// Returns an iterator that yields each component of the path in turn as a &[u8]. /// See str_components() for details. - pub fn components<'a>(&'a self) -> ComponentIter<'a> { + pub fn components<'a>(&'a self) -> Components<'a> { fn convert<'a>(x: Option<&'a str>) -> &'a [u8] { #[inline]; x.unwrap().as_bytes() @@ -648,7 +648,7 @@ impl Path { /// Returns an iterator that yields each component of the path in reverse as a &[u8]. /// See str_components() for details. - pub fn rev_components<'a>(&'a self) -> RevComponentIter<'a> { + pub fn rev_components<'a>(&'a self) -> RevComponents<'a> { fn convert<'a>(x: Option<&'a str>) -> &'a [u8] { #[inline]; x.unwrap().as_bytes() -- cgit 1.4.1-3-g733a5