private static Data.FolderData toInner(Data.IOFolder outer)
{
if (outer == null)
{
return(null);
}
var innerFolder = new Data.FolderData(outer.Name);
if (outer.ShouldSerializeSubFolders())
{
foreach (var subFolder in outer.SubFolders)
{
var inner = toInner(subFolder);
if (inner != null)
{
innerFolder.Add(inner);
}
}
}
if (outer.ShouldSerializeFiles())
{
foreach (var file in outer.Files)
{
var inner = toInner(file);
if (inner != null)
{
innerFolder.Add(inner);
}
}
}
return(innerFolder);
}
public static void Export(Data.FolderData root, string path)
{
try
{
Data.IOFolder outerRoot = toOuter(root);
if (outerRoot == null)
{
return;
}
if (string.IsNullOrWhiteSpace(path))
{
return;
}
using (var stream = createStream(path, InOut.Out))
{
using (var writer = createWriter(stream))
{
serializer.Value.Serialize(writer, outerRoot, xmlNamespaces.Value);
}
}
}
catch
{
throw;
}
}
private static Data.FolderData convert(Task <IList <Data.LZSSFileItem> > parseIndexTask)
{
var checker = Business.CodeTimeChecker.New;
Business.StatusManager.Instance.UpdateProgress(0.9);
Business.StatusManager.Instance.UpdateStatus("converting...");
try
{
if (parseIndexTask.Exception != null)
{
throw parseIndexTask.Exception;
}
if (parseIndexTask.IsCanceled)
{
return(null);
}
var lzssFiles = parseIndexTask.Result;
if (lzssFiles == null || lzssFiles.Count == 0)
{
return(null);
}
Regex folderFilter = new Regex(folderFilterToken);
var rootFolder = new Data.FolderData(rootFolderName);
var currentFolder = rootFolder;
foreach (var lzssItem in lzssFiles)
{
if (folderFilter.IsMatch(lzssItem.Name)) //folder
{
if (lzssItem.Name == currentFolder.Name)
{
continue;
}
var folder = new Data.FolderData(lzssItem.Name);
rootFolder.Add(folder);
currentFolder = folder;
}
else //file
{
var file = new Data.FileData(lzssItem);
currentFolder.Add(file);
}
}
return(rootFolder);
}
catch
{
throw;
}
finally
{
checker.Check("LZSSFileMapParser.convert");
}
}
public void Parse()
{
Data.FolderData rootFolder = null;
Assert.DoesNotThrow(delegate
{
rootFolder = Extractor.Business.LZSSFileMapParser.Parse(this.lzssFileMap);
});
Assert.NotNull(rootFolder);
LZSSFileMapParserTest.rootFolder = rootFolder;
}
public FileMapManagerViewModel(Data.FolderData root)
{
if (root == null)
{
throw new ArgumentNullException("root");
}
this.rootSource.Add(root);
this.NotifyPropertyChanged("RootSource");
}
private void generateRootFolder(string data)
{
try
{
this.rootSource.Clear();
Data.FolderData root = null;
if (!string.IsNullOrWhiteSpace(data))
{
root = Business.LZSSFileMapParser.Parse(data);
}
if (root == null)
{
MessageBox.Show(data, "Cannot get file data from nfs file");
}
else
{
Data.FolderData fakeFolder = new Data.FolderData("test");
fakeFolder.Add(new Data.FileData(new Data.LZSSFileItem()
{
Name = "test.txt",
Index = 0,
Size = 100
}));
fakeFolder.Add(new Data.FileData(new Data.LZSSFileItem()
{
Name = "test.txt",
Index = 1,
Size = 100
}));
root.SubFolders[0].Add(fakeFolder);
this.rootFolder = root;
this.rootSource.Add(root);
this.NotifyPropertyChanged("RootSource");
}
}
catch
{
throw;
}
}
private static Data.IOFolder toOuter(Data.FolderData inner)
{
if (inner == null)
{
return(null);
}
var outerFolder = new Data.IOFolder()
{
Name = inner.Name
};
if (inner.SubFolders.Count > 0)
{
outerFolder.SubFolders = new List <Data.IOFolder>();
foreach (var subFolder in inner.SubFolders)
{
var outer = toOuter(subFolder);
if (outer != null)
{
outerFolder.SubFolders.Add(outer);
}
}
}
if (inner.Files.Count > 0)
{
outerFolder.Files = new List <Data.IOFile>();
foreach (var file in inner.Files)
{
var outer = toOuter(file);
if (file != null)
{
outerFolder.Files.Add(outer);
}
}
}
return(outerFolder);
}