bool BuildChunkToStream(IO.EndianStream ecfStream, EcfFileChunkDefinition chunk)
        {
            bool success = true;

            var raw_chunk = mEcfFile.GetChunk(chunk.RawChunkIndex);

            using (var chunk_ms = EcfDefinition.GetChunkFileDataStream(chunk))
            {
                raw_chunk.BuildBuffer(ecfStream, chunk_ms);
            }

            return(success);
        }
        void SaveListing(string workPath, string listingName)
        {
            string listing_filename = Path.Combine(workPath, listingName);

            using (var xml = IO.XmlElementStream.CreateForWrite("EcfFile", this))
            {
                xml.InitializeAtRootElement();
                xml.StreamMode = FileAccess.Write;

                EcfDefinition.Serialize(xml);

                xml.Document.Save(listing_filename + EcfFileDefinition.kFileExtension);
            }
        }
        bool ReadInternal()
        {
            bool result = true;

            if (ProgressOutput != null)
            {
                ProgressOutput.WriteLine("Trying to read source listing {0}...", mSourceFile);
            }

            if (!File.Exists(mSourceFile))
            {
                result = false;
            }
            else
            {
                using (var xml = new IO.XmlElementStream(mSourceFile, FA.Read, this))
                {
                    xml.InitializeAtRootElement();
                    EcfDefinition.Serialize(xml);
                }

                EcfDefinition.CullChunksPossiblyWithoutFileData((chunkIndex, chunk) =>
                {
                    if (VerboseOutput != null)
                    {
                        VerboseOutput.WriteLine("\t\tCulling chunk #{0} since it has no associated file data",
                                                chunkIndex);
                    }
                });
            }

            if (result == false)
            {
                if (ProgressOutput != null)
                {
                    ProgressOutput.WriteLine("\tFailed!");
                }
            }

            return(result);
        }
        void ExpandChunkToFile(EcfFileChunkDefinition chunk, EcfChunk rawChunk)
        {
            string file_path = EcfDefinition.GetChunkAbsolutePath(chunk);

            if (!ExpanderOptions.Test(EcfFileExpanderOptions.DontOverwriteExistingFiles))
            {
                if (File.Exists(file_path))
                {
                    if (VerboseOutput != null)
                    {
                        VerboseOutput.WriteLine("\tSkipping chunk, output file already exists: {0}", file_path);
                    }

                    return;
                }
            }

            using (var fs = File.OpenWrite(file_path))
            {
                var chunk_bytes = rawChunk.GetBuffer(mEcfStream);
                fs.Write(chunk_bytes, 0, chunk_bytes.Length);
            }
        }
        void PopulateEcfDefinitionFromEcfFile(string workPath)
        {
            EcfDefinition.WorkingDirectory = workPath;
            EcfDefinition.Initialize(mSourceFile);

            mEcfFile.CopyHeaderDataTo(EcfDefinition);

            int raw_chunk_index = 0;

            foreach (var rawChunk in mEcfFile)
            {
                var chunk = EcfDefinition.Add(rawChunk, raw_chunk_index++);

                if (WriteChunksToFile)
                {
                    chunk.SetFilePathFromParentNameAndId();
                }
            }

            if (!WriteChunksToFile)
            {
                ReadEcfChunksToDefinitionBytes();
            }
        }