Movatterモバイル変換


[0]ホーム

URL:


Docs.rs

[][src]Structpostgres::RowIter

pub struct RowIter<'a> { /* fields omitted */ }

The iterator returned byquery_raw.

Trait Implementations

impl<'_>Drop forRowIter<'_>[src]

fndrop(&mut self)[src]

impl<'_>FallibleIterator forRowIter<'_>[src]

typeItem =Row

The type being iterated over.

typeError =Error

The error type.

fnnext(&mut self) ->Result<Option<Row>,Error>[src]

fnsize_hint(&self) ->(usize,Option<usize>)[src]

fncount(self) ->Result<usize, Self::Error>[src]

fnlast(self) ->Result<Option<Self::Item>, Self::Error>[src]

fnnth(&mut self, n:usize) ->Result<Option<Self::Item>, Self::Error>[src]

fnstep_by(self, step:usize) ->StepBy<Self>[src]

fnchain<I>(self, it: I) ->Chain<Self, I>where
    I:IntoFallibleIterator<Item = Self::Item, Error = Self::Error>, 
[src]

fnzip<I>(
    self,
    o: I
) ->Zip<Self, <I asIntoFallibleIterator>::IntoFallibleIter>where
    I:IntoFallibleIterator<Error = Self::Error>, 
[src]

fnmap<F, B>(self, f: F) ->Map<Self, F>where
    F:FnMut(Self::Item) ->Result<B, Self::Error>, 
[src]

fnfor_each<F>(self, f: F) ->Result<(), Self::Error>where
    F:FnMut(Self::Item) ->Result<(), Self::Error>, 
[src]

fnfilter<F>(self, f: F) ->Filter<Self, F>where
    F:FnMut(&Self::Item) ->Result<bool, Self::Error>, 
[src]

fnfilter_map<B, F>(self, f: F) ->FilterMap<Self, F>where
    F:FnMut(Self::Item) ->Result<Option<B>, Self::Error>, 
[src]

fnenumerate(self) ->Enumerate<Self>[src]

fnpeekable(self) ->Peekable<Self>[src]

fnskip_while<P>(self, predicate: P) ->SkipWhile<Self, P>where
    P:FnMut(&Self::Item) ->Result<bool, Self::Error>, 
[src]

fntake_while<P>(self, predicate: P) ->TakeWhile<Self, P>where
    P:FnMut(&Self::Item) ->Result<bool, Self::Error>, 
[src]

fnskip(self, n:usize) ->Skip<Self>[src]

fntake(self, n:usize) ->Take<Self>[src]

fnscan<St, B, F>(self, initial_state: St, f: F) ->Scan<Self, St, F>where
    F:FnMut(&mutSt, Self::Item) ->Result<Option<B>, Self::Error>, 
[src]

fnflat_map<U, F>(self, f: F) ->FlatMap<Self, U, F>where
    F:FnMut(Self::Item) ->Result<U, Self::Error>,
    U:IntoFallibleIterator<Error = Self::Error>, 
[src]

fnflatten(self) ->Flatten<Self>where
    Self::Item:IntoFallibleIterator,
    <Self::Item asIntoFallibleIterator>::Error == Self::Error
[src]

fnfuse(self) ->Fuse<Self>[src]

fninspect<F>(self, f: F) ->Inspect<Self, F>where
    F:FnMut(&Self::Item) ->Result<(), Self::Error>, 
[src]

fnby_ref(&mut self) ->&mutSelf[src]

fncollect<T>(self) ->Result<T, Self::Error>where
    T:FromFallibleIterator<Self::Item>, 
[src]

fnpartition<B, F>(self, f: F) ->Result<(B, B), Self::Error>where
    B:Default +Extend<Self::Item>,
    F:FnMut(&Self::Item) ->Result<bool, Self::Error>, 
[src]

fnfold<B, F>(self, init: B, f: F) ->Result<B, Self::Error>where
    F:FnMut(B, Self::Item) ->Result<B, Self::Error>, 
[src]

fntry_fold<B, E, F>(&mut self, init: B, f: F) ->Result<B, E>where
    E:From<Self::Error>,
    F:FnMut(B, Self::Item) ->Result<B, E>, 
[src]

fnall<F>(&mut self, f: F) ->Result<bool, Self::Error>where
    F:FnMut(Self::Item) ->Result<bool, Self::Error>, 
[src]

fnany<F>(&mut self, f: F) ->Result<bool, Self::Error>where
    F:FnMut(Self::Item) ->Result<bool, Self::Error>, 
[src]

fnfind<F>(&mut self, f: F) ->Result<Option<Self::Item>, Self::Error>where
    F:FnMut(&Self::Item) ->Result<bool, Self::Error>, 
[src]

fnfind_map<B, F>(&mut self, f: F) ->Result<Option<B>, Self::Error>where
    F:FnMut(Self::Item) ->Result<Option<B>, Self::Error>, 
[src]

fnposition<F>(&mut self, f: F) ->Result<Option<usize>, Self::Error>where
    F:FnMut(Self::Item) ->Result<bool, Self::Error>, 
[src]

fnmax(self) ->Result<Option<Self::Item>, Self::Error>where
    Self::Item:Ord
[src]

fnmax_by_key<B, F>(self, f: F) ->Result<Option<Self::Item>, Self::Error>where
    B:Ord,
    F:FnMut(&Self::Item) ->Result<B, Self::Error>, 
[src]

fnmax_by<F>(self, f: F) ->Result<Option<Self::Item>, Self::Error>where
    F:FnMut(&Self::Item, &Self::Item) ->Result<Ordering, Self::Error>, 
[src]

fnmin(self) ->Result<Option<Self::Item>, Self::Error>where
    Self::Item:Ord
[src]

fnmin_by_key<B, F>(self, f: F) ->Result<Option<Self::Item>, Self::Error>where
    B:Ord,
    F:FnMut(&Self::Item) ->Result<B, Self::Error>, 
[src]

fnmin_by<F>(self, f: F) ->Result<Option<Self::Item>, Self::Error>where
    F:FnMut(&Self::Item, &Self::Item) ->Result<Ordering, Self::Error>, 
[src]

fnrev(self) ->Rev<Self>where
    Self:DoubleEndedFallibleIterator
[src]

fnunzip<A, B, FromA, FromB>(self) ->Result<(FromA, FromB), Self::Error>where
    FromA:Default +Extend<A>,
    FromB:Default +Extend<B>,
    Self:FallibleIterator<Item =(A, B)>, 
[src]

fncloned<'a, T>(self) ->Cloned<Self>where
    Self:FallibleIterator<Item =&'aT>,
    T: 'a +Clone
[src]

fncycle(self) ->Cycle<Self>where
    Self:Clone
[src]

fncmp<I>(self, other: I) ->Result<Ordering, Self::Error>where
    I:IntoFallibleIterator<Item = Self::Item, Error = Self::Error>,
    Self::Item:Ord
[src]

fnpartial_cmp<I>(self, other: I) ->Result<Option<Ordering>, Self::Error>where
    I:IntoFallibleIterator<Error = Self::Error>,
    Self::Item:PartialOrd<<I asIntoFallibleIterator>::Item>, 
[src]

fneq<I>(self, other: I) ->Result<bool, Self::Error>where
    I:IntoFallibleIterator<Error = Self::Error>,
    Self::Item:PartialEq<<I asIntoFallibleIterator>::Item>, 
[src]

fnne<I>(self, other: I) ->Result<bool, Self::Error>where
    I:IntoFallibleIterator<Error = Self::Error>,
    Self::Item:PartialEq<<I asIntoFallibleIterator>::Item>, 
[src]

fnlt<I>(self, other: I) ->Result<bool, Self::Error>where
    I:IntoFallibleIterator<Error = Self::Error>,
    Self::Item:PartialOrd<<I asIntoFallibleIterator>::Item>, 
[src]

fnle<I>(self, other: I) ->Result<bool, Self::Error>where
    I:IntoFallibleIterator<Error = Self::Error>,
    Self::Item:PartialOrd<<I asIntoFallibleIterator>::Item>, 
[src]

fngt<I>(self, other: I) ->Result<bool, Self::Error>where
    I:IntoFallibleIterator<Error = Self::Error>,
    Self::Item:PartialOrd<<I asIntoFallibleIterator>::Item>, 
[src]

fnge<I>(self, other: I) ->Result<bool, Self::Error>where
    I:IntoFallibleIterator<Error = Self::Error>,
    Self::Item:PartialOrd<<I asIntoFallibleIterator>::Item>, 
[src]

fniterator(self) ->Iterator<Self>[src]

fnmap_err<B, F>(self, f: F) ->MapErr<Self, F>where
    F:FnMut(Self::Error) -> B, 
[src]

Auto Trait Implementations

impl<'a> !RefUnwindSafe forRowIter<'a>

impl<'a>Send forRowIter<'a>

impl<'a>Sync forRowIter<'a>

impl<'a>Unpin forRowIter<'a>

impl<'a> !UnwindSafe forRowIter<'a>

Blanket Implementations

impl<T>Any for Twhere
    T: 'static + ?Sized
[src]

fntype_id(&self) ->TypeId[src]

impl<T>Borrow<T> for Twhere
    T: ?Sized
[src]

fnborrow(&self) ->&T[src]

impl<T>BorrowMut<T> for Twhere
    T: ?Sized
[src]

fnborrow_mut(&mut self) ->&mutT[src]

impl<T>From<T> for T[src]

fnfrom(t: T) -> T[src]

impl<T, U>Into<U> for Twhere
    U:From<T>, 
[src]

fninto(self) -> U[src]

impl<I>IntoFallibleIterator for Iwhere
    I:FallibleIterator
[src]

typeItem = <I asFallibleIterator>::Item

The elements of the iterator.

typeError = <I asFallibleIterator>::Error

The error value of the iterator.

typeIntoFallibleIter = I

The iterator.

fninto_fallible_iter(self) -> I[src]

impl<T> Same<T> for T

typeOutput = T

Should always beSelf

impl<T, U>TryFrom<U> for Twhere
    U:Into<T>, 
[src]

typeError =Infallible

The type returned in the event of a conversion error.

fntry_from(value: U) ->Result<T, <T asTryFrom<U>>::Error>[src]

impl<T, U>TryInto<U> for Twhere
    U:TryFrom<T>, 
[src]

typeError = <U asTryFrom<T>>::Error

The type returned in the event of a conversion error.

fntry_into(self) ->Result<U, <U asTryFrom<T>>::Error>[src]

impl<V, T> VZip<V> for Twhere
    V: MultiLane<T>, 

fnvzip(self) -> V


[8]ページ先頭

©2009-2025 Movatter.jp