pub(super) unsafe fn pop(&self) -> PopResult<T> {
        let tail = *self.tail.get();
        let next = (*tail).next.load(Ordering::Acquire);

        if !next.is_null() {
            *self.tail.get() = next;
            assert!((*tail).value.is_none());
            assert!((*next).value.is_some());
            let ret = (*next).value.take().unwrap();
            drop(Box::from_raw(tail));
            return Data(ret);
        }

        if self.head.load(Ordering::Acquire) == tail {
            Empty
        } else {
            Inconsistent
        }
    }
/// Pops some data from this queue.
///
/// Note that the current implementation means that this function cannot
/// return `Option<T>`. It is possible for this queue to be in an
/// inconsistent state where many pushes have succeeded and completely
/// finished, but pops cannot return `Some(t)`. This inconsistent state
/// happens when a pusher is preempted at an inopportune moment.
///
/// This inconsistent state means that this queue does indeed have data, but
/// it does not currently have access to it at this time.
///
/// This function is unsafe because only one thread can call it at a time.
Pops some data from this queue.
Note that the current implementation means that this function cannot
return `Option`. It is possible for this queue to be in an
inconsistent state where many pushes have succeeded and completely
finished, but pops cannot return `Some(t)`. This inconsistent state
happens when a pusher is preempted at an inopportune moment.

This inconsistent state means that this queue does indeed have data, but
it does not currently have access to it at this time.

This function is unsafe because only one thread can call it at a time.
Pops some data from this queue . Note that the current implementation means that this function cannot return ` Option ` . It is possible for this queue to be in an inconsistent state where many pushes have succeeded and completely finished but pops cannot return ` Some ( t ) ` . This inconsistent state happens when a pusher is preempted at an inopportune moment . This inconsistent state means that this queue does indeed have data but it does not currently have access to it at this time . This function is unsafe because only one thread can call it at a time .
pub(super) unsafe fn pop(&self) -> PopResult<T> {
        let tail = *self.tail.get();
        let next = (*tail).next.load(Ordering::Acquire);
        if !next.is_null() {
            *self.tail.get() = next;
            assert!((*tail).value.is_none());
            assert!((*next).value.is_some());
            let ret = (*next).value.take().unwrap();
            drop(Box::from_raw(tail));
            return Data(ret);
        }
        if self.head.load(Ordering::Acquire) == tail {
            Empty
        } else {
            Inconsistent
        }
    }
pub ( super ) unsafe fn pop ( & self ) -> PopResult < T > { let tail = * self . tail . get ( ) ; let next = ( * tail ) . next . load ( Ordering :: Acquire ) ; if ! next . is_null ( ) { * self . tail . get ( ) = next ; assert ! ( ( tail ) value is_none ( ) ) ; assert ! ( ( next ) value is_some ( ) ) ; let ret = ( * next ) . value . take ( ) . unwrap ( ) ; drop ( Box :: from_raw ( tail ) ) ; return Data ( ret ) ; } if self . head . load ( Ordering :: Acquire ) == tail { Empty } else { Inconsistent } }
Pops some data from this queue.
Pops some data from this queue .
&self
&self