public static bool Push <T>(UnsafeRingBuffer *ring, T item) where T : unmanaged { if (ring->_count == ring->_items.Length) { if (ring->_overwrite) { ring->_tail = (ring->_tail + 1) % ring->_items.Length; ring->_count = (ring->_count - 1); } else { return(false); } } // store value at head *(T *)UnsafeBuffer.Element(ring->_items.Ptr, ring->_head, ring->_items.Stride) = item; // move head pointer forward ring->_head = (ring->_head + 1) % ring->_items.Length; // add count ring->_count += 1; // success! return(true); }
public static bool Pop <T>(UnsafeRingBuffer *ring, out T value) where T : unmanaged { UDebug.Assert(ring != null); UDebug.Assert(ring->_items.Ptr != null); UDebug.Assert(typeof(T).TypeHandle.Value == ring->_typeHandle); var count = ring->_count; if (count == 0) { value = default; return(false); } var head = ring->_head; var items = ring->_items; // grab result value = *items.Element <T>(head); // decrement count and head index ring->_count--; MoveNext(items.Length, ref ring->_head); return(true); }
public static bool Push <T>(UnsafeRingBuffer *ring, T item) where T : unmanaged { UDebug.Assert(ring != null); UDebug.Assert(ring->_items.Ptr != null); UDebug.Assert(typeof(T).TypeHandle.Value == ring->_typeHandle); var count = ring->_count; var items = ring->_items; if (count == items.Length) { if (ring->_overwrite == 1) { MoveNext(items.Length, ref ring->_head); ring->_count--; } else { return(false); } } var tail = ring->_tail; *items.Element <T>(tail) = item; ring->_count++; MoveNext(items.Length, ref ring->_tail); return(true); }
private static void SplitRingBuffer(UnsafeRingBuffer *q) { //Wrap tail back to 0 for (int i = 0; i < 5; i++) { UnsafeRingBuffer.Push(q, 111); } //First half for (int i = 0; i < 5; i++) { UnsafeRingBuffer.Push(q, i); } //Move head by 5 for (int i = 0; i < 5; i++) { UnsafeRingBuffer.Pop <int>(q, out _); } //Second half (head and tail are now both 5) for (int i = 5; i < 10; i++) { UnsafeRingBuffer.Push(q, i); } //Circular buffer now "ends" in the middle of the underlying array }
public static UnsafeList.Enumerator <T> GetEnumerator <T>(UnsafeRingBuffer *ringbuffer) where T : unmanaged { UDebug.Assert(ringbuffer != null); UDebug.Assert(ringbuffer->_items.Ptr != null); UDebug.Assert(typeof(T).TypeHandle.Value == ringbuffer->_typeHandle); return(new UnsafeList.Enumerator <T>(ringbuffer->_items, ringbuffer->_head, ringbuffer->_count)); }
public static void Clear(UnsafeRingBuffer *ring) { UDebug.Assert(ring != null); UDebug.Assert(ring->_items.Ptr != null); ring->_tail = 0; ring->_head = 0; ring->_count = 0; }
public static void Clear(UnsafeRingBuffer *ring) { Assert.Check(ring != null); Assert.Check(ring->_items.Ptr != null); ring->_tail = 0; ring->_head = 0; ring->_count = 0; }
public static void Free(UnsafeRingBuffer *ring) { Assert.Check(ring != null); // clear memory just in case *ring = default; // release ring memory AllocHelper.Free(ring); }
public static T *GetPtr <T>(UnsafeRingBuffer *ring, int index) where T : unmanaged { // cast to uint trick, which eliminates < 0 check if ((uint)index >= (uint)ring->_count) { throw new IndexOutOfRangeException(); } return((T *)UnsafeBuffer.Element(ring->_items.Ptr, (ring->_tail + index) % ring->_items.Length, ring->_items.Stride)); }
public static void Set <T>(UnsafeRingBuffer *ring, int index, T value) where T : unmanaged { // cast to uint trick, which eliminates < 0 check if ((uint)index >= (uint)ring->_count) { throw new IndexOutOfRangeException(); } // assign element *(T *)UnsafeBuffer.Element(ring->_items.Ptr, (ring->_tail + index) % ring->_items.Length, ring->_items.Stride) = value; }
public static T *GetPtr <T>(UnsafeRingBuffer *ring, int index) where T : unmanaged { UDebug.Assert(ring != null); UDebug.Assert(ring->_items.Ptr != null); UDebug.Assert(typeof(T).TypeHandle.Value == ring->_typeHandle); // cast to uint trick, which eliminates < 0 check if ((uint)index >= (uint)ring->_count) { throw new IndexOutOfRangeException(ThrowHelper.ArgumentOutOfRange_Index); } return(ring->_items.Element <T>((ring->_tail + index) % ring->_items.Length)); }
public static void Free(UnsafeRingBuffer *ring) { if (ring == null) { return; } // clear memory just in case *ring = default; // release ring memory Memory.Free(ring); }
public static bool Peek <T>(UnsafeRingBuffer *ring, out T value) where T : unmanaged { UDebug.Assert(ring != null); UDebug.Assert(ring->_items.Ptr != null); UDebug.Assert(typeof(T).TypeHandle.Value == ring->_typeHandle); if (ring->_count == 0) { value = default; return(false); } value = *ring->_items.Element <T>(ring->_head); return(true); }
public static bool Pop <T>(UnsafeRingBuffer *ring, out T value) where T : unmanaged { Assert.Check(ring != null); Assert.Check(ring->_items.Ptr != null); if (ring->_count == 0) { value = default; return(false); } // copy item from tail value = *(T *)UnsafeBuffer.Element(ring->_items.Ptr, ring->_tail, ring->_items.Stride); // move tail forward and decrement count ring->_tail = (ring->_tail + 1) % ring->_items.Length; ring->_count = (ring->_count - 1); return(true); }
public static bool Contains <T>(UnsafeRingBuffer *ringbuffer, T item) where T : unmanaged, IEquatable <T> { UDebug.Assert(ringbuffer != null); UDebug.Assert(ringbuffer->_items.Ptr != null); UDebug.Assert(typeof(T).TypeHandle.Value == ringbuffer->_typeHandle); int count = ringbuffer->_count; int head = ringbuffer->_head; int tail = ringbuffer->_tail; if (count == 0) { return(false); } if (head < tail) { return(UnsafeBuffer.IndexOf(ringbuffer->_items, item, head, count) > -1); } return(UnsafeBuffer.IndexOf(ringbuffer->_items, item, head, ringbuffer->_items.Length - head) > -1 || UnsafeBuffer.IndexOf(ringbuffer->_items, item, 0, tail) > -1); }
public static void CopyTo <T>(UnsafeRingBuffer *ringbuffer, void *destination, int destinationIndex) where T : unmanaged { if (destination == null) { throw new ArgumentNullException(nameof(destination)); } if (destinationIndex < 0) { throw new ArgumentOutOfRangeException(ThrowHelper.ArgumentOutOfRange_Index); } UDebug.Assert(ringbuffer != null); UDebug.Assert(ringbuffer->_items.Ptr != null); UDebug.Assert(typeof(T).TypeHandle.Value == ringbuffer->_typeHandle); int numToCopy = ringbuffer->_count; if (numToCopy == 0) { return; } int bufferLength = ringbuffer->_items.Length; int head = ringbuffer->_head; int firstPart = Math.Min(bufferLength - head, numToCopy); UnsafeBuffer.CopyTo <T>(ringbuffer->_items, head, destination, destinationIndex, firstPart); numToCopy -= firstPart; if (numToCopy > 0) { UnsafeBuffer.CopyTo <T>(ringbuffer->_items, 0, destination, destinationIndex + bufferLength - head, numToCopy); } }
public static T Get <T>(UnsafeRingBuffer *ring, int index) where T : unmanaged { return(*GetPtr <T>(ring, index)); }
public static int Capacity(UnsafeRingBuffer *ring) { Assert.Check(ring != null); Assert.Check(ring->_items.Ptr != null); return(ring->_items.Length); }
public static ref T GetRef <T>(UnsafeRingBuffer *ring, int index) where T : unmanaged { return(ref *GetPtr <T>(ring, index)); }
public static int Count(UnsafeRingBuffer *ring) { Assert.Check(ring != null); Assert.Check(ring->_items.Ptr != null); return(ring->_count); }
public static bool IsFull(UnsafeRingBuffer *ring) { Assert.Check(ring != null); Assert.Check(ring->_items.Ptr != null); return(ring->_count == ring->_items.Length); }
public NativeRingBuffer(int capacity) { m_inner = UnsafeRingBuffer.Allocate <T>(capacity); }
public static int GetCount(UnsafeRingBuffer *ring) { UDebug.Assert(ring != null); UDebug.Assert(ring->_items.Ptr != null); return(ring->_count); }
public static int GetCapacity(UnsafeRingBuffer *ring) { UDebug.Assert(ring != null); UDebug.Assert(ring->_items.Ptr != null); return(ring->_items.Length); }
public static UnsafeList.Iterator <T> GetIterator <T>(UnsafeRingBuffer *buffer) where T : unmanaged { return(new UnsafeList.Iterator <T>(buffer->_items, buffer->_tail, buffer->_count)); }
public NativeRingBuffer(int capacity, bool overwrite) { m_inner = UnsafeRingBuffer.Allocate <T>(capacity, overwrite); }
public static bool IsFull(UnsafeRingBuffer *ring) { UDebug.Assert(ring != null); UDebug.Assert(ring->_items.Ptr != null); return(ring->_count == ring->_items.Length); }