public IDataTree setUpDataTree(IBaseTree baseTree)
{
IDataTree data = DataTreeBuilder.CreateDocumentMappedTree(baseTree);
DataTreeBuilder.AddToDataTree(data, toMap);
return(data);
}
public static void MakeTrees(string contentTreeName)
{
IIO io = new FileIO();
IEnumerable<string> file = io.ReadSourceIterable(testpath + "TIME.ALL");
ITextExtractor it = new BeginMarkerExtraction(file, "*TEXT");
ITreeIO tio = new TreeIO();
IBaseTree tree = tio.LoadBaseTree(testpath + contentTreeName);
int count = 1;
while (it.HasNextContent()) {
string content = it.FindNextContent();
//Console.WriteLine("-----");
string name = "" + count;
//Console.WriteLine(name);
content = Helpers.ConsumeName(content);
//Console.WriteLine(content);
IDataTree datatree = DataTreeBuilder.CreateDocumentMappedTree(tree);
//Console.WriteLine(tree);
//Console.WriteLine(datatree.GetBaseTree());
DataTreeBuilder.AddToDataTree(datatree, content);
datatree.Name = name;
tio.SaveDataTree(datatree, testpath + @"\datatrees\" + name + ".dtree");
//Console.WriteLine(datatree.MappedWords);
count++;
}
}
public static void AddToDataTreeBoyerMoore(IDataTree dataTree, string content)
{
if (dataTree == null || content == null)
{
throw new ArgumentNullException();
}
if (dataTree.GetBaseTree() == null)
{
throw new InvalidOperationException("Data Tree's base tree cannot be null");
}
content = StringFunctions.Normalize(content);
if (dataTree is StemmedDocumentMap)
{
content = StringFunctions.StemmedWord(content);
}
foreach (Node n in dataTree.GetBaseTree())
{
//int matches = content.BoyerMooreMatchCount(n.KeyWord);
int matches = content.BoyerMooreMatchCount(" " + n.KeyWord + " ");
if (matches > 0)
{
for (int i = 0; i < matches; i++)
{
dataTree.AddConnection(n.KeyWord.Trim());
}
}
}
}
public void DocumentMappingTest2()
{
IBaseTree tree = setUpTree();
IDataTree dataTree = DataTreeBuilder.CreateDocumentMappedTree(tree, toMap);
//make sure the root has the correct number of children
Assert.AreEqual(dataTree.Root.Children.Count, 2);
//make sure each of the children has the correct weight
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "tree").FirstOrDefault().Weight, 3);
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "others").FirstOrDefault().Weight, 2);
//make sure a branch on the content tree which is not existent in the mapped tree does not exist
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "nonexistent").FirstOrDefault(), null);
//make sure each child's connections have their own correct weight
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "tree").FirstOrDefault().EndPoint.Children.Where(x => x.EndPoint.Keyword == "content").FirstOrDefault().Weight, 1);
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "tree").FirstOrDefault().EndPoint.Children.Where(x => x.EndPoint.Keyword == "mapped").FirstOrDefault().Weight, 1);
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "others").FirstOrDefault().EndPoint.Children.Where(x => x.EndPoint.Keyword == "series").FirstOrDefault().Weight, 1);
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "others").FirstOrDefault().EndPoint.Children.Where(x => x.EndPoint.Keyword == "going").FirstOrDefault().Weight, 1);
//make sure children connections do not cross
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "others").FirstOrDefault().EndPoint.Children.Where(x => x.EndPoint.Keyword == "content").FirstOrDefault(), null);
//make sure leaf children do not have any connections
Assert.AreEqual(dataTree.Root.Children.Where(c => c.EndPoint.Keyword == "tree").FirstOrDefault().EndPoint.Children.Where(x => x.EndPoint.Keyword == "content").FirstOrDefault().EndPoint.Children.Count, 0);
}
public MapFieldDataItem(IDataTree parent, IMapField field)
{
this.field = field ?? throw new ArgumentNullException(nameof(field));
this.parent = parent ?? throw new ArgumentNullException(nameof(parent));
instance = parent.Instance ?? throw new ArgumentNullException(nameof(parent.Instance));
currentValue = field.GetValue <object>(instance);
}
private void AddLead(Dictionary <string, Tuple <DataItem, int> > table, IDataTree tree)
{
foreach (var dataTree in tree.Branches)
{
AddLead(table, dataTree);
}
foreach (var leaf in tree.Leafs)
{
var type = leaf.Value.GetType();
if (!typeMap.TryGetValue(type, out bool canUse))
{
canUse = type.IsPrimitive && type.IsNumericType();
typeMap[type] = canUse;
}
if (!canUse ||
!table.TryGetValue(leaf.FullName, out Tuple <DataItem, int> dataItem))
{
dataItem = new Tuple <DataItem, int>(
new DataItem(tree.FullName, leaf.Name, leaf.Description, leaf.Value),
1);
}
else
{
var value = Calculator <object> .Add(dataItem.Item1.Value, leaf.Value);
dataItem = new Tuple <DataItem, int>(
new DataItem(tree.FullName, leaf.Name, leaf.Description, value),
dataItem.Item2 + 1);
}
table[leaf.FullName] = dataItem;
}
}
public static void TestComparison()
{
//string pathDataTree = @"D:\Donnees_VParis\PSBDADSU_VIL.C11_180126_003118_9.026.756_77.327.txt";
//string pathDataTree2 = @"D:\Donnees_VParis\PSBDADSU_VIL.C11_180126_003118_9.026.756_77.327.modifie.txt";
Stopwatch muniteur = new Stopwatch();
muniteur.Start();
using (StreamWriter writer = new StreamWriter(pathResult, false))
{
IDsnTree dsnTree = DsnTreeFactory.LoadTree(pathDsnTree);
IDataTree dataTree = DsnTreeFactory.loadDataTree(dsnTree, pathDataTree);
IDataTree dataTree2 = DsnTreeFactory.loadDataTree(dsnTree, pathDataTree2);
IDsnData dsnData = new DsnData(dataTree);
IDsnData dsnData2 = new DsnData(dataTree2);
List <DataItem> dataItems = new List <DataItem>();
foreach (var employee in dsnData.Employees)
{
if (dsnData2.Employees.ContainsKey(employee.Key))
{
var employee2 = dsnData2.Employees[employee.Key];
Comparison.CompareDictionary(employee.Value.EmployeeDataBlock.Leaves.First().Data, employee2.EmployeeDataBlock.Leaves.First().Data, dataItems);
foreach (var activityPeriod in employee.Value.ActivityPeriods)
{
var activityPeriod2 = employee2.ActivityPeriods.Find(item => item.BeginDate.Equals(activityPeriod.BeginDate));
if (activityPeriod2 != null)
{
Comparison.TextDiff(activityPeriod2.ToString(), activityPeriod.ToString(), dataItems, true);
}
}
}
}
foreach (var item in dataItems)
{
switch (item.Status)
{
case ChangeStatus.Deleted:
writer.Write("- ");
break;
case ChangeStatus.Inserted:
writer.Write("+ ");
break;
case ChangeStatus.Modified:
writer.Write("* ");
break;
default:
writer.Write(" ");
break;
}
writer.WriteLine(item.Key + ",'" + item.Value + "','" + item.OldValue + "'");
}
}
muniteur.Stop();
Console.WriteLine("Comparision in " + muniteur.Elapsed + " seconds");
}
public void DocumentMapNonexistentContentEnumberable()
{
IBaseTree tree = setUpTree();
IDataTree dataTree = DataTreeBuilder.CreateDocumentMappedTree(tree);
DataTreeBuilder.AddAllToDataTree(dataTree, null);
}
public static void PrintDataTree(this IDataTree tree)
{
Console.WriteLine(tree.Root.Keyword + " : " + tree.MappedWords);
foreach (Connection c in tree.Root.Children)
{
c.PrintConnection(" ");
}
}
//private const double IRREL_WEIGHT_VALUE = 1.5;
public static bool CompareTo(this IDataTree query, IDataTree document)
{
//double dif = Dif(query.Root, document.Root, query.MappedWords, document.MappedWords);
//double dif = DifUsingCutoffs(query.Root, document.Root, query.MappedWords, document.MappedWords);
double dif = DifUsingCutoffs(query.Root, document.Root, query.MappedWords, document.MappedWords);
return(dif < COMPARE_VALUE);
}
public HonorairePayer(IDataTree dataTree, IDataBlock honorairePayerBlock)
{
_dataTree = dataTree;
_honorairePayerBlock = honorairePayerBlock;
_honoraires = new List <IHonoraire>();
LoadHonorairePayer();
LoadHonoraires();
}
public DocumentTreeWrapper(IDataTree tree)
{
WrapperNode baseWrapper = new WrapperNode();
baseWrapper.Keyword = tree.Root.Keyword;
baseWrapper.Weight = tree.MappedWords;
Tree = new ObservableCollection <WrapperNode>();
Tree.Add(baseWrapper);
CreateNodes(tree.Root, baseWrapper);
}
public Employee(IDataTree dataTree, IDataBlock employeeDataBlock)
{
_dataTree = dataTree;
_employeeDataBlock = employeeDataBlock;
_activityPeriods = new List <IActivityPeriod>();
_specialPeriods = new List <ISpecialPeriod>();
LoadEmployee();
LoadActivityPeriods();
LoadSpecialPeriods();
}
public static void TestToString()
{
using (StreamWriter writer = new StreamWriter(pathResult, false))
{
IDsnTree dsnTree = DsnTreeFactory.LoadTree(pathDsnTree);
IDataTree dataTree = DsnTreeFactory.loadDataTree(dsnTree, pathDataTree);
IDsnData dsnData = new DsnData(dataTree);
writer.Write(dsnData.DataDispatch.ToString());
}
}
public IDataTree Create(IDataTree tree, IMapCategory mapCategory)
{
object instance = mapCategory.Parent.IsCollapsed
? mapCategory.ResolveInstance(mapCategory.Parent.ResolveInstance(tree.Instance))
: mapCategory.ResolveInstance(tree.Instance);
return(mapCategory.OwnerType == typeof(DataTree)
? (DataTree)instance
: new DataTree(instance, mapCategory));
}
public void DocumentMapChangeBaseTree()
{
IBaseTree tree = setUpTree();
IDataTree dataTree = DataTreeBuilder.CreateDocumentMappedTree(tree);
DataTreeBuilder.AddAllToDataTree(dataTree, toMapEnumerable);
dataTree.SetBaseTree(null);
Assert.AreEqual(dataTree.GetBaseTree(), null);
}
public static void AddAllToDataTree(IDataTree tree, IEnumerable <string> content)
{
if (tree == null || content == null)
{
throw new ArgumentNullException();
}
foreach (string s in content)
{
AddToDataTree(tree, s);
}
}
public static IDataTree CreateDocumentMappedTree(IBaseTree baseTree, string content)
{
if (baseTree == null || content == null)
{
throw new ArgumentNullException();
}
IDataTree toReturn = CreateDocumentMappedTree(baseTree);
AddToDataTree(toReturn, content);
return(toReturn);
}
private static void CreateVector(string prefix, IDataTree tree, List <SimpleCell> vector, bool usePrefix = true)
{
var actualPrefix = usePrefix ? prefix : string.Empty;
vector.AddRange(tree.Leafs.Select(leaf => new SimpleCell(actualPrefix + leaf.Name.CreatePureLetterText(), (double)leaf.Value)));
var treeName = tree.Name.CreatePureLetterText();
foreach (var branch in tree.Branches)
{
CreateVector(usePrefix ? $"{prefix}_{treeName}_" : string.Empty, branch, vector);
}
}
public DsnData(IDataTree dataTree)
{
_dataTree = dataTree;
_dsnTree = _dataTree.DsnTree;
_employees = new Dictionary <string, IEmployee>();
_honorairePayers = new List <IHonorairePayer>();
_establishments = new Dictionary <string, IEstablishment>();
LoadDispatch();
LoadEmplyees();
LoadHonorairePayers();
LoadEstablishments();
}
public void LoadInvalidFileTest2()
{
ITreeIO io = new TreeIO();
IBaseTree basetree = setUpBaseTree();
IDataTree datatree = setUpDataTree(basetree);
io.SaveDataTree(datatree, location);
Assert.IsTrue(File.Exists(location));
IBaseTree loadedDatatree = io.LoadBaseTree(location);
}
public IDataItem Create(IDataTree tree, IMapField field)
{
if (!map.TryGetValue(field.Name, out double value))
{
if (!field.IsOptional)
{
log.LogWarning("{0} value not found", field.Name);
}
}
return(new DataItem(tree.Name, field.Name, field.Description, value));
}
public static VectorData CreateVector(this IDataTree tree, NormalizationType normalization)
{
if (tree is null)
{
throw new ArgumentNullException(nameof(tree));
}
List <SimpleCell> vectors = new List <SimpleCell>();
CreateVector("Data", tree, vectors);
vectors = vectors.OrderBy(item => item.Name).ToList();
return(new VectorDataFactory().CreateSimple(normalization, vectors.Select(item => (ICell)item).ToArray()));
}
private void documentList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
object selectedVal = documentList.SelectedValue;
string name = selectedVal.ToString();
string filename = documentLabel.Content.ToString() + @"\" + name + ".dtree";
ITreeIO tio = new TreeIO();
IDataTree tree = tio.LoadDataTree(filename);
DocumentTreeWrapper wrapper = new DocumentTreeWrapper(tree);
dataTree.ItemsSource = wrapper.Tree;
}
private static void CreateVector(string prefix, IDataTree tree, List <SimpleCell> vector)
{
foreach (var leaf in tree.Leafs)
{
vector.Add(new SimpleCell(prefix + leaf.Name.CreatePureLetterText(), (double)leaf.Value));
}
string treeName = tree.Name.CreatePureLetterText();
foreach (var branch in tree.Branches)
{
CreateVector(prefix + "_" + treeName + "_", branch, vector);
}
}
public static void CompaireActivityPeriod(IDataTree dataTree, IDataBlock activityPeriodDataBlock, IDataBlock activityPeriodDataBlock2)
{
IDsnNode current = dataTree.DsnTree.Find(ActivityPeriod.KeyActivityPeriodBlock);
Stack <IDsnNode> stack = new Stack <IDsnNode>();
stack.Push(current);
while (stack.Count > 0)
{
current = stack.Pop();
for (var i = current.Children.Count - 1; i >= 0; i--)
{
stack.Push(current.Children[i]);
}
}
}
public static void AddToDataTree(IDataTree dataTree, string content)
{
if (dataTree == null || content == null)
{
throw new ArgumentNullException();
}
try {
string[] words = content.Split(' ');
foreach (string w in words)
{
dataTree.AddConnection(w);
}
} catch (NullReferenceException) {
throw new InvalidOperationException("Data Tree's base tree cannot be null");
}
}
internal StemmedDocumentMap(IDataTree tree)
{
baseTree = tree.GetBaseTree();
this.tree = tree;
var enumer = baseTree.GetEnumerator();
List <Node> nodes = new List <Node>();
while (enumer.MoveNext())
{
nodes.Add((Node)enumer.Current);
}
for (int i = 0; i < nodes.Count; i++)
{
Node s = nodes[i];
baseTree.Rename(s, StringFunctions.StemmedWord(s.KeyWord));
}
}
public void SaveDataTreeTest()
{
ITreeIO io = new TreeIO();
IBaseTree basetree = setUpBaseTree();
IDataTree datatree = setUpDataTree(basetree);
io.SaveDataTree(datatree, location);
Assert.IsTrue(File.Exists(location));
IDataTree loadedDatatree = io.LoadDataTree(location);
Assert.AreNotSame(basetree, loadedDatatree);
Assert.AreEqual(basetree.Root.KeyWord, loadedDatatree.Root.Keyword);
Assert.IsNull(loadedDatatree.GetBaseTree());
Assert.IsNotNull(datatree.GetBaseTree());
}
public void CompareTrees()
{
IBaseTree tree = setUpTree();
IDataTree originalDataTree = DataTreeBuilder.CreateDocumentMappedTree(tree);
DataTreeBuilder.AddToDataTree(originalDataTree, toMap);
IDataTree probablyMatches = DataTreeBuilder.CreateDocumentMappedTree(tree);
DataTreeBuilder.AddToDataTree(probablyMatches, shouldProbablyMatch);
IDataTree notAMatch = DataTreeBuilder.CreateDocumentMappedTree(tree);
DataTreeBuilder.AddToDataTree(notAMatch, shouldProbablyNotMatch);
Assert.IsTrue(originalDataTree.CompareTo(originalDataTree));
Assert.IsTrue(originalDataTree.CompareTo(probablyMatches));
Assert.IsFalse(originalDataTree.CompareTo(notAMatch));
}
