From 84295d5b35090fe74c16dbdef9ec93829e8696de Mon Sep 17 00:00:00 2001 From: Kian-Meng Ang Date: Mon, 15 Aug 2022 21:07:01 +0800 Subject: [PATCH] cargo fmt --- common/src/writer.rs | 4 +++- ownedbytes/src/lib.rs | 3 ++- src/aggregation/bucket/mod.rs | 8 +++++-- src/collector/custom_score_top_collector.rs | 6 ++++-- src/collector/facet_collector.rs | 12 ++++++++--- src/collector/filter_collector_wrapper.rs | 3 ++- src/collector/top_collector.rs | 3 ++- src/collector/tweak_score_top_collector.rs | 6 ++++-- src/directory/directory.rs | 3 ++- src/directory/file_slice.rs | 3 ++- src/postings/block_search.rs | 2 +- src/query/boolean_query/boolean_weight.rs | 4 +++- src/query/query.rs | 3 ++- src/query/union.rs | 4 +++- src/schema/document.rs | 4 +++- src/schema/facet.rs | 12 ++++++++--- src/schema/schema.rs | 12 ++++++++--- src/schema/term.rs | 21 ++++++++++++------- src/schema/value.rs | 8 +++++-- src/store/compressors.rs | 8 +++++-- src/termdict/fst_termdict/streamer.rs | 12 +++++++---- src/termdict/fst_termdict/termdict.rs | 3 ++- .../sstable_termdict/sstable/delta.rs | 6 ++++-- src/termdict/sstable_termdict/sstable/mod.rs | 6 ++++-- src/termdict/sstable_termdict/termdict.rs | 4 +++- src/tokenizer/ngram_tokenizer.rs | 6 ++++-- src/tokenizer/tokenizer.rs | 3 ++- src/tokenizer/tokenizer_manager.rs | 4 +++- 28 files changed, 122 insertions(+), 51 deletions(-) diff --git a/common/src/writer.rs b/common/src/writer.rs index 9b8b86908..473896e9a 100644 --- a/common/src/writer.rs +++ b/common/src/writer.rs @@ -65,7 +65,9 @@ pub struct AntiCallToken(()); pub trait TerminatingWrite: Write + Send { /// Indicate that the writer will no longer be used. Internally call terminate_ref. fn terminate(mut self) -> io::Result<()> - where Self: Sized { + where + Self: Sized, + { self.terminate_ref(AntiCallToken(())) } diff --git a/ownedbytes/src/lib.rs b/ownedbytes/src/lib.rs index b7e5dfd88..7e3f10d47 100644 --- a/ownedbytes/src/lib.rs +++ b/ownedbytes/src/lib.rs @@ -160,7 +160,8 @@ impl PartialEq for OwnedBytes { } impl<'a, T: ?Sized> PartialEq<&'a T> for OwnedBytes -where OwnedBytes: PartialEq +where + OwnedBytes: PartialEq, { fn eq(&self, other: &&'a T) -> bool { *self == **other diff --git a/src/aggregation/bucket/mod.rs b/src/aggregation/bucket/mod.rs index a47437952..bb0242f22 100644 --- a/src/aggregation/bucket/mod.rs +++ b/src/aggregation/bucket/mod.rs @@ -94,7 +94,9 @@ pub struct CustomOrder { impl Serialize for CustomOrder { fn serialize(&self, serializer: S) -> Result - where S: Serializer { + where + S: Serializer, + { let map: HashMap = std::iter::once((self.target.to_string(), self.order)).collect(); map.serialize(serializer) @@ -103,7 +105,9 @@ impl Serialize for CustomOrder { impl<'de> Deserialize<'de> for CustomOrder { fn deserialize(deserializer: D) -> Result - where D: Deserializer<'de> { + where + D: Deserializer<'de>, + { HashMap::::deserialize(deserializer).and_then(|map| { if let Some((key, value)) = map.into_iter().next() { Ok(CustomOrder { diff --git a/src/collector/custom_score_top_collector.rs b/src/collector/custom_score_top_collector.rs index d645004ad..0a804cf5c 100644 --- a/src/collector/custom_score_top_collector.rs +++ b/src/collector/custom_score_top_collector.rs @@ -8,7 +8,8 @@ pub(crate) struct CustomScoreTopCollector { } impl CustomScoreTopCollector -where TScore: Clone + PartialOrd +where + TScore: Clone + PartialOrd, { pub(crate) fn new( custom_scorer: TCustomScorer, @@ -113,7 +114,8 @@ where } impl CustomSegmentScorer for F -where F: 'static + FnMut(DocId) -> TScore +where + F: 'static + FnMut(DocId) -> TScore, { fn score(&mut self, doc: DocId) -> TScore { (self)(doc) diff --git a/src/collector/facet_collector.rs b/src/collector/facet_collector.rs index fc514c816..e861351b7 100644 --- a/src/collector/facet_collector.rs +++ b/src/collector/facet_collector.rs @@ -233,7 +233,9 @@ impl FacetCollector { /// If you need the correct number of unique documents for two such facets, /// just add them in separate `FacetCollector`. pub fn add_facet(&mut self, facet_from: T) - where Facet: From { + where + Facet: From, + { let facet = Facet::from(facet_from); for old_facet in &self.facets { assert!( @@ -393,7 +395,9 @@ impl FacetCounts { /// Returns an iterator over all of the facet count pairs inside this result. /// See the documentation for [FacetCollector] for a usage example. pub fn get(&self, facet_from: T) -> FacetChildIterator<'_> - where Facet: From { + where + Facet: From, + { let facet = Facet::from(facet_from); let left_bound = Bound::Excluded(facet.clone()); let right_bound = if facet.is_root() { @@ -412,7 +416,9 @@ impl FacetCounts { /// Returns a vector of top `k` facets with their counts, sorted highest-to-lowest by counts. /// See the documentation for [FacetCollector] for a usage example. pub fn top_k(&self, facet: T, k: usize) -> Vec<(&Facet, u64)> - where Facet: From { + where + Facet: From, + { let mut heap = BinaryHeap::with_capacity(k); let mut it = self.get(facet); diff --git a/src/collector/filter_collector_wrapper.rs b/src/collector/filter_collector_wrapper.rs index b1dbaaa20..4094a572b 100644 --- a/src/collector/filter_collector_wrapper.rs +++ b/src/collector/filter_collector_wrapper.rs @@ -59,7 +59,8 @@ use crate::{Score, SegmentReader, TantivyError}; /// # } /// ``` pub struct FilterCollector -where TPredicate: 'static + Clone +where + TPredicate: 'static + Clone, { field: Field, collector: TCollector, diff --git a/src/collector/top_collector.rs b/src/collector/top_collector.rs index 691ef324b..846ed0591 100644 --- a/src/collector/top_collector.rs +++ b/src/collector/top_collector.rs @@ -60,7 +60,8 @@ pub(crate) struct TopCollector { } impl TopCollector -where T: PartialOrd + Clone +where + T: PartialOrd + Clone, { /// Creates a top collector, with a number of documents equal to "limit". /// diff --git a/src/collector/tweak_score_top_collector.rs b/src/collector/tweak_score_top_collector.rs index 1a81e7361..4ae748e16 100644 --- a/src/collector/tweak_score_top_collector.rs +++ b/src/collector/tweak_score_top_collector.rs @@ -8,7 +8,8 @@ pub(crate) struct TweakedScoreTopCollector { } impl TweakedScoreTopCollector -where TScore: Clone + PartialOrd +where + TScore: Clone + PartialOrd, { pub fn new( score_tweaker: TScoreTweaker, @@ -116,7 +117,8 @@ where } impl ScoreSegmentTweaker for F -where F: 'static + FnMut(DocId, Score) -> TScore +where + F: 'static + FnMut(DocId, Score) -> TScore, { fn score(&mut self, doc: DocId, score: Score) -> TScore { (self)(doc, score) diff --git a/src/directory/directory.rs b/src/directory/directory.rs index 43d6ce5f4..7f04990e2 100644 --- a/src/directory/directory.rs +++ b/src/directory/directory.rs @@ -233,7 +233,8 @@ pub trait DirectoryClone { } impl DirectoryClone for T -where T: 'static + Directory + Clone +where + T: 'static + Directory + Clone, { fn box_clone(&self) -> Box { Box::new(self.clone()) diff --git a/src/directory/file_slice.rs b/src/directory/file_slice.rs index 42ba07bb5..26672cff9 100644 --- a/src/directory/file_slice.rs +++ b/src/directory/file_slice.rs @@ -51,7 +51,8 @@ impl FileHandle for &'static [u8] { } impl From for FileSlice -where B: StableDeref + Deref + 'static + Send + Sync +where + B: StableDeref + Deref + 'static + Send + Sync, { fn from(bytes: B) -> FileSlice { FileSlice::new(Arc::new(OwnedBytes::new(bytes))) diff --git a/src/postings/block_search.rs b/src/postings/block_search.rs index 3a53bd78f..eac587d0c 100644 --- a/src/postings/block_search.rs +++ b/src/postings/block_search.rs @@ -10,7 +10,7 @@ use crate::postings::compression::COMPRESSION_BLOCK_SIZE; // .take_while(|&&val| val < target) // .count() /// ``` -/// +/// /// the `start` argument is just used to hint that the response is /// greater than beyond `start`. the implementation may or may not use /// it for optimization. diff --git a/src/query/boolean_query/boolean_weight.rs b/src/query/boolean_query/boolean_weight.rs index 6a32f53f8..82d97ca08 100644 --- a/src/query/boolean_query/boolean_weight.rs +++ b/src/query/boolean_query/boolean_weight.rs @@ -18,7 +18,9 @@ enum SpecializedScorer { } fn scorer_union(scorers: Vec>) -> SpecializedScorer -where TScoreCombiner: ScoreCombiner { +where + TScoreCombiner: ScoreCombiner, +{ assert!(!scorers.is_empty()); if scorers.len() == 1 { return SpecializedScorer::Other(scorers.into_iter().next().unwrap()); //< we checked the size beforehand diff --git a/src/query/query.rs b/src/query/query.rs index 48ca4e7fd..fd95a5a71 100644 --- a/src/query/query.rs +++ b/src/query/query.rs @@ -82,7 +82,8 @@ pub trait QueryClone { } impl QueryClone for T -where T: 'static + Query + Clone +where + T: 'static + Query + Clone, { fn box_clone(&self) -> Box { Box::new(self.clone()) diff --git a/src/query/union.rs b/src/query/union.rs index 06ffb0ab3..f25d653fd 100644 --- a/src/query/union.rs +++ b/src/query/union.rs @@ -14,7 +14,9 @@ const HORIZON: u32 = 64u32 * HORIZON_NUM_TINYBITSETS as u32; // // Also, it does not "yield" any elements. fn unordered_drain_filter(v: &mut Vec, mut predicate: P) -where P: FnMut(&mut T) -> bool { +where + P: FnMut(&mut T) -> bool, +{ let mut i = 0; while i < v.len() { if predicate(&mut v[i]) { diff --git a/src/schema/document.rs b/src/schema/document.rs index 3bde526b1..e6aed8761 100644 --- a/src/schema/document.rs +++ b/src/schema/document.rs @@ -75,7 +75,9 @@ impl Document { /// Adding a facet to the document. pub fn add_facet(&mut self, field: Field, path: F) - where Facet: From { + where + Facet: From, + { let facet = Facet::from(path); let value = Value::Facet(facet); self.add_field_value(field, value); diff --git a/src/schema/facet.rs b/src/schema/facet.rs index 3e826e384..cbcc68106 100644 --- a/src/schema/facet.rs +++ b/src/schema/facet.rs @@ -83,7 +83,9 @@ impl Facet { /// contains a `/`, it should be escaped /// using an anti-slash `\`. pub fn from_text(path: &T) -> Result - where T: ?Sized + AsRef { + where + T: ?Sized + AsRef, + { #[derive(Copy, Clone)] enum State { Escaped, @@ -209,14 +211,18 @@ fn escape_slashes(s: &str) -> Cow<'_, str> { impl Serialize for Facet { fn serialize(&self, serializer: S) -> Result - where S: Serializer { + where + S: Serializer, + { serializer.serialize_str(&self.to_string()) } } impl<'de> Deserialize<'de> for Facet { fn deserialize(deserializer: D) -> Result - where D: Deserializer<'de> { + where + D: Deserializer<'de>, + { <&'de str as Deserialize<'de>>::deserialize(deserializer).map(Facet::from) } } diff --git a/src/schema/schema.rs b/src/schema/schema.rs index e91a31a62..e07b382e6 100644 --- a/src/schema/schema.rs +++ b/src/schema/schema.rs @@ -367,7 +367,9 @@ impl Schema { impl Serialize for Schema { fn serialize(&self, serializer: S) -> Result - where S: Serializer { + where + S: Serializer, + { let mut seq = serializer.serialize_seq(Some(self.0.fields.len()))?; for e in &self.0.fields { seq.serialize_element(e)?; @@ -378,7 +380,9 @@ impl Serialize for Schema { impl<'de> Deserialize<'de> for Schema { fn deserialize(deserializer: D) -> Result - where D: Deserializer<'de> { + where + D: Deserializer<'de>, + { struct SchemaVisitor; impl<'de> Visitor<'de> for SchemaVisitor { @@ -389,7 +393,9 @@ impl<'de> Deserialize<'de> for Schema { } fn visit_seq(self, mut seq: A) -> Result - where A: SeqAccess<'de> { + where + A: SeqAccess<'de>, + { let mut schema = SchemaBuilder { fields: Vec::with_capacity(seq.size_hint().unwrap_or(0)), fields_map: HashMap::with_capacity(seq.size_hint().unwrap_or(0)), diff --git a/src/schema/term.rs b/src/schema/term.rs index 4b63c19c4..ed89cd33b 100644 --- a/src/schema/term.rs +++ b/src/schema/term.rs @@ -34,7 +34,8 @@ pub const JSON_END_OF_PATH: u8 = 0u8; /// It actually wraps a `Vec`. #[derive(Clone)] pub struct Term>(B) -where B: AsRef<[u8]>; +where + B: AsRef<[u8]>; impl AsMut> for Term { fn as_mut(&mut self) -> &mut Vec { @@ -174,7 +175,8 @@ impl Term { } impl Ord for Term -where B: AsRef<[u8]> +where + B: AsRef<[u8]>, { fn cmp(&self, other: &Self) -> std::cmp::Ordering { self.as_slice().cmp(other.as_slice()) @@ -182,7 +184,8 @@ where B: AsRef<[u8]> } impl PartialOrd for Term -where B: AsRef<[u8]> +where + B: AsRef<[u8]>, { fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) @@ -190,7 +193,8 @@ where B: AsRef<[u8]> } impl PartialEq for Term -where B: AsRef<[u8]> +where + B: AsRef<[u8]>, { fn eq(&self, other: &Self) -> bool { self.as_slice() == other.as_slice() @@ -200,7 +204,8 @@ where B: AsRef<[u8]> impl Eq for Term where B: AsRef<[u8]> {} impl Hash for Term -where B: AsRef<[u8]> +where + B: AsRef<[u8]>, { fn hash(&self, state: &mut H) { self.0.as_ref().hash(state) @@ -208,7 +213,8 @@ where B: AsRef<[u8]> } impl Term -where B: AsRef<[u8]> +where + B: AsRef<[u8]>, { /// Wraps a object holding bytes pub fn wrap(data: B) -> Term { @@ -420,7 +426,8 @@ fn debug_value_bytes(typ: Type, bytes: &[u8], f: &mut fmt::Formatter) -> fmt::Re } impl fmt::Debug for Term -where B: AsRef<[u8]> +where + B: AsRef<[u8]>, { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let field_id = self.field().field_id(); diff --git a/src/schema/value.rs b/src/schema/value.rs index 5cd5d3894..8d1653cb0 100644 --- a/src/schema/value.rs +++ b/src/schema/value.rs @@ -38,7 +38,9 @@ impl Eq for Value {} impl Serialize for Value { fn serialize(&self, serializer: S) -> Result - where S: Serializer { + where + S: Serializer, + { match *self { Value::Str(ref v) => serializer.serialize_str(v), Value::PreTokStr(ref v) => v.serialize(serializer), @@ -56,7 +58,9 @@ impl Serialize for Value { impl<'de> Deserialize<'de> for Value { fn deserialize(deserializer: D) -> Result - where D: Deserializer<'de> { + where + D: Deserializer<'de>, + { struct ValueVisitor; impl<'de> Visitor<'de> for ValueVisitor { diff --git a/src/store/compressors.rs b/src/store/compressors.rs index 764a09bec..ea2478015 100644 --- a/src/store/compressors.rs +++ b/src/store/compressors.rs @@ -28,7 +28,9 @@ pub enum Compressor { impl Serialize for Compressor { fn serialize(&self, serializer: S) -> Result - where S: serde::Serializer { + where + S: serde::Serializer, + { match *self { Compressor::None => serializer.serialize_str("none"), Compressor::Lz4 => serializer.serialize_str("lz4"), @@ -41,7 +43,9 @@ impl Serialize for Compressor { impl<'de> Deserialize<'de> for Compressor { fn deserialize(deserializer: D) -> Result - where D: Deserializer<'de> { + where + D: Deserializer<'de>, + { let buf = String::deserialize(deserializer)?; let compressor = match buf.as_str() { "none" => Compressor::None, diff --git a/src/termdict/fst_termdict/streamer.rs b/src/termdict/fst_termdict/streamer.rs index 978ab5e0d..60136adab 100644 --- a/src/termdict/fst_termdict/streamer.rs +++ b/src/termdict/fst_termdict/streamer.rs @@ -11,14 +11,16 @@ use crate::termdict::TermOrdinal; /// `TermStreamerBuilder` is a helper object used to define /// a range of terms that should be streamed. pub struct TermStreamerBuilder<'a, A = AlwaysMatch> -where A: Automaton +where + A: Automaton, { fst_map: &'a TermDictionary, stream_builder: StreamBuilder<'a, A>, } impl<'a, A> TermStreamerBuilder<'a, A> -where A: Automaton +where + A: Automaton, { pub(crate) fn new(fst_map: &'a TermDictionary, stream_builder: StreamBuilder<'a, A>) -> Self { TermStreamerBuilder { @@ -73,7 +75,8 @@ where A: Automaton /// `TermStreamer` acts as a cursor over a range of terms of a segment. /// Terms are guaranteed to be sorted. pub struct TermStreamer<'a, A = AlwaysMatch> -where A: Automaton +where + A: Automaton, { pub(crate) fst_map: &'a TermDictionary, pub(crate) stream: Stream<'a, A>, @@ -83,7 +86,8 @@ where A: Automaton } impl<'a, A> TermStreamer<'a, A> -where A: Automaton +where + A: Automaton, { /// Advance position the stream on the next item. /// Before the first call to `.advance()`, the stream diff --git a/src/termdict/fst_termdict/termdict.rs b/src/termdict/fst_termdict/termdict.rs index 937471733..23a3d3aa3 100644 --- a/src/termdict/fst_termdict/termdict.rs +++ b/src/termdict/fst_termdict/termdict.rs @@ -26,7 +26,8 @@ pub struct TermDictionaryBuilder { } impl TermDictionaryBuilder -where W: Write +where + W: Write, { /// Creates a new `TermDictionaryBuilder` pub fn create(w: W) -> io::Result { diff --git a/src/termdict/sstable_termdict/sstable/delta.rs b/src/termdict/sstable_termdict/sstable/delta.rs index 3551891cd..65c408f5d 100644 --- a/src/termdict/sstable_termdict/sstable/delta.rs +++ b/src/termdict/sstable_termdict/sstable/delta.rs @@ -11,7 +11,8 @@ const VINT_MODE: u8 = 1u8; const BLOCK_LEN: usize = 32_000; pub struct DeltaWriter -where W: io::Write +where + W: io::Write, { block: Vec, write: CountingWriter>, @@ -99,7 +100,8 @@ pub struct DeltaReader<'a, TValueReader> { } impl<'a, TValueReader> DeltaReader<'a, TValueReader> -where TValueReader: value::ValueReader +where + TValueReader: value::ValueReader, { pub fn new(reader: R) -> Self { DeltaReader { diff --git a/src/termdict/sstable_termdict/sstable/mod.rs b/src/termdict/sstable_termdict/sstable/mod.rs index 0afef761c..a138bca6f 100644 --- a/src/termdict/sstable_termdict/sstable/mod.rs +++ b/src/termdict/sstable_termdict/sstable/mod.rs @@ -96,7 +96,8 @@ pub struct Reader<'a, TValueReader> { } impl<'a, TValueReader> Reader<'a, TValueReader> -where TValueReader: ValueReader +where + TValueReader: ValueReader, { pub fn advance(&mut self) -> io::Result { if !self.delta_reader.advance()? { @@ -126,7 +127,8 @@ impl<'a, TValueReader> AsRef<[u8]> for Reader<'a, TValueReader> { } pub struct Writer -where W: io::Write +where + W: io::Write, { previous_key: Vec, index_builder: SSTableIndexBuilder, diff --git a/src/termdict/sstable_termdict/termdict.rs b/src/termdict/sstable_termdict/termdict.rs index 29e2ffbbe..5f88df136 100644 --- a/src/termdict/sstable_termdict/termdict.rs +++ b/src/termdict/sstable_termdict/termdict.rs @@ -243,7 +243,9 @@ impl TermDictionary { // Returns a search builder, to stream all of the terms // within the Automaton pub fn search<'a, A: Automaton + 'a>(&'a self, automaton: A) -> TermStreamerBuilder<'a, A> - where A::State: Clone { + where + A::State: Clone, + { TermStreamerBuilder::::new(self, automaton) } diff --git a/src/tokenizer/ngram_tokenizer.rs b/src/tokenizer/ngram_tokenizer.rs index b268d6105..57aefc386 100644 --- a/src/tokenizer/ngram_tokenizer.rs +++ b/src/tokenizer/ngram_tokenizer.rs @@ -192,7 +192,8 @@ struct StutteringIterator { } impl StutteringIterator -where T: Iterator +where + T: Iterator, { pub fn new(mut underlying: T, min_gram: usize, max_gram: usize) -> StutteringIterator { assert!(min_gram > 0); @@ -221,7 +222,8 @@ where T: Iterator } impl Iterator for StutteringIterator -where T: Iterator +where + T: Iterator, { type Item = (usize, usize); diff --git a/src/tokenizer/tokenizer.rs b/src/tokenizer/tokenizer.rs index 0965f004f..d916a3299 100644 --- a/src/tokenizer/tokenizer.rs +++ b/src/tokenizer/tokenizer.rs @@ -159,7 +159,8 @@ impl<'a> TokenStream for Box { pub struct BoxTokenStream<'a>(Box); impl<'a, T> From for BoxTokenStream<'a> -where T: TokenStream + 'a +where + T: TokenStream + 'a, { fn from(token_stream: T) -> BoxTokenStream<'a> { BoxTokenStream(Box::new(token_stream)) diff --git a/src/tokenizer/tokenizer_manager.rs b/src/tokenizer/tokenizer_manager.rs index 73dcba21a..f3e0d5d64 100644 --- a/src/tokenizer/tokenizer_manager.rs +++ b/src/tokenizer/tokenizer_manager.rs @@ -35,7 +35,9 @@ impl TokenizerManager { /// Registers a new tokenizer associated with a given name. pub fn register(&self, tokenizer_name: &str, tokenizer: T) - where TextAnalyzer: From { + where + TextAnalyzer: From, + { let boxed_tokenizer: TextAnalyzer = TextAnalyzer::from(tokenizer); self.tokenizers .write()