• aardvark-dns 1.4.0/src/server/serve.rs
    80
    		 
                // so manually allow this
    81
    		 
                #[allow(clippy::mutex_atomic)]
    82
    		 
                let kill_switch = Arc::new(Mutex::new(false));
  • actix 0.13.0/tests/test_sync.rs
    60
    		 
    #[test]
    61
    		 
    #[allow(clippy::mutex_atomic)]
    62
    		 
    fn test_sync() {
  • actori 0.9.0/tests/test_sync.rs
    60
    		 
    #[test]
    61
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(mutex_atomic))]
    62
    		 
    fn test_sync() {
  • akd_mysql 0.8.8/src/mysql.rs
    127
    		 
            #[allow(clippy::mutex_atomic)]
    128
    		 
            let healthy = Arc::new(tokio::sync::RwLock::new(false));
  • autd-soem-link 9.0.1/src/soem_handler.rs
    80
    		 
    #[allow(clippy::mutex_atomic)]
    81
    		 
    impl RuSOEM {
  • authenticator 0.4.0-alpha.7/src/statecallback.rs
    14
    		 
        // This is used for the Condvar, which requires this kind of construction
    15
    		 
        #[allow(clippy::mutex_atomic)]
    16
    		 
        pub fn new(cb: Box<dyn Fn(T) + Send>) -> Self {
  • authenticator-ctap2-2021 0.3.2-dev.1/src/statecallback.rs
    14
    		 
        // This is used for the Condvar, which requires this kind of construction
    15
    		 
        #[allow(clippy::mutex_atomic)]
    16
    		 
        pub fn new(cb: Box<dyn Fn(T) + Send>) -> Self {
  • aws-smithy-client 0.54.1/src/retry.rs
    218
    		 
    // significantly more complicated for negligible benefit.
    219
    		 
    #[allow(clippy::mutex_atomic)]
    220
    		 
    impl CrossRequestRetryState {
  • bastion 0.4.5/src/dispatcher.rs
    650
    		 
        // the bool value
    651
    		 
        #[allow(clippy::mutex_atomic)]
    652
    		 
        impl CustomHandler {
  • bastion 0.4.5/src/system.rs
    49
    		 
    #[allow(clippy::mutex_atomic)]
    50
    		 
    impl GlobalSystem {
  • bastion-executor 0.4.2/src/sleepers.rs
    12
    		 
    #[derive(Debug)]
    13
    		 
    #[allow(clippy::mutex_atomic)]
    14
    		 
    pub struct Sleepers {
    25
    		 
    #[allow(clippy::mutex_atomic)]
    26
    		 
    impl Default for Sleepers {
    37
    		 
    #[allow(clippy::mutex_atomic)]
    38
    		 
    impl Sleepers {
  • bdk 0.26.0/src/blockchain/compact_filters/mod.rs
    273
    		 
    impl WalletSync for CompactFiltersBlockchain {
    274
    		 
        #[allow(clippy::mutex_atomic)] // Mutex is easier to understand than a CAS loop.
    275
    		 
        fn wallet_setup<D: BatchDatabase>(
    333
    		 
            #[allow(clippy::mutex_atomic)]
    334
    		 
            let last_synced_block = Arc::new(Mutex::new(synced_height));
  • bottom 0.8.0/src/bin/main.rs
    74
    		 
        // Create termination mutex and cvar
    75
    		 
        #[allow(clippy::mutex_atomic)]
    76
    		 
        let thread_termination_lock = Arc::new(Mutex::new(false));
  • cala 0.9.0/src/graphics.rs
    204
    		 
            // It's in the Condvar docs, so this is the recommended way to do it.
    205
    		 
            #[allow(clippy::mutex_atomic)]
    206
    		 
            unsafe {
  • callbag 0.14.0/tests/flatten.rs
    822
    		 
        let nursery = nursery.in_current_span();
    823
    		 
        #[allow(clippy::mutex_atomic)]
    824
    		 
        let ready_pair = Arc::new((Mutex::new(false), Condvar::new()));
    944
    		 
        let nursery = nursery.in_current_span();
    945
    		 
        #[allow(clippy::mutex_atomic)]
    946
    		 
        let ready_pair = Arc::new((Mutex::new(false), Condvar::new()));
  • callbag 0.14.0/tests/share.rs
    233
    		 
        let nursery = nursery.in_current_span();
    234
    		 
        #[allow(clippy::mutex_atomic)]
    235
    		 
        let ready_pair = Arc::new((Mutex::new(false), Condvar::new()));
  • ciboulette2pg 0.1.3/src/tests/mod.rs
    13
    		 
    mod response_elements;
    14
    		 
    #[allow(clippy::mutex_atomic)]
    15
    		 
    // mod run_migrations;
  • ckb-sentry-core 0.21.0/src/session.rs
    145
    		 
            let queue = Arc::new(Mutex::new(Vec::new()));
    146
    		 
            #[allow(clippy::mutex_atomic)]
    147
    		 
            let shutdown = Arc::new((Mutex::new(false), Condvar::new()));
  • cogo 0.1.36/src/std/sync/blocking.rs
    9
    		 
    #[derive(Debug)]
    10
    		 
    #[allow(clippy::mutex_atomic)]
    11
    		 
    pub struct ThreadPark {
    16
    		 
    #[allow(clippy::mutex_atomic)]
    17
    		 
    impl ThreadPark {
  • containerd-shim 0.3.0/src/synchronous/mod.rs
    68
    		 
    /// Shim implementations are responsible for calling [`Self::signal`].
    69
    		 
    #[allow(clippy::mutex_atomic)] // Condvar expected to be used with Mutex, not AtomicBool.
    70
    		 
    #[derive(Default)]
    73
    		 
    #[allow(clippy::mutex_atomic)]
    74
    		 
    impl ExitSignal {
  • crusty-core 0.82.0/src/hyper_utils.rs
    19
    		 
    impl Stats {
    20
    		 
    	#[allow(clippy::mutex_atomic)]
    21
    		 
    	pub fn new() -> Self {
  • dbs-upcall 0.1.0/src/lib.rs
    669
    		 
        #[allow(clippy::mutex_atomic)]
    670
    		 
        #[test]
  • dbs-virtio-devices 0.1.1/src/vsock/backend/inner.rs
    856
    		 
        #[test]
    857
    		 
        #[allow(clippy::mutex_atomic)]
    858
    		 
        fn test_inner_stream_timeout() {
  • electrscash 3.1.0/src/store.rs
    71
    		 
            block_opts.set_block_size(if opts.low_memory { 256 << 10 } else { 1 << 20 });
    72
    		 
            #[allow(clippy::mutex_atomic)]
    73
    		 
            let mut store = DbStore {
  • entity-gym-rs 0.8.0/src/low_level/vec_env.rs
    39
    		 
    impl VecEnv {
    40
    		 
        #[allow(clippy::mutex_atomic)]
    41
    		 
        pub fn new<T: Environment + Send + 'static>(
  • esp-idf-svc 0.45.0/src/ping.rs
    233
    		 
        #[allow(clippy::mutex_atomic)]
    234
    		 
        unsafe extern "C" fn on_ping_end<F: Fn(&Summary, &Reply)>(
    312
    		 
    impl<'a, F: Fn(&Summary, &Reply)> Tracker<'a, F> {
    313
    		 
        #[allow(clippy::mutex_atomic)]
    314
    		 
        pub fn new(reply_callback: Option<&'a F>) -> Self {
  • fclones 0.29.3/src/semaphore.rs
    41
    		 
    #[allow(clippy::mutex_atomic, unused)]
    42
    		 
    impl Semaphore {
  • find-simdoc 0.1.1/src/cosine.rs
    172
    		 
            let extractor = FeatureExtractor::new(&self.config);
    173
    		 
            #[allow(clippy::mutex_atomic)]
    174
    		 
            let processed = Mutex::new(0usize);
    179
    		 
                .map(|(i, doc)| {
    180
    		 
                    #[allow(clippy::mutex_atomic)]
    181
    		 
                    {
  • find-simdoc 0.1.1/src/jaccard.rs
    133
    		 
            let extractor = FeatureExtractor::new(&self.config);
    134
    		 
            #[allow(clippy::mutex_atomic)]
    135
    		 
            let processed = Mutex::new(0usize);
    140
    		 
                .map(|(i, doc)| {
    141
    		 
                    #[allow(clippy::mutex_atomic)]
    142
    		 
                    {
  • foundationdb 0.7.0/src/api.rs
    145
    		 
        /// ```
    146
    		 
        #[allow(clippy::mutex_atomic)]
    147
    		 
        pub fn build(self) -> FdbResult<(NetworkRunner, NetworkWait)> {
  • froop 0.1.1/src/lib.rs
    930
    		 
        /// ```
    931
    		 
        #[allow(clippy::mutex_atomic)]
    932
    		 
        pub fn wait(&self) {
  • gemachain-runtime 1.8.2/src/bucket_map_holder.rs
    51
    		 
    #[allow(clippy::mutex_atomic)]
    52
    		 
    impl<T: IndexValue> BucketMapHolder<T> {
  • glean-core 52.2.0/src/scheduler.rs
    24
    		 
    // See https://github.com/rust-lang/rust-clippy/issues/1516
    25
    		 
    #[allow(clippy::mutex_atomic)]
    26
    		 
    static TASK_CONDVAR: Lazy<Arc<(Mutex<bool>, Condvar)>> =
  • graphannis 2.4.2/src/annis/db/corpusstorage.rs
    447
    		 
            #[allow(clippy::mutex_atomic)]
    448
    		 
            let active_background_workers = Arc::new((Mutex::new(0), Condvar::new()));
    476
    		 
            #[allow(clippy::mutex_atomic)]
    477
    		 
            let active_background_workers = Arc::new((Mutex::new(0), Condvar::new()));
  • gst-plugin-threadshare 0.9.3/src/runtime/executor/mod.rs
    35
    		 
    // We need the `Mutex<bool>` to work in pair with `Condvar`.
    36
    		 
    #[allow(clippy::mutex_atomic)]
    37
    		 
    mod scheduler;
  • httptest 0.15.4/src/server_pool.rs
    70
    		 
    #[allow(clippy::mutex_atomic)]
    71
    		 
    #[derive(Debug)]
    78
    		 
    #[allow(clippy::mutex_atomic)]
    79
    		 
    impl InnerPool {
    121
    		 
    #[allow(clippy::mutex_atomic)]
    122
    		 
    impl Drop for InnerPool {
  • i3status-rs 0.22.0/src/blocks/bluetooth.rs
    96
    		 
            // TODO: revisit this lint
    97
    		 
            #[allow(clippy::mutex_atomic)]
    98
    		 
            let available = Arc::new(Mutex::new(initial_available));
  • i3status-rs 0.22.0/src/blocks/ibus.rs
    90
    		 
            // TODO: revisit this lint
    91
    		 
            #[allow(clippy::mutex_atomic)]
    92
    		 
            let available = Arc::new((Mutex::new(running), Condvar::new()));
  • i3status-rs 0.22.0/src/blocks/kdeconnect.rs
    209
    		 
            // TODO: revisit this lint
    210
    		 
            #[allow(clippy::mutex_atomic)]
    211
    		 
            let charging = Arc::new(Mutex::new(initial_charging));
    217
    		 
            // TODO: revisit this lint
    218
    		 
            #[allow(clippy::mutex_atomic)]
    219
    		 
            let reachable = Arc::new(Mutex::new(initial_reachable));
  • i3status-rs 0.22.0/src/blocks/notify.rs
    60
    		 
            // TODO: revisit this lint
    61
    		 
            #[allow(clippy::mutex_atomic)]
    62
    		 
            let state = Arc::new(Mutex::new(initial_state as i64));
  • indicatif 0.17.3/src/progress_bar.rs
    606
    		 
            // the thread and interrupt the ticker wait.
    607
    		 
            #[allow(clippy::mutex_atomic)]
    608
    		 
            let stopping = Arc::new((Mutex::new(false), Condvar::new()));
  • infisearch 0.10.0/src/indexer.rs
    60
    		 
    impl Indexer {
    61
    		 
        #[allow(clippy::mutex_atomic)]
    62
    		 
        pub fn new(
  • investments 4.16.1/src/quotes/mod.rs
    336
    		 
        #[test]
    337
    		 
        #[allow(clippy::mutex_atomic)]
    338
    		 
        fn cache() {
  • isla 0.2.0/src/execute-function.rs
    79
    		 
    #[allow(clippy::mutex_atomic)]
    80
    		 
    fn isla_main() -> i32 {
  • isla 0.2.0/src/property.rs
    51
    		 
    #[allow(clippy::mutex_atomic)]
    52
    		 
    fn isla_main() -> i32 {
  • isla 0.2.0/src/property129.rs
    51
    		 
    #[allow(clippy::mutex_atomic)]
    52
    		 
    fn isla_main() -> i32 {
  • libafl 0.9.0/src/bolts/os/unix_shmem_server.rs
    395
    		 
            #[allow(clippy::mutex_atomic)]
    396
    		 
            let syncpair = Arc::new((Mutex::new(ShMemServiceStatus::Starting), Condvar::new()));
  • livi 0.7.0/src/plugin.rs
    143
    		 
            let mut inner = instance.activate();
    144
    		 
            #[allow(clippy::mutex_atomic)]
    145
    		 
            let is_alive = Arc::new(Mutex::new(true));
  • lsm 0.1.0/src/level.rs
    17
    		 
        index: usize,
    18
    		 
        #[ allow(clippy::mutex_atomic) ]
    19
    		 
        next_compaction: Mutex<usize>,
    27
    		 
        pub fn new(index: usize, data_blocks: Arc<DataBlocks>, params: Arc<Params>, manifest: Arc<Manifest>) -> Self {
    28
    		 
            #[ allow(clippy::mutex_atomic) ]
    29
    		 
            Self {
    120
    		 
        pub async fn start_compaction(&self) -> (Vec<usize>, Vec<Arc<SortedTable>>) {
    121
    		 
            #[ allow(clippy::mutex_atomic) ]
    122
    		 
            let mut next_compaction = self.next_compaction.lock().await;
  • may 0.3.36/src/sync/blocking.rs
    16
    		 
    #[allow(clippy::mutex_atomic)]
    17
    		 
    impl ThreadPark {
  • mco 0.1.44/src/std/sync/blocking.rs
    9
    		 
    #[derive(Debug)]
    10
    		 
    #[allow(clippy::mutex_atomic)]
    11
    		 
    pub struct ThreadPark {
    16
    		 
    #[allow(clippy::mutex_atomic)]
    17
    		 
    impl ThreadPark {
  • mediasoup 0.11.2/src/router/consumer.rs
    475
    		 
            let closed = Arc::new(AtomicBool::new(false));
    476
    		 
            #[allow(clippy::mutex_atomic)]
    477
    		 
            let paused = Arc::new(Mutex::new(paused));
    478
    		 
            #[allow(clippy::mutex_atomic)]
    479
    		 
            let producer_paused = Arc::new(Mutex::new(producer_paused));
  • morsels_indexer 0.7.3/src/indexer.rs
    56
    		 
    impl Indexer {
    57
    		 
        #[allow(clippy::mutex_atomic)]
    58
    		 
        pub fn new(
  • nkowne63-wordle-solver-rs-01 1.0.1/src/lib.rs
    15
    		 
    #[allow(clippy::mutex_atomic)]
    16
    		 
    static SHOW_CONSOLE: Lazy<Arc<Mutex<bool>>> = Lazy::new(|| Arc::new(Mutex::new(false)));
  • ntex 0.6.3/src/server/worker.rs
    577
    		 
        #[crate::rt_test]
    578
    		 
        #[allow(clippy::mutex_atomic)]
    579
    		 
        async fn basics() {
  • nydus-storage 0.6.0/src/backend/localfs.rs
    158
    		 
        #[allow(clippy::mutex_atomic)]
    159
    		 
        fn get_blob(&self, blob_id: &str) -> LocalFsResult<Arc<dyn BlobReader>> {
  • oxygengine-core 0.30.0/src/ecs/pipeline/engines/jobs.rs
    113
    		 
        pub fn new(jobs_count: usize) -> Self {
    114
    		 
            #[allow(clippy::mutex_atomic)]
    115
    		 
            let notifier = Arc::new((Mutex::new(false), Condvar::new()));
  • parsec-service 1.1.0/src/providers/pkcs11/mod.rs
    102
    		 
        ) -> Option<Provider> {
    103
    		 
            #[allow(clippy::mutex_atomic)]
    104
    		 
            let pkcs11_provider = Provider {
  • poolio 0.2.1/tests/basic.rs
    4
    		 
    #[test]
    5
    		 
    #[allow(clippy::mutex_atomic)]
    6
    		 
    fn test_basic() {
  • ppclient 0.2.2/src/ops/env/run/ssh.rs
    18
    		 
    /// 收集远端的输出内容并返回之
    19
    		 
    #[allow(clippy::mutex_atomic)]
    20
    		 
    pub(super) fn exec(
  • pyroscope 0.5.3/src/pyroscope.rs
    307
    		 
                running: Arc::new((
    308
    		 
                    #[allow(clippy::mutex_atomic)]
    309
    		 
                    Mutex::new(false),
  • rains 0.2.2/src/main.rs
    33
    		 
    #[allow(clippy::mutex_atomic)]
    34
    		 
    async fn run() -> Result<()> {
  • requiem 0.9.0/tests/test_sync.rs
    60
    		 
    #[test]
    61
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(mutex_atomic))]
    62
    		 
    fn test_sync() {
  • rosrust 0.9.10/src/util/lossy_channel.rs
    7
    		 
    #[allow(clippy::mutex_atomic)]
    8
    		 
    pub fn lossy_channel<T>(queue_size: usize) -> (LossySender<T>, LossyReceiver<T>) {
  • routing 0.37.1/examples/ci_test.rs
    383
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(mutex_atomic))]
    384
    		 
        pub fn run_main() {
  • rquickjs-core 0.1.7/src/value/function.rs
    453
    		 
            test_with(|ctx| {
    454
    		 
                #[allow(clippy::mutex_atomic)]
    455
    		 
                let called = Arc::new(Mutex::new(false));
  • rusqlite 0.28.0/src/inner_connection.rs
    42
    		 
    impl InnerConnection {
    43
    		 
        #[allow(clippy::mutex_atomic)]
    44
    		 
        #[inline]
    151
    		 
        #[allow(clippy::mutex_atomic)]
    152
    		 
        pub fn close(&mut self) -> Result<()> {
  • rusqlite 0.28.0/src/unlock_notify.rs
    15
    		 
    #[allow(clippy::mutex_atomic)]
    16
    		 
    impl UnlockNotification {
  • rusqlite-ic 0.28.1/src/inner_connection.rs
    44
    		 
    impl InnerConnection {
    45
    		 
        #[allow(clippy::mutex_atomic)]
    46
    		 
        #[inline]
    153
    		 
        #[allow(clippy::mutex_atomic)]
    154
    		 
        pub fn close(&mut self) -> Result<()> {
  • rusqlite-ic 0.28.1/src/unlock_notify.rs
    15
    		 
    #[allow(clippy::mutex_atomic)]
    16
    		 
    impl UnlockNotification {
  • rusqlite-le 0.24.2/src/inner_connection.rs
    38
    		 
    impl InnerConnection {
    39
    		 
        #[allow(clippy::mutex_atomic)]
    40
    		 
        #[inline]
    147
    		 
        #[allow(clippy::mutex_atomic)]
    148
    		 
        pub fn close(&mut self) -> Result<()> {
  • rusqlite-le 0.24.2/src/unlock_notify.rs
    19
    		 
    #[cfg(feature = "unlock_notify")]
    20
    		 
    #[allow(clippy::mutex_atomic)]
    21
    		 
    impl UnlockNotification {
  • safecoin-runtime 1.14.3/src/bucket_map_holder.rs
    66
    		 
    #[allow(clippy::mutex_atomic)]
    67
    		 
    impl<T: IndexValue> BucketMapHolder<T> {
  • scc 1.1.1/src/wait_queue.rs
    201
    		 
        fn new(next: usize) -> SyncWait {
    202
    		 
            #[allow(clippy::mutex_atomic)]
    203
    		 
            SyncWait {
    211
    		 
        fn wait(&self) {
    212
    		 
            #[allow(clippy::mutex_atomic)]
    213
    		 
            let mut completed = unsafe { self.mutex.lock().unwrap_unchecked() };
    220
    		 
        fn signal(&self) {
    221
    		 
            #[allow(clippy::mutex_atomic)]
    222
    		 
            let mut completed = unsafe { self.mutex.lock().unwrap_unchecked() };
  • scrappy-actor 0.0.1/tests/test_sync.rs
    60
    		 
    #[test]
    61
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(mutex_atomic))]
    62
    		 
    fn test_sync() {
  • sentry-core 0.29.2/src/session.rs
    193
    		 
            let queue = Arc::new(Mutex::new(Default::default()));
    194
    		 
            #[allow(clippy::mutex_atomic)]
    195
    		 
            let shutdown = Arc::new((Mutex::new(false), Condvar::new()));
  • shared-expiry-get 0.2.0/src/lib.rs
    176
    		 
        /// Wrap a [Provider](trait.Provider.html).
    177
    		 
        #[allow(clippy::mutex_atomic)]
    178
    		 
        pub fn new(p: P) -> Self {
  • sled 0.34.7/src/flusher.rs
    38
    		 
        ) -> Self {
    39
    		 
            #[allow(clippy::mutex_atomic)] // mutex used in CondVar below
    40
    		 
            let shutdown = Arc::new(Mutex::new(ShutdownState::Running));
  • sloggers 2.1.1/src/syslog/drain.rs
    50
    		 
    /// of `closelog` either clear the pointer or don't retain it at all.)
    51
    		 
    #[allow(clippy::mutex_atomic)]
    52
    		 
    static LAST_UNIQUE_IDENT: Lazy<Mutex<usize>> =
  • solana-runtime 1.14.13/src/bucket_map_holder.rs
    66
    		 
    #[allow(clippy::mutex_atomic)]
    67
    		 
    impl<T: IndexValue> BucketMapHolder<T> {
  • spdlog-rs 0.3.7/src/periodic_worker.rs
    11
    		 
        // Panic if the `interval.is_zero()` is `true`.
    12
    		 
        #[allow(clippy::mutex_atomic)]
    13
    		 
        #[must_use]
    38
    		 
    impl Drop for PeriodicWorker {
    39
    		 
        #[allow(clippy::mutex_atomic)]
    40
    		 
        fn drop(&mut self) {
  • stage 0.2.0/src/system/mod.rs
    137
    		 
    #[allow(clippy::mutex_atomic)]
    138
    		 
    fn spawn_reactor<T: StageReactor>(
  • stage 0.2.0/src/system/reactor.rs
    106
    		 
        #[allow(clippy::mutex_atomic)]
    107
    		 
        fn stop_system(&mut self) -> Loop {
  • sysinfo 0.27.7/src/linux/system.rs
    22
    		 
    // for processes using a lot of files and using sysinfo at the same time.
    23
    		 
    #[allow(clippy::mutex_atomic)]
    24
    		 
    pub(crate) static mut REMAINING_FILES: once_cell::sync::Lazy<Arc<Mutex<isize>>> =
  • ttclient 0.2.35/src/ops/env/run/ssh.rs
    19
    		 
    /// 收集远端的输出内容并返回之
    20
    		 
    #[allow(clippy::mutex_atomic)]
    21
    		 
    pub(super) fn exec(
    80
    		 
    /// 串行执行 ssh 交互式操作
    81
    		 
    #[allow(clippy::mutex_atomic)]
    82
    		 
    pub(super) fn exec_interactive(vm_conn_info: Vec<VmConnInfo>) -> ! {
  • ureq 2.6.2/src/stream.rs
    517
    		 
        // TODO: explore supporting timeouts upstream in Socks5Proxy.
    518
    		 
        #[allow(clippy::mutex_atomic)]
    519
    		 
        let stream = if let Some(deadline) = deadline {
  • vsdbsled 0.34.7-patched/src/flusher.rs
    38
    		 
        ) -> Self {
    39
    		 
            #[allow(clippy::mutex_atomic)] // mutex used in CondVar below
    40
    		 
            let shutdown = Arc::new(Mutex::new(ShutdownState::Running));
  • waffles-solana-runtime 1.15.0/src/bucket_map_holder.rs
    77
    		 
    #[allow(clippy::mutex_atomic)]
    78
    		 
    impl<T: IndexValue> BucketMapHolder<T> {
  • waketimed 0.5.2/tests/helpers/mod.rs
    176
    		 
    {
    177
    		 
        #[allow(clippy::mutex_atomic)]
    178
    		 
        let finished_setter = Arc::new((Mutex::new(false), Condvar::new()));
  • wrflib 0.0.3/src/cx_metal.rs
    928
    		 
        fn gpu_read(&self) -> MetalRwLockGpuReadGuard {
    929
    		 
            #[allow(clippy::mutex_atomic)]
    930
    		 
            let mut reader_count = self.inner.reader_count.lock().unwrap();
    935
    		 
        fn cpu_write(&mut self) -> &mut T {
    936
    		 
            #[allow(clippy::mutex_atomic)]
    937
    		 
            let mut reader_count = self.inner.reader_count.lock().unwrap();
    945
    		 
    #[derive(Default)]
    946
    		 
    #[allow(clippy::mutex_atomic)]
    947
    		 
    // This is a false positive since Clippy is unable to detect us
    959
    		 
        fn drop(&mut self) {
    960
    		 
            #[allow(clippy::mutex_atomic)]
    961
    		 
            let mut reader_count = self.inner.reader_count.lock().unwrap();
  • xi 0.1.1/src/lib.rs
    930
    		 
        /// ```
    931
    		 
        #[allow(clippy::mutex_atomic)]
    932
    		 
        pub fn wait(&self) {
  • zaplib 0.0.3/src/cx_metal.rs
    922
    		 
        fn gpu_read(&self) -> MetalRwLockGpuReadGuard {
    923
    		 
            #[allow(clippy::mutex_atomic)]
    924
    		 
            let mut reader_count = self.inner.reader_count.lock().unwrap();
    929
    		 
        fn cpu_write(&mut self) -> &mut T {
    930
    		 
            #[allow(clippy::mutex_atomic)]
    931
    		 
            let mut reader_count = self.inner.reader_count.lock().unwrap();
    939
    		 
    #[derive(Default)]
    940
    		 
    #[allow(clippy::mutex_atomic)]
    941
    		 
    // This is a false positive since Clippy is unable to detect us
    953
    		 
        fn drop(&mut self) {
    954
    		 
            #[allow(clippy::mutex_atomic)]
    955
    		 
            let mut reader_count = self.inner.reader_count.lock().unwrap();
  • zbus 3.8.0/src/lib.rs
    635
    		 
            #[allow(clippy::mutex_atomic)]
    636
    		 
            let pair = Arc::new((Mutex::new(false), Condvar::new()));
  • arraylib 0.3.0/src/util/init.rs
    150
    		 
        // I just don't want to think about ordering
    151
    		 
        #![allow(clippy::mutex_atomic)]
  • async-std 1.12.0/src/lib.rs
    281
    		 
    #![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
    282
    		 
    #![allow(clippy::mutex_atomic, clippy::module_inception)]
    283
    		 
    #![doc(test(attr(deny(rust_2018_idioms, warnings))))]
  • authoscope 0.8.1/src/lib.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
  • cloc 0.6.2/src/spinner.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
    2
    		 
    use std::io::prelude::*;
  • cogo 0.1.36/src/std/sync/wait_group.rs
    1
    		 
    // Necessary for using `Mutex<usize>` for conditional variables
    2
    		 
    #![allow(clippy::mutex_atomic)]
  • const-tweaker 0.3.1/src/lib.rs
    51
    		 
    // Ignore the lazy_static warning about the mutex
    52
    		 
    #![allow(clippy::mutex_atomic)]
  • crossbeam-channel 0.5.6/tests/golang.rs
    12
    		 
    #![allow(clippy::mutex_atomic, clippy::redundant_clone)]
  • crossbeam-skiplist_piedb 0.8.11/tests/base.rs
    1
    		 
    #![allow(clippy::mutex_atomic, clippy::redundant_clone)]
  • crossbeam-skiplist_piedb 0.8.11/tests/map.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
  • cueball 0.3.5/src/connection_pool/types.rs
    243
    		 
    impl RebalanceCheck {
    244
    		 
        #![allow(clippy::mutex_atomic)]
    245
    		 
        pub fn new() -> Self {
  • feroxbuster 2.7.3/src/lib.rs
    1
    		 
    #![deny(clippy::all)]
    2
    		 
    #![allow(clippy::mutex_atomic)]
    3
    		 
    use anyhow::Result;
  • flattiverse_connector 36.1.1/src/dotnet/manual_reset_event.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
  • hakuban 0.7.2/src/object/remote.rs
    1
    		 
    #![allow(clippy::mutex_atomic)] //because I want the value AND the locking. I think :)
  • hakuban 0.7.2/src/tag/remote.rs
    1
    		 
    #![allow(clippy::mutex_atomic)] //because I want the value AND the locking. actually, rethink this (TODO)
  • hotdrink-rs 0.1.3/src/thread/thread_pool.rs
    71
    		 
    mod tests {
    72
    		 
        #![allow(unused_variables, clippy::mutex_atomic)]
  • http-service 0.5.0/src/lib.rs
    4
    		 
    #![warn(missing_debug_implementations, rust_2018_idioms)]
    5
    		 
    #![allow(clippy::mutex_atomic, clippy::module_inception)]
    6
    		 
    #![doc(test(attr(deny(rust_2018_idioms, warnings))))]
  • kvmi 0.4.0/src/lib.rs
    1
    		 
    #![allow(clippy::mutex_atomic)] // prevent fp with idiomatic condvar code
    2
    		 
    #[macro_use]
  • libzetta 0.3.1/tests/test_zfs.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
    2
    		 
    #[macro_use] extern crate lazy_static;
  • lightning-sys 0.2.2/src/jit.rs
    1
    		 
    #![allow(clippy::mutex_atomic)] // Avoid clippy warning about JITS_MADE
    2
    		 
    #![allow(clippy::new_without_default)] // Avoid clippy warning about Jit::new
  • locustdb 0.3.4/src/scheduler/disk_read_scheduler.rs
    1
    		 
    // background_load_in_progress used with condition variable
    2
    		 
    #![allow(clippy::mutex_atomic)]
  • lpn 0.2.0/src/codes/concatenated.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
    2
    		 
    use crate::codes::BinaryCode;
  • lpn 0.2.0/src/codes/stgen.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
  • matchtigs 1.5.5/src/implementation/mod.rs
    3
    		 
    // This lint never produces correct suggestions in our case.
    4
    		 
    #![allow(clippy::mutex_atomic)]
  • mco 0.1.44/src/std/sync/wait_group.rs
    1
    		 
    // Necessary for using `Mutex<usize>` for conditional variables
    2
    		 
    #![allow(clippy::mutex_atomic)]
  • radvisor 1.3.1/src/timer.rs
    1
    		 
    // Allow using Mutex<bool> to support Mutex/Condvar pattern
    2
    		 
    #![allow(clippy::mutex_atomic)]
  • remove_dir_all 0.7.0/src/lib.rs
    12
    		 
    // See under "known problems" https://rust-lang.github.io/rust-clippy/master/index.html#mutex_atomic
    13
    		 
    #![allow(clippy::mutex_atomic)]
  • rtlola-cli 0.1.0/src/output.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
  • shaku 0.6.1/tests/multithread.rs
    1
    		 
    #![allow(clippy::blacklisted_name, clippy::mutex_atomic)]
    2
    		 
    #![cfg(feature = "thread_safe")]
  • spirit-log 0.4.4/src/background.rs
    5
    		 
        clippy::unknown_clippy_lints,
    6
    		 
        clippy::mutex_atomic
    7
    		 
    )]
  • spirit-tokio 0.9.2/src/installer.rs
    1
    		 
    #![allow(clippy::mutex_atomic)] // Mutex<bool> needed for condvar
    2
    		 
    //! Installer of futures.
  • thread-group 1.0.0/src/wait_group.rs
    1
    		 
    // Necessary for using `Mutex<usize>` for conditional variables
    2
    		 
    #![allow(clippy::mutex_atomic)]
  • thread_local 1.1.4/src/lib.rs
    66
    		 
    #![warn(missing_docs)]
    67
    		 
    #![allow(clippy::mutex_atomic)]
  • throttle-server 0.4.2/src/litter_collection.rs
    3
    		 
    // We run into this here, so let's silence this lint for this file.
    4
    		 
    #![allow(clippy::mutex_atomic)]
  • tokio-async-std 1.5.3/src/lib.rs
    225
    		 
    #![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
    226
    		 
    #![allow(clippy::mutex_atomic, clippy::module_inception)]
    227
    		 
    #![doc(test(attr(deny(rust_2018_idioms, warnings))))]
  • tokio-test 0.4.2/src/task.rs
    3
    		 
    #![allow(clippy::mutex_atomic)]
  • try-mutex 0.4.2/benches/bench.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
  • uasync 0.1.1/src/thread_pool/semaphore.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
  • vapoursynth 0.4.0/examples/vspipe.rs
    9
    		 
    mod inner {
    10
    		 
        #![allow(clippy::cast_lossless, clippy::mutex_atomic)]
    11
    		 
        extern crate clap;
  • waithandle 0.4.0/src/lib.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
  • wpilib 0.4.0/src/ds.rs
    33
    		 
    // TODO(Lytigas) re-architecht the Driverstation
    34
    		 
    #![allow(clippy::mutex_atomic)]
  • zellij-client 0.34.4/src/command_is_executing.rs
    1
    		 
    #![allow(clippy::mutex_atomic)]
    2
    		 
    use std::sync::{Arc, Condvar, Mutex};