private static bool OnUpdate(Node node, WalkCallbacks <string> callback, string data)
{
IList <string> PropertyNames = NodeTreeHelper.EnumChildNodeProperties(node);
foreach (string PropertyName in PropertyNames)
{
if (NodeTreeHelperOptional.IsOptionalChildNodeProperty(node, PropertyName, out Type ChildNodeType))
{
NodeTreeHelperOptional.GetChildNode(node, PropertyName, out bool IsAssigned, out Node ChildNode);
if (!IsAssigned)
{
if (ChildNode is null)
{
Node NewChildNode = NodeHelper.CreateDefaultFromType(ChildNodeType);
NodeTreeHelperOptional.SetOptionalChildNode(node, PropertyName, NewChildNode);
NodeTreeHelperOptional.UnassignChildNode(node, PropertyName);
}
}
else if (ChildNode is null)
{
Node NewChildNode = NodeHelper.CreateDefaultFromType(ChildNodeType);
NodeTreeHelperOptional.SetOptionalChildNode(node, PropertyName, NewChildNode);
}
else if (NodeHelper.IsDefaultNode(ChildNode))
{
}
}
}
return(true);
}
private bool ReplicateAllBlocks(IRoot root)
{
Debug.Assert(ErrorList.IsEmpty);
foreach (IBlock <BaseNode.IClass, BaseNode.Class> Block in root.ClassBlocks.NodeBlockList)
{
foreach (IClass Item in Block.NodeList)
{
if (string.IsNullOrEmpty(Item.ClassPath))
{
ErrorList.AddError(new ErrorEmptyClassPath(Item));
}
}
}
ReplicationContext Replication = new ReplicationContext();
IWalkCallbacks <ReplicationContext> Callbacks = new WalkCallbacks <ReplicationContext>()
{
HandlerNode = OnNodeIgnoreReplicates, HandlerBlockList = OnBlockListReplicate, HandlerString = OnStringReplicateText
};
NodeTreeWalk.Walk <ReplicationContext>(root, Callbacks, Replication);
return(ErrorList.IsEmpty);
}
/// <summary></summary>
protected virtual void SealScope(IRoot root)
{
object Context = null;
IWalkCallbacks <object> Callbacks = new WalkCallbacks <object>()
{
HandlerNode = SealAllScopes, IsRecursive = true, BlockSubstitution = CreateBlockSubstitution()
};
IList <IClass> ClassList = root.ClassList;
foreach (IClass Class in ClassList)
{
NodeTreeWalk.Walk <object>(Class, Callbacks, Context);
}
}
private static Node DeserializeAndFix(FileStream fs)
{
Serializer Serializer = new Serializer();
Node RootNode;
RootNode = (Node)Serializer.Deserialize(fs);
WalkCallbacks <string> Callbacks = new WalkCallbacks <string>();
Callbacks.IsRecursive = true;
Callbacks.HandlerRoot = OnUpdateRoot;
Callbacks.HandlerNode = OnUpdateNode;
NodeTreeWalk.Walk(RootNode, Callbacks, string.Empty);
return(RootNode);
}
/// <summary></summary>
protected virtual bool Resolve(IRoot root, IRuleTemplateList ruleTemplateList, string passName)
{
BuildInferenceSourceList Context = new BuildInferenceSourceList(ruleTemplateList);
IWalkCallbacks <BuildInferenceSourceList> Callbacks = new WalkCallbacks <BuildInferenceSourceList>()
{
HandlerNode = ListAllSources, IsRecursive = true, BlockSubstitution = CreateBlockSubstitution()
};
IList <IClass> ClassList = root.ClassList;
foreach (IClass Class in ClassList)
{
NodeTreeWalk.Walk <BuildInferenceSourceList>(Class, Callbacks, Context);
}
IList <ISource> SourceList = Context.SourceList;
InferenceEngine Engine = new InferenceEngine(ruleTemplateList, SourceList, ClassList, true, InferenceRetries);
bool Success = Engine.Solve(ErrorList, passName);
Debug.Assert(Success || !ErrorList.IsEmpty);
return(Success);
}
private static bool OnUpdateNode(Node node, Node parentNode, string propertyName, WalkCallbacks <string> callback, string data)
{
return(OnUpdate(node, callback, data));
}
private static bool OnUpdateRoot(Node node, WalkCallbacks <string> callback, string data)
{
return(OnUpdate(node, callback, data));
}
