private List <MyUsedModuleInfo> ScanForUsedModules()
{
HashSet <MyModuleConfig> usedModules = new HashSet <MyModuleConfig>();
MyNodeGroup.IteratorAction scanForModules = delegate(MyNode node)
{
if (MyConfiguration.AssemblyLookup.ContainsKey(node.GetType().Assembly.FullName))
{
usedModules.Add(MyConfiguration.AssemblyLookup[node.GetType().Assembly.FullName]);
}
else
{
MyLog.WARNING.WriteLine("Unregistered module used in the project: " + node.GetType().Assembly.FullName);
}
};
Network.Iterate(true, scanForModules);
scanForModules(Network);
scanForModules(World);
List <MyUsedModuleInfo> result = new List <MyUsedModuleInfo>();
foreach (MyModuleConfig module in usedModules)
{
result.Add(new MyUsedModuleInfo()
{
Name = module.File.Name,
Version = module.GetXmlVersion()
});
}
return(result);
}
public void CloseObservers(MyNode node)
{
HashSet <ObserverForm> viewsToClose = new HashSet <ObserverForm>();
MyNodeGroup.IteratorAction checkTarget = delegate(MyNode target)
{
foreach (ObserverForm ov in ObserverViews)
{
if (ov.Observer.GenericTarget is MyAbstractMemoryBlock)
{
if ((ov.Observer.GenericTarget as MyAbstractMemoryBlock).Owner == target)
{
viewsToClose.Add(ov);
}
}
else if (ov.Observer.GenericTarget == target)
{
viewsToClose.Add(ov);
}
}
};
checkTarget(node);
if (node is MyNodeGroup)
{
(node as MyNodeGroup).Iterate(true, checkTarget);
}
foreach (ObserverForm ov in viewsToClose)
{
ov.Close();
}
}
public int UpdateAfterDeserialization(int topId, MyProject parentProject)
{
if (topId < this.Id)
{
topId = this.Id;
}
this.Owner = parentProject;
Dictionary <int, MyNode> nodes = new Dictionary <int, MyNode>();
topId = CollectNodesAndUpdate(this, nodes, topId);
parentProject.ReadOnly = false;
MyNodeGroup.IteratorAction findUnknownAction = delegate(MyNode node)
{
if (!MyConfiguration.KnownNodes.ContainsKey(node.GetType()))
{
MyLog.WARNING.WriteLine("Unknown node type in loaded project: " + node.GetType());
parentProject.ReadOnly = true;
try
{
MyNodeConfig nodeConfig = new MyNodeConfig()
{
NodeType = node.GetType(),
NodeTypeName = node.GetType().FullName
};
nodeConfig.InitIcons(Assembly.GetExecutingAssembly());
nodeConfig.AddObservers(Assembly.GetExecutingAssembly());
MyConfiguration.KnownNodes[nodeConfig.NodeType] = nodeConfig;
}
catch (Exception e)
{
MyLog.ERROR.WriteLine("Node type loading failed: " + e.Message);
}
}
};
Iterate(true, findUnknownAction);
foreach (MyConnectionProxy cp in m_connections)
{
try
{
MyConnection connection = new MyConnection(nodes[cp.From], nodes[cp.To], cp.FromIndex, cp.ToIndex);
connection.Connect();
}
catch (Exception e)
{
MyLog.ERROR.WriteLine("Error during connection deserialization: From id " + cp.From + " to id " + cp.To);
}
}
return(topId);
}
/// <summary>
/// Filter all nodes in project recursively. Returns list of nodes, for which the filter function returned True.
/// </summary>
/// <param name="filterFunc">User-defined function for filtering</param>
/// <returns>Node list</returns>
public List <MyNode> Filter(FilterFunc filterFunc)
{
List <MyNode> nodes = new List <MyNode>();
MyNodeGroup.IteratorAction a = x => { if (x.GetType() != typeof(MyNodeGroup) && filterFunc(x))
{
nodes.Add(x);
}
};
Project.Network.Iterate(true, a);
return(nodes);
}
private static void IterateNodes(IEnumerable <MyWorkingNode> nodes, MyNodeGroup.IteratorAction action)
{
foreach (MyWorkingNode node in nodes)
{
action(node);
var group = node as MyNodeGroup;
if (group != null)
{
group.Iterate(true, action);
}
}
}
private HashSet <MyNode> CollectWorkingNodes(MyNodeGroup nodeGroup)
{
HashSet <MyNode> nodes = new HashSet <MyNode>();
MyNodeGroup.IteratorAction action = delegate(MyNode node)
{
if (node is MyWorkingNode)
{
node.TopologicalOrder = -1;
nodes.Add(node);
}
};
nodeGroup.Iterate(false, action);
return(nodes);
}
private void CollectWorkingNodes(MyNodeGroup nodeGroup)
{
m_nodes.Clear();
MyNodeGroup.IteratorAction action = delegate(MyNode node)
{
if (node is MyWorkingNode)
{
if (node.Parent != null)
{
node.Sequential = node.Parent.Sequential;
}
node.TopologicalOrder = -1;
m_nodes.Add(node);
}
};
nodeGroup.Iterate(true, action);
}
/// <summary>
/// Prints info about nodes to DEBUG
/// </summary>
public void DumpNodes()
{
MyNodeGroup.IteratorAction a = x => { MyLog.DEBUG.WriteLine("[{0}] {1}: {2}", x.Id, x.Name, x.GetType()); };
Project.Network.Iterate(true, a);
}
