public DirectorySaveDataFile(DirectorySaveDataFileSystem parentFs, IFile baseFile)
{
ParentFs = parentFs;
BaseFile = baseFile;
Mode = BaseFile.Mode;
ToDispose.Add(BaseFile);
}
public HierarchicalIntegrityVerificationStorage(IntegrityVerificationInfo[] levelInfo, IntegrityCheckLevel integrityCheckLevel, bool leaveOpen)
{
Levels = new IStorage[levelInfo.Length];
IntegrityCheckLevel = integrityCheckLevel;
LevelValidities = new Validity[levelInfo.Length - 1][];
IntegrityStorages = new IntegrityVerificationStorage[levelInfo.Length - 1];
Levels[0] = levelInfo[0].Data;
for (int i = 1; i < Levels.Length; i++)
{
var levelData = new IntegrityVerificationStorage(levelInfo[i], Levels[i - 1], integrityCheckLevel, leaveOpen);
int cacheCount = Math.Min((int)Util.DivideByRoundUp(levelData.GetSize(), levelInfo[i].BlockSize), 4);
Levels[i] = new CachedStorage(levelData, cacheCount, leaveOpen);
LevelValidities[i - 1] = levelData.BlockValidities;
IntegrityStorages[i - 1] = levelData;
}
DataLevel = Levels[Levels.Length - 1];
_length = DataLevel.GetSize();
if (!leaveOpen)
{
ToDispose.Add(DataLevel);
}
}
public HierarchicalIntegrityVerificationStorage(IntegrityVerificationInfo[] levelInfo, IntegrityCheckLevel integrityCheckLevel, bool leaveOpen)
{
Levels = new IStorage[levelInfo.Length];
IntegrityCheckLevel = integrityCheckLevel;
LevelValidities = new Validity[levelInfo.Length - 1][];
IntegrityStorages = new IntegrityVerificationStorage[levelInfo.Length - 1];
Levels[0] = levelInfo[0].Data;
for (int i = 1; i < Levels.Length; i++)
{
var levelData = new IntegrityVerificationStorage(levelInfo[i], Levels[i - 1], integrityCheckLevel, leaveOpen);
Levels[i] = new CachedStorage(levelData, 4, leaveOpen);
LevelValidities[i - 1] = levelData.BlockValidities;
IntegrityStorages[i - 1] = levelData;
}
DataLevel = Levels[Levels.Length - 1];
Length = DataLevel.Length;
if (!leaveOpen)
{
ToDispose.Add(DataLevel);
}
}
public SubStorage(IStorage baseStorage, long offset, long length, bool leaveOpen)
: this(baseStorage, offset, length)
{
if (!leaveOpen)
{
ToDispose.Add(BaseStorage);
}
}
public LocalFile(string path, OpenMode mode)
{
Mode = mode;
Stream = OpenFile(path, mode);
File = new StreamFile(Stream, mode);
ToDispose.Add(File);
ToDispose.Add(Stream);
}
public LocalStorage(string path, FileAccess access, FileMode mode)
{
Path = path;
Stream = new FileStream(Path, mode, access);
Storage = new StreamStorage(Stream, false);
ToDispose.Add(Storage);
ToDispose.Add(Stream);
}
public StreamStorage(Stream baseStream, bool leaveOpen)
{
BaseStream = baseStream;
_length = BaseStream.Length;
if (!leaveOpen)
{
ToDispose.Add(BaseStream);
}
}
public LocalFile(string path, OpenMode mode)
{
Path = path;
Mode = mode;
Stream = new FileStream(Path, FileMode.Open, GetFileAccess(mode), GetFileShare(mode));
File = new StreamFile(Stream, mode);
ToDispose.Add(File);
ToDispose.Add(Stream);
}
/// <summary>
/// Disposes of the resources in <see cref="ToDispose"/>.
/// </summary>
void Dispose(bool disposing)
{
if (!disposed)
{
disposed = true;
if (disposing)
{
ToDispose?.Dispose();
}
}
}
public SectorStorage(IStorage baseStorage, int sectorSize, bool leaveOpen)
{
BaseStorage = baseStorage;
SectorSize = sectorSize;
SectorCount = (int)Util.DivideByRoundUp(BaseStorage.GetSize(), SectorSize);
_length = BaseStorage.GetSize();
if (!leaveOpen)
{
ToDispose.Add(BaseStorage);
}
}
internal ConcatenationFile(IList <IFile> sources, long splitFileSize, OpenMode mode)
{
Sources = sources.ToArray();
SplitFileSize = splitFileSize;
Mode = mode;
for (int i = 0; i < Sources.Length - 1; i++)
{
if (Sources[i].GetSize() != SplitFileSize)
{
throw new ArgumentException($"Source file must have size {splitFileSize}");
}
}
ToDispose.AddRange(Sources);
}
public IndirectStorage(IStorage bucketTreeHeader, IStorage bucketTreeData, bool leaveOpen, params IStorage[] sources)
{
Sources.AddRange(sources);
if (!leaveOpen)
{
ToDispose.AddRange(sources);
}
BucketTree = new BucketTree <RelocationEntry>(bucketTreeHeader, bucketTreeData);
RelocationEntries = BucketTree.GetEntryList();
RelocationOffsets = RelocationEntries.Select(x => x.Offset).ToList();
Length = BucketTree.BucketOffsets.OffsetEnd;
}
internal ConcatenationFile(IFileSystem baseFileSystem, string path, IEnumerable <IFile> sources, long subFileSize, OpenMode mode)
{
BaseFileSystem = baseFileSystem;
FilePath = path;
Sources = sources.ToList();
SubFileSize = subFileSize;
Mode = mode;
for (int i = 0; i < Sources.Count - 1; i++)
{
if (Sources[i].GetSize() != SubFileSize)
{
throw new ArgumentException($"Source file must have size {subFileSize}");
}
}
ToDispose.AddRange(Sources);
}
public JournalStorage(IStorage baseStorage, IStorage header, JournalMapParams mapInfo, bool leaveOpen)
{
BaseStorage = baseStorage;
HeaderStorage = header;
Header = new JournalHeader(HeaderStorage);
IStorage mapHeader = header.Slice(0x20, 0x10);
Map = new JournalMap(mapHeader, mapInfo);
BlockSize = (int)Header.BlockSize;
_length = Header.TotalSize - Header.JournalSize;
if (!leaveOpen)
{
ToDispose.Add(baseStorage);
}
}
public CachedStorage(IStorage baseStorage, int blockSize, int cacheSize, bool leaveOpen)
{
BaseStorage = baseStorage;
BlockSize = blockSize;
_length = BaseStorage.GetSize();
if (!leaveOpen)
{
ToDispose.Add(BaseStorage);
}
for (int i = 0; i < cacheSize; i++)
{
var block = new CacheBlock {
Buffer = new byte[blockSize], Index = -1
};
Blocks.AddLast(block);
}
}
public CachedStorage(IStorage baseStorage, int blockSize, int cacheSize, bool leaveOpen)
{
BaseStorage = baseStorage;
BlockSize = blockSize;
Length = BaseStorage.Length;
if (!leaveOpen)
{
ToDispose.Add(BaseStorage);
}
for (int i = 0; i < cacheSize; i++)
{
var block = new CacheBlock {
Buffer = ArrayPool <byte> .Shared.Rent(blockSize)
};
Blocks.AddLast(block);
}
}
public ConcatenationStorage(IList <IStorage> sources, bool leaveOpen)
{
Sources = new ConcatSource[sources.Count];
if (!leaveOpen)
{
ToDispose.AddRange(sources);
}
long length = 0;
for (int i = 0; i < sources.Count; i++)
{
if (sources[i].Length < 0)
{
throw new ArgumentException("Sources must have an explicit length.");
}
Sources[i] = new ConcatSource(sources[i], length, sources[i].Length);
length += sources[i].Length;
}
Length = length;
}
/// <summary>
/// Creates a new <see cref="RemapStorage"/>
/// </summary>
/// <param name="storage">A <see cref="IStorage"/> of the main data of the RemapStream.
/// The <see cref="RemapStorage"/> object assumes complete ownership of the Storage.</param>
/// <param name="header">The header for this RemapStorage.</param>
/// <param name="mapEntries">The remapping entries for this RemapStorage.</param>
/// <param name="leaveOpen"><see langword="true"/> to leave the storage open after the <see cref="RemapStorage"/> object is disposed; otherwise, <see langword="false"/>.</param>
public RemapStorage(IStorage storage, IStorage header, IStorage mapEntries, bool leaveOpen)
{
BaseStorage = storage;
HeaderStorage = header;
MapEntryStorage = mapEntries;
Header = new RemapHeader(HeaderStorage);
MapEntries = new MapEntry[Header.MapEntryCount];
var reader = new BinaryReader(MapEntryStorage.AsStream());
for (int i = 0; i < Header.MapEntryCount; i++)
{
MapEntries[i] = new MapEntry(reader);
}
if (!leaveOpen)
{
ToDispose.Add(BaseStorage);
}
Segments = InitSegments(Header, MapEntries);
}
/// <summary>
/// Disposes of the resources in <see cref="ToDispose"/>.
/// </summary>
public void Dispose()
{
ToDispose?.Dispose();
ToDispose = null;
}
