public byte[] AddFile(ulong streamId, Stream file, HashType type = HashType.None)
 {
     EnsureMaximumState(ArchiveState.PushingFiles);
     if (_state == ArchiveState.Initial)
     {
         _outputFilter = DoOutputFiltering(_hashedStream);
         _state = ArchiveState.PushingFiles;
     }
     byte[] ret = null;
     _streamIds.Add(streamId);
     _streamSizes.Add(file.Length);
     Stream stream = file;
     HashAlgorithm hash = null;
     if (type != HashType.None)
     {
         hash = Hash.New(type);
         stream = new HashCalculatorInputFilter(stream, hash);
     }
     stream.CopyTo(_outputFilter);
     if (type != HashType.None)
     {
         stream.Dispose();
         hash.FinishHashing();
         ret = hash.Hash;
     }
     AnyFile = true;
     return ret;
 }
 public void AddFso(FileSystemObject fso)
 {
     EnsureMaximumState(ArchiveState.PushingFsos);
     if (_state == ArchiveState.Initial)
     {
         _initialFsoOffset = _hashedStream.BytesWritten;
         _outputFilter = DoOutputFiltering(_hashedStream);
         _state = ArchiveState.PushingFsos;
     }
     else if (_state == ArchiveState.PushingFiles)
     {
         _outputFilter.Flush();
         _outputFilter.Dispose();
         _initialFsoOffset = _hashedStream.BytesWritten;
         _outputFilter = DoOutputFiltering(_hashedStream);
         _state = ArchiveState.PushingFsos;
     }
     var x0 = _outputFilter.BytesWritten;
     Serializer.SerializeToStream(_outputFilter, fso);
     var x1 = _outputFilter.BytesWritten;
     _baseObjectEntrySizes.Add(x1 - x0);
 }
 public override void Dispose()
 {
     if (_outputFilter != null)
     {
         _outputFilter.Dispose();
         _outputFilter = null;
     }
     if (_hashedStream != null)
     {
         _hashedStream.Dispose();
         _hashedStream = null;
     }
     if (_fileStream != null)
     {
         _fileStream.Dispose();
         _fileStream = null;
     }
     if (_transaction != null)
     {
         _transaction.Dispose();
         _transaction = null;
     }
 }
 public ArchiveWriter(string newPath)
 {
     _transaction = new KernelTransaction();
     _fileStream = File.OpenTransacted(_transaction, newPath, FileMode.Create, FileAccess.Write, FileShare.None);
     _hashedStream = new HashCalculatorOutputFilter(_fileStream, NewHash());
 }
        public void AddVersionManifest(VersionManifest versionManifest)
        {
            EnsureMinimumState(ArchiveState.PushingFsos);
            EnsureMaximumState(ArchiveState.PushingFsos);
            _outputFilter.Flush();
            _outputFilter.Dispose();
            _outputFilter = null;

            versionManifest.ArchiveMetadata = new ArchiveMetadata
            {
                EntrySizes = new List<long>(_baseObjectEntrySizes),
                StreamIds = new List<ulong>(_streamIds),
                StreamSizes = new List<long>(_streamSizes),
                //CompressionMethod = CompressionMethod,
                EntriesSizeInArchive = _hashedStream.BytesWritten - _initialFsoOffset,
            };

            long manifestLength;
            using (var filter = DoOutputFiltering(_hashedStream, false))
            {
                var x0 = _hashedStream.BytesWritten;
                Serializer.SerializeToStream(filter, versionManifest);
                filter.Flush();
                var x1 = _hashedStream.BytesWritten;
                manifestLength = x1 - x0;
            }
            var bytes = BitConverter.GetBytes(manifestLength);
            _hashedStream.Write(bytes, 0, bytes.Length);
            _hashedStream.Dispose();
            _hashedStream = null;
            _hash.FinishHashing();
            bytes = _hash.Hash;
            _fileStream.Write(bytes, 0, bytes.Length);
            _fileStream.Flush();
            _fileStream.Dispose();
            _transaction.Commit();
            _fileStream = null;
            _transaction.Dispose();
            _transaction = null;
            _state = ArchiveState.Final;
        }