Пример #1
0
        public byte[] ReadBlob(long pageIndex)
        {
            //Create buffer from the length specified in the first page
            byte[] buffer = new byte[pages[(int)pageIndex].total_blob_length];

            //Begin reading pages
            long nextPageIndex    = pageIndex;
            int  currentPageIndex = 0; //Read index for writing to our buffer

            //Loop through this page and it's decendants
            while (nextPageIndex != -1)
            {
                //Get page
                DatabasePage page = pages[(int)nextPageIndex];

                //Get index of the next page
                nextPageIndex = page.next_page_index;

                //Calculate read parameters
                int readOffset = currentPageIndex * pageContentSize;
                int readLength = Math.Min(pageContentSize, buffer.Length - readOffset);

                //Jump to and read
                file.Position = GetPageFileOffset(page.index) + PAGE_HEADER_SIZE;
                file.Read(buffer, readOffset, readLength);
                currentPageIndex++;
            }

            return(buffer);
        }
Пример #2
0
        private DatabasePage CreateDatabasePage()
        {
            //Jump to new page location
            file.Position = GetPageFileOffset(pages.Count);

            //Write placeholder data
            for (int i = 0; i < pageTotalSize; i++)
            {
                file.WriteByte(0x00);
            }

            //Add page info
            DatabasePage pageInfo = new DatabasePage
            {
                index           = pages.Count,
                type            = PAGE_TYPE_ORPHAN,
                modified_utc    = GetCurrentUtcEpoch(),
                next_page_index = -1
            };

            pages.Add(pageInfo);
            orphanedPages.Add(pageInfo);

            //Jump to counter and update
            file.Position = 16;
            WriteInt64ToStream(pages.Count);

            //Jump to new page location
            file.Position = GetPageFileOffset(pageInfo.index);

            return(pageInfo);
        }
Пример #3
0
        public void ReadHeader()
        {
            //Jump to beginning
            file.Position = 0;

            //Read file signature
            if (ReadInt32FromStream() != FILE_SIN)
            {
                throw new Exception("This is not a Delta Web Map Content file.");
            }

            //Read version
            if (ReadInt32FromStream() != 1)
            {
                throw new Exception("Unknown file version.");
            }

            //Read header data
            pageContentSize = ReadInt32FromStream();
            modifiedUtc     = ReadInt32FromStream();
            long pageCount = ReadInt64FromStream();

            //Read data for each page
            pages = new List <DatabasePage>();
            for (long i = 0; i < pageCount; i += 1)
            {
                //Jump to page
                file.Position = GetPageFileOffset(i);

                //Read
                int  pageType        = ReadInt32FromStream();
                int  pageModifiedUtc = ReadInt32FromStream();
                int  pageContentSize = ReadInt32FromStream();
                int  pageReserved    = ReadInt32FromStream();
                long pageNextIndex   = ReadInt64FromStream();

                //Make
                var page = new DatabasePage
                {
                    index             = i,
                    type              = pageType,
                    modified_utc      = pageModifiedUtc,
                    total_blob_length = pageContentSize,
                    flags             = pageReserved,
                    next_page_index   = pageNextIndex
                };

                //Add
                pages.Add(page);

                //If this is an orphaned page, set it as so
                if (pageTotalSize == PAGE_TYPE_ORPHAN)
                {
                    orphanedPages.Add(page);
                }
            }
        }
Пример #4
0
        public long WriteNewBlob(int objectType, byte[] payload)
        {
            //Calculate number of chunks we need
            int objectPageCount = (payload.Length / pageContentSize) + 1;

            //Find orphaned pages. These are pages that are unused
            DatabasePage[] objectPages     = new DatabasePage[objectPageCount];
            int            objectPageIndex = 0;

            foreach (var p in orphanedPages)
            {
                if (p.type == PAGE_TYPE_ORPHAN)
                {
                    objectPages[objectPageIndex] = p;
                    objectPageIndex++;
                    if (objectPageIndex == objectPageCount)
                    {
                        break;
                    }
                }
            }

            //If we need additional pages, create them
            while (objectPageIndex < objectPageCount)
            {
                objectPages[objectPageIndex] = CreateDatabasePage();
                objectPageIndex++;
            }

            //Now write content to each page
            for (int i = 0; i < objectPageCount; i += 1)
            {
                //Find the index of the next page
                long nextPageIndex;
                if (i + 1 == objectPageCount)
                {
                    nextPageIndex = -1;
                }
                else
                {
                    nextPageIndex = objectPages[i + 1].index;
                }

                //Make flags
                int flags = 0;
                if (i != 0) //If this is not the first one, set the continuation flag to true
                {
                    flags |= 1 << DatabasePage.FLAG_CONTINUATION;
                }

                //Write content
                UpdateDatabasePage(objectPages[i], objectType, nextPageIndex, payload, i, flags);
            }

            return(objectPages[0].index);
        }
Пример #5
0
        private void UpdateDatabasePage(DatabasePage page, int pageType, long nextPageIndex, byte[] buffer, int pageIndex, int flags)
        {
            //Update metadata
            UpdateDatabasePage(page, pageType, nextPageIndex, buffer.Length, flags);

            //Calculate where to read from the buffer
            int bufferReadOffset = pageIndex * pageContentSize;
            int bufferReadLength = Math.Min(pageContentSize, buffer.Length - bufferReadOffset);

            //Copy content
            file.Write(buffer, bufferReadOffset, bufferReadLength);
        }
Пример #6
0
        public void DeleteBlob(long pageIndex)
        {
            //Get first page
            long nextPageIndex = pageIndex;

            //Loop through this page and it's decendants
            while (nextPageIndex != -1)
            {
                //Get page
                DatabasePage page = pages[(int)nextPageIndex];

                //Get index of the next page before it's removed
                nextPageIndex = page.next_page_index;

                //Update the page selected
                UpdateDatabasePage(page, PAGE_TYPE_ORPHAN, -1, 0, 0x00);
            }
        }
Пример #7
0
        private void UpdateDatabasePage(DatabasePage page, int pageType, long nextPageIndex, int totalBlobLength, int flags)
        {
            //Get current last modified time
            int modifiedUtc = GetCurrentUtcEpoch();

            //Jump to file header to write the current UTC time
            file.Position = 12;
            WriteInt32ToStream(modifiedUtc);

            //Jump to the header for this page
            file.Position = GetPageFileOffset(page.index);

            //Update type
            WriteInt32ToStream(pageType);
            page.type = pageType;

            //Update UTC time
            WriteInt32ToStream(modifiedUtc);
            page.modified_utc = modifiedUtc;

            //Update blob length
            WriteInt32ToStream(totalBlobLength);
            page.total_blob_length = totalBlobLength;

            //Update flags
            WriteInt32ToStream(flags);
            page.flags = flags;

            //Update next page index
            WriteInt64ToStream(nextPageIndex);
            page.next_page_index = nextPageIndex;

            //Add/remove to orphaned pages if needed
            bool isInOrphaned = orphanedPages.Contains(page);

            if (pageType == PAGE_TYPE_ORPHAN && !isInOrphaned)
            {
                orphanedPages.Add(page);
            }
            if (pageTotalSize != PAGE_TYPE_ORPHAN && isInOrphaned)
            {
                orphanedPages.Remove(page);
            }
        }