public SteamDepotFile(String fileFullName, Int32 fileVersion, SteamDepotFileTypes fileType, SteamDepot steamDepot)
{
if (String.IsNullOrEmpty(fileFullName))
throw new ArgumentNullException("fileFullName");
if (steamDepot == null)
throw new ArgumentNullException("steamDepot");
name = fileFullName;
version = fileVersion;
type = fileType;
depot = steamDepot;
relativeName = name.Remove(0, depot.GetDirectory(version, type).FullName.Length);
if (relativeName[0] == Path.DirectorySeparatorChar)
relativeName = relativeName.Remove(0, 1);
}
public SteamDepotFile[] GetFiles(SteamDepotFileTypes fileTypes, CultureInfo culture)
{
if (fileTypes == SteamDepotFileTypes.None)
return null;
List<SteamDepotFile> result = new List<SteamDepotFile>();
foreach (List<SteamDepotFile> filesList in files.Values)
{
SteamDepotFile resultFile = null;
Int32 fileIndex = -1;
Int32 fileVersion = -1;
SteamDepotFile file;
SteamDepot depot;
// Find index of file (file should not be fix)
for (Int32 i = 0; i < filesList.Count; i++)
{
file = filesList[i];
depot = file.SteamDepot;
if (!depot.IsOptional || depot.IsHaveCulture(culture) || depot.IsInvariant)
{
if (file.FileType != SteamDepotFileTypes.Fix)
fileIndex = i;
}
}
// Finded not fix file
if (fileIndex != -1)
{
for (Int32 i = fileIndex; i < filesList.Count; i++)
{
file = filesList[i];
depot = file.SteamDepot;
if (!depot.IsOptional || depot.IsHaveCulture(culture) || depot.IsInvariant)
{
if (file.FileType != SteamDepotFileTypes.Fix && file.Version > fileVersion)
fileVersion = file.Version;
if ((file.FileType & fileTypes) > 0 && file.Version == fileVersion)
{
resultFile = file;
// Add not fix file to result list if result file is fix and method should return not only fix files
if (resultFile.FileType == SteamDepotFileTypes.Fix && fileTypes != SteamDepotFileTypes.Fix)
result.Add(filesList[fileIndex]);
}
}
}
}
else // Finded fix file which do not replace any common or update file
{
for (Int32 i = 0; i < filesList.Count; i++)
{
file = filesList[i];
depot = file.SteamDepot;
if (!depot.IsOptional || depot.IsHaveCulture(culture) || depot.IsInvariant)
{
if ((file.FileType & fileTypes) > 0 && file.Version == depot.GetLatestVersion(SteamDepotFileTypes.Common)) // TODO: file.Version == depot latest version include update files
resultFile = file;
}
}
}
if (resultFile != null)
result.Add(resultFile);
}
if (result.Count > 0)
return result.ToArray();
else
return null;
}
public SteamDepotFile[][] GetSameFiles(SteamDepotFileTypes fileTypes)
{
if (fileTypes == SteamDepotFileTypes.None)
return null;
List<SteamDepotFile[]> result = new List<SteamDepotFile[]>();
SHA512Managed sha = new SHA512Managed();
foreach (List<SteamDepotFile> filesList in files.Values)
{
if (filesList.Count > 1)
{
Dictionary<Int64, List<SteamDepotFile>> filesDict = new Dictionary<Int64, List<SteamDepotFile>>();
Dictionary<Byte[], List<SteamDepotFile>> hashesDict = new Dictionary<Byte[], List<SteamDepotFile>>();
foreach (SteamDepotFile depotFile in filesList)
{
if ((depotFile.FileType & fileTypes) != SteamDepotFileTypes.None)
{
FileInfo file = new FileInfo(depotFile.FullName);
if (!filesDict.ContainsKey(file.Length))
filesDict.Add(file.Length, new List<SteamDepotFile>(1));
filesDict[file.Length].Add(depotFile);
}
}
foreach (Int64 fileLength in filesDict.Keys)
{
if (filesDict[fileLength].Count > 1)
{
foreach (SteamDepotFile depotFile in filesDict[fileLength])
{
FileStream stream = File.OpenRead(depotFile.FullName);
Byte[] hash1 = sha.ComputeHash(stream);
Byte[] hash2 = null;
stream.Close();
foreach (Byte[] dictHash in hashesDict.Keys)
{
Boolean isSameHash = true;
for (Int32 i = 0; i < hash1.Length; i++)
{
if (hash1[i] != dictHash[i])
{
isSameHash = false;
break;
}
}
if (isSameHash)
{
hash2 = dictHash;
break;
}
}
if (hash2 == null)
{
hashesDict.Add(hash1, new List<SteamDepotFile>(1));
hash2 = hash1;
}
hashesDict[hash2].Add(depotFile);
}
}
}
foreach (Byte[] hash in hashesDict.Keys)
{
if (hashesDict[hash].Count > 1)
result.Add(hashesDict[hash].ToArray());
}
}
}
sha.Clear();
return result.ToArray();
}
private void AddFiles(SteamDepot depot, SteamDepotFileTypes filesType)
{
Int32[] versions = depot.GetDepotVersions(filesType);
for (Int32 j = 0; j < versions.Length; j++)
AddFiles(depot, versions[j], filesType);
}
public void AddFiles(SteamDepot depot, Int32 filesVersion, SteamDepotFileTypes filesType)
{
if (depot == null)
throw new ArgumentNullException("depot");
SteamDepotFile[] depotFiles = depot.GetFiles(filesVersion, filesType);
foreach (SteamDepotFile depotFile in depotFiles)
AddFile(depotFile);
}
/// <summary>
/// Returns array with depot files of specified version and type.
/// </summary>
/// <param name="filesVersion">Version of files.</param>
/// <param name="filesType">Type of files.</param>
/// <returns>Array with depot files of specified version and type.</returns>
public SteamDepotFile[] GetFiles(Int32 filesVersion, SteamDepotFileTypes filesType)
{
List<SteamDepotFile> depotFiles = new List<SteamDepotFile>();
Queue<DirectoryInfo> directoriesQueue = new Queue<DirectoryInfo>();
DirectoryInfo directory = GetDirectory(filesVersion, filesType);
// Add shared files from source depot
if (filesType == SteamDepotFileTypes.Common && sharedFiles.Count > 0)
{
foreach (SteamDepotSharedFile sharedFile in sharedFiles)
{
if (sharedFile.SourceDepot != this)
{
SteamDepotFile depotFile = sharedFile.SourceDepot.GetFile(sharedFile.RelativeName, sharedFile.SourceDepot.GetLatestVersion(filesType), filesType);
depotFile.SteamDepot = this;
depotFiles.Add(depotFile);
}
}
}
do
{
if (directoriesQueue.Count > 0)
directory = directoriesQueue.Dequeue();
FileInfo[] files = directory.GetFiles();
foreach (FileInfo file in files)
depotFiles.Add(new SteamDepotFile(file.FullName, filesVersion, filesType, this));
DirectoryInfo[] subDirectories = directory.GetDirectories();
foreach (DirectoryInfo subDirectory in subDirectories)
directoriesQueue.Enqueue(subDirectory);
} while (directoriesQueue.Count > 0);
return depotFiles.ToArray();
}
private SteamDepotFile GetFile(String fileRelativeName, Int32 fileVersion, SteamDepotFileTypes fileType)
{
SteamDepotFile[] depotFiles = this.GetFiles(fileVersion, fileType);
foreach (SteamDepotFile depotFile in depotFiles)
{
if (String.Compare(fileRelativeName, depotFile.RelativeName, StringComparison.OrdinalIgnoreCase) == 0)
return depotFile;
}
return null;
}
public DirectoryInfo GetLatestVersionDirectory(SteamDepotFileTypes filesType)
{
return GetDirectory(GetLatestVersion(filesType), filesType);
}
/// <summary>
/// Returns latest version of files in depot with specified type.
/// </summary>
public Int32 GetLatestVersion(SteamDepotFileTypes filesType)
{
Int32 latestVersion = -1;
Dictionary<Int32, DirectoryInfo> directories;
if (filesType == SteamDepotFileTypes.Common)
directories = commonDirectories;
else if (filesType == SteamDepotFileTypes.Fix)
directories = fixesDirectories;
else // TODO: updates system
throw new ArgumentException("Invalid files type.", "filesType");
foreach (Int32 directoryVersion in directories.Keys)
{
if (directoryVersion >= latestVersion)
latestVersion = directoryVersion;
}
return latestVersion;
}
public Int32[] GetDepotVersions(SteamDepotFileTypes filesType)
{
if (filesType == SteamDepotFileTypes.Common)
return commonDirectories.Keys.ToArray();
else if (filesType == SteamDepotFileTypes.Fix)
return fixesDirectories.Keys.ToArray();
else // TODO: updates system
throw new ArgumentException("Invalid files type.", "filesType");
}
public Int32 GetDirectoriesCount(SteamDepotFileTypes filesType)
{
if (filesType == SteamDepotFileTypes.Common)
return commonDirectories.Count;
else if (filesType == SteamDepotFileTypes.Fix)
return fixesDirectories.Count;
else // TODO: updates system
throw new ArgumentException("Invalid files type.", "filesType");
}
public DirectoryInfo GetDirectory(Int32 filesVersion, SteamDepotFileTypes filesType)
{
if (filesType == SteamDepotFileTypes.Common && commonDirectories.ContainsKey(filesVersion))
return commonDirectories[filesVersion];
else if (filesType == SteamDepotFileTypes.Fix && fixesDirectories.ContainsKey(filesVersion))
return fixesDirectories[filesVersion];
else // TODO: updates system
return null;
}
