2019-05-18 15:06:42 +02:00
pub fn filter_substring < ' a > ( needle : & str , haystack : & Vec < & ' a str > ) -> Vec < & ' a str > {
return haystack
. iter ( )
. filter ( | s | s . contains ( needle ) )
. cloned ( )
. collect ( ) ;
}
pub fn filter_subsequence < ' a > ( needle : & str , haystack : & Vec < & ' a str > ) -> Vec < & ' a str > {
return haystack
. iter ( )
. filter ( | s | is_subsequence ( needle , s ) )
. cloned ( )
. collect ( ) ;
}
fn is_subsequence ( needle : & str , string : & str ) -> bool {
// we need to explicitly convert here to iterate over chars
// (UTF-8, so possibly multiple bytes long)
let mut chars = string . chars ( ) ;
2019-05-18 15:16:59 +02:00
' needle : for nc in needle . chars ( ) {
for c in & mut chars {
if c = = nc {
continue 'needle ;
2019-05-18 15:06:42 +02:00
}
}
2019-05-18 15:16:59 +02:00
return false ;
2019-05-18 15:06:42 +02:00
}
true
}
#[ cfg(test) ]
mod tests {
2019-05-18 15:16:59 +02:00
use crate ::{ filter_subsequence , filter_substring } ;
2019-05-18 15:06:42 +02:00
#[ test ]
fn test_filter_substring_single ( ) {
let needle = " sdf " ;
let hay = vec! [ " asdf " , " qwer " ] ;
let expected = vec! [ " asdf " ] ;
assert_eq! ( filter_substring ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_substring_none ( ) {
let needle = " sdf " ;
let hay = vec! [ " qwertz " ] ;
let expected : Vec < & str > = Vec ::new ( ) ;
assert_eq! ( filter_substring ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_substring_multiple ( ) {
let needle = " sdf " ;
let hay = vec! [ " asdf " , " asd " , " sdfg " , " dfgh " ] ;
let expected = vec! [ " asdf " , " sdfg " ] ;
assert_eq! ( filter_substring ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_subsequence_single ( ) {
let needle = " asa " ;
let hay = vec! [ " aaass " , " aasda " ] ;
let expected = vec! [ " aasda " ] ;
assert_eq! ( filter_subsequence ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_subsequence_none ( ) {
let needle = " asa " ;
let hay = vec! [ " aas " ] ;
let expected : Vec < & str > = Vec ::new ( ) ;
assert_eq! ( filter_subsequence ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_subsequence_multiple ( ) {
let needle = " asa " ;
let hay = vec! [ " asa " , " assa " , " qwerafwfsferfssaas " ] ;
assert_eq! ( filter_subsequence ( & needle , & hay ) , hay ) ;
}
}