Exemple #1
0
        //# });
        #endregion

        #region Multi-Dimensional Arrays

        //# ignoreTypes.ForEach(t => {
        public void WriteBig(__t__[,] array, long count)
        {
            unsafe
            {
                int  itemsPerBlock = c_bufferSize / sizeof(__t__);
                long index         = 0;
                fixed(__t__ *a = array)
                {
                    while (count > 0)
                    {
                        int blockSize = count > (long)itemsPerBlock
                                            ? itemsPerBlock : (int)count;
                        fixed(byte *p = m_buffer)
                        {
                            __t__ *v = (__t__ *)p;

                            for (int i = 0; i < blockSize; i++)
                            {
                                v[i] = a[index++];
                            }
                        }

                        Write(m_buffer, 0, blockSize * sizeof(__t__));
                        count -= (long)blockSize;
                    }
                }
            }
        }
Exemple #2
0
        //# }
        #endregion

        //# if (ignoreTypes != null) {
        #region Arrays

        //# ignoreTypes.ForEach(t => {
        public void WriteBig(__t__[] array, long index, long count)
        {
            unsafe
            {
                int itemsPerBlock = c_bufferSize / sizeof(__t__);
                while (count > 0)
                {
                    int blockSize = count > (long)itemsPerBlock
                                        ? itemsPerBlock : (int)count;
                    // array.CopyIntoBuffer(index, blockSize, m_buffer, 0);
                    // index += blockSize;
                    fixed(byte *p = m_buffer)
                    {
                        __t__ *v = (__t__ *)p;

                        for (int i = 0; i < blockSize; i++)
                        {
                            v[i] = array[index++];
                        }
                    }

                    Write(m_buffer, 0, blockSize * sizeof(__t__));
                    count -= (long)blockSize;
                }
            }
        }
        //# });
        #endregion

        #region Lists

        //# ignoreTypes.ForEach(t => {
        public int Read(List <__t__> buffer, int index, int count)
        {
            int end = index + count;

            while (buffer.Count < end)
            {
                buffer.Add(default(__t__));
            }
            int complete = 0;

            unsafe
            {
                var itemsPerBlock = c_bufferSize / sizeof(__t__);
                while (count > 0)
                {
                    int blockSize = Fun.Min(count, itemsPerBlock);
                    int request   = blockSize * sizeof(__t__);
                    int total     = 0;
                    do
                    {
                        int finished = Read(m_buffer, total, request);
                        if (finished == 0)
                        {
                            break;
                        }
                        total += finished; request -= finished;
                    }while (request > 0);
                    total /= sizeof(__t__);
                    fixed(byte *p = m_buffer)
                    {
                        __t__ *v = (__t__ *)p;

                        for (int i = 0; i < total; i++)
                        {
                            buffer[index++] = v[i];
                        }
                    }

                    count -= total; complete += total;
                    if (total < blockSize)
                    {
                        break;
                    }
                }
            }
            return(complete);
        }
        public long ReadBig(__t__[, ,] array, long count)
        {
            long complete = 0;

            unsafe
            {
                int  itemsPerBlock = c_bufferSize / sizeof(__t__);
                long index         = 0;
                fixed(__t__ *a = array)
                {
                    while (count > 0)
                    {
                        int blockSize = count > (long)itemsPerBlock
                                            ? itemsPerBlock : (int)count;
                        int request = blockSize * sizeof(__t__);
                        int total   = 0;
                        do
                        {
                            int finished = Read(m_buffer, total, request);
                            if (finished == 0)
                            {
                                break;
                            }
                            total += finished; request -= finished;
                        }while (request > 0);
                        total /= sizeof(__t__);
                        fixed(byte *p = m_buffer)
                        {
                            __t__ *v = (__t__ *)p;

                            for (int i = 0; i < total; i++)
                            {
                                a[index++] = v[i];
                            }
                        }

                        count -= total; complete += total;
                        if (total < blockSize)
                        {
                            break;
                        }
                    }
                }
            }
            return(complete);
        }
Exemple #5
0
        //# });
        #endregion

        #region Lists

        //# ignoreTypes.ForEach(t => {
        public void Write(List <__t__> buffer, int index, int count)
        {
            unsafe
            {
                var itemsPerBlock = c_bufferSize / sizeof(__t__);
                while (count > 0)
                {
                    int blockSize = Fun.Min(count, itemsPerBlock);
                    fixed(byte *p = m_buffer)
                    {
                        __t__ *v = (__t__ *)p;

                        for (int i = 0; i < blockSize; i++)
                        {
                            v[i] = buffer[index++];
                        }
                    }

                    Write(m_buffer, 0, blockSize * sizeof(__t__));
                    count -= blockSize;
                }
            }
        }