コード例 #1
0
        public uint GetEntryCount(EntryType entry)
        {
            Checks.CheckEntryTypeValueIsValidAndThrow(entry);
            var entryData = m_Entries[(int)entry];

            return(entryData.Count);
        }
コード例 #2
0
        public ulong GetSizeForEntryRange(EntryType entry, uint offset, uint count)
        {
            Checks.CheckEntryTypeValueIsValidAndThrow(entry);
            var entryData = m_Entries[(int)entry];

            Checks.CheckIndexOutOfBoundsAndThrow(offset + count, entryData.Count);

            return(entryData.ComputeByteSizeForEntryRange(offset, count, true));
        }
コード例 #3
0
        unsafe ScheduleResult InternalRead(EntryType entry, uint offset, uint count, void *buffer, int bufferLength)
        {
            Checks.CheckEntryTypeValueIsValidAndThrow(entry);
            var result = new ScheduleResult();

            var entryData = m_Entries[(int)entry];

            if (entryData.Count < 1)
            {
                result.error = ReadError.EmptyFormatEntry;
                return(result); //guard against reading empty format entries
            }

            Checks.CheckIndexOutOfBoundsAndThrow(offset, count);
            Checks.CheckIndexOutOfBoundsAndThrow((long)entryData.ComputeByteSizeForEntryRange(offset, count, true), bufferLength);
            long rangeByteSize = (long)entryData.ComputeByteSizeForEntryRange(offset, count, false);

            var        bufferPtr  = (byte *)buffer;
            ReadHandle readHandle = default(ReadHandle);

            switch (entryData.Header.Format)
            {
            case EntryFormat.SingleElement:
                readHandle   = ScheduleSingleElementEntryReads(entryData, rangeByteSize, bufferPtr);
                result.error = ReadError.InProgress;
                break;

            case EntryFormat.ConstantSizeElementArray:
                readHandle   = ScheduleConstSizeElementArrayRead(entryData, offset, rangeByteSize, bufferPtr);
                result.error = ReadError.InProgress;
                break;

            case EntryFormat.DynamicSizeElementArray:

                bool readHeaderMeta           = count + offset == entryData.Count;
                long dynamicEntryLengthsArray = (count + 1) * sizeof(long);

                //dynamic entries require x bytes in front of the data to store lengths
                UnsafeUtility.MemCpy(bufferPtr, entryData.GetAdditionalStoragePtr() + offset, dynamicEntryLengthsArray - (readHeaderMeta? sizeof(long) : 0));

                if (readHeaderMeta)
                {
                    var lastOffset = ((long *)bufferPtr) + count;
                    *   lastOffset = (long)entryData.Header.HeaderMeta;
                }

                //shift the offsets, so that we remove the lengths of the skipped elements
                if (offset > 0)
                {
                    var   offsetDiff = entryData.GetAdditionalStoragePtr()[offset];
                    long *offsetsPtr = (long *)bufferPtr;
                    for (int i = 0; i < count + 1; ++i)
                    {
                        var offsetVal    = *offsetsPtr;
                        *   offsetsPtr++ = offsetVal - offsetDiff;
                    }
                }

                //offset to jump over where we copied the lengths
                bufferPtr    = bufferPtr + dynamicEntryLengthsArray;
                readHandle   = ScheduleDynamicSizeElementArrayReads(entryData, offset, count, rangeByteSize, bufferPtr);
                result.error = ReadError.InProgress;
                break;

            default:
                result.error = ReadError.InvalidEntryFormat;
                break;
            }

            result.handle = readHandle;
            return(result);
        }