public static Dictionary <Guid, Type> DataTypePerParam(this ClusterContent content)
{
Dictionary <Guid, Type> types = new Dictionary <Guid, Type>();
if (content == null)
{
return(types);
}
content.InternalNodes = content.InternalNodes.Select(x => x.IPopulateTypes()).ToList();
foreach (DataParam input in content.Inputs)
{
types[input.BHoM_Guid] = input.DataType;
}
foreach (ReceiverParam output in content.Outputs)
{
types[output.BHoM_Guid] = output.DataType;
}
foreach (INode child in content.InternalNodes)
{
Dictionary <Guid, Type> childTypes = child.IDataTypePerParam();
foreach (KeyValuePair <Guid, Type> kvp in childTypes)
{
types[kvp.Key] = kvp.Value;
}
}
return(types);
}
public static ClusterContent PopulateTypes(this ClusterContent content)
{
if (content == null)
{
return(content);
}
content.InternalNodes = content.InternalNodes.Select(x => x.IPopulateTypes()).ToList();
// Collect the types
Dictionary <Guid, Type> nodeTypes = content.DataTypePerParam();
// Assign the types to the inputs
foreach (DataParam input in content.Inputs)
{
if (input.TargetIds.Count > 0 && nodeTypes.ContainsKey(input.TargetIds[0]))
{
input.DataType = nodeTypes[input.TargetIds[0]];
}
}
// Assign the types to the outputs
foreach (ReceiverParam output in content.Outputs)
{
if (nodeTypes.ContainsKey(output.SourceId))
{
output.DataType = nodeTypes[output.SourceId];
}
}
return(content);
}
/*******************************************/
protected override void SolveInstance(IGH_DataAccess DA)
{
BH.Engine.Base.Compute.ClearCurrentEvents();
try
{
// Get the input component
IGH_Param source = Params.Input[0].Sources.FirstOrDefault();
if (source == null)
{
return;
}
IGH_DocumentObject component = source.Attributes.GetTopLevel.DocObject;
GH_Cluster cluster = source.Attributes.GetTopLevel.DocObject as GH_Cluster;
List <IGH_DocumentObject> content = cluster.Document("").Objects.ToList();
List <GH_ClusterInputHook> inputs = content.OfType <GH_ClusterInputHook>().ToList();
List <GH_ClusterOutputHook> outputs = content.OfType <GH_ClusterOutputHook>().ToList();
List <GH_Component> components = content.OfType <GH_Component>().ToList();
List <GH_Group> groups = content.OfType <GH_Group>().ToList();
List <IGH_Param> parameters = content.OfType <IGH_Param>().ToList();
groups = groups.Except(groups.SelectMany(x => x.Objects().OfType <GH_Group>())).ToList();
ClusterContent nodeContent = new ClusterContent
{
Name = cluster.NickName,
Inputs = inputs.Select(x => new DataParam {
Name = x.NickName,
Description = x.Description,
TargetIds = x.Recipients.Select(r => r.InstanceGuid).ToList(),
BHoM_Guid = x.InstanceGuid
}).ToList(),
Outputs = outputs.Select(x => new ReceiverParam {
Name = x.NickName,
Description = x.Description,
SourceId = x.Sources.First().InstanceGuid,
BHoM_Guid = x.InstanceGuid
}).ToList(),
InternalNodes = components.Select(x => ToNode(x)).Concat(parameters.Select(x => ToNode(x))).Where(x => x != null).ToList(),
NodeGroups = ClearUnsafeGroups(groups.Select(x => x.ToNodeGroup()).ToList()),
BHoM_Guid = cluster.InstanceGuid
};
nodeContent = nodeContent.PopulateTypes();
DA.SetData(0, nodeContent);
Helpers.ShowEvents(this, BH.Engine.Base.Query.CurrentEvents());
}
catch (Exception e)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message);
}
}
