/// <summary></summary>
protected virtual void MergeLanguageRoot(IRoot root, IRoot languageRoot)
{
Debug.Assert(languageRoot.LibraryBlocks.NodeBlockList.Count == 1);
BaseNode.IBlock <BaseNode.ILibrary, BaseNode.Library> BlockLibrary = languageRoot.LibraryBlocks.NodeBlockList[0];
Debug.Assert(BlockLibrary.NodeList.Count == 1);
root.LibraryBlocks.NodeBlockList.Add(BlockLibrary);
BaseNode.ILibrary LanguageLibrary = BlockLibrary.NodeList[0];
Debug.Assert(LanguageLibrary.ClassIdentifierBlocks.NodeBlockList.Count == 1);
BaseNode.IBlock <BaseNode.IIdentifier, BaseNode.Identifier> BlockIdentifier = LanguageLibrary.ClassIdentifierBlocks.NodeBlockList[0];
Debug.Assert(BlockIdentifier.NodeList.Count == LanguageClasses.NameToGuid.Count);
Debug.Assert(BlockIdentifier.NodeList.Count == LanguageClasses.GuidToName.Count);
List <string> IdentifierList = new List <string>();
foreach (IIdentifier Item in BlockIdentifier.NodeList)
{
Debug.Assert(!IdentifierList.Contains(Item.Text));
IdentifierList.Add(Item.Text);
}
Debug.Assert(languageRoot.ClassBlocks.NodeBlockList.Count == 1);
BaseNode.IBlock <BaseNode.IClass, BaseNode.Class> BlockClass = languageRoot.ClassBlocks.NodeBlockList[0];
Debug.Assert(BlockClass.NodeList.Count == LanguageClasses.NameToGuid.Count);
Debug.Assert(BlockClass.NodeList.Count == LanguageClasses.GuidToName.Count);
foreach (IClass Item in BlockClass.NodeList)
{
Debug.Assert(LanguageClasses.NameToGuid.ContainsKey(Item.EntityName.Text));
Debug.Assert(LanguageClasses.NameToGuid[Item.EntityName.Text] == Item.ClassGuid);
Debug.Assert(LanguageClasses.GuidToName.ContainsKey(Item.ClassGuid));
Debug.Assert(LanguageClasses.GuidToName[Item.ClassGuid] == Item.EntityName.Text);
Debug.Assert(IdentifierList.Contains(Item.EntityName.Text));
}
root.ClassBlocks.NodeBlockList.Add(BlockClass);
Debug.Assert(languageRoot.Replicates.Count == 0);
// Remove hard-coded classes.
List <BaseNode.IIdentifier> IdentifierCopyList = new List <BaseNode.IIdentifier>(BlockIdentifier.NodeList);
foreach (IIdentifier Item in IdentifierCopyList)
{
if (Item.Text == "Any" || Item.Text == "Any Reference" || Item.Text == "Any Value")
{
BlockIdentifier.NodeList.Remove(Item);
}
}
List <BaseNode.IClass> ClassCopyList = new List <BaseNode.IClass>(BlockClass.NodeList);
foreach (IClass Item in ClassCopyList)
{
if (Item.EntityName.Text == "Any" || Item.EntityName.Text == "Any Reference" || Item.EntityName.Text == "Any Value")
{
BlockClass.NodeList.Remove(Item);
}
}
}
private static Main CreateRoot(Guid valueGuid, Imperfections imperfection)
{
Guid MainGuid = Guid.NewGuid();
Guid LeafGuid0 = Guid.NewGuid();
Tree PlaceholderTree = CreateTree();
Leaf PlaceholderLeaf = CreateLeaf(imperfection == Imperfections.BadGuid ? MainGuid : LeafGuid0);
BaseNode.Document UnassignedOptionalLeafDocument = BaseNodeHelper.NodeHelper.CreateSimpleDocument("leaf doc", Guid.NewGuid());
Leaf UnassignedOptionalLeaf = new Leaf(UnassignedOptionalLeafDocument, "optional unassigned");
Easly.IOptionalReference <Leaf> UnassignedOptional = BaseNodeHelper.OptionalReferenceHelper.CreateReference <Leaf>(UnassignedOptionalLeaf);
Easly.IOptionalReference <Leaf> EmptyOptional = BaseNodeHelper.OptionalReferenceHelper.CreateReference(new Leaf());
Leaf AssignedOptionalLeaf = CreateLeaf(Guid.NewGuid());
Easly.IOptionalReference <Leaf> AssignedOptionalForLeaf = BaseNodeHelper.OptionalReferenceHelper.CreateReference <Leaf>(AssignedOptionalLeaf);
AssignedOptionalForLeaf.Assign();
Tree AssignedOptionalTree = CreateTree();
Easly.IOptionalReference <Tree> AssignedOptionalForTree = BaseNodeHelper.OptionalReferenceHelper.CreateReference <Tree>(AssignedOptionalTree);
AssignedOptionalForTree.Assign();
Leaf FirstChild = CreateLeaf(Guid.NewGuid());
Leaf SecondChild = CreateLeaf(Guid.NewGuid());
Leaf ThirdChild = CreateLeaf(Guid.NewGuid());
Leaf FourthChild = CreateLeaf(Guid.NewGuid());
BaseNode.IBlock <Leaf> SecondBlock = BaseNodeHelper.BlockListHelper.CreateBlock <Leaf>(new List <Leaf>()
{
SecondChild, ThirdChild
});
BaseNode.IBlock <Leaf> ThirdBlock = BaseNodeHelper.BlockListHelper.CreateBlock <Leaf>(new List <Leaf>()
{
FourthChild
});
BaseNode.IBlockList <Leaf> LeafBlocks = BaseNodeHelper.BlockListHelper.CreateSimpleBlockList <Leaf>(FirstChild);
LeafBlocks.NodeBlockList.Add(SecondBlock);
LeafBlocks.NodeBlockList.Add(ThirdBlock);
BaseNodeHelper.NodeTreeHelper.SetCommentText(SecondBlock.Documentation, "test");
Leaf FirstPath = CreateLeaf(Guid.NewGuid());
Leaf SecondPath = CreateLeaf(Guid.NewGuid());
IList <Leaf> LeafPath = new List <Leaf>();
LeafPath.Add(FirstPath);
LeafPath.Add(SecondPath);
BaseNode.Document RootDocument = BaseNodeHelper.NodeHelper.CreateSimpleDocument("main doc", MainGuid);
Main Root = new Main(RootDocument);
BaseNodeHelper.NodeTreeHelperChild.SetChildNode(Root, nameof(Main.PlaceholderTree), PlaceholderTree);
BaseNodeHelper.NodeTreeHelperChild.SetChildNode(Root, nameof(Main.PlaceholderLeaf), PlaceholderLeaf);
BaseNodeHelper.NodeTreeHelperOptional.SetOptionalReference(Root, nameof(Main.UnassignedOptionalLeaf), (Easly.IOptionalReference)UnassignedOptional);
BaseNodeHelper.NodeTreeHelperOptional.SetOptionalReference(Root, nameof(Main.EmptyOptionalLeaf), (Easly.IOptionalReference)EmptyOptional);
BaseNodeHelper.NodeTreeHelperOptional.SetOptionalReference(Root, nameof(Main.AssignedOptionalTree), (Easly.IOptionalReference)AssignedOptionalForTree);
BaseNodeHelper.NodeTreeHelperOptional.SetOptionalReference(Root, nameof(Main.AssignedOptionalLeaf), (Easly.IOptionalReference)AssignedOptionalForLeaf);
BaseNodeHelper.NodeTreeHelperBlockList.SetBlockList(Root, nameof(Main.LeafBlocks), (BaseNode.IBlockList)LeafBlocks);
BaseNodeHelper.NodeTreeHelperList.SetChildNodeList(Root, nameof(Main.LeafPath), (IList)LeafPath);
BaseNodeHelper.NodeTreeHelper.SetBooleanProperty(Root, nameof(Main.ValueBoolean), true);
BaseNodeHelper.NodeTreeHelper.SetEnumProperty(Root, nameof(Main.ValueEnum), BaseNode.CopySemantic.Value);
BaseNodeHelper.NodeTreeHelper.SetStringProperty(Root, nameof(Main.ValueString), "s");
BaseNodeHelper.NodeTreeHelper.SetGuidProperty(Root, nameof(Main.ValueGuid), valueGuid);
return(Root);
}
