public class SequenceBuffer32 where T : new()

in Networked Physics/Assets/Scripts/Network.cs [925:1038]
97 lines of code
9 McCabe index (conditional complexity)

    public class SequenceBuffer32<T> where T : new()
    {
        public T[] m_entries;
        uint[] m_entry_sequence;
        int m_size;
        uint m_sequence;

        public T[] Entries
        {                              
            get
            {
                return m_entries;
            }
        }

        public SequenceBuffer32( int size )
        {
            Assert.IsTrue( size > 0 );
            m_size = size;
            m_sequence = 0;
            m_entry_sequence = new uint[size];
            m_entries = new T[size];
            for ( int i = 0; i < size; ++i )
                m_entries[i] = new T();
            Reset();
        }

        public void Reset()
        {
            m_sequence = 0;
            for ( int i = 0; i < m_size; ++i )
            {
                m_entry_sequence[i] = 0xFFFFFFFF;
            }
        }

        public int Insert( uint sequence )
        {
            Assert.IsTrue( sequence != 0xFFFFFFFF );

            if ( sequence + 1 > m_sequence )
            {
                RemoveEntries( m_sequence, sequence );

                m_sequence = sequence + 1;
            }
            else if ( sequence < m_sequence - m_size )
            {
                return -1;
            }

            int index = (int) ( sequence % m_size );

            m_entry_sequence[index] = sequence;

            return index;
        }

        public void Remove( uint sequence )
        {
            Assert.IsTrue( sequence != 0xFFFFFFFF );
            m_entry_sequence[sequence % m_size] = 0xFFFFFFFF;
        }

        public bool Available( uint sequence )
        {
            Assert.IsTrue( sequence != 0xFFFFFFFF );
            return m_entry_sequence[sequence % m_size] == 0xFFFFFFFF;
        }

        public bool Exists( uint sequence )
        {
            Assert.IsTrue( sequence != 0xFFFFFFFF );
            return m_entry_sequence[sequence % m_size] == sequence;
        }

        public int Find( uint sequence )
        {
            Assert.IsTrue( sequence != 0xFFFFFFFF );
            int index = (int) ( sequence % m_size );
            if ( m_entry_sequence[index] == sequence )
                return index;
            else
                return -1;
        }

        public uint GetSequence()
        {
            return m_sequence;
        }

        public int GetSize()
        {
            return m_size;
        }

        public void RemoveEntries( uint start_sequence, uint finish_sequence )
        {
            Assert.IsTrue( start_sequence <= finish_sequence );

            if ( finish_sequence - start_sequence < m_size )
            {
                for ( uint sequence = start_sequence; sequence <= finish_sequence; ++sequence )
                    m_entry_sequence[sequence % m_size] = 0xFFFFFFFF;
            }
            else
            {
                for ( int i = 0; i < m_size; ++i )
                {
                    m_entry_sequence[i] = 0xFFFFFFFF;
                }
            }
        }
    }