Lines Matching full:safety

32 //! Rust memory safety is based on this rule: Given an object `T`, it is only
55 //! maintaining Rust's safety guarantees.  For this reason, unlike
60 //! release builds, providing runtime safety during development with no overhead
74 //! thread-safety issues.
153 //! safety by modifying memory even if it is shared.  Furthermore, C structs
161 //! require `unsafe` blocks, making it clear where safety guarantees must be
229         // SAFETY: integration tests are run with --test-threads=1, while  in bql_start_test()
239     // SAFETY: the function does nothing but return a thread-local bool  in bql_locked()
245         // SAFETY: this only adjusts a counter  in bql_block_unlock()
262 // SAFETY: Same as for std::sync::Mutex.  In the end this *is* a Mutex,
376         // SAFETY: This can cause data races if called from multiple threads,  in replace()
417         // SAFETY: This can cause data races if called from multiple threads,  in get()
610             // SAFETY: `BorrowRef` ensures that there is only immutable access  in borrow()
662             // SAFETY: this only adjusts a counter  in borrow_mut()
665             // SAFETY: `BorrowRefMut` guarantees unique access.  in borrow_mut()
694 // SAFETY: Same as for std::sync::Mutex.  In the end this is a Mutex that is
835         // SAFETY: the value is accessible as long as we hold our borrow.  in deref()
918         // SAFETY: the value is accessible as long as we hold our borrow.  in deref()
926         // SAFETY: the value is accessible as long as we hold our borrow.  in deref_mut()
969     /// # Safety
974         // SAFETY: Self is a transparent wrapper over T  in from_raw()
980     /// # Safety
997     /// # Safety
1048     /// # Safety
1081 /// # Safety