Exemplo n.º 1
0
        /// <summary>
        /// Compiles a new Package File from the currently stored Information
        /// </summary>
        /// <returns>The MemoryStream representing the new Package File</returns>
        public MemoryStream Build()
        {
            this.LockStream();
            OpenReader();
            System.IO.MemoryStream ms     = new MemoryStream(10000);
            System.IO.BinaryWriter writer = new BinaryWriter(ms);


            //make sure we write the correct Version!
            if ((header.majorversion == 1) && (header.minorversion == 0))
            {
                header.minorversion = 1;
                header.majorversion = 1;
                filelist            = null;
            }

            int oldcount = 0;

            if (this.Index != null)
            {
                oldcount = this.Index.Length;
            }

            //now save the stuff
            header.Save(writer);

            //now save the files
            PackedFileDescriptors tmpindex = new PackedFileDescriptors();
            ArrayList             tmpcmp   = new ArrayList();

            if (this.fileindex == null)
            {
                fileindex = new SimPe.Interfaces.Files.IPackedFileDescriptor[0];
            }

            PrepareCompression();

            foreach (PackedFileDescriptor pfd in this.fileindex)
            {
                pfd.Changed = false;

                //we write the filelist as last File
                if (pfd == this.filelist)
                {
                    continue;
                }
                if (pfd.Type == Data.MetaData.DIRECTORY_FILE)
                {
                    continue;
                }
                if (pfd.MarkForDelete)
                {
                    continue;
                }

                //PackedFileDescriptor newpfd = (PackedFileDescriptor)pfd.Clone();
                PackedFileDescriptor newpfd = (PackedFileDescriptor)pfd;


                PackedFile pf = null;
                if (pfd.MarkForReCompress)
                {
                    try
                    {
                        if (pfd.HasUserdata)
                        {
                            pf         = new PackedFile(PackedFile.Compress(pfd.UserData));
                            pf.uncsize = (uint)pfd.UserData.Length;
                        }
                        else
                        {
                            byte[] data = ((PackedFile)this.Read(pfd)).UncompressedData;
                            pf         = new PackedFile(PackedFile.Compress(data));
                            pf.uncsize = (uint)data.Length;
                        }

                        pf.size       = pf.data.Length;
                        pf.signature  = Data.MetaData.COMPRESS_SIGNATURE;
                        pf.headersize = 9;
                        newpfd.size   = pf.data.Length;
                        newpfd.SetUserData(null, false);

                        //recreate the FileList
                        filelist = null;
                    }
                    catch (Exception ex)
                    {
                        pf          = (PackedFile)this.Read(pfd);
                        newpfd.size = pf.data.Length;
                        newpfd.SetUserData(pfd.UserData, false);

                        if (Helper.DebugMode)
                        {
                            Helper.ExceptionMessage(ex);
                        }
                    }
                }
                else
                {
                    pf          = (PackedFile)this.Read(pfd);
                    newpfd.size = pf.data.Length;
                    newpfd.SetUserData(pfd.UserData, false);
                }

                newpfd.offset            = (uint)writer.BaseStream.Position;
                newpfd.Changed           = false;
                newpfd.MarkForReCompress = false;
                newpfd.fldata            = pf;
                newpfd.WasCompressed     = pf.IsCompressed;



                tmpcmp.Add(pf.IsCompressed);
                tmpindex.Add(newpfd);

                writer.Write(pf.data);
            }

            //Last Entry should be the Filelist
            WriteFileList(writer, ref tmpindex, tmpcmp);

            //create a new Index
            IPackedFileDescriptor[] myindex = new PackedFileDescriptor[tmpindex.Count];
            tmpindex.CopyTo(myindex);

            //write the hole index
            header.HoleIndex.Offset = 0;
            header.HoleIndex.Size   = (int)(header.HoleIndex.ItemSize * 0);
            header.HoleIndex.Count  = 0;
            holeindex = new HoleIndexItem[0];

            //write the packed Fileindex
            header.Index.Offset = (uint)writer.BaseStream.Position;
            header.Index.Size   = (int)(header.Index.ItemSize * myindex.Length);
            header.Index.Count  = myindex.Length;
            SaveIndex(writer, myindex);
            Index = myindex;


            //rewrite Header
            ms.Seek(0, SeekOrigin.Begin);
            header.Save(writer);

            ms.Seek(0, SeekOrigin.Begin);
            this.UnLockStream();
            CloseReader();

            FireIndexEvent();
            if (Index.Length < oldcount)
            {
                this.FireRemoveEvent();
            }
            else if (Index.Length > oldcount)
            {
                this.FireAddEvent();
            }
            return(ms);
        }