simplelock 0.4.1

use crate::*;

use std::sync::{
    atomic::{AtomicBool, Ordering},
    Arc,
};

/// A dummy lock which is actually just a boolean flag.
/// This is used to test the functionality of higher level
/// functionality where locks would have been useful.
///
/// Please don't really use this...
pub struct FakeLock {
    val: Arc<AtomicBool>,
}

impl Clone for FakeLock {
    fn clone(&self) -> Self {
        FakeLock {
            val: self.val.clone(),
        }
    }
}

impl Default for FakeLock {
    fn default() -> Self {
        FakeLock::new(false)
    }
}

impl FakeLock {
    /// Create a fake lock with a default lock status.
    pub fn new(is_locked: bool) -> Self {
        FakeLock {
            val: Arc::new(is_locked.into()),
        }
    }
}

// FakeLock is not a ConcreteLock, it just implements the 
// basic Lock trait.
impl Lock for FakeLock {
    fn status(&self) -> SimpleLockResult<LockStatus> {
        if self.val.load(Ordering::Relaxed) {
            Ok(LockStatus::Mine)
        } else {
            Ok(LockStatus::Open)
        }
    }

    fn lock(&mut self) -> SimpleLockResult<()> {
        self.val.store(true, Ordering::Relaxed);
        Ok(())
    }

    fn unlock(&mut self) -> SimpleLockResult<()> {
        self.val.store(false, Ordering::Relaxed);
        Ok(())
    }
}