pub fn new(level: u32) -> Self {

	Self {

	    level:	level.into(),

	}

    }

    pub fn level(&self) -> u32 {

	self.level.load(O::Relaxed)

    }

    pub fn acquire(&self) -> BucketGuard {

	let do_release = self.level

	    .fetch_update(O::Relaxed, O::Relaxed, |v| match v {

		0	=> None,

		v	=> Some(v - 1)

	    }).is_ok();

	BucketGuard {

	    bucket:	self,

	    do_release:	do_release,

	}

    }

    fn release(&self) {

	self.level.fetch_add(1, O::Relaxed);

    }

    fn drop(&mut self) {

	if self.do_release {

	    self.bucket.release()

	}

    }

    pub fn is_ok(&self) -> bool {

	self.do_release

    }

    pub fn release(self) {

    }

    #[test]

    fn test_bucket() {

	let bucket = Bucket::new(4);

	assert_eq!(bucket.level(), 4);

	    let g0 = bucket.acquire();

	    assert_eq!(bucket.level(), 3);

	    assert!(g0.is_ok());

	    let g1 = bucket.acquire();

	    assert_eq!(bucket.level(), 2);

	    assert!(g1.is_ok());

		let g2 = bucket.acquire();

		assert_eq!(bucket.level(), 1);

		assert!(g2.is_ok());

		let g3 = bucket.acquire();

		assert_eq!(bucket.level(), 0);

		assert!(g3.is_ok());

		    let g4 = bucket.acquire();

		    assert_eq!(bucket.level(), 0);

		    assert!(!g4.is_ok());

		assert_eq!(bucket.level(), 0);

		g3.release();

		assert_eq!(bucket.level(), 1);

		let g5 = bucket.acquire();

		assert_eq!(bucket.level(), 0);

		assert!(g5.is_ok());

	    assert_eq!(bucket.level(), 2);

    }