Silence warnings

ipc-queue/src/fifo.rs

@@ -356,10 +356,12 @@ impl Offsets {
         }
     }
 
+    #[allow(unused)]
     pub(crate) fn read_high_bit(&self) -> bool {
         self.read & self.len == self.len
     }
 
+    #[allow(unused)]
     pub(crate) fn write_high_bit(&self) -> bool {
         self.write & self.len == self.len
     }

ipc-queue/src/lib.rs

@@ -146,11 +146,13 @@ pub trait AsyncSynchronizer: Clone {
     fn notify(&self, event: QueueEvent);
 }
 
+#[allow(dead_code)]
 pub struct AsyncSender<T: 'static, S> {
     inner: Fifo<T>,
     synchronizer: S,
 }
 
+#[allow(dead_code)]
 pub struct AsyncReceiver<T: 'static, S> {
     inner: Fifo<T>,
     synchronizer: S,
@@ -159,6 +161,7 @@ pub struct AsyncReceiver<T: 'static, S> {
 
 /// `DescriptorGuard<T>` can produce a `FifoDescriptor<T>` that is guaranteed
 /// to remain valid as long as the DescriptorGuard is not dropped.
+#[allow(dead_code)]
 pub struct DescriptorGuard<T> {
     descriptor: FifoDescriptor<T>,
     #[cfg(not(target_env = "sgx"))]

ipc-queue/src/position.rs

@@ -19,18 +19,22 @@ use std::sync::atomic::Ordering;
 /// arranged as a ring buffer, we can assign a position to each value written/
 /// read to/from the queue. This is useful in case we want to know whether or
 /// not a particular value written to the queue has been read.
+#[allow(dead_code)]
 pub struct PositionMonitor<T: 'static> {
     read_epoch: Arc<AtomicU64>,
     fifo: Fifo<T>,
 }
 
 /// A read position in a queue.
+#[allow(dead_code)]
 pub struct ReadPosition(u64);
 
 /// A write position in a queue.
+#[allow(dead_code)]
 pub struct WritePosition(u64);
 
 impl<T> PositionMonitor<T> {
+    #[allow(dead_code)]
     pub (crate) fn new(read_epoch: Arc<AtomicU64>,fifo: Fifo<T>) -> PositionMonitor<T> {
         PositionMonitor {
             read_epoch,