/// <summary>
        /// Inserts the elements of a collection into the List at the specified index.
        /// </summary>
        /// <param name="index">The zero-based index at which the new elements should be inserted.</param>
        /// <param name="collection">The collection whose elements should be inserted into the List. The collection itself cannot be null, but it can contain elements that are null, if type T is a reference type.</param>
        public unsafe void InsertRange(int index, List <byte> collection)
        {
            if (collection == null)
            {
                throw new ArgumentNullException("collection is null.");
            }
            if (index < 0)
            {
                throw new ArgumentOutOfRangeException("index is less than 0.");
            }
            if (index > Count)
            {
                throw new ArgumentOutOfRangeException("index is greater than Count.");
            }
            byteListAccessor tmpAccessor = collection;
            byte *           targetPtr   = CellPtr;

            targetPtr += index;
            int offset = (int)(targetPtr - CellPtr);

            CellPtr = ResizeFunction(CellPtr - 4, offset + 4, tmpAccessor.length);
            Memory.Copy(tmpAccessor.CellPtr, CellPtr + offset + 4, tmpAccessor.length);
            *(int *)CellPtr += tmpAccessor.length;
            this.CellPtr    += 4;
        }
        /// <summary>
        /// Adds the elements of the specified collection to the end of the List
        /// </summary>
        /// <param name="collection">The collection whose elements should be added to the end of the List. The collection itself cannot be null.</param>
        public unsafe void AddRange(byteListAccessor collection)
        {
            if (collection == null)
            {
                throw new ArgumentNullException("collection is null.");
            }
            int delta = collection.length;

            if (collection.CellID != CellID)
            {
                CellPtr = ResizeFunction(CellPtr - 4, *(int *)(CellPtr - 4) + 4, delta);
                Memory.Copy(collection.CellPtr, CellPtr + *(int *)CellPtr + 4, delta);
                *(int *)CellPtr += delta;
            }
            else
            {
                byte[] tmpcell = new byte[delta];
                fixed(byte *tmpcellptr = tmpcell)
                {
                    Memory.Copy(collection.CellPtr, tmpcellptr, delta);
                    CellPtr = ResizeFunction(CellPtr - 4, *(int *)(CellPtr - 4) + 4, delta);
                    Memory.Copy(tmpcellptr, CellPtr + *(int *)CellPtr + 4, delta);
                    *(int *)CellPtr += delta;
                }
            }
            this.CellPtr += 4;
        }
        /// <summary>
        /// Determines whether this instance and a specified object have the same value.
        /// </summary>
        /// <param name="obj">The byteList to compare to this instance.</param>
        /// <returns>true if obj is a byteList and its value is the same as this instance; otherwise, false.</returns>
        public override bool Equals(object obj)
        {
            byteListAccessor b = obj as byteListAccessor;

            if (b == null)
            {
                return(false);
            }
            return(this == b);
        }
        /// <summary>
        /// Adds the elements of the specified collection to the end of the List
        /// </summary>
        /// <param name="collection">The collection whose elements should be added to the end of the List. The collection itself cannot be null.</param>
        public unsafe void AddRange(List <byte> collection)
        {
            if (collection == null)
            {
                throw new ArgumentNullException("collection is null.");
            }
            byteListAccessor tcollection = collection;
            int delta = tcollection.length;

            CellPtr = ResizeFunction(CellPtr - 4, *(int *)(CellPtr - 4) + 4, delta);
            Memory.Copy(tcollection.CellPtr, CellPtr + *(int *)CellPtr + 4, delta);
            *(int *)CellPtr += delta;
            this.CellPtr    += 4;
        }
 internal _iterator(byteListAccessor target)
 {
     targetPtr = target.CellPtr;
     endPtr    = target.CellPtr + target.length;
 }