Trait cron::lib::std::prelude::v1::v1::Send

pub unsafe auto trait Send { }

Types that can be transferred across thread boundaries.

This trait is automatically implemented when the compiler determines it's appropriate.

An example of a non-Send type is the reference-counting pointer rc::Rc. If two threads attempt to clone Rcs that point to the same reference-counted value, they might try to update the reference count at the same time, which is undefined behavior because Rc doesn't use atomic operations. Its cousin sync::Arc does use atomic operations (incurring some overhead) and thus is Send.

See the Nomicon for more details.

Implementations on Foreign Types

impl Send for Argument

impl Send for FormatSpec

impl Send for Alignment

impl Send for Count

impl Send for Error

impl Send for ErrorKind

impl<T> Send for Sender<T> where
    T: Send, 

impl<T> Send for SyncSender<T> where
    T: Send, 

impl !Send for Args

impl<'a> Send for IoSlice<'a>

impl<'a> Send for IoSliceMut<'a>

impl<'_, T> !Send for RwLockReadGuard<'_, T> where
    T: ?Sized, 

impl<'_, T> !Send for RwLockWriteGuard<'_, T> where
    T: ?Sized, 

impl<T> Send for RwLock<T> where
    T: Send + ?Sized, 

impl Send for Once

impl<'_, T> !Send for MutexGuard<'_, T> where
    T: ?Sized, 

impl !Send for ArgsOs

impl<T> Send for JoinHandle<T>

impl<T> Send for Receiver<T> where
    T: Send, 

impl<T> Send for Mutex<T> where
    T: Send + ?Sized, 

impl<T> Send for Cell<T> where
    T: Send + ?Sized, 

impl<T> !Send for *const T where
    T: ?Sized, 

impl<T> !Send for *mut T where
    T: ?Sized, 

impl<'_, T> Send for &'_ T where
    T: Sync + ?Sized, 

impl Send for Waker

impl<T> !Send for NonNull<T> where
    T: ?Sized, 

NonNull pointers are not Send because the data they reference may be aliased.

impl<'_, T> Send for &'_ mut T where
    T: Send + ?Sized, 

impl<T> Send for AtomicPtr<T>

impl<T> Send for RefCell<T> where
    T: Send + ?Sized, 

impl<T> !Send for Weak<T> where
    T: ?Sized, 

impl<T> Send for Weak<T> where
    T: Send + Sync + ?Sized, 

impl<T> Send for Arc<T> where
    T: Send + Sync + ?Sized, 

impl<T> !Send for Rc<T> where
    T: ?Sized, 

impl<'_, K, V> Send for RustcOccupiedEntry<'_, K, V> where
    K: Send,
    V: Send, 

impl<'_, K, V> Send for IterMut<'_, K, V> where
    K: Send,
    V: Send, 

impl<'_, K, V> Send for RawOccupiedEntryMut<'_, K, V> where
    K: Send,
    V: Send, 

impl<'_, K, V, S> Send for OccupiedEntry<'_, K, V, S> where
    K: Send,
    S: Send,
    V: Send, 

impl Send for isize

impl Send for i8

impl Send for i16

impl Send for i32

impl Send for i64

impl Send for i128

impl Send for usize

impl Send for u8

impl Send for u16

impl Send for u32

impl Send for u64

impl Send for u128

impl Send for f32

impl Send for f64

impl Send for bool

impl Send for char

impl Send for str

impl<T> Send for [T] where
    T: Send, 

impl Send for [u8]

Loading content...

Implementors

impl<'_> Send for cron::lib::std::string::Drain<'_>

impl<'_, T> Send for Cursor<'_, T> where
    T: Sync, 

impl<'_, T> Send for CursorMut<'_, T> where
    T: Send, 

impl<'_, T> Send for cron::lib::std::collections::linked_list::Iter<'_, T> where
    T: Sync, 

impl<'_, T> Send for cron::lib::std::collections::linked_list::IterMut<'_, T> where
    T: Send, 

impl<'_, T> Send for cron::lib::std::collections::vec_deque::Drain<'_, T> where
    T: Send, 

impl<'_, T> Send for cron::lib::std::slice::Iter<'_, T> where
    T: Sync, 

impl<'_, T> Send for cron::lib::std::slice::IterMut<'_, T> where
    T: Send, 

impl<'_, T> Send for cron::lib::std::vec::Drain<'_, T> where
    T: Send, 

impl<T> Send for Empty<T>

impl<T> Send for LinkedList<T> where
    T: Send, 

impl<T> Send for cron::lib::std::vec::IntoIter<T> where
    T: Send, 

impl<Tz> Send for Date<Tz> where
    Tz: TimeZone,
    <Tz as TimeZone>::Offset: Send, 

impl<Tz> Send for DateTime<Tz> where
    Tz: TimeZone,
    <Tz as TimeZone>::Offset: Send, 

Loading content...

Auto implementors

impl Send for Weekday

impl Send for Local

impl Send for Utc

impl Send for FixedOffset

impl Send for NaiveDate

impl Send for NaiveTime

impl Send for NaiveDateTime

impl Send for SecondsFormat

impl Send for IsoWeek

impl Send for Pad

impl Send for Numeric

impl Send for InternalNumeric

impl Send for Fixed

impl Send for InternalFixed

impl Send for ParseError

impl Send for Parsed

impl Send for ParseWeekdayError

impl Send for Duration

impl Send for String

impl Send for Ordering

impl Send for RandomState

impl Send for DefaultHasher

impl Send for TryReserveError

impl Send for Infallible

impl Send for cron::lib::std::fmt::Alignment

impl Send for cron::lib::std::fmt::Error

impl Send for SipHasher

impl Send for RangeFull

impl Send for NoneError

impl Send for SearchStep

impl Send for ParseBoolError

impl Send for Needed

impl Send for CompareResult

impl Send for Endianness

impl Send for cron::example_generated::inner::Error

impl Send for cron::example_generated::inner::ErrorKind

impl Send for cron::example_generated::Error

impl Send for cron::example_generated::ErrorKind

impl Send for Backtrace

impl Send for cron::error::Error

impl Send for cron::error::ErrorKind

impl Send for Schedule

impl Send for Field

impl Send for Specifier

impl Send for DaysOfMonth

impl Send for DaysOfWeek

impl Send for Hours

impl Send for Minutes

impl Send for Months

impl Send for Seconds

impl Send for Years

impl Send for Utf8Error

impl Send for FromUtf16Error

impl Send for FromUtf8Error

impl<'a> !Send for Arguments<'a>

impl<'a> !Send for Formatter<'a>

impl<'a> !Send for ErrorChainIter<'a>

impl<'a> Send for Item<'a>

impl<'a> Send for StrftimeItems<'a>

impl<'a> Send for CharSearcher<'a>

impl<'a> Send for SplitAsciiWhitespace<'a>

impl<'a> Send for SplitWhitespace<'a>

impl<'a> Send for Bytes<'a>

impl<'a> Send for CharIndices<'a>

impl<'a> Send for Chars<'a>

impl<'a> Send for EscapeDebug<'a>

impl<'a> Send for EscapeDefault<'a>

impl<'a> Send for EscapeUnicode<'a>

impl<'a> Send for Lines<'a>

impl<'a> Send for LinesAny<'a>

impl<'a> Send for CompleteStr<'a>

impl<'a> Send for CompleteByteSlice<'a>

impl<'a> Send for OrdinalIter<'a>

impl<'a> Send for OrdinalRangeIter<'a>

impl<'a> Send for EncodeUtf16<'a>

impl<'a, 'b> !Send for DebugList<'a, 'b>

impl<'a, 'b> !Send for DebugMap<'a, 'b>

impl<'a, 'b> !Send for DebugSet<'a, 'b>

impl<'a, 'b> !Send for DebugStruct<'a, 'b>

impl<'a, 'b> !Send for DebugTuple<'a, 'b>

impl<'a, 'b> Send for CharSliceSearcher<'a, 'b>

impl<'a, 'b> Send for StrSearcher<'a, 'b>

impl<'a, A> Send for cron::lib::std::option::Iter<'a, A> where
    A: Sync, 

impl<'a, A> Send for cron::lib::std::option::IterMut<'a, A> where
    A: Send, 

impl<'a, F> Send for CharPredicateSearcher<'a, F> where
    F: MultiCharEq + Send, 

impl<'a, I> Send for Splice<'a, I> where
    I: Send,
    <I as Iterator>::Item: Send, 

impl<'a, K> Send for cron::lib::std::collections::hash_set::Drain<'a, K> where
    K: Send, 

impl<'a, K> Send for cron::lib::std::collections::hash_set::Iter<'a, K> where
    K: Sync, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::Entry<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::Entry<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::Iter<'a, K, V> where
    K: Sync,
    V: Sync, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::IterMut<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::Keys<'a, K, V> where
    K: Sync,
    V: Sync, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::OccupiedEntry<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::Range<'a, K, V> where
    K: Sync,
    V: Sync, 

impl<'a, K, V> Send for RangeMut<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::VacantEntry<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::Values<'a, K, V> where
    K: Sync,
    V: Sync, 

impl<'a, K, V> Send for cron::lib::std::collections::btree_map::ValuesMut<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::Drain<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::Iter<'a, K, V> where
    K: Sync,
    V: Sync, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::IterMut<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::Keys<'a, K, V> where
    K: Sync,
    V: Sync, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::OccupiedEntry<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::RawOccupiedEntryMut<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::VacantEntry<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::Values<'a, K, V> where
    K: Sync,
    V: Sync, 

impl<'a, K, V> Send for cron::lib::std::collections::hash_map::ValuesMut<'a, K, V> where
    K: Send,
    V: Send, 

impl<'a, K, V, F> Send for cron::lib::std::collections::btree_map::DrainFilter<'a, K, V, F> where
    F: Send,
    K: Send,
    V: Send, 

impl<'a, K, V, S> Send for RawEntryMut<'a, K, V, S> where
    K: Send,
    S: Sync,
    V: Send, 

impl<'a, K, V, S> Send for RawEntryBuilder<'a, K, V, S> where
    K: Sync,
    S: Sync,
    V: Sync, 

impl<'a, K, V, S> Send for RawEntryBuilderMut<'a, K, V, S> where
    K: Send,
    S: Send,
    V: Send, 

impl<'a, K, V, S> Send for RawVacantEntryMut<'a, K, V, S> where
    K: Send,
    S: Sync,
    V: Send, 

impl<'a, P> Send for MatchIndices<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for Matches<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for RMatchIndices<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for RMatches<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for cron::lib::std::str::RSplit<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for cron::lib::std::str::RSplitN<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for RSplitTerminator<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for cron::lib::std::str::Split<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for cron::lib::std::str::SplitN<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, P> Send for SplitTerminator<'a, P> where
    <P as Pattern<'a>>::Searcher: Send, 

impl<'a, T> Send for cron::lib::std::collections::binary_heap::Drain<'a, T> where
    T: Send, 

impl<'a, T> Send for DrainSorted<'a, T> where
    T: Send, 

impl<'a, T> Send for cron::lib::std::collections::binary_heap::Iter<'a, T> where
    T: Sync, 

impl<'a, T> Send for PeekMut<'a, T> where
    T: Send, 

impl<'a, T> Send for cron::lib::std::collections::btree_set::Difference<'a, T> where
    T: Sync, 

impl<'a, T> Send for cron::lib::std::collections::btree_set::Intersection<'a, T> where
    T: Sync, 

impl<'a, T> Send for cron::lib::std::collections::btree_set::Iter<'a, T> where
    T: Sync, 

impl<'a, T> Send for cron::lib::std::collections::btree_set::Range<'a, T> where
    T: Sync, 

impl<'a, T> Send for cron::lib::std::collections::btree_set::SymmetricDifference<'a, T> where
    T: Sync, 

impl<'a, T> Send for cron::lib::std::collections::btree_set::Union<'a, T> where
    T: Sync, 

impl<'a, T> Send for cron::lib::std::collections::vec_deque::Iter<'a, T> where
    T: Sync, 

impl<'a, T> Send for cron::lib::std::collections::vec_deque::IterMut<'a, T> where
    T: Send, 

impl<'a, T> Send for cron::lib::std::result::Iter<'a, T> where
    T: Sync, 

impl<'a, T> Send for cron::lib::std::result::IterMut<'a, T> where
    T: Send, 

impl<'a, T> Send for Chunks<'a, T> where
    T: Sync, 

impl<'a, T> Send for ChunksExact<'a, T> where
    T: Sync, 

impl<'a, T> Send for ChunksExactMut<'a, T> where
    T: Send, 

impl<'a, T> Send for ChunksMut<'a, T> where
    T: Send, 

impl<'a, T> Send for RChunks<'a, T> where
    T: Sync, 

impl<'a, T> Send for RChunksExact<'a, T> where
    T: Sync, 

impl<'a, T> Send for RChunksExactMut<'a, T> where
    T: Send, 

impl<'a, T> Send for RChunksMut<'a, T> where
    T: Send, 

impl<'a, T> Send for Windows<'a, T> where
    T: Sync, 

impl<'a, T, F> !Send for cron::lib::std::collections::linked_list::DrainFilter<'a, T, F>

impl<'a, T, F> Send for cron::lib::std::collections::btree_set::DrainFilter<'a, T, F> where
    F: Send,
    T: Send, 

impl<'a, T, F> Send for cron::lib::std::vec::DrainFilter<'a, T, F> where
    F: Send,
    T: Send, 

impl<'a, T, P> Send for cron::lib::std::slice::RSplit<'a, T, P> where
    P: Send,
    T: Sync, 

impl<'a, T, P> Send for RSplitMut<'a, T, P> where
    P: Send,
    T: Send, 

impl<'a, T, P> Send for cron::lib::std::slice::RSplitN<'a, T, P> where
    P: Send,
    T: Sync, 

impl<'a, T, P> Send for RSplitNMut<'a, T, P> where
    P: Send,
    T: Send, 

impl<'a, T, P> Send for cron::lib::std::slice::Split<'a, T, P> where
    P: Send,
    T: Sync, 

impl<'a, T, P> Send for SplitMut<'a, T, P> where
    P: Send,
    T: Send, 

impl<'a, T, P> Send for cron::lib::std::slice::SplitN<'a, T, P> where
    P: Send,
    T: Sync, 

impl<'a, T, P> Send for SplitNMut<'a, T, P> where
    P: Send,
    T: Send, 

impl<'a, T, S> Send for cron::lib::std::collections::hash_set::Difference<'a, T, S> where
    S: Sync,
    T: Sync, 

impl<'a, T, S> Send for cron::lib::std::collections::hash_set::Intersection<'a, T, S> where
    S: Sync,
    T: Sync, 

impl<'a, T, S> Send for cron::lib::std::collections::hash_set::SymmetricDifference<'a, T, S> where
    S: Sync,
    T: Sync, 

impl<'a, T, S> Send for cron::lib::std::collections::hash_set::Union<'a, T, S> where
    S: Sync,
    T: Sync, 

impl<'a, T: ?Sized> Send for Display<'a, T> where
    T: Sync, 

impl<'a, Z> Send for ScheduleIterator<'a, Z> where
    <Z as TimeZone>::Offset: Send, 

impl<A> Send for Repeat<A> where
    A: Send, 

impl<A> Send for cron::lib::std::option::IntoIter<A> where
    A: Send, 

impl<A, B> Send for Chain<A, B> where
    A: Send,
    B: Send, 

impl<A, B> Send for Zip<A, B> where
    A: Send,
    B: Send, 

impl<E> Send for cron::ErrorKind<E> where
    E: Send, 

impl<F> Send for FromFn<F> where
    F: Send, 

impl<F> Send for OnceWith<F> where
    F: Send, 

impl<F> Send for RepeatWith<F> where
    F: Send, 

impl<H> Send for BuildHasherDefault<H> where
    H: Send, 

impl<I> Send for DelayedFormat<I> where
    I: Send, 

impl<I> Send for Cloned<I> where
    I: Send, 

impl<I> Send for Copied<I> where
    I: Send, 

impl<I> Send for Cycle<I> where
    I: Send, 

impl<I> Send for Enumerate<I> where
    I: Send, 

impl<I> Send for Flatten<I> where
    I: Send,
    <<I as Iterator>::Item as IntoIterator>::IntoIter: Send, 

impl<I> Send for Fuse<I> where
    I: Send, 

impl<I> Send for Peekable<I> where
    I: Send,
    <I as Iterator>::Item: Send, 

impl<I> Send for Skip<I> where
    I: Send, 

impl<I> Send for StepBy<I> where
    I: Send, 

impl<I> Send for Take<I> where
    I: Send, 

impl<I, E> Send for Context<I, E> where
    E: Send,
    I: Send, 

impl<I, E> Send for Err<I, E> where
    E: Send,
    I: Send, 

impl<I, F> Send for FilterMap<I, F> where
    F: Send,
    I: Send, 

impl<I, F> Send for Inspect<I, F> where
    F: Send,
    I: Send, 

impl<I, F> Send for Map<I, F> where
    F: Send,
    I: Send, 

impl<I, P> Send for Filter<I, P> where
    I: Send,
    P: Send, 

impl<I, P> Send for MapWhile<I, P> where
    I: Send,
    P: Send, 

impl<I, P> Send for SkipWhile<I, P> where
    I: Send,
    P: Send, 

impl<I, P> Send for TakeWhile<I, P> where
    I: Send,
    P: Send, 

impl<I, St, F> Send for Scan<I, St, F> where
    F: Send,
    I: Send,
    St: Send, 

impl<I, U, F> Send for FlatMap<I, U, F> where
    F: Send,
    I: Send,
    <U as IntoIterator>::IntoIter: Send, 

impl<Idx> Send for cron::lib::std::ops::Range<Idx> where
    Idx: Send, 

impl<Idx> Send for RangeFrom<Idx> where
    Idx: Send, 

impl<Idx> Send for RangeInclusive<Idx> where
    Idx: Send, 

impl<Idx> Send for RangeTo<Idx> where
    Idx: Send, 

impl<Idx> Send for RangeToInclusive<Idx> where
    Idx: Send, 

impl<K> Send for cron::lib::std::collections::hash_set::IntoIter<K> where
    K: Send, 

impl<K, V> Send for cron::lib::std::collections::btree_map::IntoIter<K, V> where
    K: Send,
    V: Send, 

impl<K, V> Send for cron::lib::std::collections::hash_map::IntoIter<K, V> where
    K: Send,
    V: Send, 

impl<K, V> Send for BTreeMap<K, V> where
    K: Send,
    V: Send, 

impl<K, V, S> Send for HashMap<K, V, S> where
    K: Send,
    S: Send,
    V: Send, 

impl<T> Send for LocalResult<T> where
    T: Send, 

impl<T> Send for Bound<T> where
    T: Send, 

impl<T> Send for Option<T> where
    T: Send, 

impl<T> Send for Reverse<T> where
    T: Send, 

impl<T> Send for cron::lib::std::collections::binary_heap::IntoIter<T> where
    T: Send, 

impl<T> Send for IntoIterSorted<T> where
    T: Send, 

impl<T> Send for cron::lib::std::collections::btree_set::IntoIter<T> where
    T: Send, 

impl<T> Send for cron::lib::std::collections::linked_list::IntoIter<T> where
    T: Send, 

impl<T> Send for BTreeSet<T> where
    T: Send, 

impl<T> Send for BinaryHeap<T> where
    T: Send, 

impl<T> Send for VecDeque<T> where
    T: Send, 

impl<T> Send for cron::lib::std::collections::vec_deque::IntoIter<T> where
    T: Send, 

impl<T> Send for cron::lib::std::iter::Once<T> where
    T: Send, 

impl<T> Send for Rev<T> where
    T: Send, 

impl<T> Send for Discriminant<T> where
    <T as DiscriminantKind>::Discriminant: Send, 

impl<T> Send for cron::lib::std::result::IntoIter<T> where
    T: Send, 

impl<T> Send for Vec<T> where
    T: Send, 

impl<T> Send for Input<T> where
    T: Send, 

impl<T> Send for MaybeUninit<T> where
    T: Send, 

impl<T, E> Send for Result<T, E> where
    E: Send,
    T: Send, 

impl<T, F> Send for Successors<T, F> where
    F: Send,
    T: Send, 

impl<T, S> Send for HashSet<T, S> where
    S: Send,
    T: Send, 

impl<T: ?Sized> Send for Box<T> where
    T: Send, 

impl<T: ?Sized> Send for ManuallyDrop<T> where
    T: Send, 

impl<Y, R> Send for GeneratorState<Y, R> where
    R: Send,
    Y: Send, 

Loading content...