public static void TestDynamicEnumSource()
{
TypeSet t = new TypeSet();
{
DynamicEnumerationData d1 = new DynamicEnumerationData("d1", ParameterType.Parse("ed53be0d-c62a-4c0c-9f6e-e92d996bf3df"));
DynamicEnumerationData d2 = new DynamicEnumerationData("d2", ParameterType.Parse("6980f4d7-4ad8-4bc0-bacb-4907d922d4e9"));
t.AddDynamicEnum(d1);
t.AddDynamicEnum(d2);
var doc1 = new object();
var doc2 = new object();
var A1 = t.Make(d1.TypeId, "test1", Id <Parameter> .Parse("f95d62c4-b6c5-4c31-be69-c0cc3a35697e"), "default1", doc1) as IDynamicEnumParameter;
var A2 = t.Make(d1.TypeId, "test2", Id <Parameter> .Parse("3ff9251e-bd1f-4543-9719-3b8e5992f8ce"), "default2", doc2) as IDynamicEnumParameter;
var B1 = t.Make(d2.TypeId, "test3", Id <Parameter> .Parse("117a01a5-21df-4252-8120-8a11fe601ec6"), "default3", doc1) as IDynamicEnumParameter;
A1.SetValueAction("shane").Value.Redo();
B1.SetValueAction("not").Value.Redo();
Assert.That(A1.Options, Is.EquivalentTo(new[] { "shane", "default2" }));
Assert.That(A2.Options, Is.EquivalentTo(new[] { "shane", "default2" }));
Assert.That(B1.Options, Is.EquivalentTo(new[] { "not" }));
}
}
private static void CheckDynamicEnums(List <DynamicEnumerationData> dynamicEnums, TypeSet t, Action CheckContents, ref ParameterType modifiedType)
{
DynamicEnumerationData DE1 = new DynamicEnumerationData("DE1", ParameterType.Parse("89e54648-0572-4de2-82a6-3cdf5ea8aebc"));
DynamicEnumerationData DE2 = new DynamicEnumerationData("DE2", ParameterType.Parse("17b8ce6a-da16-459e-ab58-c77f62c5eba4"));
DynamicEnumerationData DE3 = new DynamicEnumerationData("DE3", ParameterType.Parse("882d169d-b697-4ff3-8f4d-d0a3b18549c7"));
t.AddDynamicEnum(DE1);
dynamicEnums.Add(DE1);
Assert.That(modifiedType, Is.EqualTo(DE1.TypeId));
modifiedType = null;
CheckContents();
t.Remove(DE1.TypeId);
dynamicEnums.Remove(DE1);
Assert.That(modifiedType, Is.EqualTo(DE1.TypeId));
modifiedType = null;
CheckContents();
t.AddDynamicEnum(DE2);
dynamicEnums.Add(DE2);
Assert.That(modifiedType, Is.EqualTo(DE2.TypeId));
modifiedType = null;
CheckContents();
t.AddDynamicEnum(DE3);
dynamicEnums.Add(DE3);
Assert.That(modifiedType, Is.EqualTo(DE3.TypeId));
modifiedType = null;
CheckContents();
DynamicEnumerationData DE3Modified = new DynamicEnumerationData("DE3Modified", ParameterType.Parse("882d169d-b697-4ff3-8f4d-d0a3b18549c7"));
t.RenameType(DE3.TypeId, DE3Modified.Name);
dynamicEnums[dynamicEnums.IndexOf(DE3)] = DE3Modified;
Assert.That(modifiedType, Is.EqualTo(DE3Modified.TypeId));
modifiedType = null;
CheckContents();
}
/// <summary>
/// Fill the data source from all the data stored in all domain files
/// </summary>
/// <param name="domains">All the domain files used to populate the datasource</param>
public ConversationDataSource(IEnumerable <DomainData> domains)
{
domains = domains.Evaluate();
//Types must be generated before Nodes and can be generated before NodeTypes
foreach (var domain in domains)
{
foreach (var typeData in domain.DynamicEnumerations)
{
m_types.AddDynamicEnum(typeData.TypeID, (name, guid) => typeData.Make(name, guid));
}
foreach (var typeData in domain.Enumerations)
{
IEnumeration enumeration = typeData.Make();
m_enumerations.Add(enumeration);
m_types.AddEnum(enumeration.TypeId, enumeration.Parameter);
}
foreach (var typeData in domain.Decimals)
{
m_types.AddDecimal(typeData.TypeID, typeData.Make);
}
foreach (var typeData in domain.Integers)
{
m_types.AddInteger(typeData.TypeID, typeData.Make);
}
}
//NodeTypes must be generated before Nodes and can be generated before Types. NodeTypes may have interdependencies between files
var nodeTypeData = domains.SelectMany(d => d.NodeTypes).ToList();
var duplicates = nodeTypeData.GroupBy(a => a.Guid).Where(g => g.Count() > 1);
if (duplicates.Any())
{
throw new Exception("The following node types have duplicate definitions: " + string.Join(", ", duplicates.Select(g => g.Key).ToArray()));
}
List <NodeType> nodeTypes = new List <NodeType> {
};
nodeTypes.Add(m_nodeHeirarchy);
//foreach (var data in nodeTypeData.Where(d => d.Parent == DomainGUIDS.CATEGORY_NONE).ToList())
//{
// var newNodeType = new NodeType(data.Name, data.Guid);
// m_nodes.m_childTypes.Add(newNodeType);
// nodeTypes.Add(newNodeType);
// nodeTypeData.Remove(data);
//}
bool gotOne = true;
while (nodeTypeData.Any() && gotOne)
{
gotOne = false;
for (int i = 0; i < nodeTypes.Count; i++)
{
var parent = nodeTypes[i];
foreach (var data in nodeTypeData.Where(d => d.Parent == parent.Guid).ToList())
{
var newNodeType = new NodeType(data.Name, data.Guid);
parent.m_childTypes.Add(newNodeType);
nodeTypes.Add(newNodeType);
gotOne = true;
nodeTypeData.Remove(data);
}
}
}
if (!gotOne)
{
//TODO: How to express this to the user?
//Do they even need to know? It may just be autoresolved
//throw new Exception("The following node types are ancestors of an unknown node type: " + string.Join(", ", nodeTypeData.Select(d => d.Guid).ToArray()));
MessageBox.Show("The following node types are ancestors of an unknown node type: " + string.Join(", ", nodeTypeData.Select(d => d.Guid).ToArray()));
foreach (var orphan in nodeTypeData)
{
m_nodeHeirarchy.m_childTypes.Add(new NodeType(orphan.Name, orphan.Guid));
}
}
//Connectors must be generated after Types but before Nodes
Dictionary <ID <TConnectorDefinition>, ConnectorDefinitionData> connectorDefinitions = new Dictionary <ID <TConnectorDefinition>, ConnectorDefinitionData>()
{
{ SpecialConnectors.Output.Id, SpecialConnectors.Output },
{ SpecialConnectors.Input.Id, SpecialConnectors.Input },
};
foreach (var domain in domains)
{
foreach (var connector in domain.Connectors)
{
connectorDefinitions[connector.Id] = connector;
}
}
//Nodes must be generated after NodeTypes, Types and Connectors
foreach (var domain in domains)
{
foreach (var node in domain.Nodes)
{
var name = node.Name;
var guid = node.Guid;
Func <NodeData.ConnectorData, Func <IEditable, Output> > processConnector = c =>
{
Func <IEditable, List <Parameter>, Output> a = connectorDefinitions[c.TypeID].Make(c.Id, ConversationConnectionRules.Instance);
return(data => a(data, c.Parameters));
};
IEnumerable <Func <IEditable, Output> > connectors = node.Connectors.Select(processConnector).Evaluate();
var parameters = node.Parameters.Select <NodeData.ParameterData, Func <Parameter> >(p => () => p.Make(m_types.Make)).Evaluate();
var config = node.Config.ToDictionary(b => b.Name, b => b.Value, StringComparer.OrdinalIgnoreCase);
var parent = m_nodeHeirarchy.Collapse(x => x.m_childTypes, x => x.Only()).SingleOrDefault(x => x.Guid == node.Type) ?? m_nodeHeirarchy;
var nodeGenerator = new GenericEditableGenerator(name, guid, config, (id, ng) => new ExternalFunction(ng, id, connectors, parameters.Select(b => b()).ToArray()));
parent.m_nodes.Add(nodeGenerator);
m_nodes[guid] = nodeGenerator;
}
}
}
