read_head: AtomicUsize,

}

impl<T: Sized> CompStore<T> {

    fn new(initial_count: usize) -> Self {

        // Allocate data

        debug_assert!(size_of::<T>() > 0); // No ZST during testing (and definitely not in production)

    fn get_index_from_freelist(&self) -> u32 {

        let compare_mask = (self.count * 2) - 1;

        'try_loop: loop {

            let limit_index = self.limit_head.load(Ordering::Acquire); // limit index second

            // By definition we always have `read_index <= limit_index` (if we would

                // reader currently updating the read_head.

                //

                // To test if we are supposed to resize the backing buffer we

                // stored indices are always in the range [0, 2*count). So if

                // container.

                //

                // Furthermore, setting the limit index to this high value also

                // again, as they're writing to a buffer that is going to get

                // trashed.

                todo!("finish reallocation code");

                    Ok(_) => {

                        // Limit index has changed, so we're now the ones that

                        // are supposed to resize the

            } else {

                // It seems we have space to read

                let preemptive_read = unsafe { *self.freelist.add(read_index & self.mask) };

                    // Failed to do the CAS, try again. We need to start at the

                    // start again because we might have had other readers that

                    // were successful, so at the very least, the preemptive

                    // read we did is no longer correct.

                    continue 'try_loop;

                }

    }

    fn put_back_index_into_freelist(&self, index: u32) {

            // Failed to do the CAS, try again

        }

            // We are now the only ones that can write at `write_index`. Try to

            // do so

            unsafe { *self.freelist.add(write_index & self.mask) = index; }

            // `write_index + 1`, but we might have to spin to achieve it.

            // Furthermore, the `limit_head` is used by the index-retrieval

            // function to indicate that a read is in progress.

                match self.limit_head.compare_exchange(write_index, (write_index + 1) & compare_mask, Ordering::SeqCst, Ordering::Acquire) {

                    Ok(_) => break,

                    Err(new_value) => {

                        // But if it is very large (relatively) then this is the

                        // signal from the reader that the entire storage is

                        // being resized

                    }

                }

            }